@kylecheng3146/agent-ops 0.1.20 → 0.1.22

package/README.md

@@ -68,7 +68,8 @@ agent-ops uninstall --dry-run --json
 
 `loop` is an explicit, project-only profile for agy, Codex, and Claude Code.
 agy installs its native `PreInvocation`, `PreToolUse(run_command)`, and optional
-`Stop` subset directly in `.agents/hooks.json`; doctor reports its loop as
+`Stop` subset directly in `.agents/hooks.json`, plus project routing in
+`GEMINI.md` to `.agent-ops/GEMINI.md`; doctor reports its loop as
 degraded because prompt, permission, compact, and subagent events are unavailable.
 Claude Code supports native Windows through a generated PowerShell launcher;
 Codex's loop launcher still requires POSIX-compatible `bash`. Preview it
@@ -80,6 +81,24 @@ agent-ops init --dry-run --scope project --harness codex,claude --profile loop -
 agent-ops init --scope project --harness codex,claude --profile loop --yes
 ```
 
+For a project agy loop, the wizard recommends the hard completion gate. In
+automation, opt in explicitly:
+
+```bash
+agent-ops init --scope project --harness agy --profile loop --completion-gate --yes
+```
+
+The gate lets pure Q&A, analysis, and read-only diagnostics stop normally. It
+activates only after that conversation creates a Git-visible net change, then
+requires an attached completed task with two to five criteria, current PASS
+evidence, and a PASS review for the current source fingerprint. It never runs
+tests or review from `Stop`. Error, max-step, and non-idle stops continue. A
+user can approve one fingerprint-bound escape with
+`agent-ops allow-stop --session <conversationId>`. Use
+`agent-ops agy-run -- <agy arguments>` for a process-exit recheck in headless or
+CI use. Codex, Claude Code, and OpenCode retain their existing non-blocking Stop
+behavior in this release.
+
 On native Windows, select `--harness claude` unless Codex is running in a
 POSIX environment; the Codex loop still invokes `bash`.
 
@@ -250,10 +269,10 @@ After changing Stop configuration, run `agent-ops update`; its approved plan
 updates native registrations and the exact trust binding together. Stop is
 report-only: `PASS`, `FAIL`, and `UNKNOWN` continue
 the harness, emit bounded command evidence, and never complete a task.
-Config v1 migrates to config v2 with Stop disabled; migration invalidates the
-old trust binding, and pre-v1 binaries cannot read the migrated config.
+Older configs migrate to config v3 with both Stop verification and the agy
+completion gate disabled; migration invalidates the old trust binding.
 
-The generated `AGENTS.md` and `CLAUDE.md` routing blocks are supplemental: they
+The generated `AGENTS.md`, `CLAUDE.md`, and agy `GEMINI.md` routing blocks are supplemental: they
 load the managed baseline while leaving project-specific instructions in those
 files authoritative. Existing installations with the previous canonical
 wording are migrated by `agent-ops update`; changed managed blocks still fail

package/dist/packages/cli/src/agy-headless.js

@@ -0,0 +1,18 @@
+/** Headless wrapper: native Stop is bounded by agy, process exit is not. */
+export async function runAgyHeadless(options) {
+    await options.gate.initialize(options.sessionId);
+    const exitCode = await options.run(options.args, {
+        ...(options.env ?? process.env),
+        AGENT_OPS_SESSION_ID: options.sessionId
+    });
+    if (exitCode !== 0)
+        return exitCode;
+    const result = await options.gate.handle({
+        event: "stop",
+        projectRoot: options.root,
+        sessionId: options.sessionId,
+        terminationReason: "model_stop",
+        fullyIdle: true
+    });
+    return result?.action === "block" ? 2 : 0;
+}

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

@@ -8,7 +8,8 @@ export const COMMAND_NAMES = [
     "uninstall",
     "task",
     "verify",
-    "review"
+    "review",
+    "allow-stop"
 ];
 const COMMAND_SET = new Set(COMMAND_NAMES);
 const SCOPES = new Set(["project", "user"]);
@@ -73,6 +74,7 @@ export function parseArgs(argv) {
     const criteria = [];
     const evidence = [];
     let checkAuth = false;
+    let completionGate;
     let dryRun = false;
     let json = false;
     let yes = false;
@@ -203,6 +205,12 @@ export function parseArgs(argv) {
                 }
                 checkAuth = true;
                 break;
+            case "--completion-gate":
+                if (completionGate !== undefined) {
+                    duplicate(token);
+                }
+                completionGate = true;
+                break;
             case "--dry-run":
                 if (dryRun) {
                     duplicate(token);
@@ -291,6 +299,7 @@ export function parseArgs(argv) {
             criteria.length > 0 ||
             evidence.length > 0 ||
             reviewTargets.length > 0 ||
+            completionGate !== undefined ||
             sessionId !== undefined ||
             base !== undefined ||
             checkAuth ||
@@ -317,6 +326,7 @@ export function parseArgs(argv) {
     if (command !== "task" &&
         command !== "verify" &&
         command !== "review" &&
+        command !== "allow-stop" &&
         (hasTaskTargetOptions || hasTaskMutationOptions)) {
         throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "Task target options may be used only with task or verify.");
     }
@@ -338,7 +348,12 @@ 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.");
     }
     if (command === "task") {
         if (harness !== undefined ||
@@ -349,8 +364,7 @@ export function parseArgs(argv) {
         }
         const taskOptionInvalid = (action === "create" &&
             (taskId !== undefined ||
-                evidence.length > 0 ||
-                sessionId !== undefined)) ||
+                evidence.length > 0)) ||
             (action === "status" &&
                 (title !== undefined ||
                     criteria.length > 0 ||
@@ -400,9 +414,24 @@ 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" &&
+        (sessionId === undefined ||
+            scope !== undefined ||
+            harness !== undefined ||
+            taskId !== undefined ||
+            profiles.length > 0 ||
+            title !== undefined ||
+            criteria.length > 0 ||
+            evidence.length > 0 ||
+            dryRun ||
+            yes)) {
+        throw new CliArgumentError("CLI_OPTION_NOT_ALLOWED", "allow-stop requires only --session (and optional --json).");
+    }
     return {
         command,
         ...(action === undefined ? {} : { action }),
@@ -415,6 +444,7 @@ export function parseArgs(argv) {
         ...(targetVersion === undefined ? {} : { targetVersion }),
         ...(title === undefined ? {} : { title }),
         ...(reviewTargets.length === 0 ? {} : { reviewTargets }),
+        ...(completionGate === undefined ? {} : { completionGate }),
         ...(criteria.length === 0 ? {} : { criteria }),
         ...(evidence.length === 0 ? {} : { evidence }),
         ...(sessionId === undefined ? {} : { sessionId }),

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

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import { readFile } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { execFileSync } from "node:child_process";
+import { execFileSync, spawn } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { commonHarnessAdapters, harnessHookPath, HARNESS_IDS } from "../../../runtime/src/install/harness.js";
 import { agyRuntimeStatus, agyVersionSupported, hookRegistrationDrift, repositoryTrustStatus, smokeAvailabilityStatus } from "../../../runtime/src/install/probes.js";
@@ -28,13 +29,16 @@ 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";
+import { CompletionGateService } from "../../../runtime/src/hooks/completion-gate.js";
 import { formatUpdatePlan, runUpdateCommand } from "./commands/update.js";
 import { errorEnvelope } from "./output.js";
+import { runAgyHeadless } from "./agy-headless.js";
 const HOOK_RUNTIME_PATH = fileURLToPath(new URL("./hook-entry.js", import.meta.url));
 async function readOptionalText(path) {
     try {
@@ -122,7 +126,40 @@ function runAgy(args, options = {}) {
         ...(process.platform === "win32" ? { shell: true } : {})
     });
 }
-if (argv[0] === "hook") {
+if (argv[0] === "agy-run") {
+    try {
+        const root = process.cwd();
+        const config = (await loadEffectiveConfig(root, "project")).config;
+        if (!config.features.completionGate.enabled) {
+            throw new Error("agy-run requires features.completionGate.enabled.");
+        }
+        const taskService = new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root));
+        const gate = new CompletionGateService({
+            root,
+            config,
+            gitRunner: gitRunner(root),
+            taskService,
+            evidenceStore: new FileEvidenceStore(root, root)
+        });
+        const agyArgs = argv[1] === "--" ? argv.slice(2) : argv.slice(1);
+        process.exitCode = await runAgyHeadless({
+            root,
+            sessionId: `agy-headless-${randomUUID()}`,
+            args: agyArgs,
+            gate,
+            run: async (args, env) => await new Promise((resolve) => {
+                const child = spawn("agy", [...args], { cwd: root, env, stdio: "inherit" });
+                child.once("error", () => resolve(1));
+                child.once("exit", (code) => resolve(code ?? 1));
+            })
+        });
+    }
+    catch (error) {
+        process.stderr.write(`${error instanceof Error ? error.message : "agy-run failed."}\n`);
+        process.exitCode = 2;
+    }
+}
+else if (argv[0] === "hook") {
     process.exitCode = await runHookProcess(argv.slice(1), {
         stdin: process.stdin,
         writeStdout: (value) => process.stdout.write(value),
@@ -147,7 +184,8 @@ else {
             "uninstall",
             "task",
             "verify",
-            "review"
+            "review",
+            "allow-stop"
         ].map((command) => [command, async (args) => {
                 const root = args.scope === "user"
                     ? process.env.AGENT_OPS_HOME ?? homedir()
@@ -316,6 +354,19 @@ else {
                     });
                 }
                 const taskService = new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root));
+                if (args.command === "allow-stop") {
+                    const config = (await loadEffectiveConfig(root, "project")).config;
+                    return await runAllowStopCommand({
+                        args,
+                        gate: new CompletionGateService({
+                            root,
+                            config,
+                            gitRunner: gitRunner(root),
+                            taskService,
+                            evidenceStore: new FileEvidenceStore(root, root)
+                        })
+                    });
+                }
                 if (args.command === "task") {
                     const sessionId = process.env.AGENT_OPS_SESSION_ID;
                     const policyConfigHash = args.action === "create"
@@ -332,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

@@ -27,14 +27,17 @@ Commands:
              Manage independent task acceptance state
   verify     Run configured verification
   review     Run an independent review
+  allow-stop Grant one fingerprint-bound agy Stop permit (requires --session)
+  agy-run    Run headless agy with a process-exit completion recheck
 
 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
                                       targets in fallback-chain order
+  --completion-gate                  Init only: enable the agy project-loop gate
   --check-auth                        Doctor only: probe each review target's
                                       authentication with one real call
   --task <id>

package/dist/packages/cli/src/commands/allow-stop.js

@@ -0,0 +1,11 @@
+import { AgentOpsError } from "../../../../runtime/src/fs/paths.js";
+import { okEnvelope } from "../output.js";
+export async function runAllowStopCommand(options) {
+    if (options.args.command !== "allow-stop" || options.args.sessionId === undefined) {
+        throw new AgentOpsError("COMPLETION_GATE_SESSION_REQUIRED", "allow-stop requires --session.");
+    }
+    await options.gate.grantPermit(options.args.sessionId);
+    return okEnvelope("COMPLETION_GATE_PERMIT_GRANTED", {
+        message: "One Stop is permitted for this conversation and current source fingerprint."
+    });
+}

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

@@ -49,11 +49,22 @@ export async function runHookCommand(options) {
             capabilities,
             trusted: options.trusted,
             advisory: options.advisory ?? runLifecycleAdvisory,
-            ...(stopVerification === undefined ? {} : { stopVerification })
+            ...(stopVerification === undefined ? {} : { stopVerification }),
+            ...(options.completionGate === undefined
+                ? {}
+                : { completionGate: options.completionGate })
         });
         return descriptor.runtime.formatOutput(options.event, result);
     }
     catch {
+        if (options.harness === "agy" && options.completionGate !== undefined) {
+            return harnessDescriptor("agy").runtime.formatOutput(options.event, {
+                action: "block",
+                status: "UNKNOWN",
+                code: "COMPLETION_GATE_UNAVAILABLE",
+                remedy: "Run agent-ops doctor; a user-approved one-time permit may be used after diagnosing the failure."
+            });
+        }
         return { exitCode: 0, stdout: "", stderr: "" };
     }
 }

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

@@ -102,7 +102,10 @@ export async function runInitCommand(options) {
             : { hookTargets: options.hookTargets ?? args.hookTargets }),
         ...(args.reviewTargets === undefined
             ? {}
-            : { reviewTargets: args.reviewTargets })
+            : { reviewTargets: args.reviewTargets }),
+        ...(args.completionGate === undefined
+            ? {}
+            : { completionGateEnabled: args.completionGate })
     });
     const trust = await trustChange(options, plan);
     const warnings = plan.harness.includes("agy") && options.agyWarning !== undefined

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/packages/cli/src/commands/task.js

@@ -95,9 +95,12 @@ export async function runTaskCommand(options) {
                     : { policyConfigHash: options.policyConfigHash }),
                 ...(options.args.parentTaskId === undefined
                     ? {}
-                    : { parentTaskId: options.args.parentTaskId })
+                    : { parentTaskId: options.args.parentTaskId }),
+                ...(sessionId === undefined ? {} : { sessionId })
             });
-            return taskEnvelope(action, "TASK_CREATED", `Created task ${record.task.id}.`, record);
+            return taskEnvelope(action, "TASK_CREATED", sessionId === undefined
+                ? `Created task ${record.task.id}.`
+                : `Created and attached task ${record.task.id}.`, record);
         }
         if (action === "status") {
             if (options.args.taskId === undefined && sessionId === undefined) {

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

@@ -9,12 +9,15 @@ import { AgentOpsError } from "../../../runtime/src/fs/paths.js";
 import { localStatePaths } from "../../../runtime/src/security/permissions.js";
 import { calculateTrustBinding, FileTrustStore } from "../../../runtime/src/security/trust.js";
 export const DEFAULT_CONFIG = {
-    schemaVersion: 2,
+    schemaVersion: 3,
     profiles: [],
     verification: { commands: [] },
     features: {
         stopVerification: {
             enabled: false
+        },
+        completionGate: {
+            enabled: false
         }
     },
     pathMappings: [],