@kylecheng3146/agent-ops 0.3.0 → 0.3.2

package/dist/runtime/src/review/execute.js

@@ -28,6 +28,17 @@ export const DEFAULT_REVIEW_TIMEOUT_MS = 900_000;
  * thinking hard is never cut off.
  */
 export const DEFAULT_STALL_IDLE_MS = 90_000;
+/**
+ * agy writes nothing to stdout, stderr or its log while one generation
+ * streams, so a long think is indistinguishable from a wedge. Its own logs
+ * show normal generations silent for up to ~177s; 90s cut real reviews off.
+ */
+export const AGY_STALL_IDLE_MS = 240_000;
+/**
+ * A call the service dropped before answering. It produced no verdict, so
+ * one fresh retry is not review shopping.
+ */
+const TRANSIENT_NETWORK = /\b(?:network issue|503|service is currently unavailable|ECONNRESET|ETIMEDOUT|socket hang up)\b/iu;
 /** Two rounds at the per-target default: the previous worst case, now bounded. */
 export const DEFAULT_REVIEW_CHAIN_TIMEOUT_MS = 2 * DEFAULT_REVIEW_TIMEOUT_MS;
 /**
@@ -425,7 +436,8 @@ async function attemptTarget(request, options) {
         }
         throwIfInterrupted(target, options);
         options.onProgress?.(`${target}: review started (timeout: ${Math.ceil((options.timeoutMs ?? DEFAULT_REVIEW_TIMEOUT_MS) / 1_000)}s)`);
-        const stallIdleMs = options.stallIdleMs ?? DEFAULT_STALL_IDLE_MS;
+        const stallIdleMs = options.stallIdleMs ??
+            (target === "agy" ? AGY_STALL_IDLE_MS : DEFAULT_STALL_IDLE_MS);
         const stallWatch = watchForStall(heartbeatLog, options.signal, stallIdleMs);
         let spawned;
         try {
@@ -481,8 +493,11 @@ async function attemptTarget(request, options) {
         }
         if (spawned.failureClass === "nonzero-exit") {
             const output = `${spawned.stderr}\n${spawned.stdout}`;
-            return skip(rejectedCallReason(output), firstComplaint(spawned.stderr, spawned.stdout) ??
-                `the call was rejected with exit ${spawned.exitCode ?? "unknown"} and no output`);
+            return {
+                ...skip(rejectedCallReason(output), firstComplaint(spawned.stderr, spawned.stdout) ??
+                    `the call was rejected with exit ${spawned.exitCode ?? "unknown"} and no output`),
+                ...(TRANSIENT_NETWORK.test(output) ? { transient: true } : {})
+            };
         }
         if (spawned.failureClass === "signal-exit") {
             return skip("capability-unavailable", `the reviewer exited after ${spawned.signal ?? "an unknown signal"}`);
@@ -522,6 +537,18 @@ async function attemptTarget(request, options) {
         await rm(attemptDirectory, { recursive: true, force: true });
     }
 }
+/**
+ * `attemptTarget`, retried once in a fresh session when the service dropped
+ * the call. Only once: a service that is down stays down.
+ */
+async function attemptTargetWithRetry(request, options) {
+    const first = await attemptTarget(request, options);
+    if (first.kind !== "skip" || first.transient !== true || budgetSpent(options)) {
+        return first;
+    }
+    options.onProgress?.(`${request.target}: ${first.diagnostic} → retrying once`);
+    return attemptTarget(request, options);
+}
 /** Builds the `execute` callback with one necessary and one adversarial review. */
 export function createReviewExecutor(options) {
     const report = options.onProgress ?? (() => { });
@@ -630,7 +657,7 @@ export function createReviewExecutor(options) {
             report("chain: review deadline reached before the first round");
             return { status: "NOT_RUN", reason: "timeout", attempts: [] };
         }
-        const primaryOutcome = await attemptTarget({
+        const primaryOutcome = await attemptTargetWithRetry({
             ...shared,
             target: primaryTarget,
             label: `${primaryTarget}-primary`,
@@ -739,7 +766,7 @@ export function createReviewExecutor(options) {
             };
         }
         // The second round draws on what is left, never a fresh full budget.
-        const adversarialOutcome = await attemptTarget({
+        const adversarialOutcome = await attemptTargetWithRetry({
             ...shared,
             target: adversarialTarget,
             label: `${adversarialTarget}-adversarial`,

package/dist/runtime/src/task/completion.js

@@ -38,7 +38,7 @@ export async function checkTaskCompletionEvidence(stored, options) {
             }
         }
     }
-    const attestation = await findReviewAttestation(root, sourceFingerprint);
+    const attestation = await findReviewAttestation(root, sourceFingerprint, stored.task.id);
     if (attestation === null || attestation.taskId !== stored.task.id) {
         return { status: "FAIL", code: "REVIEW_REQUIRED", remedy: `Run agent-ops review --task ${stored.task.id} --yes for the whole task and current source.` };
     }

package/dist/runtime/src/task/service.js

@@ -130,9 +130,17 @@ export class TaskService {
             state.tasks.push(record);
             if (input.sessionId !== undefined) {
                 const currentIndex = state.sessions.findIndex(({ sessionId }) => sessionId === input.sessionId);
+                // A subtask keeps the session on the top of its tree: the completion
+                // gate checks the attached task and everything under it, so attaching
+                // the subtask would let a Stop through with its parent unfinished.
+                let rootId = record.task.id;
+                for (let parentId = record.task.parentTaskId; parentId !== undefined;) {
+                    rootId = parentId;
+                    parentId = state.tasks.find(({ task }) => task.id === parentId)?.task.parentTaskId;
+                }
                 const attachment = {
                     sessionId: input.sessionId,
-                    taskId: record.task.id,
+                    taskId: rootId,
                     attachedAt: now
                 };
                 if (currentIndex === -1) {
@@ -304,7 +312,12 @@ export class TaskService {
      * task accepts evidence: a completed record must stay exactly as it was
      * verified.
      */
-    async recordEvidence(taskId, evidenceInput) {
+    async recordEvidence(taskId, evidenceInput, 
+    /**
+     * A PASS review's base: set records it, null clears it (the review covered
+     * uncommitted work), undefined leaves the record's value alone.
+     */
+    reviewBase) {
         const now = assertTimestamp(this.#now());
         return await this.#store.mutate((state) => {
             const current = findTask(state, taskId);
@@ -328,10 +341,13 @@ export class TaskService {
                     ...new Set([...(evidence[criterionId] ?? []), ...references])
                 ];
             }
+            const { reviewBase: previousBase, ...rest } = current;
+            const base = reviewBase === undefined ? previousBase : reviewBase ?? undefined;
             const updated = {
-                ...current,
+                ...rest,
                 evidence,
-                updatedAt: now
+                updatedAt: now,
+                ...(base === undefined ? {} : { reviewBase: base })
             };
             replaceTask(state, updated);
             return cloneRecord(updated);

package/dist/runtime/src/task/store.js

@@ -66,7 +66,7 @@ function parseTaskRecord(value) {
     ];
     // Every record written before an optional field existed must still parse, so
     // the accepted shapes are every combination of them.
-    const optionalKeys = ["completionBase", "failureFingerprint", "policyConfigHash"];
+    const optionalKeys = ["completionBase", "failureFingerprint", "policyConfigHash", "reviewBase"];
     const allowedKeys = new Set(Array.from({ length: 1 << optionalKeys.length }, (_unused, mask) => [
         ...baseKeys,
         ...optionalKeys.filter((_key, position) => (mask & (1 << position)) !== 0)
@@ -146,6 +146,10 @@ function parseTaskRecord(value) {
         (typeof completionBase !== "string" || !/^[a-f0-9]{40,64}$/u.test(completionBase))) {
         return invalidState("Task state contains an invalid completion base.");
     }
+    if (value.reviewBase !== undefined &&
+        (typeof value.reviewBase !== "string" || !/^[a-f0-9]{40,64}$/u.test(value.reviewBase))) {
+        return invalidState("Task state contains an invalid review base.");
+    }
     return {
         task: task.value,
         status,
@@ -156,7 +160,8 @@ function parseTaskRecord(value) {
         archivedAt: value.archivedAt,
         failureFingerprint,
         policyConfigHash,
-        completionBase
+        completionBase,
+        ...(value.reviewBase === undefined ? {} : { reviewBase: value.reviewBase })
     };
 }
 function parseSession(value) {

package/docs/en/guides/configuration.md

@@ -152,6 +152,17 @@ evidence. Give each editing conversation its own worktree instead:
   On Claude Code a direct Edit or Write of the main checkout outside
   `.worktrees/` is denied (run `agent-ops update` once so the PreToolUse hook
   matches the file tools). Absent or `"off"` keeps today's single checkout.
+- `agent-ops task create` run from the main checkout with a known session
+  creates that session's worktree first (or reuses it) and records the task
+  there, so the work starts in the worktree. Its output names the path to
+  enter and the `--base` to verify against.
+- As a fallback on Claude Code, the first denied edit creates that worktree:
+  `.worktrees/session-<first eight characters of the session id>`, setup
+  included, bound to the session. The denial names the path to enter with
+  EnterWorktree; a later denial for the same session reuses it. If creation
+  fails, the denial says why and falls back to the manual `worktree add`.
+  Run `agent-ops update` once so the PreToolUse hook gets the 600-second
+  timeout setup needs.
 - `add` creates `.worktrees/<name>` on branch `agent-ops/<name>` from the main
   checkout's HEAD and excludes `/.worktrees/` through `.git/info/exclude`,
   never `.gitignore`. It copies the ignored files agent-ops installed and any
@@ -166,10 +177,20 @@ evidence. Give each editing conversation its own worktree instead:
 - The session's completion gate follows it: Claude Code enters the worktree
   with EnterWorktree, and a host that cannot move a session (agy) is judged by
   the worktree's gate through a redirect the main checkout records.
+- In a worktree, verify and review each task but do not run `task complete`
+  (Claude Code refuses it inside an isolated worktree session). `agent-ops
+  worktree finish <name>` completes every non-archived task in the worktree,
+  subtasks before their parents, each against the base its PASS review
+  recorded (the worktree's base when none was recorded), before any rebase.
+  If one cannot complete, nothing merges and the error names the task.
+  Creating a subtask keeps the session attached to the top of its tree, and
+  each task keeps its own review record, so a parent and a subtask reviewed
+  on the same source do not overwrite each other.
 - `agent-ops worktree finish <name>` merges by fast-forward only, one finish
   at a time. If the target moved, it rebases; a clean rebase whose own patch
   is unchanged is re-verified before merging, and a conflict is reported with
-  the `refs/notes/agent-ops` intent of the work that landed first.
+  the `refs/notes/agent-ops` intent of the work that landed first. The note
+  records every task of the worktree, subtasks indented under their parent.
 - `worktree list`, `resume <name> --session <id>` and `remove <name>` manage
   what is left; `remove --force` discards work and asks the user first.
   `doctor` reports worktrees idle for more than seven days.

package/docs/zh-TW/guides/configuration.md

@@ -136,6 +136,14 @@ fingerprint，因此兩個對話修改同一個 checkout 會互相作廢對方
   Write 修改主 checkout 中 `.worktrees/` 以外的檔案會被拒絕（需先執行一次
   `agent-ops update`，讓 PreToolUse hook 比對檔案工具）。未設定或 `"off"` 則維持
   目前的單一 checkout。
+- 在主 checkout、已知 session 的情況下執行 `agent-ops task create`，會先建立（或重用）
+  該 session 的 worktree，並把 task 記錄在那裡，讓工作一開始就在 worktree 內。輸出會列出
+  要進入的路徑與 verify 用的 `--base`。
+- 作為 Claude Code 上的後備，第一次被拒絕的編輯會自動建立該 worktree：
+  `.worktrees/session-<session id 前八個字元>`，包含 setup，並綁定該 session。
+  拒絕訊息會列出要以 EnterWorktree 進入的路徑；同一 session 之後被拒絕時會重用它。
+  建立失敗時，拒絕訊息會說明原因並退回手動 `worktree add`。需先執行一次
+  `agent-ops update`，讓 PreToolUse hook 取得 setup 所需的 600 秒逾時。
 - `add` 從主 checkout 的 HEAD 建立 `.worktrees/<name>` 與 branch
   `agent-ops/<name>`，並透過 `.git/info/exclude`（而非 `.gitignore`）排除
   `/.worktrees/`。它會複製 agent-ops 安裝的 ignored 檔案，以及根目錄
@@ -148,10 +156,17 @@ fingerprint，因此兩個對話修改同一個 checkout 會互相作廢對方
 - Session 的 completion gate 會跟著它：Claude Code 以 EnterWorktree 進入
   worktree；無法移動 session 的 host（agy）則透過主 checkout 記錄的 redirect，
   由 worktree 的 gate 判定。
+- 在 worktree 裡對每個 task 執行 verify 與 review，但不要執行 `task complete`
+  （Claude Code 在隔離的 worktree session 中會拒絕它）。`agent-ops worktree finish
+  <name>` 會在任何 rebase 之前 complete worktree 內每個未封存的 task，先 subtask
+  後 parent，各自使用其 PASS review 記錄的 base（沒有記錄時使用 worktree 的 base）。
+  任一 task 無法完成時不會合併，錯誤訊息會指出是哪個 task。建立 subtask 時 session
+  維持附著在 task 樹最上層，且每個 task 各自保留 review 紀錄，所以在同一份原始碼上
+  review 的 parent 與 subtask 不會互相覆蓋。
 - `agent-ops worktree finish <name>` 只以 fast-forward 合併，一次只執行一個
   finish。Target 若已前進會先 rebase；沒有衝突且自身 patch 不變的 rebase 會先
   重新驗證再合併；衝突則連同先合併那份工作在 `refs/notes/agent-ops` 的意圖一起
-  回報。
+  回報。Note 會記錄 worktree 的每個 task，subtask 縮排在其 parent 之下。
 - `worktree list`、`resume <name> --session <id>` 與 `remove <name>` 管理剩下的
   worktree；`remove --force` 會丟棄工作，執行前會先詢問使用者。`doctor` 會回報
   閒置超過七天的 worktree。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kylecheng3146/agent-ops",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Evidence-driven development loops for agy, Codex, Claude Code, and opencode",
   "type": "module",
   "license": "MIT",