pi-amq 0.1.1

package/dist/extension/worker-runtime.js

@@ -0,0 +1,974 @@
+import { spawn as spawnChild } from "node:child_process";
+import { createHash } from "node:crypto";
+import { access, readFile } from "node:fs/promises";
+import { constants } from "node:fs";
+import { delimiter, isAbsolute, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { openLaunchPreview, } from "../integration/launch-preview.js";
+import { WorkerCompletionNotifier, } from "../integration/worker-completion-notifier.js";
+import { limited, UNLIMITED } from "../workflow/budget.js";
+import { describeCurrentPiSessionFork } from "../workflow/pi-session-fork.js";
+import { ensureRunArtifactDirectory, withRunArtifactContext, } from "../workflow/run-artifacts.js";
+import { confirmCleanupDeletion, WorkflowRunCleanup, } from "../workflow/run-cleanup.js";
+import { effectiveWorkerContract, WorkflowRunStore, } from "../workflow/run-store.js";
+import { SystemProcessIdentityInspector } from "../workflow/system-process-inspector.js";
+import { WorkflowDoctor } from "../workflow/workflow-doctor.js";
+import { reportMatchesSchema } from "../workflow/worker-gate.js";
+import { buildWorkerModelGuidance, floorAuditorModel, selectWorkerModel, } from "../workflow/worker-model-catalog.js";
+import { buildWorkerPrompt } from "../workflow/worker-prompt-capsule.js";
+import { WorkerRolePresetCatalog, workerRoleContract, } from "../workflow/worker-role-presets.js";
+import { LaunchPreviewCoordinator, loadConfirmSpawnsPolicy, } from "../workflow/spawn-confirmation.js";
+import { projectWorkerLifecycle } from "../workflow/lifecycle-projection.js";
+import { NodePiProcessFactory, WorkerProcessSupervisor, } from "../workflow/worker-process-supervisor.js";
+import { WorkflowLeaseManager } from "../workflow/workflow-lease.js";
+import { defaultPiStateDirectory, workflowNamespaceDirectory, workflowWorkspaceId, } from "../workflow/workspace-paths.js";
+const DRIVER_DOCTRINE = [
+    "## Supervised Workers (pi-amq)",
+    "You are the driver: delegate bounded evidence-producing work, retain final synthesis and acceptance authority, and collect before concluding.",
+    "Use spawn_worker/list_workers/collect/cancel/steer/revise_contract only. A collected candidate is not done until every declared Gate fact passes.",
+    "Stall facts are observations only; never infer permission to nudge, retry, or cancel.",
+].join("\n");
+const CAPABILITY_TOOLS = {
+    "repo.read": ["read", "grep", "find", "ls"],
+    "repo.write": ["read", "grep", "find", "ls", "write", "edit"],
+    shell: ["bash"],
+    message_worker: ["message_worker"],
+};
+export class PiWorkerRuntime {
+    #publishFleet;
+    #unlimitedDeclaration;
+    #publishLifecycle;
+    #publishNotice;
+    #launchPreview = new LaunchPreviewCoordinator();
+    #previewAuditFloors = new Map();
+    #lifecycleStates = new Map();
+    #cwd;
+    #store;
+    #supervisor;
+    #cleanup;
+    #doctor;
+    #artifactDirectory;
+    #requestKey;
+    #error;
+    #guidance = DRIVER_DOCTRINE;
+    #runtimes = new Map();
+    constructor(publishFleet = () => { }, unlimitedDeclaration = () => undefined, publishLifecycle = async () => { }, publishNotice = () => { }) {
+        this.#publishFleet = publishFleet;
+        this.#unlimitedDeclaration = unlimitedDeclaration;
+        this.#publishLifecycle = publishLifecycle;
+        this.#publishNotice = publishNotice;
+    }
+    async start(ctx) {
+        await this.refreshGuidance(ctx);
+        const existing = this.#runtimes.get(ctx.cwd);
+        if (existing) {
+            this.#cwd = ctx.cwd;
+            this.#store = existing.store;
+            this.#supervisor = existing.supervisor;
+            this.#cleanup = existing.cleanup;
+            this.#doctor = existing.doctor;
+            this.#artifactDirectory = existing.artifactDirectory;
+            this.#requestKey = existing.requestKey;
+            existing.supervisor.updateLaunchAuthority(await launchAuthority(ctx));
+            this.#publish(await requiredRun(existing.store, existing.requestKey));
+            void this.#publishWithConversation(await requiredRun(existing.store, existing.requestKey));
+            return;
+        }
+        try {
+            const runBudget = await confirmedRunBudget(ctx, this.#unlimitedDeclaration());
+            const authority = await launchAuthority(ctx);
+            const namespaceDirectory = workflowNamespaceDirectory(defaultPiStateDirectory(), ctx.cwd);
+            const inspector = new SystemProcessIdentityInspector();
+            const leaseManager = new WorkflowLeaseManager({
+                namespaceDirectory,
+                workspaceId: workflowWorkspaceId(ctx.cwd),
+                inspector,
+            });
+            const acquired = await leaseManager.acquireSupervisor();
+            if (acquired.kind !== "acquired") {
+                throw new Error(acquired.kind === "held"
+                    ? `worker supervisor is held by PID ${acquired.owner.pid}`
+                    : acquired.diagnostic);
+            }
+            const store = new WorkflowRunStore({
+                namespaceDirectory,
+                leaseManager,
+                supervisorGeneration: acquired.owner.generation,
+            });
+            const sessionIdentity = ctx.sessionManager.getSessionFile() ?? `process:${process.pid}`;
+            const requestKey = `pi-session:${hash(`${ctx.cwd}\0${sessionIdentity}`)}`;
+            await store.startRun({
+                requestKey,
+                source: {
+                    kind: "interactive",
+                    amqMessageId: null,
+                    driverSessionId: sessionIdentity,
+                },
+                objective: {
+                    schema: 1,
+                    goal: "Supervise bounded workers for the current pi session",
+                    acceptance: ["Every accepted worker outcome passes its declared Gate facts"],
+                    constraints: ["Workers stay within explicit capability and workspace grants"],
+                    permissions: Object.keys(CAPABILITY_TOOLS),
+                    budget: runBudget,
+                },
+            });
+            const artifactDirectory = await ensureRunArtifactDirectory(namespaceDirectory, requestKey);
+            const supervisor = new WorkerProcessSupervisor({
+                namespaceDirectory,
+                store,
+                leaseManager,
+                supervisorGeneration: acquired.owner.generation,
+                inspector,
+                processFactory: new NodePiProcessFactory(),
+                launchAuthority: authority,
+            });
+            const cleanup = new WorkflowRunCleanup({
+                namespaceDirectory,
+                store,
+                leaseManager,
+                supervisorGeneration: acquired.owner.generation,
+            });
+            const doctor = new WorkflowDoctor({
+                namespaceDirectory,
+                runs: store,
+                leases: leaseManager,
+                inspector,
+            });
+            const initial = await requiredRun(store, requestKey);
+            this.#baselineLifecycle(initial);
+            const notifier = new WorkerCompletionNotifier({ publish: this.#publishNotice });
+            notifier.baseline(initial);
+            const unsubscribeStore = store.subscribe((projection) => {
+                this.#publish(projection);
+                void this.#publishWithConversation(projection);
+                void this.#publishLifecycleChanges(projection).catch(() => { });
+                notifier.observe(projection);
+            });
+            const unsubscribe = () => {
+                unsubscribeStore();
+                notifier.dispose();
+            };
+            const reconciled = await supervisor.reconcileRun(requestKey);
+            this.#cwd = ctx.cwd;
+            this.#store = store;
+            this.#supervisor = supervisor;
+            this.#cleanup = cleanup;
+            this.#doctor = doctor;
+            this.#artifactDirectory = artifactDirectory;
+            this.#requestKey = requestKey;
+            this.#runtimes.set(ctx.cwd, {
+                store,
+                supervisor,
+                cleanup,
+                doctor,
+                artifactDirectory,
+                requestKey,
+                unsubscribe,
+            });
+            this.#error = undefined;
+            this.#publish(reconciled);
+        }
+        catch (error) {
+            this.#error = toError(error).message;
+            this.#store = undefined;
+            this.#supervisor = undefined;
+            this.#cleanup = undefined;
+            this.#doctor = undefined;
+            this.#artifactDirectory = undefined;
+            this.#requestKey = undefined;
+        }
+    }
+    async shutdown() {
+        // Workers own a parent-liveness descriptor. Session changes do not imply cancellation,
+        // so the runtime intentionally retains the supervisor instead of inventing a stop policy.
+    }
+    async refreshGuidance(ctx) {
+        try {
+            const current = currentLiveModel(ctx);
+            if (!current) {
+                this.#guidance = DRIVER_DOCTRINE;
+                return;
+            }
+            const guidance = await buildWorkerModelGuidance({
+                available: availableLiveModels(ctx),
+                current,
+                globalNotesPath: join(defaultPiStateDirectory(), "pi-amq", "model-notes.md"),
+                projectNotesPath: join(ctx.cwd, ".pi", "pi-amq", "model-notes.md"),
+                projectTrusted: ctx.isProjectTrusted(),
+            });
+            this.#guidance = `${DRIVER_DOCTRINE}\n\n${guidance.text}${guidance.notices.length > 0 ? `\n${guidance.notices.join("\n")}` : ""}`;
+            if (this.#cwd === ctx.cwd) {
+                this.#supervisor?.updateLaunchAuthority(await launchAuthority(ctx));
+            }
+        }
+        catch (error) {
+            this.#guidance = `${DRIVER_DOCTRINE}\n\nWorker catalog unavailable: ${toError(error).message}`;
+        }
+    }
+    appendGuidance(systemPrompt) {
+        return `${systemPrompt}\n\n${this.#guidance}`;
+    }
+    async spawn(params, signal, ctx) {
+        const runtime = this.#required();
+        await this.refreshGuidance(ctx);
+        const roles = await WorkerRolePresetCatalog.load({
+            projectDirectory: ctx.cwd,
+            projectTrusted: ctx.isProjectTrusted(),
+        });
+        const requestedRole = params.role ?? "worker";
+        const preset = roles.resolve(requestedRole);
+        let auditFloor;
+        if (requestedRole.trim().toLowerCase() === "auditor" && !params.audits_worker_id) {
+            throw new Error("An auditor must name audits_worker_id");
+        }
+        if (params.audits_worker_id) {
+            const run = await requiredRun(runtime.store, runtime.requestKey);
+            const audited = effectiveWorkerContract(requiredWorker(run, params.audits_worker_id)).model;
+            auditFloor = availableLiveModels(ctx).find((model) => model.provider === audited.provider && model.id === audited.id);
+            if (!auditFloor)
+                throw new Error("Audited implementer model is not in the live catalog");
+        }
+        const request = withRunArtifactContext(this.#workerRequest(params, ctx, auditFloor, preset), runtime.artifactDirectory);
+        const policy = await loadConfirmSpawnsPolicy({
+            projectDirectory: ctx.cwd,
+            projectTrusted: ctx.isProjectTrusted(),
+        });
+        if (auditFloor)
+            this.#previewAuditFloors.set(request.requestKey, auditFloor);
+        try {
+            const gated = await this.#launchPreview.submit({
+                groupKey: `${ctx.cwd}\0${ctx.sessionManager.getSessionId()}`,
+                policy,
+                tui: ctx.mode === "tui" && ctx.hasUI,
+                request,
+                ...(signal ? { signal } : {}),
+                preview: async (requests) => openLaunchPreview(ctx, this.#launchPreviewOptions(requests, roles, ctx)),
+                launch: async (accepted) => {
+                    const result = await runtime.supervisor.spawnWorker(runtime.requestKey, {
+                        request: accepted,
+                        prompt: buildWorkerPrompt(accepted),
+                        depth: 1,
+                        ...(params.continue_worker_id === undefined
+                            ? {}
+                            : { continueWorkerId: params.continue_worker_id }),
+                    });
+                    const current = await requiredRun(runtime.store, runtime.requestKey);
+                    this.#publish(current);
+                    if (result.kind === "started") {
+                        void result.settlement.then((projection) => this.#publish(projection)).catch(() => { });
+                    }
+                    return {
+                        kind: result.kind,
+                        worker: projectWorkerForTools(result.worker),
+                        attempt: result.attempt,
+                    };
+                },
+            });
+            return gated.kind === "cancelled"
+                ? gated
+                : gated.value;
+        }
+        finally {
+            this.#previewAuditFloors.delete(request.requestKey);
+        }
+    }
+    async list(params, _ctx) {
+        const runtime = this.#required();
+        let run = await runtime.store.readRun(runtime.requestKey);
+        if (!run)
+            throw new Error("Current worker run is missing");
+        for (const worker of Object.values(run.workers)) {
+            if (isTerminal(worker.state) || worker.stall.silent.detected)
+                continue;
+            try {
+                run = await runtime.store.recordSilentStall(runtime.requestKey, { workerId: worker.workerId });
+            }
+            catch {
+                // Silence has not crossed its budget-derived cadence.
+            }
+        }
+        this.#publish(run);
+        return Object.values(run.workers).slice(0, params.limit ?? 50).map(projectWorkerForTools);
+    }
+    async collect(params, signal, ctx) {
+        const runtime = this.#required();
+        const collected = [];
+        for (const rawWorkerId of params.worker_ids) {
+            if (signal?.aborted)
+                throw signal.reason ?? new Error("collect aborted");
+            const workerId = rawWorkerId;
+            let run = await requiredRun(runtime.store, runtime.requestKey);
+            let worker = requiredWorker(run, workerId);
+            const contract = effectiveWorkerContract(worker);
+            const candidate = worker.attempts.at(-1)?.candidateOutcome.valueOrRef ?? null;
+            const report = params.structured_reports?.[workerId] ?? parseJsonCandidate(candidate);
+            if (report !== undefined) {
+                run = await runtime.store.recordCollectObservation(runtime.requestKey, {
+                    workerId,
+                    structuredPayload: report,
+                    consecutiveRounds: 3,
+                });
+                worker = requiredWorker(run, workerId);
+            }
+            const reportMatches = contract.report_schema
+                ? reportMatchesSchema(contract.report_schema, report)
+                : null;
+            const acceptanceCheckExitCode = contract.acceptance_check
+                ? await runAcceptanceCheck(contract, signal)
+                : null;
+            const humanApproved = contract.requires_human_approval === true
+                ? await requestHumanApproval(ctx, worker)
+                : null;
+            run = await runtime.store.recordGateEvaluation(runtime.requestKey, {
+                workerId,
+                reportMatches,
+                acceptanceCheckExitCode,
+                humanApproved,
+                evidenceExists: report !== undefined || candidate !== null,
+            });
+            collected.push(projectWorkerForTools(requiredWorker(run, workerId)));
+            this.#publish(run);
+        }
+        return collected;
+    }
+    async cancel(params, _signal, _ctx) {
+        const runtime = this.#required();
+        const result = await runtime.supervisor.cancelWorker(runtime.requestKey, {
+            workerId: params.worker_id,
+            reason: params.reason,
+        });
+        this.#publish(result.projection);
+        return result;
+    }
+    async steer(params, _signal, _ctx) {
+        const runtime = this.#required();
+        const projection = await runtime.supervisor.steerWorker(runtime.requestKey, {
+            workerId: params.worker_id,
+            message: params.message,
+            ...(params.correlation === undefined ? {} : { correlation: params.correlation }),
+        });
+        this.#publish(projection);
+        return projectWorkerForTools(requiredWorker(projection, params.worker_id));
+    }
+    async reviseContract(params, _signal, _ctx) {
+        const runtime = this.#required();
+        const projection = await runtime.supervisor.reviseWorkerContract(runtime.requestKey, {
+            workerId: params.worker_id,
+            ...(params.correlation === undefined ? {} : { correlation: params.correlation }),
+            ...(params.goal === undefined ? {} : { goal: params.goal }),
+            ...(params.acceptance === undefined ? {} : { acceptance: params.acceptance }),
+            ...(params.constraints === undefined ? {} : { constraints: params.constraints }),
+            ...(params.report_schema === undefined ? {} : { report_schema: params.report_schema }),
+            ...(params.requires_human_approval === undefined
+                ? {}
+                : { requires_human_approval: params.requires_human_approval }),
+            ...(params.acceptance_check === undefined
+                ? {}
+                : { acceptance_check: params.acceptance_check }),
+        });
+        this.#publish(projection);
+        return projectWorkerForTools(requiredWorker(projection, params.worker_id));
+    }
+    async cleanupRuns(params, _signal, ctx) {
+        const runtime = this.#required();
+        const dryRun = params.dry_run !== false;
+        if (dryRun)
+            return runtime.cleanup.plan(params.older_than_ms);
+        const confirmed = await confirmCleanupDeletion({
+            dryRun,
+            yes: params.yes === true,
+            tui: ctx.mode === "tui" && ctx.hasUI,
+            ...(ctx.mode === "tui" && ctx.hasUI ? {
+                confirm: () => ctx.ui.confirm("Delete old pi-amq workflow runs?", "This permanently removes the listed terminal runs, worker session files, and artifacts."),
+            } : {}),
+        });
+        return runtime.cleanup.execute({ olderThanMs: params.older_than_ms, confirmed });
+    }
+    async doctorWorkflow(_signal, _ctx) {
+        return this.#required().doctor.inspect();
+    }
+    async canReplaceSession() {
+        if (!this.#store || !this.#requestKey)
+            return true;
+        try {
+            const run = await requiredRun(this.#store, this.#requestKey);
+            return canReplaceWorkerRun(run);
+        }
+        catch {
+            return false;
+        }
+    }
+    async steerFromFleet(workerId, generation, message) {
+        const runtime = this.#required();
+        const run = await requiredRun(runtime.store, runtime.requestKey);
+        const worker = requiredWorker(run, workerId);
+        const attempt = worker.attempts.at(-1);
+        if (!attempt || attempt.workerAttemptGeneration !== generation) {
+            throw new Error("Fleet steer refused: worker generation is stale");
+        }
+        if (effectiveWorkerContract(worker).channel !== "rpc") {
+            throw new Error("one-shot worker, cannot steer");
+        }
+        await runtime.supervisor.steerWorker(runtime.requestKey, {
+            workerId: worker.workerId,
+            message,
+        });
+    }
+    async cancelFromFleet(workerId, generation) {
+        const runtime = this.#required();
+        const run = await requiredRun(runtime.store, runtime.requestKey);
+        const worker = requiredWorker(run, workerId);
+        const attempt = worker.attempts.at(-1);
+        if (!attempt || attempt.workerAttemptGeneration !== generation) {
+            throw new Error("Fleet cancel refused: worker generation is stale");
+        }
+        await runtime.supervisor.cancelWorker(runtime.requestKey, {
+            workerId: worker.workerId,
+            reason: "operator requested stop from FleetView",
+        });
+    }
+    #workerRequest(params, ctx, auditFloor, preset) {
+        if (params.context === "fork" && params.continue_worker_id !== undefined) {
+            throw new TypeError("context=fork and continue_worker_id are mutually exclusive");
+        }
+        const current = currentLiveModel(ctx);
+        if (!current)
+            throw new Error("Current pi model is unavailable");
+        const available = availableLiveModels(ctx);
+        const scoped = scopedLiveModels(ctx);
+        const difficulty = params.difficulty ?? preset.difficulty;
+        let selected = params.model
+            ? available.find((model) => model.provider === params.model?.provider && model.id === params.model.id)
+            : selectWorkerModel({
+                difficulty,
+                available,
+                scoped,
+                current,
+            }).model;
+        if (!selected)
+            throw new Error(`Requested model is not in the live catalog`);
+        if (auditFloor && preset.name === "reviewer")
+            selected = floorAuditorModel(selected, auditFloor);
+        const thinkingLevel = params.model?.thinking_level
+            ?? selected.thinkingLevel
+            ?? (selected.provider === current.provider && selected.id === current.id
+                ? ctx.thinkingLevel
+                : undefined)
+            ?? (selected.reasoning ? "medium" : "off");
+        const modelFallbacks = (params.fallback_models ?? []).map((fallback) => {
+            const live = available.find((model) => model.provider === fallback.provider && model.id === fallback.id);
+            if (!live)
+                throw new Error(`Fallback model is not in the live catalog: ${fallback.provider}/${fallback.id}`);
+            return {
+                provider: live.provider,
+                id: live.id,
+                thinkingLevel: fallback.thinking_level
+                    ?? live.thinkingLevel
+                    ?? (live.reasoning ? "medium" : "off"),
+            };
+        });
+        const modelKeys = [
+            `${selected.provider}/${selected.id}`,
+            ...modelFallbacks.map((model) => `${model.provider}/${model.id}`),
+        ];
+        if (new Set(modelKeys).size !== modelKeys.length) {
+            throw new TypeError("Primary and fallback model chain entries must be unique");
+        }
+        const context = params.context ?? "fresh";
+        const forkSource = context === "fork"
+            ? describeCurrentPiSessionFork(ctx.sessionManager)
+            : undefined;
+        return {
+            schema: 1,
+            requestKey: params.request_key,
+            difficulty,
+            role: workerRoleContract(preset),
+            context,
+            ...(forkSource ? { forkSource } : {}),
+            goal: params.goal,
+            acceptance: params.acceptance,
+            constraints: params.constraints,
+            budget: {
+                maxAttempts: params.budget.max_attempts,
+                maxWallClockMs: params.budget.max_wall_clock_ms,
+                maxTokens: params.budget.max_tokens,
+                maxCostUsd: params.budget.max_cost_usd,
+                maxOutputBytes: params.budget.max_output_bytes,
+            },
+            model: { provider: selected.provider, id: selected.id, thinkingLevel },
+            ...(modelFallbacks.length > 0 ? { modelFallbacks } : {}),
+            capabilities: params.capabilities ?? preset.capabilities,
+            workspace: {
+                path: params.workspace.path,
+                mode: params.workspace.mode,
+                ...(params.workspace.worktree_path === undefined
+                    ? {}
+                    : { worktreePath: params.workspace.worktree_path }),
+            },
+            contextRefs: params.context_refs,
+            channel: params.channel,
+            sideEffectPolicy: params.side_effect_policy,
+            ...(params.report_schema === undefined ? {} : { report_schema: params.report_schema }),
+            ...(params.requires_human_approval === undefined
+                ? {}
+                : { requires_human_approval: params.requires_human_approval }),
+            ...(params.acceptance_check === undefined
+                ? {}
+                : { acceptance_check: params.acceptance_check }),
+        };
+    }
+    #launchPreviewOptions(requests, roles, ctx) {
+        const current = currentLiveModel(ctx);
+        if (!current)
+            throw new Error("Current pi model is unavailable");
+        const available = availableLiveModels(ctx);
+        const scoped = scopedLiveModels(ctx);
+        const defaultFor = (difficulty) => toModelSpec(selectWorkerModel({ difficulty, available, scoped, current }).model, ctx);
+        const normalizeModel = (requestKey, roleName, model) => {
+            const auditFloor = this.#previewAuditFloors.get(requestKey);
+            if (roleName !== "reviewer" || !auditFloor)
+                return model;
+            const selected = available.find((candidate) => candidate.provider === model.provider && candidate.id === model.id);
+            if (!selected)
+                throw new Error("Preview model is not in the live catalog");
+            return toModelSpec(floorAuditorModel(selected, auditFloor), ctx);
+        };
+        return {
+            requests,
+            roles: roles.presets().map((role) => ({
+                preset: role,
+                defaultModel: defaultFor(role.difficulty),
+            })),
+            models: available.map((model) => toModelSpec(model, ctx)),
+            difficultyModels: {
+                easy: defaultFor("easy"),
+                medium: defaultFor("medium"),
+                hard: defaultFor("hard"),
+            },
+            normalizeModel,
+        };
+    }
+    #required() {
+        if (!this.#store || !this.#supervisor || !this.#cleanup || !this.#doctor
+            || !this.#artifactDirectory || !this.#requestKey) {
+            throw new Error(`worker runtime is unavailable${this.#error ? `: ${this.#error}` : ""}`);
+        }
+        return {
+            store: this.#store,
+            supervisor: this.#supervisor,
+            cleanup: this.#cleanup,
+            doctor: this.#doctor,
+            artifactDirectory: this.#artifactDirectory,
+            requestKey: this.#requestKey,
+        };
+    }
+    #publish(run) {
+        this.#publishFleet(projectFleetRecords(run));
+    }
+    async #publishWithConversation(run) {
+        const records = await Promise.all(Object.values(run.workers).map(async (worker) => {
+            const attempt = worker.attempts.at(-1);
+            const contract = effectiveWorkerContract(worker);
+            const selectedModel = attempt?.modelSelection?.model ?? contract.model;
+            const tierDegraded = worker.attempts.some((candidate) => candidate.modelSelection?.fallbackReason);
+            const activeWait = worker.waits.filter((wait) => wait.status === "waiting").at(-1);
+            const conversation = attempt?.session.file
+                ? await readConversationTail(attempt.session.file)
+                : [];
+            return {
+                id: worker.workerId,
+                handle: worker.workerId,
+                role: "worker",
+                model: `${selectedModel.provider}/${selectedModel.id}`,
+                state: fleetState(worker.state),
+                spend: attempt?.usage.costUsd ?? null,
+                lastActivity: worker.lastLedgerAt,
+                mode: contract.channel === "rpc" ? "rpc" : "json",
+                ...(attempt ? { generation: attempt.workerAttemptGeneration } : {}),
+                conversation: conversation.length > 0 ? conversation : [
+                    `attempt_state=${attempt?.state ?? "none"}`,
+                    `tier_degraded=${tierDegraded}`,
+                    `peer.pending=${worker.peerMessages.filter((message) => message.status === "pending").length}`,
+                    `wait.reason=${activeWait?.reason ?? "none"}`,
+                    `wait.correlation=${activeWait?.correlation ?? "none"}`,
+                    `control=${attempt?.control.status ?? "none"}`,
+                    `gate.blockers=${worker.gate.blockers.join(",") || "none"}`,
+                ],
+            };
+        }));
+        if (this.#requestKey === run.requestKey)
+            this.#publishFleet(records);
+    }
+    #baselineLifecycle(run) {
+        for (const worker of Object.values(run.workers)) {
+            this.#lifecycleStates.set(`${run.requestKey}\0${worker.workerId}`, worker.state);
+        }
+    }
+    async #publishLifecycleChanges(run) {
+        for (const worker of Object.values(run.workers)) {
+            const key = `${run.requestKey}\0${worker.workerId}`;
+            if (this.#lifecycleStates.get(key) === worker.state)
+                continue;
+            this.#lifecycleStates.set(key, worker.state);
+            await this.#publishLifecycle(projectWorkerLifecycle(worker.workerId, worker.state)).catch(() => { });
+        }
+    }
+}
+export function projectFleetRecords(run) {
+    return Object.values(run.workers).map((worker) => {
+        const attempt = worker.attempts.at(-1);
+        const contract = effectiveWorkerContract(worker);
+        const selectedModel = attempt?.modelSelection?.model ?? contract.model;
+        const tierDegraded = worker.attempts.some((candidate) => candidate.modelSelection?.fallbackReason);
+        const activeWait = worker.waits.filter((wait) => wait.status === "waiting").at(-1);
+        return {
+            id: worker.workerId,
+            handle: worker.workerId,
+            role: "worker",
+            model: `${selectedModel.provider}/${selectedModel.id}`,
+            state: fleetState(worker.state),
+            spend: attempt?.usage.costUsd ?? null,
+            lastActivity: worker.lastLedgerAt,
+            mode: contract.channel === "rpc" ? "rpc" : "json",
+            ...(attempt ? { generation: attempt.workerAttemptGeneration } : {}),
+            conversation: [
+                `attempt_state=${attempt?.state ?? "none"}`,
+                `tier_degraded=${tierDegraded}`,
+                `peer.pending=${worker.peerMessages.filter((message) => message.status === "pending").length}`,
+                `wait.reason=${activeWait?.reason ?? "none"}`,
+                `wait.correlation=${activeWait?.correlation ?? "none"}`,
+                `stall.silent=${worker.stall.silent.detected}`,
+                `stall.no_progress=${worker.stall.noProgress.detected}`,
+                `gate.blockers=${worker.gate.blockers.join(",") || "none"}`,
+            ],
+        };
+    });
+}
+export function canReplaceWorkerRun(run) {
+    if (run.state === "ambiguous" || run.state === "needs-attention")
+        return false;
+    return Object.values(run.workers).every((worker) => {
+        const attempt = worker.attempts.at(-1);
+        if (!attempt)
+            return true;
+        if (attempt.control.status === "detached" || attempt.sideEffects.status === "uncertain") {
+            return false;
+        }
+        return isTerminal(worker.state);
+    });
+}
+async function readConversationTail(path) {
+    try {
+        const raw = await readFile(path, "utf8");
+        const bounded = raw.slice(-128 * 1024);
+        const lines = [];
+        for (const line of bounded.split("\n").filter(Boolean).slice(-80)) {
+            try {
+                const value = JSON.parse(line);
+                const message = value["message"];
+                if (typeof message !== "object" || message === null)
+                    continue;
+                const role = message["role"];
+                const content = message["content"];
+                const text = typeof content === "string"
+                    ? content
+                    : Array.isArray(content)
+                        ? content.flatMap((part) => typeof part === "object" && part !== null
+                            && typeof part["text"] === "string"
+                            ? [part["text"]]
+                            : []).join(" ")
+                        : "";
+                if (text)
+                    lines.push(`${typeof role === "string" ? role : "message"}: ${text.slice(0, 2_000)}`);
+            }
+            catch {
+                // Session tails may begin in the middle of a JSONL line.
+            }
+        }
+        return lines.slice(-24);
+    }
+    catch {
+        return [];
+    }
+}
+const RUN_BUDGET_DIMENSIONS = [
+    "workers", "concurrency", "depth", "attempts", "wall-clock", "tokens", "cost", "output",
+];
+export function parseUnlimitedBudgetDimensions(value) {
+    if (value === undefined || value === false || value === "")
+        return [];
+    if (typeof value !== "string")
+        throw new TypeError("--worker-unlimited must be a comma-separated string");
+    const requested = value.split(",").map((item) => item.trim()).filter(Boolean);
+    if (requested.includes("all")) {
+        if (requested.length !== 1)
+            throw new TypeError("--worker-unlimited=all cannot be combined with dimensions");
+        return RUN_BUDGET_DIMENSIONS;
+    }
+    const allowed = new Set(RUN_BUDGET_DIMENSIONS);
+    for (const dimension of requested) {
+        if (!allowed.has(dimension))
+            throw new TypeError(`Unknown unlimited budget dimension: ${dimension}`);
+    }
+    return [...new Set(requested)];
+}
+export async function confirmedRunBudget(ctx, declaration) {
+    const unlimited = parseUnlimitedBudgetDimensions(declaration);
+    if (unlimited.length > 0) {
+        if (ctx.mode !== "tui" || !ctx.hasUI) {
+            throw new Error("Unlimited worker budgets require explicit TUI confirmation before run creation");
+        }
+        const confirmed = await ctx.ui.confirm("Confirm unlimited worker budget", `Unlimited dimensions: ${unlimited.join(", ")}. Worker contracts must re-declare each dimension.`);
+        if (!confirmed)
+            throw new Error("Unlimited worker budget was not confirmed; no run was created");
+    }
+    const selected = new Set(unlimited);
+    const limit = (dimension, value) => selected.has(dimension) ? UNLIMITED : limited(value);
+    return {
+        maxWorkers: limit("workers", 8),
+        maxConcurrency: limit("concurrency", 4),
+        maxDepth: limit("depth", 3),
+        maxAttempts: limit("attempts", 16),
+        maxWallClockMs: limit("wall-clock", 3_600_000),
+        maxTokens: limit("tokens", 500_000),
+        maxCostUsd: limit("cost", 50),
+        maxOutputBytes: limit("output", 67_108_864),
+    };
+}
+async function launchAuthority(ctx) {
+    const models = availablePiModels(ctx);
+    return {
+        piExecutable: await resolvePiExecutable(),
+        childExtensionPath: await resolveChildExtensionPath(),
+        grantedCapabilities: Object.keys(CAPABILITY_TOOLS),
+        capabilityTools: CAPABILITY_TOOLS,
+        availableModels: models.map((model) => {
+            const defaultLevel = defaultThinkingLevel(model, ctx);
+            const thinkingLevels = supportedThinkingLevels(model, defaultLevel);
+            return {
+                provider: model.provider,
+                id: model.id,
+                thinkingLevels,
+                defaultThinkingLevel: defaultLevel,
+            };
+        }),
+        projectTrust: ctx.isProjectTrusted() ? "trusted" : "untrusted",
+        requiresProjectResources: true,
+        inheritedEnvironment: process.env,
+    };
+}
+async function resolvePiExecutable() {
+    const configured = process.env.PI_AMQ_PI_EXECUTABLE;
+    if (configured !== undefined) {
+        if (!isAbsolute(configured))
+            throw new Error("PI_AMQ_PI_EXECUTABLE must be absolute");
+        await access(configured, constants.X_OK);
+        return configured;
+    }
+    const argvExecutable = process.argv[1];
+    if (argvExecutable && isAbsolute(argvExecutable)) {
+        try {
+            await access(argvExecutable, constants.X_OK);
+            return argvExecutable;
+        }
+        catch { }
+    }
+    for (const directory of (process.env.PATH ?? "").split(delimiter)) {
+        if (!directory)
+            continue;
+        const candidate = join(directory, "pi");
+        try {
+            await access(candidate, constants.X_OK);
+            return candidate;
+        }
+        catch { }
+    }
+    throw new Error("pi executable was not found; set PI_AMQ_PI_EXECUTABLE");
+}
+async function resolveChildExtensionPath() {
+    const candidates = [
+        fileURLToPath(new URL("../workflow/worker-child-extension.js", import.meta.url)),
+        fileURLToPath(new URL("../workflow/worker-child-extension.ts", import.meta.url)),
+    ];
+    for (const candidate of candidates) {
+        try {
+            await access(candidate, constants.R_OK);
+            return candidate;
+        }
+        catch { }
+    }
+    throw new Error("worker child extension is missing from the package");
+}
+function availablePiModels(ctx) {
+    return ctx.modelRegistry.getAvailable();
+}
+function availableLiveModels(ctx) {
+    return availablePiModels(ctx).map((model) => toLiveModel(model));
+}
+function scopedLiveModels(ctx) {
+    return ctx.scopedModels.map((scoped) => ({
+        ...toLiveModel(scoped.model),
+        ...(scoped.thinkingLevel === undefined ? {} : { thinkingLevel: scoped.thinkingLevel }),
+    }));
+}
+function currentLiveModel(ctx) {
+    return ctx.model ? {
+        ...toLiveModel(ctx.model),
+        ...(ctx.thinkingLevel === undefined ? {} : { thinkingLevel: ctx.thinkingLevel }),
+    } : undefined;
+}
+function toLiveModel(model) {
+    return {
+        provider: model.provider,
+        id: model.id,
+        name: model.name,
+        cost: model.cost.input + model.cost.output,
+        contextWindow: model.contextWindow,
+        maxTokens: model.maxTokens,
+        reasoning: model.reasoning,
+    };
+}
+function supportedThinkingLevels(model, defaultLevel) {
+    const levels = ["off", "minimal", "low", "medium", "high", "xhigh"]
+        .filter((level) => model.thinkingLevelMap?.[level] !== null);
+    return levels.includes(defaultLevel) ? levels : [...levels, defaultLevel];
+}
+function defaultThinkingLevel(model, ctx) {
+    if (ctx.model?.provider === model.provider && ctx.model.id === model.id && ctx.thinkingLevel) {
+        return ctx.thinkingLevel;
+    }
+    const scoped = ctx.scopedModels.find((candidate) => candidate.model.provider === model.provider && candidate.model.id === model.id);
+    return scoped?.thinkingLevel ?? (model.reasoning ? "medium" : "off");
+}
+function toModelSpec(model, ctx) {
+    const catalogModel = availablePiModels(ctx).find((candidate) => candidate.provider === model.provider && candidate.id === model.id);
+    if (!catalogModel)
+        throw new Error("Preview model is not in the live catalog");
+    return {
+        provider: model.provider,
+        id: model.id,
+        thinkingLevel: model.thinkingLevel ?? defaultThinkingLevel(catalogModel, ctx),
+    };
+}
+async function runAcceptanceCheck(contract, signal) {
+    const check = contract.acceptance_check;
+    if (!check)
+        return null;
+    if (signal?.aborted)
+        throw signal.reason ?? new Error("acceptance check aborted");
+    return new Promise((resolve, reject) => {
+        const child = spawnChild(check.command, [...check.args], {
+            cwd: contract.workspace.worktreePath ?? contract.workspace.path,
+            shell: false,
+            stdio: "ignore",
+        });
+        const onAbort = () => { child.kill("SIGTERM"); };
+        signal?.addEventListener("abort", onAbort, { once: true });
+        child.once("error", (error) => {
+            signal?.removeEventListener("abort", onAbort);
+            reject(error);
+        });
+        child.once("exit", (code) => {
+            signal?.removeEventListener("abort", onAbort);
+            resolve(code);
+        });
+    });
+}
+async function requestHumanApproval(ctx, worker) {
+    if (ctx.mode !== "tui" || !ctx.hasUI)
+        return null;
+    return ctx.ui.confirm("Accept worker outcome?", `${worker.workerId}: ${effectiveWorkerContract(worker).goal}`);
+}
+export function projectWorkerForTools(worker) {
+    const attempt = worker.attempts.at(-1);
+    const contract = effectiveWorkerContract(worker);
+    return {
+        worker_id: worker.workerId,
+        role: contract.role ? {
+            name: contract.role.name,
+            tier: contract.role.tier,
+            preset_source: contract.role.presetSource,
+        } : null,
+        proposal: contract.proposal ?? null,
+        context: contract.context,
+        fork_source: contract.forkSource ?? null,
+        attempted_models: worker.attempts.map((candidate) => ({
+            model: candidate.modelSelection?.model ?? candidate.launchContract?.model ?? contract.model,
+            fallback_reason: candidate.modelSelection?.fallbackReason ?? null,
+        })),
+        tier_degraded: worker.attempts.some((candidate) => candidate.modelSelection?.fallbackReason),
+        peer_messages: worker.peerMessages,
+        waits: worker.waits,
+        continuation: worker.continuation,
+        context_refs: contract.contextRefs,
+        state: worker.state,
+        attempt: attempt ? {
+            attempt_id: attempt.attemptId,
+            state: attempt.state,
+            candidate: attempt.candidateOutcome,
+            usage: attempt.usage,
+            side_effects: attempt.sideEffects,
+        } : null,
+        gate: worker.gate,
+        stall: worker.stall,
+        contract_revisions: worker.contractRevisions.map((revision) => ({
+            revision_id: revision.revisionId,
+            revision: revision.revision,
+            status: revision.status,
+            correlation: revision.correlation,
+            requested_at: revision.requestedAt,
+            delivered_at: revision.deliveredAt,
+        })),
+    };
+}
+function requiredWorker(run, workerId) {
+    const worker = run.workers[workerId];
+    if (!worker)
+        throw new Error(`Unknown worker ${workerId}`);
+    return worker;
+}
+async function requiredRun(store, requestKey) {
+    const run = await store.readRun(requestKey);
+    if (!run)
+        throw new Error(`Unknown run ${requestKey}`);
+    return run;
+}
+function parseJsonCandidate(candidate) {
+    if (candidate === null)
+        return undefined;
+    try {
+        return JSON.parse(candidate);
+    }
+    catch {
+        return undefined;
+    }
+}
+function isTerminal(state) {
+    return state === "done" || state === "failed" || state === "cancelled";
+}
+function fleetState(state) {
+    switch (state) {
+        case "pending":
+            return "idle";
+        case "running":
+            return "busy";
+        case "blocked":
+            return "paused";
+        case "ambiguous":
+            return "ambiguous";
+        case "done":
+        case "failed":
+        case "cancelled":
+            return "offline";
+        default:
+            return "ambiguous";
+    }
+}
+function hash(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error(String(error));
+}
+//# sourceMappingURL=worker-runtime.js.map