import crypto from "node:crypto"; import fs from "node:fs"; import path from "node:path"; import { execFileSync } from "node:child_process"; import { fileURLToPath } from "node:url"; import { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager, type AgentSession, type ExtensionAPI, type ExtensionContext, } from "@earendil-works/pi-coding-agent"; import { Type } from "typebox"; import { loadAdapterIdentity } from "../adapter-identity.mjs"; import { authorizeActivationLaunch, beginActivation, completeActivation, recordActivationFailure, } from "./activation.mjs"; import { createCompletionChannel } from "./completion-channel.mjs"; import { createLaunchAdmission, registerCompletionRestoration, settleCompletion, shutdownAdapter, } from "./control.mjs"; import { classifyScoutTerminal } from "./lifecycle.mjs"; import { createRecoveryPolicy } from "./recovery.mjs"; import { activeDeliveryDegradation, completeCoordinatorRenewal, recordDeliveryDegradation, requestCoordinatorRenewal, } from "./renewal.mjs"; const ADAPTER_CONTRACT = "dirtyloops-harness/1"; const SUPPORTED_SUBAGENTS_PROTOCOL = 1; const SUBAGENTS_RPC_REQUEST_EVENT = "subagents:rpc:v1:request"; const SUBAGENTS_RPC_REPLY_PREFIX = "subagents:rpc:v1:reply:"; const DIRTYLOOPS_SCOUT_AGENT = "dirtyloops.scout"; const MAX_COMPLETION_CHARS = 12_000; const MAX_ACTIVE_CHILDREN = 4; const SKILL_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../.."); const LOADED_ADAPTER_IDENTITY = loadAdapterIdentity(SKILL_ROOT, "pi"); type ChildStatus = "starting" | "running" | "completed" | "failed" | "cancelled"; type ChildKind = "session" | "delegate"; type ChildBackend = "vanilla" | "pi-subagents"; interface ChildRecord { handle: string; kind: ChildKind; backend: ChildBackend; status: ChildStatus; description: string; cwd: string; docRoot: string; activationProbe?: boolean; activityUnsubscribe?: () => void; session?: AgentSession; sessionId?: string; sessionFile?: string; pluginId?: string; pluginAsyncDir?: string; pluginWatcher?: { close(): void }; result?: string; error?: string; cancelRequested?: boolean; } interface RpcReply { version?: number; requestId?: string; method?: string; success: boolean; data?: T; error?: { code?: string; message?: string }; } interface SubagentsPing { version: number; methods?: string[]; capabilities?: { status?: boolean; asyncSpawn?: boolean; stop?: boolean; }; events?: { request?: string; replyPrefix?: string; }; } interface SubagentsSpawn { text?: string; details?: { runId?: string; asyncId?: string; asyncDir?: string; }; } interface SubagentsStatus { runId?: string; sessionId?: string; sessionFile?: string; state?: "queued" | "running" | "complete" | "failed" | "paused" | "stopped"; outputFile?: string; error?: string; } interface AdapterDependencies { createAgentSession: typeof createAgentSession; DefaultResourceLoader: typeof DefaultResourceLoader; getAgentDir: typeof getAgentDir; SessionManager: typeof SessionManager; now?: () => number; recoveryCooldownMs?: number; recoveryMinSilenceMs?: number; renewalCheckout: typeof renewalCheckout; } function textResult(text: string, details: unknown = {}) { return { content: [{ type: "text" as const, text }], details }; } function git(cwd: string, args: string[]): string { return execFileSync("git", args, { cwd, encoding: "utf8", timeout: 10_000 }).trim(); } function validateLaunchEnvironment(params: { cwd: string; mutation: string; expected_repo_root?: string; expected_branch?: string; }) { if (!path.isAbsolute(params.cwd)) throw new Error("cwd must be an absolute path"); if (!fs.existsSync(params.cwd) || !fs.statSync(params.cwd).isDirectory()) throw new Error("cwd must be an existing directory"); if (params.mutation === "read-only") return { cwd: fs.realpathSync(params.cwd) }; if (!params.expected_repo_root || !params.expected_branch) { throw new Error("write and review missions require expected_repo_root and expected_branch"); } const cwd = fs.realpathSync(params.cwd); const root = fs.realpathSync(git(cwd, ["rev-parse", "--show-toplevel"])); const branch = git(cwd, ["symbolic-ref", "--short", "HEAD"]); if (root !== fs.realpathSync(params.expected_repo_root)) throw new Error(`repo root mismatch: expected ${params.expected_repo_root}, got ${root}`); if (branch !== params.expected_branch) throw new Error(`branch mismatch: expected ${params.expected_branch}, got ${branch}`); return { cwd, root, branch, status: git(cwd, ["status", "--short", "--branch"]) }; } function renewalCheckout(docRoot: string, expectedBranch?: string) { const cwd = fs.realpathSync(docRoot); const root = fs.realpathSync(git(cwd, ["rev-parse", "--show-toplevel"])); const relativeDocRoot = path.relative(root, cwd); if (relativeDocRoot === ".." || relativeDocRoot.startsWith(`..${path.sep}`)) { throw new Error("renewal doc_root is outside the active repository"); } const branch = git(cwd, ["symbolic-ref", "--short", "HEAD"]); if (!expectedBranch) throw new Error("renewal requires expected_branch"); if (branch !== expectedBranch) throw new Error(`branch mismatch: expected ${expectedBranch}, got ${branch}`); return { branch, head: git(cwd, ["rev-parse", "HEAD"]), dirty: Boolean(git(cwd, ["status", "--porcelain"])), }; } function assistantContentText(message: any): string { if (typeof message.content === "string") return message.content; if (!Array.isArray(message.content)) return ""; return message.content.filter((item: any) => item?.type === "text").map((item: any) => item.text).join("\n").trim(); } function finalAssistantText(session: AgentSession): string { const message = [...session.state.messages].reverse().find((candidate: any) => candidate?.role === "assistant") as any; return message ? assistantContentText(message) : ""; } function completionPayload(record: ChildRecord) { const result = record.result ?? ""; return { type: "dirtyloops-child-completion", adapter_contract: ADAPTER_CONTRACT as "dirtyloops-harness/1", handle: record.handle, kind: record.kind, backend: record.backend, lifecycle_source: record.backend === "pi-subagents" ? "pi-subagents-scout" : "vanilla-session", status: record.status, description: record.description, cwd: record.cwd, doc_root: record.docRoot, activation_probe: record.activationProbe === true, session_id: record.sessionId, session_file: record.sessionFile, result: result.length > MAX_COMPLETION_CHARS ? `${result.slice(0, MAX_COMPLETION_CHARS)}\n…truncated; inspect the child session for the full result` : result, error: record.error, }; } function rpcErrorMessage(reply: RpcReply): string { return reply.error?.message ?? reply.error?.code ?? "RPC request failed"; } function nicobailonRpc(pi: ExtensionAPI, method: "ping" | "status" | "spawn" | "interrupt" | "stop", params: Record = {}, timeoutMs = 250): Promise> { return new Promise((resolve) => { const requestId = crypto.randomUUID(); const replyChannel = `${SUBAGENTS_RPC_REPLY_PREFIX}${requestId}`; let settled = false; const unsubscribe = pi.events.on(replyChannel, (reply: unknown) => { if (settled) return; settled = true; clearTimeout(timer); unsubscribe(); const envelope = reply as RpcReply; if (envelope.version !== SUPPORTED_SUBAGENTS_PROTOCOL || envelope.requestId !== requestId || envelope.method !== method) { resolve({ success: false, error: { code: "invalid_reply", message: "RPC reply did not match the requested v1 envelope" } }); return; } resolve(envelope); }); const timer = setTimeout(() => { if (settled) return; settled = true; unsubscribe(); resolve({ success: false, error: { code: "timeout", message: "RPC handshake timed out" } }); }, timeoutMs); pi.events.emit(SUBAGENTS_RPC_REQUEST_EVENT, { version: SUPPORTED_SUBAGENTS_PROTOCOL, requestId, method, params, source: { extension: "dirtyloops" }, }); }); } async function probeSubagents(pi: ExtensionAPI) { const reply = await nicobailonRpc(pi, "ping"); if (!reply.success) return { name: "nicobailon/pi-subagents", status: "unavailable" as const }; const protocol = reply.data?.version; if (protocol !== SUPPORTED_SUBAGENTS_PROTOCOL) { return { name: "nicobailon/pi-subagents", status: "incompatible" as const, protocol: String(protocol ?? "unknown") }; } const methods = new Set(reply.data?.methods ?? []); const capabilities = reply.data?.capabilities; const events = reply.data?.events; const certified = ["ping", "status", "spawn", "stop"].every((method) => methods.has(method)) && capabilities?.status === true && capabilities?.asyncSpawn === true && capabilities?.stop === true && events?.request === SUBAGENTS_RPC_REQUEST_EVENT && events?.replyPrefix === SUBAGENTS_RPC_REPLY_PREFIX; if (!certified) return { name: "nicobailon/pi-subagents", status: "incompatible" as const, protocol: "rpc-v1" }; return { name: "nicobailon/pi-subagents", status: "certified" as const, protocol: "rpc-v1" }; } function readSubagentsStatus(asyncDir: string): SubagentsStatus | undefined { const statusFile = path.join(asyncDir, "status.json"); if (!fs.existsSync(statusFile)) return undefined; try { return JSON.parse(fs.readFileSync(statusFile, "utf8")) as SubagentsStatus; } catch { return undefined; } } function subagentsOutput(asyncDir: string, status: SubagentsStatus): string { if (status.sessionFile) { try { const sessionFile = path.isAbsolute(status.sessionFile) ? status.sessionFile : path.join(asyncDir, status.sessionFile); const entries = fs.readFileSync(sessionFile, "utf8").trim().split(/\r?\n/).reverse(); for (const line of entries) { const entry = JSON.parse(line); const message = entry?.message ?? entry; if (message?.role === "assistant") { const text = assistantContentText(message); if (text) return text; } } } catch { // Fall back to the stable async output artifact below. } } const outputFile = status.outputFile ? (path.isAbsolute(status.outputFile) ? status.outputFile : path.join(asyncDir, status.outputFile)) : path.join(asyncDir, "output-0.log"); try { return fs.readFileSync(outputFile, "utf8").trim(); } catch { return ""; } } function runtimeManifest(optionalBackend: Awaited>, coordinatorId: string) { return { harness: "pi" as const, adapter: "dirtyloops-pi-vanilla", adapter_contract: ADAPTER_CONTRACT as "dirtyloops-harness/1", adapter_identity: LOADED_ADAPTER_IDENTITY, coordinator_id: coordinatorId, capabilities: [ "runtime-identification", "explicit-cwd", "symbolic-branch-verification", "structured-completion", "acknowledged-completion", "reasoned-recovery", "coordinator-renewal", "persistent-child-session", "bounded-delegates", "background-completion", "model-selection", "reasoning-selection", "steering", "cancellation", "concurrent-children", ], optional_backends: [optionalBackend], }; } export function registerDirtyloopsPiAdapter(pi: ExtensionAPI, overrides: Partial = {}) { const dependencies: AdapterDependencies = { createAgentSession, DefaultResourceLoader, getAgentDir, SessionManager, renewalCheckout, ...overrides, }; const children = new Map(); const completionChannel = createCompletionChannel({ append: (customType, data) => pi.appendEntry(customType, data), emit: (payload) => pi.sendMessage({ customType: "dirtyloops-child-completion", content: JSON.stringify(payload), display: true, details: payload, }, { deliverAs: "followUp", triggerTurn: true }), }); const recoveryPolicy = createRecoveryPolicy({ append: (customType, data) => pi.appendEntry(customType, data), ...(dependencies.now ? { now: dependencies.now } : {}), ...(dependencies.recoveryCooldownMs ? { cooldownMs: dependencies.recoveryCooldownMs } : {}), ...(dependencies.recoveryMinSilenceMs ? { minSilenceMs: dependencies.recoveryMinSilenceMs } : {}), }); const recordRenewedRecovery = (renewal: any, coordinatorId: string) => { if (renewal.status !== "completed" || !renewal.activation) return undefined; return recoveryPolicy.markRenewed({ handles: renewal.recovery_handles ?? [], coordinatorId, generationId: renewal.activation.generation_id, }); }; const reconcileRenewedRecovery = (docRoot: string, coordinatorId: string) => { try { const renewal = completeCoordinatorRenewal({ docRoot, coordinatorId, ...(dependencies.now ? { now: dependencies.now } : {}), }); recordRenewedRecovery(renewal, coordinatorId); } catch { // Stay fail-closed on the existing degraded launch blocker. } }; const launchAdmission = createLaunchAdmission({ children, completionChannel, maxActiveChildren: MAX_ACTIVE_CHILDREN, }); const completionRestoration = registerCompletionRestoration(pi, completionChannel); let recoveryRestored = false; const restoreRecovery = (ctx: ExtensionContext) => { recoveryPolicy.restore(ctx.sessionManager.getBranch()); recoveryRestored = true; }; pi.on("session_start", (_event, ctx) => restoreRecovery(ctx)); pi.on("session_tree", (_event, ctx) => restoreRecovery(ctx)); const ensureRecovery = (ctx: ExtensionContext) => { if (!recoveryRestored) restoreRecovery(ctx); }; const notifyCompletion = (record: ChildRecord) => { record.activityUnsubscribe?.(); record.activityUnsubscribe = undefined; try { settleCompletion(completionChannel, record, completionPayload(record)); } catch (error: any) { if (record.activationProbe) recordActivationFailure({ docRoot: record.docRoot, boundary: completionChannel.has(record.handle) ? "emission" : "recording", message: error?.message ?? String(error), coordinatorId: JSON.parse(fs.readFileSync(path.join(record.docRoot, "runtime/activation.json"), "utf8")).probe.coordinator_id, }); throw error; } }; const finishSubagentsRun = (record: ChildRecord) => { if (!record.pluginAsyncDir || completionChannel.has(record.handle)) return; const status = readSubagentsStatus(record.pluginAsyncDir); if (status) recoveryPolicy.observe(record.handle, `pi-subagents:${status.state ?? "status"}`); const terminal = classifyScoutTerminal(status?.state, record.cancelRequested, status?.error); if (!status || !terminal) return; record.sessionId = status.sessionId; record.sessionFile = status.sessionFile; record.result = subagentsOutput(record.pluginAsyncDir, status); record.status = terminal.status; record.error = terminal.error; notifyCompletion(record); }; const watchSubagentsRun = (record: ChildRecord) => { if (!record.pluginAsyncDir) throw new Error("pi-subagents launch did not return an async directory"); const watcher = fs.watch(record.pluginAsyncDir, (_event, filename) => { if (!filename || filename.toString() === "status.json") finishSubagentsRun(record); }); watcher.on("error", (error) => { if (completionChannel.has(record.handle)) return; record.status = "failed"; record.error = `pi-subagents lifecycle watcher failed: ${error.message}`; notifyCompletion(record); }); record.pluginWatcher = watcher; finishSubagentsRun(record); }; pi.registerTool({ name: "dirtyloops_runtime", label: "Dirtyloops Runtime", description: "Report capabilities, activate a generated runtime, or request a safe coordinator renewal.", promptSnippet: "Inspect the active dirtyloops harness adapter and certified capabilities", promptGuidelines: ["Use dirtyloops_runtime before running or inspecting a Pi-bound dirtyloop."], parameters: Type.Object({ action: Type.Optional(Type.Union([Type.Literal("manifest"), Type.Literal("activate"), Type.Literal("renew")])), doc_root: Type.Optional(Type.String()), reason: Type.Optional(Type.Union([ Type.Literal("degraded-delivery"), Type.Literal("context-pressure"), Type.Literal("operator-request"), ])), handle: Type.Optional(Type.String()), safe_boundary: Type.Optional(Type.Boolean()), phase_issue_id: Type.Optional(Type.String()), turn_doc: Type.Optional(Type.String()), pr: Type.Optional(Type.String()), expected_branch: Type.Optional(Type.String()), detail: Type.Optional(Type.String()), }), async execute(_toolCallId, params, _signal, _onUpdate, ctx: ExtensionContext) { const optionalBackend = await probeSubagents(pi); const manifest = runtimeManifest(optionalBackend, ctx.sessionManager.getSessionId()); const action = params.action ?? "manifest"; if (action === "manifest") return textResult(JSON.stringify(manifest, null, 2), manifest); if (!params.doc_root || !path.isAbsolute(params.doc_root)) return textResult(`${action} requires an absolute doc_root`); try { if (action === "renew") { completionRestoration.ensure(ctx); ensureRecovery(ctx); const active = [...children.values()].filter((child) => child.status === "starting" || child.status === "running"); if (active.length) return textResult(`renewal blocked: ${active.length} child sessions still own work`); if (completionChannel.pending().length) return textResult("renewal blocked: acknowledge pending completions before handoff"); const checkout = dependencies.renewalCheckout(params.doc_root, params.expected_branch); const renewal = requestCoordinatorRenewal({ docRoot: params.doc_root, coordinatorId: ctx.sessionManager.getSessionId(), reason: params.reason, safeBoundary: params.safe_boundary, phaseIssueId: params.phase_issue_id, turnDoc: params.turn_doc, pr: params.pr, expectedBranch: params.expected_branch, checkout, contextUsage: ctx.getContextUsage(), recoveryEvidence: activeDeliveryDegradation({ docRoot: params.doc_root, selectedHandle: params.handle, }), detail: params.detail, }); const result = { ...manifest, renewal }; return textResult(JSON.stringify(result, null, 2), result); } const activation = beginActivation({ docRoot: params.doc_root, manifest }); const result = { ...manifest, activation }; return textResult(JSON.stringify(result, null, 2), result); } catch (error: any) { return textResult(`${action} blocked: ${error.message}`); } }, }); pi.registerTool({ name: "dirtyloops_child", label: "Dirtyloops Child", description: "Launch, recover, steer, cancel, or acknowledge a certified dirtyloops child session or delegate.", promptSnippet: "Control durable sessions and bounded delegates through the Pi dirtyloops adapter", promptGuidelines: [ "Use dirtyloops_child only after dirtyloops_runtime confirms a compatible Pi binding.", "Use kind=session for durable implementation or review ownership and kind=delegate for bounded evidence work.", "Pass the absolute loop doc_root on every launch so activation is checked for that exact generation.", "Use explicit cwd, expected_repo_root, and expected_branch for every write or review mission.", "Acknowledge every terminal completion with its exact handle and nonce before launching another child.", "Normal completion is callback-driven. Use recover, or legacy status, only with a certified recovery reason.", ], parameters: Type.Object({ action: Type.Union([Type.Literal("launch"), Type.Literal("recover"), Type.Literal("status"), Type.Literal("steer"), Type.Literal("cancel"), Type.Literal("ack")]), handle: Type.Optional(Type.String()), nonce: Type.Optional(Type.String()), kind: Type.Optional(Type.Union([Type.Literal("session"), Type.Literal("delegate")])), backend: Type.Optional(Type.Union([Type.Literal("auto"), Type.Literal("vanilla"), Type.Literal("pi-subagents")])), mission: Type.Optional(Type.String()), description: Type.Optional(Type.String()), cwd: Type.Optional(Type.String()), doc_root: Type.Optional(Type.String()), mutation: Type.Optional(Type.Union([Type.Literal("read-only"), Type.Literal("write"), Type.Literal("review")])), expected_repo_root: Type.Optional(Type.String()), expected_branch: Type.Optional(Type.String()), model: Type.Optional(Type.String()), thinking: Type.Optional(Type.Union([ Type.Literal("off"), Type.Literal("minimal"), Type.Literal("low"), Type.Literal("medium"), Type.Literal("high"), Type.Literal("xhigh"), Type.Literal("max"), ])), message: Type.Optional(Type.String()), reason: Type.Optional(Type.Union([ Type.Literal("missed-heartbeat"), Type.Literal("delivery-recovery"), Type.Literal("operator-request"), ])), detail: Type.Optional(Type.String()), }), async execute(_toolCallId, params, _signal, _onUpdate, ctx: ExtensionContext) { completionRestoration.ensure(ctx); ensureRecovery(ctx); if (params.action !== "launch") { if (!params.handle) return textResult("handle is required"); if (params.action === "ack") { if (!params.nonce) return textResult("nonce is required for acknowledgement"); if (!params.doc_root || !path.isAbsolute(params.doc_root)) { return textResult("acknowledgement requires an absolute doc_root"); } const completion = completionChannel.get(params.handle); if (!completion) return textResult(`unknown child handle: ${params.handle}`); const completionDocRoot = typeof completion.doc_root === "string" ? completion.doc_root : undefined; if (!completionDocRoot || !path.isAbsolute(completionDocRoot) || path.resolve(completionDocRoot) !== path.resolve(params.doc_root)) { return textResult("acknowledgement blocked: completion does not belong to the supplied loop doc_root"); } const acknowledgement = completionChannel.acknowledge(params.handle, params.nonce); if (!acknowledgement.ok) { return textResult(`acknowledgement rejected: ${acknowledgement.error}`, acknowledgement); } if (completion.activation_probe === true) { const activation = completeActivation({ docRoot: params.doc_root, coordinatorId: ctx.sessionManager.getSessionId(), completion, acknowledgement, }); const renewal = activation.status === "ready" ? completeCoordinatorRenewal({ docRoot: params.doc_root, coordinatorId: ctx.sessionManager.getSessionId(), ...(dependencies.now ? { now: dependencies.now } : {}), }) : { status: "none" }; recordRenewedRecovery(renewal, ctx.sessionManager.getSessionId()); const result = { acknowledgement, activation, renewal }; return textResult(JSON.stringify(result, null, 2), result); } return textResult(`acknowledged completion ${params.handle}`, acknowledgement); } const record = children.get(params.handle); const durableCompletion = completionChannel.get(params.handle); if (params.action === "recover" || params.action === "status") { if (!params.reason) return textResult(`${params.action} requires a recovery reason`); const recovery = recoveryPolicy.recover({ handle: params.handle, reason: params.reason, detail: params.detail, child: record ? completionPayload(record) : undefined, completion: durableCompletion, reemit: (handle) => completionChannel.recover(handle), degrade: (recovery) => { const degradationRoot = durableCompletion?.doc_root; if (typeof degradationRoot !== "string" || !path.isAbsolute(degradationRoot)) { throw new Error("delivery recovery completion has no absolute doc_root"); } return recordDeliveryDegradation({ docRoot: degradationRoot, coordinatorId: ctx.sessionManager.getSessionId(), recovery, ...(dependencies.now ? { now: dependencies.now } : {}), }); }, }); return textResult(JSON.stringify(recovery, null, 2), recovery); } if (!record && !durableCompletion) return textResult(`unknown child handle: ${params.handle}`); if (!record) return textResult(`child ${params.handle} is terminal; acknowledge its completion instead`); if (params.action === "steer") { if (!params.message) return textResult("message is required for steer"); if (record.backend !== "vanilla" || !record.session || record.status !== "running") return textResult("this child is not a running steerable vanilla session"); await record.session.steer(params.message); return textResult(`steered ${record.handle}`); } if (record.backend === "pi-subagents" && record.pluginId) { record.cancelRequested = true; const reply = await nicobailonRpc(pi, "stop", { id: record.pluginId }, 2_000); if (!reply.success) { record.cancelRequested = false; return textResult(`cancel failed: ${rpcErrorMessage(reply)}`); } } else if (record.session && record.status === "running") { record.cancelRequested = true; record.status = "cancelled"; await record.session.abort(); } record.status = "cancelled"; notifyCompletion(record); return textResult(`cancelled ${record.handle}`); } if (!params.kind || !params.mission || !params.description || !params.cwd || !params.doc_root) { return textResult("launch requires kind, mission, description, cwd, and doc_root"); } if (!path.isAbsolute(params.doc_root)) return textResult("launch requires an absolute doc_root"); reconcileRenewedRecovery(params.doc_root, ctx.sessionManager.getSessionId()); let authorization; try { authorization = authorizeActivationLaunch({ docRoot: params.doc_root, coordinatorId: ctx.sessionManager.getSessionId(), params, }); } catch (error: any) { return textResult(`launch blocked: activation lease is invalid: ${error.message}`); } if (!authorization.ok) return textResult(`launch blocked: ${authorization.error}`); let durableDegradation = authorization.probe ? undefined : activeDeliveryDegradation({ docRoot: params.doc_root }); let recoveryBlocker = recoveryPolicy.launchBlocker(); if ((durableDegradation || recoveryBlocker) && !authorization.probe) { reconcileRenewedRecovery(params.doc_root, ctx.sessionManager.getSessionId()); durableDegradation = activeDeliveryDegradation({ docRoot: params.doc_root }); recoveryBlocker = recoveryPolicy.launchBlocker(); } const degradedHandle = durableDegradation?.selected_handle ?? recoveryBlocker?.handle; if (degradedHandle && !authorization.probe) { return textResult(`launch blocked: degraded completion ${degradedHandle} requires coordinator renewal`); } const activationRoot = authorization.probe ? params.doc_root : undefined; const activationLaunchFailure = (message: string) => { if (activationRoot) recordActivationFailure({ docRoot: activationRoot, boundary: "launch", message, coordinatorId: ctx.sessionManager.getSessionId(), }); return textResult(`launch blocked: ${message}`); }; const mutation = params.mutation ?? "read-only"; let environment; try { environment = validateLaunchEnvironment({ cwd: params.cwd, mutation, expected_repo_root: params.expected_repo_root, expected_branch: params.expected_branch, }); } catch (error: any) { return activationLaunchFailure(error.message); } const optionalBackend = await probeSubagents(pi); const requestedBackend = params.backend ?? "auto"; const backend: ChildBackend = requestedBackend === "pi-subagents" ? "pi-subagents" : "vanilla"; if (backend === "pi-subagents" && optionalBackend.status !== "certified") { return activationLaunchFailure(`pi-subagents backend is ${optionalBackend.status}; use vanilla`); } if (backend === "pi-subagents" && params.kind !== "delegate") { return activationLaunchFailure("pi-subagents is available only for bounded delegates; durable sessions use vanilla Pi"); } if (backend === "pi-subagents" && mutation !== "read-only") { return activationLaunchFailure("pi-subagents is certified only for read-only delegates; use vanilla Pi for write ownership"); } const handle = crypto.randomUUID(); const record: ChildRecord = { handle, kind: params.kind, backend, status: "starting", description: params.description, cwd: environment.cwd, docRoot: path.resolve(params.doc_root), activationProbe: authorization.probe, }; try { authorization = authorizeActivationLaunch({ docRoot: params.doc_root, coordinatorId: ctx.sessionManager.getSessionId(), params, }); } catch (error: any) { return activationLaunchFailure(`activation lease changed during launch: ${error.message}`); } if (!authorization.ok) return activationLaunchFailure(`activation lease changed during launch: ${authorization.error}`); const currentDurableDegradation = authorization.probe ? undefined : activeDeliveryDegradation({ docRoot: params.doc_root }); const currentRecoveryBlocker = recoveryPolicy.launchBlocker(); const currentDegradedHandle = currentDurableDegradation?.selected_handle ?? currentRecoveryBlocker?.handle; if (currentDegradedHandle && !authorization.probe) { return activationLaunchFailure(`degraded completion ${currentDegradedHandle} requires coordinator renewal`); } const admission = launchAdmission.reserve(record); if (!admission.ok) return activationLaunchFailure(admission.error); recoveryPolicy.observe(handle, "launch"); if (backend === "pi-subagents") { const reply = await nicobailonRpc(pi, "spawn", { agent: DIRTYLOOPS_SCOUT_AGENT, task: params.mission, cwd: environment.cwd, async: true, clarify: false, context: "fresh", artifacts: true, output: false, progress: false, agentScope: "user", ...(params.model ? { model: params.model } : {}), }, 2_000); const pluginId = reply.data?.details?.runId ?? reply.data?.details?.asyncId; const pluginAsyncDir = reply.data?.details?.asyncDir; if (!reply.success || !pluginId || !pluginAsyncDir) { children.delete(handle); return activationLaunchFailure(`pi-subagents launch failed: ${reply.success ? "missing async lifecycle details" : rpcErrorMessage(reply)}`); } record.pluginId = pluginId; record.pluginAsyncDir = pluginAsyncDir; record.status = "running"; try { watchSubagentsRun(record); } catch (error: any) { await nicobailonRpc(pi, "stop", { id: pluginId }, 2_000).catch(() => undefined); children.delete(handle); return activationLaunchFailure(`pi-subagents launch failed: ${error.message}`); } return textResult(JSON.stringify({ handle, backend, status: record.status, run_id: pluginId, async_dir: pluginAsyncDir }, null, 2), { handle, backend, runId: pluginId, asyncDir: pluginAsyncDir }); } const agentDir = dependencies.getAgentDir(); const modelRegistry = ctx.modelRegistry; const authStorage = modelRegistry.authStorage; let model = ctx.model; if (params.model) { const separator = params.model.indexOf("/"); if (separator < 1) { children.delete(handle); return activationLaunchFailure("model must use provider/model-id form"); } model = modelRegistry.find(params.model.slice(0, separator), params.model.slice(separator + 1)); if (!model) { children.delete(handle); return activationLaunchFailure(`model is unavailable: ${params.model}`); } } if (!model) { children.delete(handle); return activationLaunchFailure("no Pi model is available for the child"); } let sessionManager: SessionManager; let session: AgentSession; try { const parentSession = ctx.sessionManager.getSessionFile(); sessionManager = params.kind === "session" ? dependencies.SessionManager.create(environment.cwd, undefined, { parentSession }) : dependencies.SessionManager.inMemory(environment.cwd, { parentSession }); sessionManager.appendSessionInfo(`dirtyloop:${params.description}`); const loader = new dependencies.DefaultResourceLoader({ cwd: environment.cwd, agentDir, noExtensions: true, noPromptTemplates: true, noThemes: true, systemPromptOverride: (base) => `${base ?? "You are a Pi coding agent."}\n\n\nYou are a ${params.kind} completing one bounded mission for a parent orchestrator. Work only in the supplied cwd. Preserve checkout ownership. Return compact evidence, changed files, validation, and blockers. Do not mutate Beads or advance the loop.\n`, }); await loader.reload(); const tools = mutation === "write" ? ["read", "bash", "edit", "write", "grep", "find", "ls"] : ["read", "grep", "find", "ls"]; ({ session } = await dependencies.createAgentSession({ cwd: environment.cwd, agentDir, authStorage, modelRegistry, model, thinkingLevel: (params.thinking ?? pi.getThinkingLevel()) as any, resourceLoader: loader, sessionManager, tools, })); } catch (error: any) { children.delete(handle); return activationLaunchFailure(error?.message ?? String(error)); } record.session = session; record.sessionId = sessionManager.getSessionId(); record.sessionFile = sessionManager.getSessionFile(); record.status = "running"; record.activityUnsubscribe = session.subscribe((event) => recoveryPolicy.observe(handle, event.type)); void session.prompt(params.mission).then(() => { record.result = finalAssistantText(session); if (record.cancelRequested) { record.status = "cancelled"; } else { record.status = record.result ? "completed" : "failed"; if (!record.result) record.error = session.state.errorMessage ?? "child returned no assistant result"; } notifyCompletion(record); session.dispose(); }).catch((error: any) => { record.status = record.cancelRequested ? "cancelled" : "failed"; if (!record.cancelRequested) record.error = error?.message ?? String(error); notifyCompletion(record); session.dispose(); }); return textResult(JSON.stringify({ handle, backend, status: record.status, session_id: record.sessionId, session_file: record.sessionFile, environment, }, null, 2), { handle, backend, sessionId: record.sessionId }); }, }); pi.on("session_shutdown", async () => { await shutdownAdapter(completionChannel, children); }); } export default function dirtyloopsPiAdapter(pi: ExtensionAPI) { return registerDirtyloopsPiAdapter(pi); }