@kylecheng3146/agent-ops 0.1.18 → 0.1.20

package/README.md

@@ -1,7 +1,7 @@
 # Loop Engineering Toolkit
 
 Loop Engineering Toolkit is an evidence-driven development-loop toolkit for
-Codex, Claude Code, and opencode. It is designed to turn acceptance criteria, explicit
+agy, Codex, Claude Code, and opencode. It is designed to turn acceptance criteria, explicit
 verification, safe lifecycle hooks, and independent review into a repeatable
 engineering workflow.
 
@@ -34,9 +34,9 @@ automation. The wizard never writes files until you review and confirm its
 installation plan.
 
 The interactive multi-select screens start with no harness or profile selected.
-Choose at least one of `codex`, `claude`, and `opencode`, and at least one of
+Choose at least one of `agy`, `codex`, `claude`, and `opencode`, and at least one of
 the `core`, `advisory`, `guardrails`, and `loop` profiles before confirming. For
-scripted use, `--harness all` selects all three harnesses; comma-separated
+scripted use, `--harness all` selects all four harnesses; comma-separated
 selections such as `codex,opencode` are also supported. The legacy `both` value
 remains an alias for `codex,claude`.
 
@@ -66,7 +66,10 @@ agent-ops uninstall --dry-run --json
 
 ### Project-local loop
 
