@kylecheng3146/agent-ops 0.10.0 → 0.10.2

package/dist/packages/cli/src/run-entry.js

@@ -8,7 +8,7 @@ import { recordNativeRunAuthorization } from "../../../runtime/src/run/authoriza
 import { observeRunFailure } from "../../../runtime/src/run/verification.js";
 import { criteriaProgress, recordRunPhase } from "../../../runtime/src/run/phase.js";
 import { compareFailureObservations } from "../../../runtime/src/run/convergence.js";
-import { RunControlService } from "../../../runtime/src/run/controls.js";
+import { RunControlService, nativeResumeTime } from "../../../runtime/src/run/controls.js";
 import { beginPolicyTransition, markPolicyTransitionStage, completePolicyTransition, discoverPendingPolicyTransition } from "../../../runtime/src/run/policy-transition.js";
 import { readReviewReportArtifact } from "../../../runtime/src/review/attestation.js";
 import { execFile, spawn } from "node:child_process";
@@ -17,6 +17,7 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { setTimeout as delay } from "node:timers/promises";
 import { AgentOpsError, resolveContainedPath } from "../../../runtime/src/fs/paths.js";
+import { ensureRunPolicy } from "./context.js";
 import { bindRunPolicy, readRunPolicy, runRuntimeHash, validateRunPolicyChange } from "../../../runtime/src/run/policy.js";
 import { sha256 } from "../../../runtime/src/fs/hash.js";
 import { calculateConfigHash, canonicalJson } from "../../../runtime/src/config/hash.js";
@@ -27,7 +28,7 @@ import { RunSupervisor } from "../../../runtime/src/run/supervisor.js";
 import { NativeRunTransport, nativeProcessIdentity } from "../../../runtime/src/run/transport.js";
 import { workerPlan } from "../../../runtime/src/run/planning.js";
 import { RunScheduler } from "../../../runtime/src/run/scheduler.js";
-import { activeWallTimeMs } from "../../../runtime/src/run/scheduler.js";
+import { activeWallTimeMs, remainingRunTimeMs } from "../../../runtime/src/run/scheduler.js";
 import { readBootIdentity, readGuiLoginIdentity, LaunchdController } from "../../../runtime/src/run/macOS.js";
 import { readPrivateFile, writePrivateFile, withPrivateFileLock } from "../../../runtime/src/security/permissions.js";
 import { TaskService } from "../../../runtime/src/task/service.js";
@@ -42,6 +43,31 @@ const exec = promisify(execFile);
 const plain = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 const active = (worker) => ["assigned", "starting", "running", "idle", "handing-off"].includes(worker.status);
 const cli = fileURLToPath(new URL("./bin.js", import.meta.url));
