@kylecheng3146/agent-ops 0.1.19 → 0.1.21

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

@@ -13,7 +13,10 @@ function formatUninstallPlan(plan, trust) {
                 ? []
                 : [
                     `Scope: ${plan.manifest.scope}`,
-                    `Harness: ${plan.manifest.harness}`
+                    `Harness: ${plan.manifest.harness}`,
+                    ...(plan.selectedHarnesses === undefined
+                        ? []
+                        : [`Removing harness: ${plan.selectedHarnesses.join(", ")}`])
                 ])
         ],
         operations: toPublicUninstallPlan(plan).operations
@@ -31,6 +34,18 @@ async function trustChange(options, plan) {
     if (plan.manifest?.scope === "user") {
         return { action: "skipped", reason: "user-scope" };
     }
+    if (plan.resultingManifest !== undefined) {
+        if (options.calculateTrustBinding === undefined ||
+            options.trustStore === undefined) {
+            return { action: "skipped", reason: "not-configured" };
+        }
+        const binding = await options.calculateTrustBinding();
+        if (binding === null) {
+            return { action: "skipped", reason: "no-verification-commands" };
+        }
+        const status = await options.trustStore.status(binding);
+        return { action: "unchanged", binding, status: status.status };
+    }
     if (options.calculateTrustBinding === undefined ||
         options.trustStore === undefined) {
         return { action: "skipped", reason: "not-configured" };
@@ -41,7 +56,7 @@ async function trustChange(options, plan) {
         : await planTrustRevoke(binding, options.trustStore);
 }
 export async function runUninstallCommand(options) {
-    const plan = await createUninstallPlan(options.root);
+    const plan = await createUninstallPlan(options.root, options.args.harness);
     if (!plan.installed) {
         return okEnvelope("UNINSTALL_NOT_INSTALLED", {
             applied: false,
@@ -80,7 +95,9 @@ export async function runUninstallCommand(options) {
     return okEnvelope("UNINSTALL_APPLIED", {
         applied: true,
         plan: toPublicUninstallPlan(plan, trust),
-        message: "Managed installation content was removed."
+        message: plan.selectedHarnesses === undefined
+            ? "Managed installation content was removed."
+            : `Managed ${plan.selectedHarnesses.join(", ")} harness content was removed; remaining harnesses were preserved.`
     });
 }
 export { formatUninstallPlan };

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: [],

package/dist/packages/cli/src/hook-process.js

@@ -9,6 +9,10 @@ import { resolveContainedPath } from "../../../runtime/src/fs/paths.js";
 import { redactSecrets } from "../../../runtime/src/security/redact.js";
 import { claudeStopRecursionMarker } from "../../../runtime/src/adapters/claude/input.js";
 import { HARNESS_IDS, harnessDescriptor } from "../../../runtime/src/install/harness.js";
+import { CompletionGateService } from "../../../runtime/src/hooks/completion-gate.js";
+import { TaskService } from "../../../runtime/src/task/service.js";
+import { FileTaskStore } from "../../../runtime/src/task/store.js";
+import { FileEvidenceStore } from "../../../runtime/src/verify/evidence.js";
 import { STOP_VERIFICATION_ENV, StopVerificationService } from "../../../runtime/src/hooks/stop-service.js";
 import { NodeVerificationProcessRunner } from "../../../runtime/src/verify/spawn.js";
 import { normalizeHookInput, runHookCommand, HOOK_EVENTS } from "./commands/hook.js";
@@ -40,6 +44,16 @@ function parseInput(source) {
         return null;
     }
 }
+function withInjectedSession(harness, input) {
+    const sessionId = process.env.AGENT_OPS_SESSION_ID;
+    return harness === "agy" &&
+        sessionId !== undefined &&
+        typeof input === "object" &&
+        input !== null &&
+        !Array.isArray(input)
+        ? { ...input, conversationId: sessionId }
+        : input;
+}
 function writeHookOutput(io, output) {
     if (output.stdout.length > 0) {
         io.writeStdout(output.stdout);
@@ -195,11 +209,14 @@ function shouldBuildStopVerification(harness, event, config, rawInput) {
     return harnessDescriptor(harness).control.registrations.some(({ capability, support }) => capability === "optional-stop-verify" && support !== "unsupported");
 }
 /**
- * Runs one hook invocation. Always resolves to exit code 0: a hook that
- * cannot answer must never block the harness it advises.
+ * Runs one hook invocation. Exit code stays zero because native JSON carries
+ * decisions; only an explicitly installed agy completion gate fails closed.
  */
 export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
     const [harness, event] = argv;
+    const completionGateInstalled = harness === "agy" &&
+        event === "Stop" &&
+        argv.includes("--completion-gate");
     if (harness === undefined ||
         !HARNESSES.has(harness) ||
         event === undefined ||
@@ -212,13 +229,31 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
         const harnessId = harness;
         const hookEvent = event;
         if (process.env.AGENT_OPS_DISABLE === "1") {
+            if (completionGateInstalled) {
+                writeHookOutput(io, harnessDescriptor("agy").runtime.formatOutput("Stop", {
+                    action: "block",
+                    status: "UNKNOWN",
+                    code: "COMPLETION_GATE_DISABLE_REJECTED",
+                    remedy: "Use a user-approved one-time permit instead of disabling agent-ops."
+                }));
+                return 0;
+            }
             writeHookOutput(io, failOpenOutput(harnessId, hookEvent));
             return 0;
         }
         const rawInput = await readStdin(io.stdin);
-        const parsedInput = parseInput(rawInput);
+        const parsedInput = withInjectedSession(harnessId, parseInput(rawInput));
         const configOutcome = await hookConfigOutcome(root, dependencies.loadConfig);
         if (configOutcome.kind === "invalid") {
+            if (completionGateInstalled) {
+                writeHookOutput(io, harnessDescriptor("agy").runtime.formatOutput("Stop", {
+                    action: "block",
+                    status: "UNKNOWN",
+                    code: "COMPLETION_GATE_CONFIG_INVALID",
+                    remedy: `Fix ${redactSecrets(configOutcome.path)} and run agent-ops doctor.`
+                }));
+                return 0;
+            }
             const output = await invalidConfigOutput({
                 root,
                 harness: harnessId,
@@ -249,6 +284,17 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
                 processRunner
             })
             : undefined;
+        const completionGate = harnessId === "agy" && config.features.completionGate.enabled
+            ? dependencies.completionGate ?? {
+                handle: async (normalized) => await new CompletionGateService({
+                    root,
+                    config,
+                    gitRunner,
+                    taskService: new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root)),
+                    evidenceStore: new FileEvidenceStore(root, root)
+                }).handle(normalized)
+            }
+            : undefined;
         const output = await runHookCommand({
             harness: harness,
             event: hookEvent,
@@ -258,12 +304,20 @@ export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
             ...(dependencies.advisory === undefined
                 ? {}
                 : { advisory: dependencies.advisory }),
-            ...(stopVerification === undefined ? {} : { stopVerification })
+            ...(stopVerification === undefined ? {} : { stopVerification }),
+            ...(completionGate === undefined ? {} : { completionGate })
         });
         writeHookOutput(io, output);
     }
     catch {
-        // ponytail: fail-open by design; hook failures stay invisible to the harness.
+        if (completionGateInstalled) {
+            writeHookOutput(io, harnessDescriptor("agy").runtime.formatOutput("Stop", {
+                action: "block",
+                status: "UNKNOWN",
+                code: "COMPLETION_GATE_UNAVAILABLE",
+                remedy: "Run agent-ops doctor; use a user-approved one-time permit only after diagnosis."
+            }));
+        }
     }
     return 0;
 }

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

@@ -217,7 +217,9 @@ export async function selectOption(question, choices, io, defaultIndex = 0) {
 export async function selectOptions(question, choices, io, defaultValues = [], options = {}) {
     assertChoices(choices);
     const defaultIndexes = new Set(choices.flatMap((choice, index) => defaultValues.includes(choice.value) ? [index] : []));
-    if (defaultIndexes.size === 0 && options.selectAll !== true) {
+    if (defaultIndexes.size === 0 &&
+        options.selectAll !== true &&
+        options.startEmpty !== true) {
         defaultIndexes.add(0);
     }
     if (typeof io.input.setRawMode !== "function" ||

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

@@ -15,11 +15,14 @@ const REVIEW_TARGET_CHOICES = DEFAULT_REVIEW_TARGETS.map((id) => ({
             ? "Runs in sandboxed plan mode against a disposable clone."
             : "Runs in fresh safe mode with context isolation."
 }));
-function selectReviewTargets(raw) {
+function selectReviewTargets(raw, defaults = []) {
     const values = raw
         .split(",")
         .map((value) => value.trim())
         .filter((value) => value.length > 0);
+    if (values.length === 0) {
+        return REVIEW_TARGET_ORDER.filter((target) => defaults.includes(target));
+    }
     for (const value of values) {
         if (!REVIEW_TARGET_SET.has(value)) {
             throw new CliArgumentError("CLI_INVALID_VALUE", `Invalid review target: ${value}`, "--review-target");
@@ -31,6 +34,11 @@ function selectReviewTargets(raw) {
 function affirmative(raw) {
     return /^(y|yes)$/i.test(raw.trim());
 }
+function completionGateEligible(scope, harness, profiles) {
+    return scope === "project" &&
+        harness.includes("agy") &&
+        profiles.includes("loop");
+}
 async function probeReviewTargets(targets, setup) {
     const probe = setup.probeReviewTarget;
     if (probe === undefined) {
@@ -68,10 +76,10 @@ const PROFILE_CHOICES = [
     {
         label: "loop",
         value: "loop",
-        description: "Installs the shared Codex and Claude Code local loop with secret and destructive-command interception."
+        description: "Installs the local loop; agy uses its supported lifecycle subset and is reported as degraded."
     }
 ];
-const WIZARD_SUBTITLE = "Safe setup for Codex, Claude Code, and opencode with profile-driven rules, verification, and hooks.";
+const WIZARD_SUBTITLE = "Safe setup for agy, Codex, Claude Code, and opencode with profile-driven rules, verification, and hooks.";
 async function createPromptSession(io) {
     if (!io.isTTY) {
         throw new CliArgumentError("CLI_INTERACTIVE_REQUIRED", "Missing init choices require an interactive terminal.");
@@ -146,6 +154,7 @@ export async function completeInitChoices(args, io, setup = {}) {
         const scope = args.scope ?? await selectOption("Scope", SCOPE_CHOICES, selectorIo);
         const harness = args.harness ??
             await selectOptions("Harness (multi-select: ↑↓ move, Space toggle, Enter confirm)", HARNESS_CHOICES, selectorIo, [...DEFAULT_HARNESS], {
+                startEmpty: true,
                 selectAll: true,
                 selectAllLabel: "Select all",
                 selectAllDescription: "Install for every supported harness."
@@ -157,6 +166,20 @@ export async function completeInitChoices(args, io, setup = {}) {
                 selectAllLabel: "Select all",
                 selectAllDescription: "Enable core, advisory, guardrails, and loop together."
             });
+        const completionGate = args.completionGate ?? (completionGateEligible(scope, harness, profiles)
+            ? await selectOption("Enable the agy completion gate?", [
+                {
+                    label: "yes",
+                    value: true,
+                    description: "Recommended. Blocks changed sessions until task evidence and review pass."
+                },
+                {
+                    label: "no",
+                    value: false,
+                    description: "Keep advisory loop behavior."
+                }
+            ], selectorIo)
+            : false);
         const enabled = args.reviewTargets !== undefined ||
             (await selectOption("External review: call another agent CLI to review your work?", [
                 { label: "no", value: false, description: "Default. Nothing is spawned." },
@@ -166,8 +189,9 @@ export async function completeInitChoices(args, io, setup = {}) {
                     description: "Pick target CLIs; each is probed for authentication."
                 }
             ], selectorIo));
-        const reviewTargets = args.reviewTargets ?? (enabled
-            ? await selectOptions("Review targets (multi-select: tried in listed order)", REVIEW_TARGET_CHOICES, selectorIo, [])
+        const eligibleReviewChoices = REVIEW_TARGET_CHOICES.filter((choice) => harness.includes(choice.value));
+        const reviewTargets = args.reviewTargets ?? (enabled && eligibleReviewChoices.length > 0
+            ? await selectOptions("Review targets (multi-select: tried in listed order)", eligibleReviewChoices, selectorIo, REVIEW_TARGET_ORDER.filter((target) => harness.includes(target)), { startEmpty: true })
             : []);
         await probeReviewTargets(reviewTargets, setup);
         return {
@@ -175,6 +199,7 @@ export async function completeInitChoices(args, io, setup = {}) {
             scope,
             harness,
             profiles,
+            ...(completionGate ? { completionGate: true } : {}),
             ...(reviewTargets.length === 0 ? {} : { reviewTargets })
         };
     }
@@ -187,8 +212,12 @@ export async function completeInitChoices(args, io, setup = {}) {
         const profiles = args.profiles.length > 0
             ? args.profiles
             : selectProfiles(await session.question("Profiles (core,advisory,guardrails,loop) [core]: "));
+        const completionGate = args.completionGate ?? (completionGateEligible(scope, harness, profiles)
+            ? !/^(n|no)$/i.test((await session.question("Enable the recommended agy completion gate? [Y/n]: ")).trim())
+            : false);
+        const defaultReviewTargets = REVIEW_TARGET_ORDER.filter((target) => harness.includes(target));
         const reviewTargets = args.reviewTargets ?? (affirmative(await session.question("Enable external review by another agent CLI? [y/N]: "))
-            ? selectReviewTargets(await session.question(`Review targets (${DEFAULT_REVIEW_TARGETS.join(",")}): `))
+            ? selectReviewTargets(await session.question(`Review targets (${defaultReviewTargets.join(",") || "none"}): `), defaultReviewTargets)
             : []);
         await probeReviewTargets(reviewTargets, setup);
         return {
@@ -196,6 +225,7 @@ export async function completeInitChoices(args, io, setup = {}) {
             scope,
             harness,
             profiles,
+            ...(completionGate ? { completionGate: true } : {}),
             ...(reviewTargets.length === 0 ? {} : { reviewTargets })
         };
     }

package/dist/runtime/src/adapters/agy/config.js

@@ -0,0 +1,115 @@
+import { AgentOpsError } from "../../fs/paths.js";
+const MARKER = "--managed-by=agent-ops";
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function handler(runtimePath, event, platform, completionGate = false) {
+    const gateFlag = completionGate ? " --completion-gate" : "";
+    const command = platform === "win32"
+        ? `cmd /c node ${JSON.stringify(runtimePath).replaceAll("\\\\", "\\")} agy ${event}${gateFlag} ${MARKER}`
+        : `node ${JSON.stringify(runtimePath)} agy ${event}${gateFlag} ${MARKER}`;
+    return {
+        type: "command",
+        command,
+        timeout: 30
+    };
+}
+function exactKeys(value, keys) {
+    return Object.keys(value).length === keys.length && keys.every((key) => key in value);
+}
+function managedHandler(value, event) {
+    const candidate = record(value);
+    return candidate !== null &&
+        exactKeys(candidate, ["type", "command", "timeout"]) &&
+        candidate.type === "command" &&
+        candidate.timeout === 30 &&
+        typeof candidate.command === "string" &&
+        (candidate.command.startsWith("node \"") ||
+            candidate.command.startsWith("cmd /c node \"")) &&
+        (candidate.command.endsWith(` agy ${event} ${MARKER}`) ||
+            (event === "Stop" &&
+                candidate.command.endsWith(` agy Stop --completion-gate ${MARKER}`)));
+}
+function managedEvent(value, event) {
+    if (!Array.isArray(value) || value.length !== 1)
+        return false;
+    if (event !== "PreToolUse") {
+        return managedHandler(value[0], event === "PreInvocation" ? "SessionStart" : "Stop");
+    }
+    const group = record(value[0]);
+    return group !== null &&
+        exactKeys(group, ["matcher", "hooks"]) &&
+        group.matcher === "run_command" &&
+        Array.isArray(group.hooks) &&
+        group.hooks.length === 1 &&
+        managedHandler(group.hooks[0], "PreToolUse");
+}
+export function buildAgyHookSettings(capabilities, runtimePath, platform = process.platform) {
+    if (runtimePath.length === 0 ||
+        runtimePath.length > 4096 ||
+        /[\0\r\n]/u.test(runtimePath) ||
+        (platform === "win32" && runtimePath.includes('"'))) {
+        throw new AgentOpsError("AGY_HOOK_PATH_INVALID", "agy hook runtime path is invalid.");
+    }
+    const hooks = {};
+    if (capabilities.includes("lifecycle-summary") || capabilities.includes("project-loop")) {
+        hooks.PreInvocation = [handler(runtimePath, "SessionStart", platform)];
+    }
+    if (capabilities.includes("command-policy") || capabilities.includes("project-loop")) {
+        hooks.PreToolUse = [{ matcher: "run_command", hooks: [handler(runtimePath, "PreToolUse", platform)] }];
+    }
+    if (capabilities.includes("optional-stop-verify") ||
+        capabilities.includes("completion-gate")) {
+        hooks.Stop = [handler(runtimePath, "Stop", platform, capabilities.includes("completion-gate"))];
+    }
+    return { hooks };
+}
+export function isAgyManagedHook(value) {
+    const named = record(value)?.["agent-ops"];
+    const hook = record(named);
+    if (hook === null || hook.enabled !== true)
+        return false;
+    const events = Object.keys(hook).filter((key) => key !== "enabled");
+    return events.length > 0 &&
+        events.every((event) => (event === "PreInvocation" || event === "PreToolUse" || event === "Stop") &&
+            managedEvent(hook[event], event));
+}
+export function isAgyHookRegistered(value, capabilities) {
+    const expected = buildAgyHookSettings(capabilities, "probe").hooks;
+    if (Object.keys(expected).length === 0)
+        return true;
+    const named = record(record(value)?.["agent-ops"]);
+    if (named === null || !isAgyManagedHook(value))
+        return false;
+    const eventsMatch = Object.keys(expected)
+        .every((event) => managedEvent(named[event], event));
+    if (!eventsMatch || !capabilities.includes("completion-gate")) {
+        return eventsMatch;
+    }
+    const stop = Array.isArray(named.Stop) ? record(named.Stop[0]) : null;
+    return typeof stop?.command === "string" &&
+        stop.command.endsWith(` agy Stop --completion-gate ${MARKER}`);
+}
+export function mergeAgyHooks(existing, managed) {
+    const source = record(existing);
+    if (source === null) {
+        throw new AgentOpsError("AGY_HOOKS_INVALID", "agy hooks must be a JSON object.");
+    }
+    if (source["agent-ops"] !== undefined && !isAgyManagedHook(source)) {
+        throw new AgentOpsError("AGY_HOOK_NAME_CONFLICT", "Refusing to replace the existing non-agent-ops hook named agent-ops.");
+    }
+    return { ...source, "agent-ops": { enabled: true, ...managed.hooks } };
+}
+export function stripAgyHooks(existing) {
+    const source = record(existing);
+    if (source === null) {
+        throw new AgentOpsError("AGY_HOOKS_INVALID", "agy hooks must be a JSON object.");
+    }
+    if (source["agent-ops"] !== undefined && !isAgyManagedHook(source)) {
+        throw new AgentOpsError("AGY_HOOK_NAME_CONFLICT", "The agent-ops hook is not owned by agent-ops.");
+    }
+    const { "agent-ops": _owned, ...rest } = source;
+    return rest;
+}

package/dist/runtime/src/adapters/agy/events.js

@@ -0,0 +1,35 @@
+export const AGY_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "lifecycle-summary",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        hostEvent: "PreInvocation",
+        surfaceId: "agy-hooks",
+        support: "degraded",
+        runtimeFailure: "fail-open"
+    },
+    {
+        capability: "command-policy",
+        normalizedEvent: "command",
+        nativeEvent: "PreToolUse",
+        surfaceId: "agy-hooks",
+        support: "supported",
+        runtimeFailure: "fail-closed"
+    },
+    {
+        capability: "completion-gate",
+        normalizedEvent: "stop",
+        nativeEvent: "Stop",
+        surfaceId: "agy-hooks",
+        support: "supported",
+        runtimeFailure: "fail-closed"
+    },
+    {
+        capability: "optional-stop-verify",
+        normalizedEvent: "stop",
+        nativeEvent: "Stop",
+        surfaceId: "agy-hooks",
+        support: "degraded",
+        runtimeFailure: "fail-open"
+    }
+];

package/dist/runtime/src/adapters/agy/input.js

@@ -0,0 +1,48 @@
+import { normalizeHookEvent } from "../../hooks/normalize.js";
+import { normalizeShellHookEvent } from "../../hooks/shell.js";
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+export function normalizeAgyHookInput(input) {
+    const value = record(input);
+    if (value === null)
+        return normalizeHookEvent(input);
+    const workspacePaths = Array.isArray(value.workspacePaths)
+        ? value.workspacePaths
+        : [];
+    const projectRoot = typeof workspacePaths[0] === "string"
+        ? workspacePaths[0]
+        : undefined;
+    const sessionId = typeof value.conversationId === "string"
+        ? value.conversationId
+        : undefined;
+    const toolCall = record(value.toolCall);
+    const args = record(toolCall?.args);
+    if (toolCall?.name === "run_command" && typeof args?.CommandLine === "string") {
+        return {
+            ...normalizeShellHookEvent(args.CommandLine, projectRoot),
+            ...(sessionId === undefined ? {} : { sessionId })
+        };
+    }
+    if (typeof value.terminationReason === "string") {
+        return {
+            event: "stop",
+            projectRoot: projectRoot ?? process.cwd(),
+            ...(sessionId === undefined ? {} : { sessionId }),
+            terminationReason: value.terminationReason,
+            ...(typeof value.fullyIdle === "boolean"
+                ? { fullyIdle: value.fullyIdle }
+                : {})
+        };
+    }
+    if (typeof value.invocationNum === "number") {
+        return {
+            event: "session-start",
+            projectRoot: projectRoot ?? process.cwd(),
+            ...(sessionId === undefined ? {} : { sessionId })
+        };
+    }
+    return normalizeHookEvent({ event: "unsupported", projectRoot });
+}

package/dist/runtime/src/adapters/agy/output.js

@@ -0,0 +1,28 @@
+export function agyHookOutput(event, result) {
+    if (result.action === "continue" && result.status === "PASS") {
+        return {
+            exitCode: 0,
+            stdout: event === "PreToolUse" || event === "Stop"
+                ? JSON.stringify({ decision: "allow" })
+                : "{}",
+            stderr: ""
+        };
+    }
+    const reason = result.remedy === undefined
+        ? `agent-ops: ${result.code}`
+        : `agent-ops: ${result.code}: ${result.remedy}`;
+    const value = event === "PreToolUse"
+        ? result.code === "COMPLETION_GATE_PERMIT_CONFIRMATION"
+            ? { decision: "force_ask", reason }
+            : result.action === "block"
+                ? { decision: "deny", reason }
+                : { decision: "allow" }
+        : event === "SessionStart"
+            ? { injectSteps: [{ ephemeralMessage: reason }] }
+            : event === "Stop"
+                ? result.action === "block" && result.code.startsWith("COMPLETION_GATE_")
+                    ? { decision: "continue", reason }
+                    : { decision: "allow", reason }
+                : {};
+    return { exitCode: 0, stdout: JSON.stringify(value), stderr: "" };
+}

package/dist/runtime/src/adapters/agy/surfaces.js

@@ -0,0 +1,9 @@
+export function agySurfaces(scope) {
+    return [{
+            id: "agy-hooks",
+            path: scope === "project" ? ".agents/hooks.json" : ".gemini/config/hooks.json",
+            scope,
+            access: "managed-default",
+            representation: "json"
+        }];
+}

package/dist/runtime/src/config/explain.js

@@ -2,6 +2,11 @@ export function explainConfig(merged) {
     return {
         schemaVersion: merged.config.schemaVersion,
         features: {
+            completionGate: {
+                enabled: merged.config.features.completionGate.enabled,
+                source: merged.provenance.features.source,
+                sourcePath: merged.provenance.features.sourcePath
+            },
             stopVerification: {
                 enabled: merged.config.features.stopVerification.enabled,
                 source: merged.provenance.features.source,

package/dist/runtime/src/config/migrate.js

@@ -25,7 +25,7 @@ const MIGRATIONS = new Map([
             const { schemaVersion: _schemaVersion, ...rest } = input;
             return {
                 ...rest,
-                schemaVersion: CONFIG_SCHEMA_VERSION,
+                schemaVersion: 2,
                 features: {
                     stopVerification: {
                         enabled: false
@@ -33,6 +33,20 @@ const MIGRATIONS = new Map([
                 }
             };
         }
+    ],
+    [
+        2,
+        (input) => {
+            const { schemaVersion: _schemaVersion, features, ...rest } = input;
+            return {
+                ...rest,
+                schemaVersion: CONFIG_SCHEMA_VERSION,
+                features: {
+                    ...(isRecord(features) ? features : {}),
+                    completionGate: { enabled: false }
+                }
+            };
+        }
     ]
 ]);
 function schemaVersionOf(value) {

package/dist/runtime/src/contracts.js

@@ -1,4 +1,4 @@
-export const CONFIG_SCHEMA_VERSION = 2;
+export const CONFIG_SCHEMA_VERSION = 3;
 export const TASK_SCHEMA_VERSION = 1;
 export const EVIDENCE_SCHEMA_VERSION = 2;
 /** @deprecated Use the document-specific schema version constants. */