@kylecheng3146/agent-ops 0.1.21 → 0.1.22

package/dist/packages/cli/src/args.js

@@ -348,7 +348,9 @@ export function parseArgs(argv) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--check-auth may be used only with doctor.");
     }
     if (reviewTargets.length > 0 && command !== "init") {
-        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--review-target may be used only with init.");
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", command === "review"
+            ? "--review-target configures init; for one review run, use --harness <target>."
+            : "--review-target may be used only with init.");
     }
     if (completionGate !== undefined && command !== "init") {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "--completion-gate may be used only with init.");
@@ -412,7 +414,9 @@ export function parseArgs(argv) {
         (criteria.length > 0 || evidence.length > 0)) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Review criteria and evidence require --task.");
     }
-    if (command === "review" && harness !== undefined && harness.length !== 1) {
+    if (command === "review" &&
+        harness !== undefined &&
+        (harness.length !== 1 || !REVIEW_TARGETS.has(harness[0] ?? ""))) {
         invalidValue("--harness", harness.join(","));
     }
     if (command === "allow-stop" &&

package/dist/packages/cli/src/bin.js

@@ -29,9 +29,9 @@ import { formatInstallPlan, runInitCommand } from "./commands/init.js";
 import { formatUninstallPlan, runUninstallCommand } from "./commands/uninstall.js";
 import { runTaskCommand } from "./commands/task.js";
 import { runReviewCommand } from "./commands/review.js";
-import { createReviewExecutor } from "../../../runtime/src/review/execute.js";
+import { createReviewExecutor, ReviewInterruptedError } from "../../../runtime/src/review/execute.js";
 import { probeReviewTarget } from "../../../runtime/src/review/probe.js";
-import { resolveReviewRole } from "../../../runtime/src/review/roles.js";
+import { detectHostTarget, orderChain, resolveReviewRole } from "../../../runtime/src/review/roles.js";
 import { runTrustCommand } from "./commands/trust.js";
 import { runVerifyCommand } from "./commands/verify.js";
 import { runAllowStopCommand } from "./commands/allow-stop.js";
@@ -383,42 +383,69 @@ else {
                     const reviewSessionId = process.env.AGENT_OPS_SESSION_ID;
                     const reviewConfig = (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config;
                     const reviewRole = resolveReviewRole("independent-review", reviewConfig.reviewRoles ?? []);
-                    return await runReviewCommand({
-                        args,
-                        authorized: args.yes,
-                        tasks: taskService,
-                        ...(args.taskId === undefined ? {} : { taskId: args.taskId }),
-                        ...(reviewSessionId === undefined
-                            ? {}
-                            : { sessionId: reviewSessionId }),
-                        ...(reviewConfig.reviewRoles === undefined
-                            ? {}
-                            : { roles: reviewConfig.reviewRoles }),
-                        root,
-                        gitRunner: gitRunner(root),
-                        policyConfigHash: calculateConfigHash(reviewConfig),
-                        currentPolicyConfigHash: async () => calculateConfigHash((await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config),
-                        config: reviewConfig,
-                        evidenceStore: new FileEvidenceStore(root, root),
-                        execute: createReviewExecutor({
-                            targets: reviewRole?.targets ?? [],
-                            cwd: root,
-                            ...(reviewRole?.model === undefined
-                                ? {}
-                                : { model: reviewRole.model }),
-                            ...(reviewRole?.effort === undefined
+                    const selectedReviewTarget = args.harness?.[0];
+                    const plannedReviewTargets = orderChain(selectedReviewTarget === undefined
+                        ? reviewRole?.targets ?? []
+                        : [selectedReviewTarget], detectHostTarget(process.env));
+                    const controller = new AbortController();
+                    let interruptedBy;
+                    const interrupt = (signal) => {
+                        interruptedBy ??= signal;
+                        controller.abort(signal);
+                    };
+                    const onSigint = () => interrupt("SIGINT");
+                    const onSigterm = () => interrupt("SIGTERM");
+                    process.once("SIGINT", onSigint);
+                    process.once("SIGTERM", onSigterm);
+                    try {
+                        return await runReviewCommand({
+                            args,
+                            authorized: args.yes,
+                            tasks: taskService,
+                            ...(args.taskId === undefined ? {} : { taskId: args.taskId }),
+                            ...(reviewSessionId === undefined
                                 ? {}
-                                : { effort: reviewRole.effort }),
-                            ...(reviewRole?.timeoutMs === undefined
+                                : { sessionId: reviewSessionId }),
+                            ...(reviewConfig.reviewRoles === undefined
                                 ? {}
-                                : { timeoutMs: reviewRole.timeoutMs }),
-                            onProgress: (line) => {
-                                if (!args.json) {
+                                : { roles: reviewConfig.reviewRoles }),
+                            targets: plannedReviewTargets,
+                            root,
+                            gitRunner: gitRunner(root),
+                            policyConfigHash: calculateConfigHash(reviewConfig),
+                            currentPolicyConfigHash: async () => calculateConfigHash((await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config),
+                            config: reviewConfig,
+                            evidenceStore: new FileEvidenceStore(root, root),
+                            execute: createReviewExecutor({
+                                targets: plannedReviewTargets,
+                                cwd: root,
+                                ...(reviewRole?.model === undefined
+                                    ? {}
+                                    : { model: reviewRole.model }),
+                                ...(reviewRole?.effort === undefined
+                                    ? {}
+                                    : { effort: reviewRole.effort }),
+                                ...(reviewRole?.timeoutMs === undefined
+                                    ? {}
+                                    : { timeoutMs: reviewRole.timeoutMs }),
+                                signal: controller.signal,
+                                onProgress: (line) => {
                                     process.stderr.write(`${line}\n`);
                                 }
-                            }
-                        })
-                    });
+                            })
+                        });
+                    }
+                    catch (error) {
+                        if (error instanceof ReviewInterruptedError &&
+                            interruptedBy !== undefined) {
+                            process.exit(interruptedBy === "SIGINT" ? 130 : 143);
+                        }
+                        throw error;
+                    }
+                    finally {
+                        process.removeListener("SIGINT", onSigint);
+                        process.removeListener("SIGTERM", onSigterm);
+                    }
                 }
                 if (args.command === "config") {
                     return explainConfigCommand(await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project"));

package/dist/packages/cli/src/cli.js

@@ -32,7 +32,7 @@ Commands:
 
 Options:
   --scope <project|user>
-  --harness <all|both|agy|claude|codex|opencode|comma-separated>  Init/update/uninstall
+  --harness <all|both|agy|claude|codex|opencode|comma-separated>  Init/update/uninstall; review accepts one configured target
   --hook-target <harness=surface-id>  Repeatable advanced init/update option
   --profile <core|advisory|guardrails|loop>  Repeatable
   --review-target <codex|agy|claude>  Repeatable init option; external review

package/dist/packages/cli/src/commands/review.js

@@ -213,6 +213,9 @@ function sourceChangedResult(result) {
         model: result.model,
         effort: result.effort,
         prompt: result.prompt,
+        ...(result.plannedTargets === undefined
+            ? {}
+            : { plannedTargets: result.plannedTargets }),
         ...(result.scope === undefined ? {} : { scope: result.scope }),
         ...(result.independence === undefined
             ? {}
@@ -229,7 +232,22 @@ function sourceChangedResult(result) {
 export async function runReviewCommand(options) {
     const role = resolveReviewRole(options.role ?? "independent-review", options.roles ?? []);
     const selectedHarness = harness(options.args.harness);
-    const target = role?.targets[0] ?? selectedHarness ?? "codex";
+    const configuredTargets = role?.targets ?? [];
+    if (selectedHarness !== undefined &&
+        !configuredTargets.includes(selectedHarness)) {
+        throw new AgentOpsError("REVIEW_TARGET_NOT_CONFIGURED", `${selectedHarness} is not enabled for independent-review. Configure it with init --review-target ${selectedHarness}.`);
+    }
+    const plannedTargets = selectedHarness === undefined
+        ? options.targets ?? configuredTargets
+        : [selectedHarness];
+    const target = plannedTargets[0] ?? selectedHarness ?? "codex";
+    const resultBase = {
+        harness: target,
+        plannedTargets,
+        model: role?.model ?? options.model ?? "configured",
+        effort: role?.effort ?? options.effort ?? "configured",
+        prompt: ""
+    };
     const context = await taskContext(options);
     const evidenceRequirements = (options.args.evidence ?? []).map((value) => {
         const separator = value.indexOf("=");
@@ -253,24 +271,18 @@ export async function runReviewCommand(options) {
             const reason = scopeReason(error);
             if (reason !== undefined) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN",
-                    reason,
-                    harness: target,
-                    model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured",
-                    prompt: ""
+                    reason
                 });
             }
             throw error;
         }
         if (scope.changedFiles.some(isReviewerPolicyPath)) {
             return notRunEnvelope({
+                ...resultBase,
                 status: "NOT_RUN",
                 reason: "reviewer-policy-changed",
-                harness: target,
-                model: role?.model ?? options.model ?? "configured",
-                effort: role?.effort ?? options.effort ?? "configured",
-                prompt: "",
                 scope
             });
         }
@@ -278,16 +290,16 @@ export async function runReviewCommand(options) {
         if (context !== undefined && options.policyConfigHash !== undefined) {
             if (context.policyConfigHash === null) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN", reason: "reviewer-policy-baseline-missing",
-                    harness: target, model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured", prompt: "", scope
+                    scope
                 });
             }
             if (context.policyConfigHash !== options.policyConfigHash) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN", reason: "reviewer-policy-changed",
-                    harness: target, model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured", prompt: "", scope
+                    scope
                 });
             }
         }
@@ -295,9 +307,9 @@ export async function runReviewCommand(options) {
             const preflight = await preflightReview(options, context, sourceFingerprint);
             if (!preflight.ok) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN", reason: preflight.reason,
-                    harness: target, model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured", prompt: "", scope
+                    scope
                 });
             }
             verification = preflight.summary;
@@ -324,12 +336,9 @@ export async function runReviewCommand(options) {
                     : undefined;
             if (reason !== undefined) {
                 return notRunEnvelope({
+                    ...resultBase,
                     status: "NOT_RUN",
-                    reason,
-                    harness: target,
-                    model: role?.model ?? options.model ?? "configured",
-                    effort: role?.effort ?? options.effort ?? "configured",
-                    prompt: ""
+                    reason
                 });
             }
         }
@@ -338,6 +347,7 @@ export async function runReviewCommand(options) {
     const result = await runIndependentReview({
         invocation: {
             harness: target,
+            plannedTargets,
             model: role?.model ?? options.model ?? "configured",
             effort: role?.effort ?? options.effort ?? "configured",
             packet,

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

@@ -15,6 +15,14 @@ import { buildAdversarialPrompt, buildReviewPrompt } from "./runner.js";
  * review while looking like an unavailable target.
  */
 export const DEFAULT_REVIEW_TIMEOUT_MS = 900_000;
+export class ReviewInterruptedError extends Error {
+    signal;
+    constructor(signal) {
+        super("Independent review was interrupted.");
+        this.name = "ReviewInterruptedError";
+        this.signal = signal;
+    }
+}
 // USER is load-bearing, not cosmetic: a credential store keyed by account name
 // — the macOS keychain claude reads — cannot be opened without it, and its
 // absence surfaces as "Not logged in" on an install that is logged in.
@@ -81,8 +89,7 @@ const REQUIRED_HELP_FLAGS = {
  */
 const ADVANCING = new Set([
     "missing-executable",
-    "spawn-failed",
-    "timeout"
+    "spawn-failed"
 ]);
 const DIAGNOSTIC_MAX_CHARS = 200;
 /**
@@ -114,6 +121,16 @@ function rejectedCallReason(output) {
     }
     return "capability-unavailable";
 }
+function throwIfInterrupted(target, options, failureClass) {
+    if (failureClass !== "aborted" && options.signal?.aborted !== true) {
+        return;
+    }
+    const signal = typeof options.signal?.reason === "string"
+        ? options.signal.reason
+        : undefined;
+    options.onProgress?.(`${target}: review interrupted${signal === undefined ? "" : ` by ${signal}`}`);
+    throw new ReviewInterruptedError(signal);
+}
 async function snapshotRepository(request, destination, options) {
     const cloned = await runVerificationCommand({
         id: `review-snapshot-${request.label}`,
@@ -125,8 +142,10 @@ async function snapshotRepository(request, destination, options) {
         timeoutMs: Math.min(options.timeoutMs ?? DEFAULT_REVIEW_TIMEOUT_MS, 60_000)
     }, {
         cwd: dirname(destination),
-        ...(options.runner === undefined ? {} : { runner: options.runner })
+        ...(options.runner === undefined ? {} : { runner: options.runner }),
+        ...(options.signal === undefined ? {} : { signal: options.signal })
     });
+    throwIfInterrupted(request.target, options, cloned.failureClass);
     if (cloned.status !== "PASS") {
         return firstComplaint(cloned.stderr, cloned.stdout) ??
             `git clone failed (${cloned.failureClass})`;
@@ -184,6 +203,8 @@ async function attemptTarget(request, options) {
             return skip("capability-unavailable", "no read-only mode is available for this target", "skipping");
         }
         const environment = isolatedReviewEnvironment(target, attemptDirectory, options.env ?? process.env);
+        throwIfInterrupted(target, options);
+        options.onProgress?.(`${target}: checking reviewer capability`);
         const capability = await runVerificationCommand({
             id: `review-capability-${request.label}`,
             command: invocation.command,
@@ -196,8 +217,10 @@ async function attemptTarget(request, options) {
             cwd: attemptDirectory,
             ...(options.runner === undefined ? {} : { runner: options.runner }),
             env: environment,
-            replaceEnv: true
+            replaceEnv: true,
+            ...(options.signal === undefined ? {} : { signal: options.signal })
         });
+        throwIfInterrupted(target, options, capability.failureClass);
         const help = `${capability.stdout}\n${capability.stderr}`;
         const missingFlags = (REQUIRED_HELP_FLAGS[target] ?? []).filter((flag) => !help.includes(flag));
         if (capability.status !== "PASS" ||
@@ -238,6 +261,8 @@ async function attemptTarget(request, options) {
         if (invocation === undefined) {
             return skip("capability-unavailable", "review invocation disappeared", "skipping");
         }
+        throwIfInterrupted(target, options);
+        options.onProgress?.(`${target}: review started (timeout: ${Math.ceil((options.timeoutMs ?? DEFAULT_REVIEW_TIMEOUT_MS) / 1_000)}s)`);
         const spawned = await runVerificationCommand({
             id: `review-${request.label}`,
             command: invocation.command,
@@ -254,8 +279,13 @@ async function attemptTarget(request, options) {
                 : { outputLimitBytes: options.outputLimitBytes }),
             stdin: invocation.stdin,
             env: environment,
-            replaceEnv: true
+            replaceEnv: true,
+            ...(options.signal === undefined ? {} : { signal: options.signal })
         });
+        throwIfInterrupted(target, options, spawned.failureClass);
+        if (spawned.failureClass === "timeout") {
+            return skip("timeout", "the reviewer exceeded its timeout");
+        }
         if (ADVANCING.has(spawned.failureClass)) {
             return {
                 ...skip("missing-cli", `the process did not complete: ${spawned.failureClass}`),
@@ -273,6 +303,9 @@ async function attemptTarget(request, options) {
             return skip(rejectedCallReason(output), firstComplaint(spawned.stderr, spawned.stdout) ??
                 `the call was rejected with exit ${spawned.exitCode ?? "unknown"} and no output`);
         }
+        if (spawned.failureClass === "signal-exit") {
+            return skip("capability-unavailable", `the reviewer exited after ${spawned.signal ?? "an unknown signal"}`);
+        }
         const payload = extractReviewObject(target, spawned.stdout);
         const parsed = payload === undefined
             ? undefined
@@ -343,8 +376,8 @@ export function createReviewExecutor(options) {
                     prompt: buildAdversarialPrompt({ ...request.invocation, harness: target }, primary)
                 }, options);
                 if (outcome.kind === "skip") {
-                    // Recorded, not just reported: progress is suppressed under --json,
-                    // and without this a PASS with no `adversarial` field cannot be told
+                    // Recorded, not just reported: stderr progress is transient, and
+                    // without this a PASS with no `adversarial` field cannot be told
                     // apart from a PASS that had no second target to challenge it.
                     attempts.push({
                         target,

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

@@ -7,9 +7,11 @@ function lineList(values) {
     return values.length === 0 ? ["- none"] : values.map((value) => `- ${safe(value)}`);
 }
 export function renderReviewResult(result) {
+    const plannedTargets = result.plannedTargets ?? [result.harness];
     const lines = [
         `Independent review: ${result.status}`,
-        `Reviewer: ${result.harness}; model: ${safe(result.model)}; effort: ${safe(result.effort)}.`
+        `Reviewer: ${result.harness}; model: ${safe(result.model)}; effort: ${safe(result.effort)}.`,
+        `Planned reviewers: ${plannedTargets.length === 0 ? "none" : plannedTargets.join(" → ")}.`
     ];
     if (result.scope !== undefined) {
         lines.push(result.scope.mode === "base"

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

@@ -160,6 +160,7 @@ function safeReport(report) {
 export async function runIndependentReview(options) {
     const base = {
         harness: options.invocation.harness,
+        plannedTargets: options.invocation.plannedTargets ?? [options.invocation.harness],
         model: options.invocation.model,
         effort: options.invocation.effort,
         prompt: buildReviewPrompt(options.invocation),

package/dist/runtime/src/verify/spawn.js

@@ -270,6 +270,9 @@ function hasAcknowledgedShell(command) {
 export async function runVerificationCommand(command, options) {
     const now = options.now ?? Date.now;
     const startedAt = now();
+    if (options.signal?.aborted === true) {
+        return emptyResult(command.id, "aborted", elapsedMilliseconds(startedAt, now()));
+    }
     if (!hasAcknowledgedShell(command)) {
         return emptyResult(command.id, "shell-risk-unacknowledged", elapsedMilliseconds(startedAt, now()));
     }
@@ -298,21 +301,35 @@ export async function runVerificationCommand(command, options) {
     const timeout = new Promise((resolve) => {
         timer = setTimeout(() => resolve({ kind: "timeout" }), timeoutMs);
     });
+    let removeAbortListener = () => { };
+    const aborted = new Promise((resolve) => {
+        const signal = options.signal;
+        if (signal === undefined) {
+            return;
+        }
+        const onAbort = () => resolve({ kind: "abort" });
+        signal.addEventListener("abort", onAbort, { once: true });
+        removeAbortListener = () => signal.removeEventListener("abort", onAbort);
+    });
     const outcome = await Promise.race([
         running.completion.then((completion) => ({
             kind: "completion",
             completion
         })),
-        timeout
+        timeout,
+        aborted
     ]);
+    removeAbortListener();
     if (timer !== undefined) {
         clearTimeout(timer);
     }
     let completion;
     let timedOut = false;
+    let wasAborted = false;
     let terminationFailed = false;
-    if (outcome.kind === "timeout") {
-        timedOut = true;
+    if (outcome.kind === "timeout" || outcome.kind === "abort") {
+        timedOut = outcome.kind === "timeout";
+        wasAborted = outcome.kind === "abort";
         try {
             await running.terminateTree(terminationGrace);
         }
@@ -330,14 +347,19 @@ export async function runVerificationCommand(command, options) {
         settleCapturedOutput(stdout, terminationGrace),
         settleCapturedOutput(stderr, terminationGrace)
     ]);
-    const classified = timedOut
+    const classified = wasAborted
         ? {
             status: terminationFailed ? "UNKNOWN" : "FAIL",
-            failureClass: terminationFailed
-                ? "termination-failed"
-                : "timeout"
+            failureClass: "aborted"
         }
-        : classifyCompletion(completion, capturedStdout.failed || capturedStderr.failed);
+        : timedOut
+            ? {
+                status: terminationFailed ? "UNKNOWN" : "FAIL",
+                failureClass: terminationFailed
+                    ? "termination-failed"
+                    : "timeout"
+            }
+            : classifyCompletion(completion, capturedStdout.failed || capturedStderr.failed);
     return {
         commandId: command.id,
         status: classified.status,

package/docs/en/guides/configuration.md

@@ -55,6 +55,12 @@ A bare review uses the built-in `change-quality` criterion; `--task` uses the
 task criteria and requires fresh PASS evidence for required checks. The full
 report is printed, and PASS persists only a source-fingerprint attestation.
 
+`--review-target` belongs to `init` and configures that persistent chain.
+For one run, `review --harness <target>` narrows the chain to exactly one
+already-configured target; it never enables a target absent from project
+policy. The configured model, effort, and timeout still apply. Review JSON
+includes `plannedTargets` in the actual host-adjusted order.
+
 Every attempt starts from a fresh session and disposable repository clone with
 native read-only mode.
 Claude uses complete safe-mode isolation. Codex and Agy preserve their existing
@@ -88,6 +94,12 @@ failure, oversized output, or unparseable output. Every attempt and reason is
 preserved in human and JSON output. A `PASS` or `FAIL` verdict is **terminal**,
 so the chain cannot shop for a passing review.
 
+Capability checks and model starts are reported on stderr, including under
+`--json`; stdout remains one final JSON envelope and raw reviewer output is
+never streamed. SIGINT or SIGTERM terminates the active reviewer process tree,
+does not advance the fallback chain, and never writes an attestation. An
+exhausted timeout chain reports `timeout`, not `missing-cli`.
+
 If Claude Code is the host (`CLAUDECODE` is set), `claude` is moved to the end
 of the chain. It still runs when it is the only configured target, with a
 `reviewer == host` warning.

package/docs/en/spec/review.md

@@ -31,6 +31,12 @@ when an installation supports multiple harnesses.
 - Positive: `review --harness claude` resolves one target.
 - Negative: `Run one review invocation against every installed harness implicitly.`
 
+The explicit target MUST already exist in the configured independent-review
+role. It narrows the configured chain to one target while preserving model,
+effort, and timeout policy. Without `--harness`, host-aware ordering applies to
+the complete configured chain. Every result carries that order as
+`plannedTargets`.
+
 ## REVIEW-READONLY-001
 
 A review target MUST be launched with its own read-only mechanism, and a target
@@ -48,6 +54,11 @@ different CLI from the hosting CLI; when no other usable target exists,
 same-target fresh review is allowed but MUST render as `DEGRADED: isolated
 self-review`. A resumed development session is never an independent review.
 
+Capability and model-start progress goes to stderr even when stdout is JSON.
+Raw reviewer output remains bounded and unstreamed. SIGINT or SIGTERM aborts
+the active process tree without fallback or attestation; timeout remains a
+distinct NOT_RUN reason rather than being flattened to `missing-cli`.
+
 ## REVIEW-CHAIN-001
 
 Configured targets form an ordered fallback chain that MUST advance only when

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

@@ -49,6 +49,11 @@ Claude 與 Codex lifecycle support 為 `supported`，OpenCode 從 app initializa
 `--task` 使用 task criteria，並要求必要驗證的最新 PASS evidence。完整 report
 會顯示給人看，PASS 後只持久化 source-fingerprint attestation。
 
+`--review-target` 只屬於 `init`，用來設定持久 fallback chain。單次執行可用
+`review --harness <target>`，將 chain 縮窄為一個已在 project policy 啟用的
+target；它不會臨時啟用未設定的 reviewer。既有 model、effort 與 timeout 仍會
+沿用，review JSON 的 `plannedTargets` 會列出經 host 調整後的實際順序。
+
 每次嘗試都從全新 session、一次性 repository clone 與原生唯讀模式啟動。Claude 使用完整 safe-mode
 隔離；Codex 與 Agy 為了支援既有 OAuth 登入而保留登入環境，因此 context
 隔離較弱。Agy 會取得一次性 clone，即使 sandboxed plan mode 寫入 cwd，也無法
@@ -77,6 +82,11 @@ agent-ops 刻意不傳會繞過權限邊界的 `--dangerously-skip-permissions`
 都會保留每次 attempt 及原因。`PASS` 或 `FAIL` 判定是**終局**，因此不會產生
 自動化的 review shopping。
 
+Capability check 與模型啟動進度都寫到 stderr，包括 `--json` 模式；stdout
+仍只有最終 JSON envelope，且不會串流 reviewer 原始輸出。SIGINT 或 SIGTERM
+會終止目前 reviewer 的完整 process tree、不進入 fallback，也不寫入
+attestation。整條 chain 逾時時回報 `timeout`，不會誤報 `missing-cli`。
+
 若 host 是 Claude Code（`CLAUDECODE` 已設定），`claude` 會被移到鏈尾。
 當它是唯一設定的目標時仍會執行，並附上 `reviewer == host` 警告。
 

package/docs/zh-TW/spec/review.md

@@ -32,6 +32,11 @@ English source version: 2026-07-23. Revalidate: when the English specification c
 - Positive: `review --harness claude` 解析成一個 target。
 - Negative: `讓一次 review invocation 隱式跑過所有已安裝 harness。`
 
+明確指定的 target MUST 已存在於 configured independent-review role。它只會將
+configured chain 縮窄為單一 target，並保留 model、effort 與 timeout policy。
+未提供 `--harness` 時，完整 configured chain 仍套用 host-aware ordering；每個
+結果都以 `plannedTargets` 保存這個實際順序。
+
 ## REVIEW-READONLY-001
 
 review target MUST 以其自身的唯讀機制啟動；沒有唯讀機制的 target MUST 被跳過，而非在無沙箱狀態下執行。
@@ -47,6 +52,11 @@ disposable repository clone 中執行。review chain 優先選擇不同於 hosti
 target；沒有其他可用 target 時，才允許同 CLI 的 fresh review，但輸出 MUST 明確
 標示 `DEGRADED: isolated self-review`。不得 resume 開發 session 作為獨立審查。
 
+Capability 與模型啟動進度即使在 JSON 模式也寫到 stderr；reviewer 原始輸出仍
+維持 bounded capture，不直接串流。SIGINT 或 SIGTERM 會中止 active process
+tree，不 fallback、不寫 attestation；timeout 保留獨立 NOT_RUN reason，不得被
+扁平化為 `missing-cli`。
+
 ## REVIEW-CHAIN-001
 
 已設定的 targets 組成有序後備鏈，MUST 僅在「沒有審到」時換下一家，且 MUST NOT 在取得判定後繼續往下試。

package/package.json

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