-`loop` is an explicit, project-only profile for Codex, Claude Code, or both.
+`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
+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
 first, then install only after reviewing the plan. `loop` also implies the
@@ -286,13 +289,17 @@ to a deterministic worktree (or `--base`) scope. `--task` reviews keep their
 task criteria and require current verification evidence. The detailed report
 is displayed; a minimal source-fingerprint attestation is persisted after PASS.
 
-Each attempt uses a fresh temporary cwd, a small allowlisted environment, and a
-target-native read-only mode. Claude additionally uses its complete safe mode;
-Codex ignores user config and persistence, while Agy runs in sandboxed plan
-mode against a disposable repository clone. Codex and Agy preserve their
+Each attempt uses a fresh temporary session and disposable repository clone, a
+small allowlisted environment, and a target-native read-only mode. Claude
+additionally uses its complete safe mode; Codex ignores user config and
+persistence, while Agy runs in sandboxed plan mode. Codex and Agy preserve their
 existing login environment, so their context isolation is intentionally weaker
 than Claude's. `opencode` is not a review target.
 
+The chain prefers a reviewer CLI different from the hosting CLI. If none is
+usable, a fresh same-target session is allowed but is rendered as
+`DEGRADED: isolated self-review`; a development session is never resumed.
+
 The first valid `PASS` or `FAIL` is final. Attempts that produce no verdict —
 including login failures and unparseable output — advance to the next target
 and remain visible in the result's `attempts`. `--yes` is still required for
@@ -313,7 +320,7 @@ See [Configuration](docs/en/guides/configuration.md) for the full contract.
 - Treat command output and current filesystem state as evidence.
 - Keep advisory automation separate from blocking guardrails.
 - Preserve user configuration through managed, reversible updates.
-- Support Codex, Claude Code, and opencode without project-specific assumptions.
+- Support agy, Codex, Claude Code, and opencode without project-specific assumptions.
 - Collect no network telemetry.
 
 ## Project status

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

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { execFileSync } from "node:child_process";
 import { fileURLToPath } from "node:url";
 import { commonHarnessAdapters, harnessHookPath, HARNESS_IDS } from "../../../runtime/src/install/harness.js";
-import { hookRegistrationDrift, repositoryTrustStatus, smokeAvailabilityStatus } from "../../../runtime/src/install/probes.js";
+import { agyRuntimeStatus, agyVersionSupported, hookRegistrationDrift, repositoryTrustStatus, smokeAvailabilityStatus } from "../../../runtime/src/install/probes.js";
 import { parseInstallManifest } from "../../../runtime/src/fs/manifest.js";
 import { NpmRegistryClient } from "../../../runtime/src/registry/npm.js";
 import { TaskService } from "../../../runtime/src/task/service.js";
@@ -92,13 +92,13 @@ function gitRunner(root) {
         }
     };
 }
-async function confirmInit(plan, trust) {
+async function confirmInit(plan, trust, warnings = []) {
     writeBanner({
         isTTY: process.stdout.isTTY === true,
         columns: process.stdout.columns,
         write: (value) => process.stdout.write(value)
     });
-    return await confirmPlan(formatInstallPlan(plan, trust));
+    return await confirmPlan(formatInstallPlan(plan, trust, warnings));
 }
 async function confirmPlan(text) {
     process.stdout.write(text);
@@ -115,6 +115,13 @@ async function plannedTrustBinding(root, projectConfig) {
         : await repositoryTrustBinding(root, config, CLI_VERSION);
 }
 const argv = process.argv.slice(2);
+function runAgy(args, options = {}) {
+    return execFileSync("agy", [...args], {
+        ...options,
+        encoding: "utf8",
+        ...(process.platform === "win32" ? { shell: true } : {})
+    });
+}
 if (argv[0] === "hook") {
     process.exitCode = await runHookProcess(argv.slice(1), {
         stdin: process.stdin,
@@ -157,20 +164,53 @@ else {
                         isTTY,
                         toolkitVersion: CLI_VERSION,
                         hookRuntimePath: HOOK_RUNTIME_PATH,
+                        agyWarning: () => {
+                            try {
+                                const output = runAgy(["--version"], { timeout: 5_000 });
+                                return agyVersionSupported(output)
+                                    ? undefined
+                                    : "agy is installed, but version 1.1.12 or newer is required; run `agent-ops doctor` after updating.";
+                            }
+                            catch {
+                                return "agy is not installed or could not be started; install agy 1.1.12 or newer, then run `agent-ops doctor`.";
+                            }
+                        },
                         ...(args.hookTargets === undefined
                             ? {}
                             : { hookTargets: args.hookTargets }),
                         trustStore: store,
                         calculateTrustBinding: async (config) => await plannedTrustBinding(root, config),
-                        confirm: async (plan, trust) => await confirmInit(plan, trust)
+                        confirm: async (plan, trust, warnings) => await confirmInit(plan, trust, warnings)
                     });
                 }
                 if (args.command === "doctor") {
+                    const doctorManifest = await installedManifest(root);
                     const config = (await loadEffectiveConfig(root, args.scope === "user" ? "user" : "project")).config;
                     return await runDoctorCommand({
                         root,
                         toolkitVersion: CLI_VERSION,
                         probes: {
+                            ...(doctorManifest?.harness.includes("agy") === true
+                                ? {
+                                    agyRuntime: () => {
+                                        try {
+                                            return agyRuntimeStatus(runAgy(["--version"]), runAgy([
+                                                "-p", "/hooks", "--output-format", "json",
+                                                ...(doctorManifest.scope === "project"
+                                                    ? ["--new-project"]
+                                                    : [])
+                                            ], { cwd: root }), doctorManifest.hooks?.find(({ harness }) => harness === "agy")?.events ?? []);
+                                        }
+                                        catch {
+                                            return {
+                                                status: "FAIL",
+                                                message: "agy is missing or could not report its loaded hooks.",
+                                                remediation: "Install agy 1.1.12 or newer and run `agent-ops doctor` again."
+                                            };
+                                        }
+                                    }
+                                }
+                                : {}),
                             hookRegistration: async () => {
                                 const drifted = hookRegistrationDrift({
                                     harness: await installedHarness(root),
@@ -246,23 +286,33 @@ else {
                 }
                 if (args.command === "update") {
                     const store = trustStore();
+                    const manifest = await installedManifest(root);
+                    const addAgy = isTTY &&
+                        !args.yes &&
+                        args.harness === undefined &&
+                        manifest !== null &&
+                        !manifest.harness.includes("agy") &&
+                        await selectYesNo("Add newly supported harness: agy?", { input: process.stdin, output: process.stdout }, false);
+                    const updateArgs = addAgy
+                        ? { ...args, harness: [...(manifest?.harness ?? []), "agy"] }
+                        : args;
                     return await runUpdateCommand({
-                        args,
+                        args: updateArgs,
                         root,
                         adapters: commonHarnessAdapters(),
                         registry: new NpmRegistryClient(),
                         isTTY,
                         toolkitVersion: CLI_VERSION,
                         hookRuntimePath: HOOK_RUNTIME_PATH,
-                        ...(args.hookTargets === undefined
+                        ...(updateArgs.hookTargets === undefined
                             ? {}
-                            : { hookTargets: args.hookTargets }),
+                            : { hookTargets: updateArgs.hookTargets }),
                         trustStore: store,
                         calculateTrustBinding: async (config) => await plannedTrustBinding(root, config),
                         confirm: async (plan, trust) => await confirmPlan(formatUpdatePlan(plan, trust)),
-                        ...(args.targetVersion === undefined
+                        ...(updateArgs.targetVersion === undefined
                             ? {}
-                            : { targetVersion: args.targetVersion })
+                            : { targetVersion: updateArgs.targetVersion })
                     });
                 }
                 const taskService = new TaskService(new FileTaskStore(join(root, ".agent-ops", "tasks", "state.json"), root));

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

@@ -30,7 +30,7 @@ Commands:
 
 Options:
   --scope <project|user>
-  --harness <all|both|claude|codex|opencode|comma-separated>  Init/update
+  --harness <all|both|agy|claude|codex|opencode|comma-separated>  Init/update/uninstall
   --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/init.js

@@ -5,7 +5,7 @@ import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
 import { toPublicInstallPlan } from "../public-plan.js";
 import { formatTrustChange, planTrustGrant } from "./trust.js";
-export function formatInstallPlan(plan, trust) {
+export function formatInstallPlan(plan, trust, warnings = []) {
     const hooks = plan.manifest.hooks ?? [];
     const detectedVerification = plan.detectedVerification;
     return formatOperationPlan({
@@ -14,6 +14,12 @@ export function formatInstallPlan(plan, trust) {
             `Scope: ${plan.scope}`,
             `Harness: ${plan.harness}`,
             `Profiles: ${plan.profiles.join(", ")}`,
+            ...(plan.scope === "user" && plan.harness.includes("agy")
+                ? ["Notice: .gemini/GEMINI.md is a shared Gemini rule surface."]
+                : []),
+            ...(warnings.length === 0
+                ? []
+                : ["Warnings:", ...warnings.map((warning) => `  - ${warning}`)]),
             ...(trust === undefined ? [] : formatTrustChange(trust)),
             ...(hooks.length === 0
                 ? ["Hooks: none selected"]
@@ -42,11 +48,19 @@ function appliedMessage(plan) {
         ...hooks.map((hook) => `- ${hook.harness}: ${hook.path} (${hook.events.join(", ")})`)
     ].join("\n");
 }
-function initError(code, message, plan, trust, applied = false) {
+function initError(code, message, plan, trust, warnings = [], applied = false) {
+    const displayMessage = warnings.length === 0
+        ? message
+        : `${message}\nWarnings:\n${warnings.map((warning) => `- ${warning}`).join("\n")}`;
     return {
         code,
         status: "error",
-        data: { applied, plan: toPublicInstallPlan(plan, trust), message },
+        data: {
+            applied,
+            plan: toPublicInstallPlan(plan, trust),
+            message: displayMessage,
+            ...(warnings.length === 0 ? {} : { warnings })
+        },
         errors: [{ code, message }]
     };
 }
@@ -91,21 +105,33 @@ export async function runInitCommand(options) {
             : { reviewTargets: args.reviewTargets })
     });
     const trust = await trustChange(options, plan);
+    const warnings = plan.harness.includes("agy") && options.agyWarning !== undefined
+        ? (() => {
+            try {
+                const warning = options.agyWarning();
+                return warning === undefined ? [] : [warning];
+            }
+            catch {
+                return ["agy could not be probed; run `agent-ops doctor` to verify it."];
+            }
+        })()
+        : [];
     if (args.dryRun) {
         return okEnvelope("INIT_PLAN_READY", {
             applied: false,
             plan: toPublicInstallPlan(plan, trust),
             message: "Installation plan calculated; no files were written.",
-            text: formatInstallPlan(plan, trust)
+            ...(warnings.length === 0 ? {} : { warnings }),
+            text: formatInstallPlan(plan, trust, warnings)
         });
     }
     if (!args.yes && !options.isTTY) {
-        return initError("INIT_CONFIRMATION_REQUIRED", "Non-interactive init requires --yes after all choices are explicit.", plan, trust);
+        return initError("INIT_CONFIRMATION_REQUIRED", "Non-interactive init requires --yes after all choices are explicit.", plan, trust, warnings);
     }
     if (!args.yes &&
         options.isTTY &&
-        !(await options.confirm(plan, trust))) {
-        return initError("INIT_CANCELLED", "Installation was cancelled; no files were written.", plan, trust);
+        !(await options.confirm(plan, trust, warnings))) {
+        return initError("INIT_CANCELLED", "Installation was cancelled; no files were written.", plan, trust, warnings);
     }
     await applyInstallPlan(options.root, plan);
     if (trust.action === "grant") {
@@ -116,12 +142,16 @@ export async function runInitCommand(options) {
             await options.trustStore.grant(trust.binding);
         }
         catch {
-            return initError("INIT_TRUST_FAILED", "Installation was applied, but repository trust was not granted. Run `agent-ops trust grant --yes`.", plan, trust, true);
+            return initError("INIT_TRUST_FAILED", "Installation was applied, but repository trust was not granted. Run `agent-ops trust grant --yes`.", plan, trust, warnings, true);
         }
     }
+    const message = appliedMessage(plan);
     return okEnvelope("INIT_APPLIED", {
         applied: true,
         plan: toPublicInstallPlan(plan, trust),
-        message: appliedMessage(plan)
+        message: warnings.length === 0
+            ? message
+            : `${message}\nWarnings:\n${warnings.map((warning) => `- ${warning}`).join("\n")}`,
+        ...(warnings.length === 0 ? {} : { warnings })
     });
 }

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

@@ -217,6 +217,9 @@ function sourceChangedResult(result) {
         ...(result.independence === undefined
             ? {}
             : { independence: result.independence }),
+        ...(result.sessionIsolation === undefined
+            ? {}
+            : { sessionIsolation: result.sessionIsolation }),
         ...(result.attempts === undefined ? {} : { attempts: result.attempts }),
         ...(result.verification === undefined
             ? {}

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/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");
@@ -68,10 +71,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 +149,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."
@@ -166,8 +170,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 {
@@ -187,8 +192,9 @@ 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 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 {

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

@@ -0,0 +1,105 @@
+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) {
+    const command = platform === "win32"
+        ? `cmd /c node ${JSON.stringify(runtimePath).replaceAll("\\\\", "\\")} agy ${event} ${MARKER}`
+        : `node ${JSON.stringify(runtimePath)} agy ${event} ${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}`);
+}
+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")) {
+        hooks.Stop = [handler(runtimePath, "Stop", platform)];
+    }
+    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;
+    return Object.keys(expected)
+        .every((event) => managedEvent(named[event], event));
+}
+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,27 @@
+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: "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,30 @@
+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 toolCall = record(value.toolCall);
+    const args = record(toolCall?.args);
+    if (toolCall?.name === "run_command" && typeof args?.CommandLine === "string") {
+        return normalizeShellHookEvent(args.CommandLine, projectRoot);
+    }
+    if (typeof value.terminationReason === "string") {
+        return normalizeHookEvent({ event: "stop", projectRoot });
+    }
+    if (typeof value.invocationNum === "number") {
+        return normalizeHookEvent({ event: "session-start", projectRoot });
+    }
+    return normalizeHookEvent({ event: "unsupported", projectRoot });
+}

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

@@ -0,0 +1,24 @@
+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.action === "block"
+            ? { decision: "deny", reason }
+            : { decision: "allow" }
+        : event === "SessionStart"
+            ? { injectSteps: [{ ephemeralMessage: reason }] }
+            : event === "Stop"
+                ? { 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"
+        }];
+}