+/** Release the sole native slot only after confirmed coordinator death. */
+export async function prepareSerialSchedule(repository, supervisor, runId) {
+    const current = await repository.read(runId);
+    if (current === null || current.jobs !== 1 || current.rootTaskId === null || current.status !== "active" || current.disableRestart || current.awaitingResume)
+        return null;
+    const children = current.tasks.filter(task => task.taskId !== current.rootTaskId);
+    const coordinator = current.workers.find(worker => worker.workerId === current.coordinatorId);
+    if (children.length === 0 || coordinator === undefined)
+        return null;
+    if (children.some(task => !["delivered", "complete", "blocked"].includes(task.status))) {
+        if (active(coordinator)) {
+            await supervisor.stopWorker(runId, coordinator.workerId, coordinator.generation, "handoff");
+            await repository.appendEvent(runId, { type: "diagnostic", code: "RUN_COORDINATOR_YIELDED", workerId: coordinator.workerId,
+                taskId: coordinator.taskId, detail: "Coordinator process death confirmed before assigning the sole slot to children." });
+        }
+        return null;
+    }
+    return coordinator.status === "stopped" && !current.workers.some(worker => worker.workerId !== coordinator.workerId && active(worker)) ? coordinator : null;
+}
+/** Retain the structured child failure instead of hiding it behind recovery text. */
+export function runStepError(result, fallback) {
+    const details = Array.isArray(result.errors) ? result.errors.filter(plain)
+        .map(error => typeof error.message === "string" ? error.message : "").filter(Boolean).join("; ") : "";
+    return new AgentOpsError(typeof result.code === "string" ? result.code : "RUN_INTEGRATION_RECOVERY_REQUIRED", `${fallback}${details.length === 0 ? "" : ": " + details.slice(0, 4096)}`);
+}
 /** Recheck after confirmed death and after verification, before publishing the frozen SHA. */
 export async function assertRunDeliverySnapshot(root, taskId, head, contract, tasks) {
     const runner = gitRunner(root);
@@ -104,6 +130,15 @@ export async function superviseNativeRun(root, runId) {
             await blockStartup("RUN_RESTART_STORM");
             return;
         }
+        let manualResumeAt;
+        await repository.mutate(runId, current => {
+            manualResumeAt = nativeResumeTime(current);
+            if (manualResumeAt === undefined)
+                return current;
+            // Consume the latest control durably; bounded event history is not a one-shot fence.
+            return { ...current, controls: current.controls.map((control, index) => index === current.controls.length - 1
+                    ? { ...control, appliedAt: new Date().toISOString() } : control) };
+        });
         await repository.appendEvent(runId, { type: "status", code: "RUN_SUPERVISOR_START", workerId: null, taskId: null, detail: null });
         let version;
         try {
@@ -171,7 +206,7 @@ export async function superviseNativeRun(root, runId) {
             await writePrivateFile(path, JSON.stringify(content, null, 2), worker.worktree);
             return "Read .agent-ops/tasks/run-instructions.json and carry its immutable original goal through the evidence loop. Submit a plan if rootTaskId is null; otherwise implement and repair the assigned task. A child requests handoff after local green; the coordinator waits for all child deliveries, then requests finalization. Never substitute native goal completion for agent-ops evidence.";
         }
-        async function start(worker, diagnostic) {
+        async function start(worker, diagnostic, resumeAt) {
             if (await discoverPendingPolicyTransition(repository, runId) !== null)
                 throw new AgentOpsError("RUN_POLICY_TRANSITION_PENDING", "Finish policy synchronization before acquiring a new writer generation.");
             if (worker.worktree === null)
@@ -195,7 +230,7 @@ export async function superviseNativeRun(root, runId) {
                 throw new AgentOpsError("RUN_WORKTREE_OWNERSHIP", "The worker checkout is not registered to this run.");
             await writeWorktreeRecord({ ...record, workerGeneration: worker.generation });
             const goal = await instructions(worker, diagnostic);
-            const running = await supervisor.startWorker(runId, worker.workerId, worker.generation, goal);
+            const running = await supervisor.startWorker(runId, worker.workerId, worker.generation, goal, resumeAt);
             await recordRunPhase(repository, runId, worker.workerId, (await repository.read(runId)).rootTaskId === null ? "planning" : "implementing");
             try {
                 await transport.activateRegistered(runId, running, goal);
@@ -206,14 +241,22 @@ export async function superviseNativeRun(root, runId) {
             }
         }
         async function schedule() {
+            const coordinator = await prepareSerialSchedule(repository, supervisor, runId);
+            if (coordinator !== null) {
+                await start(coordinator);
+                return;
+            }
             const current = (await repository.read(runId));
             for (const node of await scheduler.next(runId)) {
                 if (node.planDigest === undefined || node.taskId === current.rootTaskId)
                     continue;
                 const existing = current.workers.find(worker => worker.taskId === node.taskId);
                 if (existing !== undefined && existing.worktree !== null &&
-                    (await deps.tasks(existing.worktree).list()).some(r => r.task.id === node.taskId))
+                    (await deps.tasks(existing.worktree).list()).some(r => r.task.id === node.taskId)) {
+                    if (existing.status === "stopped")
+                        await start(existing);
                     continue;
+                }
                 const planPath = join(directory, runId, "plans", node.taskId + ".json");
                 const source = await readPrivateFile(planPath, commonDir);
                 if (source === null || sha256(source) !== node.planDigest)
@@ -291,12 +334,14 @@ export async function superviseNativeRun(root, runId) {
             if (absent)
                 return (await recoverRunIntegrationAfterCleanup(commonDir, runId, deps.git)).receiptPath;
             const result = await advance(saved);
-            if (result.status !== "ok" || !plain(result.data) || typeof result.data.receipt !== "string")
-                throw new AgentOpsError("RUN_INTEGRATION_RECOVERY_REQUIRED", "Recover the sealed transaction before allowing any writer to resume.");
+            if (result.status !== "ok")
+                throw runStepError(result, "Recover the sealed transaction before allowing any writer to resume");
+            if (!plain(result.data) || typeof result.data.receipt !== "string")
+                throw new AgentOpsError("RUN_INTEGRATION_RECOVERY_REQUIRED", "Recovery did not return the sealed receipt.");
             return result.data.receipt;
         }
         async function step(cwd, args, saved) {
-            const remaining = saved.budget.limitMs - activeWallTimeMs(saved.budget.activeIntervals, Date.now());
+            const remaining = remainingRunTimeMs(saved);
             if (remaining <= 0)
                 throw new AgentOpsError("RUN_BUDGET_EXHAUSTED", "No active time remains for final proof.");
             return await new Promise((resolve, reject) => {
@@ -327,7 +372,7 @@ export async function superviseNativeRun(root, runId) {
                             catch { }
                     }, 3000);
                 };
-                const timeout = setTimeout(terminate, remaining);
+                const timeout = Number.isFinite(remaining) ? setTimeout(terminate, remaining) : undefined;
                 const registration = (async () => {
                     const identity = child.pid === undefined ? null : await nativeProcessIdentity(child.pid);
                     if (identity === null || closed) {
@@ -637,11 +682,20 @@ export async function superviseNativeRun(root, runId) {
                 await synchronizePolicy();
             state = (await repository.read(runId));
             for (const worker of state.workers.filter(w => active(w) || w.status === "stopped")) {
+                if (state.jobs === 1 && state.rootTaskId !== null) {
+                    const pending = state.tasks.filter(task => task.taskId !== state.rootTaskId && !["delivered", "complete", "blocked"].includes(task.status));
+                    const node = pending.find(task => task.taskId === worker.taskId);
+                    if (pending.length > 0 && (worker.workerId === state.coordinatorId || node === undefined ||
+                        node.dependencies.some(id => !state.tasks.some(task => task.taskId === id && ["delivered", "complete"].includes(task.status)))))
+                        continue;
+                }
                 if (worker.workerId !== state.coordinatorId && (worker.worktree === null ||
                     !(await deps.tasks(worker.worktree).list()).some(r => r.task.id === worker.taskId)))
                     continue;
                 try {
-                    await start(worker);
+                    await start(worker, undefined, manualResumeAt);
+                    if (state.jobs === 1)
+                        break;
                 }
                 catch (cause) {
                     await repository.appendEvent(runId, { type: "diagnostic", code: cause instanceof AgentOpsError ? cause.code : "RUN_RECOVERY_FAILED",
@@ -677,8 +731,9 @@ export async function superviseNativeRun(root, runId) {
                     await stopAll(state.status === "budget-limited" ? "budget" : "stop");
                     return;
                 }
+                state = await ensureRunPolicy(repository, state);
                 const elapsed = activeWallTimeMs(state.budget.activeIntervals, Date.now());
-                if (elapsed >= state.budget.limitMs) {
+                if (state.budget.limitMs !== null && elapsed >= state.budget.limitMs) {
                     await repository.mutate(runId, current => ({ ...current, status: "budget-limited", disableRestart: true }));
                     await launchd.disableRestart(runDescriptor(state), "active run time budget exhausted");
                     await stopAll("budget");
@@ -688,7 +743,12 @@ export async function superviseNativeRun(root, runId) {
                         accumulatedMs: activeWallTimeMs(current.budget.activeIntervals, Date.now()), lastObservedAt: new Date().toISOString() } }));
                 await schedule();
                 state = (await repository.read(runId));
-                for (const worker of state.workers.filter(w => ["running", "idle"].includes(w.status))) {
+                for (const candidateWorker of state.workers.filter(w => ["running", "idle"].includes(w.status))) {
+                    const freshState = (await repository.read(runId));
+                    const currentWorker = freshState.workers.find(w => w.workerId === candidateWorker.workerId);
+                    if (currentWorker === undefined || !["running", "idle"].includes(currentWorker.status))
+                        continue;
+                    const worker = currentWorker;
                     await supervisor.heartbeat(runId, worker.workerId, worker.generation);
                     const observation = await supervisor.observeWorker(runId, worker.workerId, worker.generation);
                     if (!observation.processAlive) {
@@ -888,7 +948,7 @@ export async function superviseNativeRun(root, runId) {
                             await recordRunPhase(repository, runId, worker.workerId, "verifying");
                             const result = await advance(current);
                             if (result.status !== "ok")
-                                throw new AgentOpsError(result.code, "Final proof failed; inspect saved verifier and fresh review reports before repair.");
+                                throw runStepError(result, "Final proof failed; inspect saved verifier and fresh review reports before repair");
                             const data = result.data;
                             if (!plain(data) || typeof data.receipt !== "string")
                                 throw new AgentOpsError("RUN_RECEIPT_REQUIRED", "Finalization requires the receipt returned by the existing finish gate.");
@@ -904,9 +964,8 @@ export async function superviseNativeRun(root, runId) {
                         const stopped = latest.workers.find(w => w.workerId === worker.workerId);
                         if (request.action === "finalize" && latest.integration !== null && (latest.integration.status !== "prepared" ||
                             (await deps.git(root, ["rev-parse", latest.targetBranch + "^{commit}"])).stdout.trim() === latest.integration.candidate)) {
-                            const recovered = await recoverIntegration(latest);
-                            await acceptReceipt(latest, recovered);
-                            response = { requestId: request.requestId, code: "RUN_COMPLETE", receipt: recovered };
+                            // Preserve the failed step; a manual resume reconciles the sealed transaction after remediation.
+                            throw cause;
                         }
                         else if (request.action === "policy" && await discoverPendingPolicyTransition(repository, runId) !== null) {
                             await repository.appendEvent(runId, { type: "diagnostic", code: "RUN_POLICY_RECOVERY_REQUIRED", workerId: worker.workerId, taskId: worker.taskId,
@@ -936,7 +995,7 @@ export async function superviseNativeRun(root, runId) {
         }
         catch (cause) {
             await repository.appendEvent(runId, { type: "diagnostic", code: cause instanceof AgentOpsError ? cause.code : "RUN_SUPERVISOR_FAILED",
-                workerId: null, taskId: null, detail: "Supervisor stopped; worktree and proof artifacts are preserved." });
+                workerId: null, taskId: null, detail: cause instanceof AgentOpsError ? cause.message : "Supervisor stopped; worktree and proof artifacts are preserved." });
             try {
                 await stopAll("crash");
             }

package/dist/packages/cli/src/run-setup-entry.js

@@ -1,6 +1,6 @@
 import { FileRunRepository } from "../../../runtime/src/run/service.js";
 import { readRunPolicy, runRuntimeHash } from "../../../runtime/src/run/policy.js";
-import { activeWallTimeMs } from "../../../runtime/src/run/scheduler.js";
+import { remainingRunTimeMs } from "../../../runtime/src/run/scheduler.js";
 import { runVerificationCommand, NodeVerificationProcessRunner } from "../../../runtime/src/verify/spawn.js";
 import { redactSecrets } from "../../../runtime/src/security/redact.js";
 import { join } from "node:path";
@@ -21,7 +21,7 @@ const policy = await readRunPolicy(state, await runRuntimeHash());
 const step = /^(?:0|[1-9][0-9]*)$/u.test(index) ? policy?.config.worktree?.setup?.[Number(index)] : undefined;
 if (step === undefined)
     throw new Error("Setup must select an authorized fixed policy command.");
-const remaining = state.budget.limitMs - activeWallTimeMs(state.budget.activeIntervals, Date.now());
+const remaining = remainingRunTimeMs(state);
 if (remaining <= 0)
     throw new Error("Run budget is exhausted.");
 const result = await runVerificationCommand({ id: "run-setup", ...step, cwd: ".", required: true,

package/dist/runtime/src/install/harness.js

@@ -340,8 +340,11 @@ function autoRunInstruction(descriptor, context) {
         "`WORKTREE_NESTED`, say so in one line naming the code and fall back to",
         "the subtask flow (`task create --parent`, then batch or advance).",
         "`RUN_REPO_UNTRUSTED` means stop and ask the user; never work",
-        "around trust. If the run ends without completing (blocked, budget",
-        "exhausted, stopped, failing review), report the `agent-ops run status",
+        "around trust. New runs have no total time cap; legacy finite runs upgrade",
+        "only on manual resume, preserving accounting and independent blockers.",
+        "Command/review timeouts, provider limits and DEBUG budgets remain effective.",
+        "If the run ends without completing (blocked, stopped, failing review),",
+        "report the `agent-ops run status",
         "<id>` state and code, the last `agent-ops run logs <id>` events, and the",
         "exact `agent-ops run resume <id>` and `agent-ops run stop <id>` commands,",
         "then stop: never resume automatically or take over the run's work.",

package/dist/runtime/src/office/scene.js

@@ -122,7 +122,7 @@ export function sceneModel(snapshot) {
         return { key, sourceIndex: index, kind: "run", title: titled(repo, run.title), top: 0, props, actors, phaseAreas: makeAreas(), questions, criteria,
             activities: activitiesOf(optional(run).activities),
             board: boardFor(rootProgress, run.status, taskId, questions.length), papers, books: { lit: rootProgress?.passed ?? 0, total: rootProgress?.total ?? 0 },
-            clock: run.budget.limitMs > 0 ? run.budget.remainingMs / run.budget.limitMs : 0, phase: run.phase, status: run.status,
+            clock: run.budget.limitMs !== null && run.budget.remainingMs !== null && run.budget.limitMs > 0 ? run.budget.remainingMs / run.budget.limitMs : 1, phase: run.phase, status: run.status,
             completedAt, repo, overview: { x: 0, y: 0, width: 0, height: 0 } };
     };
     const activitiesOf = (value) => (Array.isArray(value) ? value : []).map(raw => {

package/dist/runtime/src/office/server.js

@@ -25,7 +25,7 @@ function send(res, status, type, body, headers = {}) {
 }
 /** Loopback-only, token-gated, GET-only view of the building. */
 export function createOfficeServer(options) {
-    const token = options.token ?? randomBytes(24).toString("base64url");
+    let token = options.token ?? randomBytes(24).toString("base64url");
     const now = options.now ?? Date.now;
     const idleMs = options.idleMs ?? OFFICE_IDLE_MS;
     let lastActive = now();
@@ -40,6 +40,8 @@ export function createOfficeServer(options) {
         const url = new URL(req.url ?? "/", `http://127.0.0.1:${port}`);
         if (!same(url.searchParams.get("token") ?? "", token))
             return send(res, 403, "text/plain", "Forbidden\n");
+        if (url.pathname === "/health")
+            return send(res, 200, "text/plain", "ok\n");
         if (url.pathname === "/") {
             const nonce = randomBytes(16).toString("base64");
             return send(res, 200, "text/html; charset=utf-8", officePage(nonce), { "Content-Security-Policy": `default-src 'none'; script-src 'nonce-${nonce}'; style-src 'nonce-${nonce}'; connect-src 'self'; base-uri 'none'; form-action 'none'` });
@@ -54,16 +56,25 @@ export function createOfficeServer(options) {
         else
             res.end(); });
     });
+    const bind = (candidate) => new Promise((resolve, reject) => {
+        const onError = (error) => { server.removeListener("listening", onListening); reject(error); };
+        const onListening = () => {
+            server.removeListener("error", onError);
+            const address = server.address();
+            port = typeof address === "object" && address !== null ? address.port : 0;
+            resolve(port);
+        };
+        server.once("error", onError);
+        server.once("listening", onListening);
+        server.listen(candidate, "127.0.0.1");
+    });
     return {
-        server, token,
-        listen: async () => await new Promise((resolve, reject) => {
-            server.once("error", reject);
-            server.listen(0, "127.0.0.1", () => {
-                const address = server.address();
-                port = typeof address === "object" && address !== null ? address.port : 0;
-                resolve(port);
-            });
-        }),
+        server,
+        get token() { return token; },
+        set token(value) { token = value; },
+        listen: async (preferredPort = 0) => preferredPort > 0
+            ? await bind(preferredPort).catch(async () => await bind(0))
+            : await bind(0),
         tick: async () => {
             const snapshot = await options.snapshot().catch(() => null);
             const sessionIsPresent = snapshot?.lobby.some(desk => (desk.sessionActive ?? desk.status === "active") && (desk.completedAt === undefined || desk.completedAt === null)) ?? false;
@@ -86,16 +97,29 @@ function alive(pid) {
         return error.code === "EPERM";
     }
 }
-/** A recorded server counts only if its process lives and it answers with its own token. */
-export async function readLiveOffice(home) {
+export async function readOfficeRecord(home) {
     const source = await readPrivateFile(officeRecordPath(home), home.anchor).catch(() => null);
     if (source === null)
         return null;
     try {
         const record = JSON.parse(source);
-        if (!Number.isSafeInteger(record.pid) || !Number.isSafeInteger(record.port) || typeof record.token !== "string" || !alive(record.pid))
-            return null;
-        const response = await fetch(`http://127.0.0.1:${record.port}/snapshot.json?token=${encodeURIComponent(record.token)}`, { signal: AbortSignal.timeout(2000) });
+        return Number.isSafeInteger(record.pid) && Number.isSafeInteger(record.port) &&
+            record.port > 0 && record.port <= 65535 &&
+            typeof record.token === "string" && record.token.length > 0
+            ? record
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** A recorded server counts only if its process lives and it answers with its own token. */
+export async function readLiveOffice(home) {
+    const record = await readOfficeRecord(home);
+    if (record === null || !alive(record.pid))
+        return null;
+    try {
+        const response = await fetch(`http://127.0.0.1:${record.port}/health?token=${encodeURIComponent(record.token)}`, { signal: AbortSignal.timeout(2000) });
         await response.body?.cancel();
         return response.status === 200 ? record : null;
     }
@@ -111,7 +135,10 @@ export async function claimOffice(home, office, pid = process.pid) {
     return await withPrivateFileLock(officeRecordPath(home), home.anchor, async () => {
         if (await readLiveOffice(home) !== null)
             return null;
-        const record = { pid, port: await office.listen(), token: office.token, startedAt: new Date().toISOString() };
+        const previous = await readOfficeRecord(home);
+        if (previous !== null)
+            office.token = previous.token;
+        const record = { pid, port: await office.listen(previous?.port), token: office.token, startedAt: new Date().toISOString() };
         await writePrivateFile(officeRecordPath(home), JSON.stringify(record) + "\n", home.anchor);
         return record;
     });

package/dist/runtime/src/office/snapshot.js

@@ -52,7 +52,7 @@ export function buildOfficeSnapshot(input) {
             ...(rootTaskId === null ? {} : { progress: rootTree?.progress ?? rootTask?.progress ?? null,
                 ...(rootTree?.criteria === undefined ? {} : { criteria: rootTree.criteria }) }),
             status: run.status, phase: run.phase ?? "unknown",
-            budget: { limitMs: run.budget.limitMs, usedMs, remainingMs: Math.max(0, run.budget.limitMs - usedMs) },
+            budget: { limitMs: run.budget.limitMs, usedMs, remainingMs: run.budget.limitMs === null ? null : Math.max(0, run.budget.limitMs - usedMs) },
             questions, agents, reviewers,
             ...(run.status === "complete" || run.status === "failed" ? { completedAt: run.updatedAt } : {}),
             commands: [`agent-ops run status ${run.runId}`, `agent-ops run logs ${run.runId}`,