@kylecheng3146/agent-ops 0.1.4 → 0.1.6

package/dist/packages/cli/src/public-plan.js

@@ -0,0 +1,62 @@
+import { redactSecrets } from "../../../runtime/src/security/redact.js";
+import { sha256 } from "../../../runtime/src/fs/hash.js";
+const OPAQUE_SUMMARY = "Opaque managed settings content withheld.";
+function publicPath(path) {
+    return redactSecrets(path);
+}
+export function disclosureOf(operation) {
+    return operation.disclosure ?? "full";
+}
+export function toPublicOperation(operation) {
+    const path = publicPath(operation.path);
+    if (operation.kind === "remove") {
+        return {
+            kind: "remove",
+            path,
+            expectedHash: operation.expectedHash
+        };
+    }
+    if (disclosureOf(operation) === "opaque") {
+        return {
+            kind: "write",
+            path,
+            expectedHash: operation.expectedHash,
+            contentHash: sha256(operation.content),
+            summary: redactSecrets(OPAQUE_SUMMARY)
+        };
+    }
+    return {
+        kind: "write",
+        path,
+        expectedHash: operation.expectedHash,
+        content: operation.content
+    };
+}
+export function toPublicOperations(operations) {
+    return operations.map(toPublicOperation);
+}
+export function toPublicInstallPlan(plan) {
+    return {
+        scope: plan.scope,
+        harness: plan.harness,
+        profiles: plan.profiles,
+        capabilities: plan.capabilities,
+        manifest: plan.manifest,
+        operations: toPublicOperations(plan.operations)
+    };
+}
+export function toPublicUpdatePlan(plan) {
+    return {
+        targetVersion: plan.targetVersion,
+        migrationSteps: plan.migrationSteps,
+        installation: toPublicInstallPlan(plan.installation)
+    };
+}
+export function toPublicUninstallPlan(plan) {
+    return {
+        installed: plan.installed,
+        manifest: plan.manifest,
+        manifestHash: plan.manifestHash,
+        operations: toPublicOperations(plan.operations)
+    };
+}

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

@@ -1,3 +1,3 @@
 // Single source of the published CLI version. Release preparation updates
 // this constant; bin.ts and the hook entry both read it from here.
-export const CLI_VERSION = "0.1.4";
+export const CLI_VERSION = "0.1.6";

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

@@ -1,17 +1,14 @@
 import { CliArgumentError } from "./args.js";
+import { HARNESS_IDS, resolveHarnessSelection } from "../../../runtime/src/install/harness.js";
 import { selectOption, selectOptions } from "./ui.js";
 const SCOPES = new Set(["project", "user"]);
-const HARNESSES = new Set(["both", "claude", "codex"]);
-const PROFILES = new Set(["advisory", "core", "guardrails"]);
+const PROFILES = new Set(["advisory", "core", "guardrails", "loop"]);
+const DEFAULT_HARNESS = [];
 const SCOPE_CHOICES = [
     { label: "project", value: "project" },
     { label: "user", value: "user" }
 ];
-const HARNESS_CHOICES = [
-    { label: "both", value: "both" },
-    { label: "claude", value: "claude" },
-    { label: "codex", value: "codex" }
-];
+const HARNESS_CHOICES = HARNESS_IDS.map((id) => ({ label: id, value: id }));
 const PROFILE_CHOICES = [
     {
         label: "core",
@@ -26,10 +23,15 @@ const PROFILE_CHOICES = [
     {
         label: "guardrails",
         value: "guardrails",
-        description: "Blocks high-confidence unsafe commands and enables optional Stop verification."
+        description: "Blocks high-confidence unsafe commands; Stop verification is a separate opt-in feature."
+    },
+    {
+        label: "loop",
+        value: "loop",
+        description: "Installs the shared Codex and Claude Code local loop with secret and destructive-command interception."
     }
 ];
-const WIZARD_SUBTITLE = "Safe setup for Codex + Claude Code with profile-driven rules, verification, and hooks.";
+const WIZARD_SUBTITLE = "Safe setup for 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.");
@@ -60,6 +62,16 @@ function selectValue(raw, fallback, allowed, label) {
     }
     return value;
 }
+function selectHarness(raw) {
+    if (raw.trim() === "") {
+        throw new CliArgumentError("CLI_INVALID_VALUE", "Choose at least one harness.");
+    }
+    const selection = resolveHarnessSelection(raw);
+    if (selection === null) {
+        throw new CliArgumentError("CLI_INVALID_VALUE", `Harness must be a unique comma-separated list of ${HARNESS_IDS.join(", ")}.`);
+    }
+    return selection;
+}
 function selectProfiles(raw) {
     const values = raw.trim() === ""
         ? ["core"]
@@ -67,7 +79,7 @@ function selectProfiles(raw) {
     if (values.length === 0 ||
         values.some((value) => !PROFILES.has(value)) ||
         new Set(values).size !== values.length) {
-        throw new CliArgumentError("CLI_INVALID_VALUE", "Profiles must be a unique comma-separated list of core, advisory, or guardrails.");
+        throw new CliArgumentError("CLI_INVALID_VALUE", "Profiles must be a unique comma-separated list of core, advisory, guardrails, or loop.");
     }
     return values;
 }
@@ -81,20 +93,29 @@ export async function completeInitChoices(args, io) {
     if (!io.isTTY) {
         throw new CliArgumentError("CLI_INTERACTIVE_REQUIRED", "Non-interactive init requires --scope, --harness, and at least one --profile.");
     }
-    if (io.input !== undefined && io.output !== undefined) {
+    const canUseRawSelectors = io.input !== undefined &&
+        io.output !== undefined &&
+        typeof io.input.setRawMode === "function" &&
+        io.input.isTTY === true;
+    if (canUseRawSelectors) {
         const selectorIo = {
             input: io.input,
             output: io.output
         };
         selectorIo.output.write(`${WIZARD_SUBTITLE}\n\n`);
         const scope = args.scope ?? await selectOption("Scope", SCOPE_CHOICES, selectorIo);
-        const harness = args.harness ?? await selectOption("Harness", HARNESS_CHOICES, selectorIo);
+        const harness = args.harness ??
+            await selectOptions("Harness (multi-select: ↑↓ move, Space toggle, Enter confirm)", HARNESS_CHOICES, selectorIo, [...DEFAULT_HARNESS], {
+                selectAll: true,
+                selectAllLabel: "Select all",
+                selectAllDescription: "Install for every supported harness."
+            });
         const profiles = args.profiles.length > 0
             ? args.profiles
             : await selectOptions("Profiles (multi-select: ↑↓ move, Space toggle, Enter confirm)", PROFILE_CHOICES, selectorIo, [], {
                 selectAll: true,
                 selectAllLabel: "Select all",
-                selectAllDescription: "Enable core, advisory, and guardrails together."
+                selectAllDescription: "Enable core, advisory, guardrails, and loop together."
             });
         return {
             ...args,
@@ -108,10 +129,10 @@ export async function completeInitChoices(args, io) {
         const scope = args.scope ??
             selectValue(await session.question("Scope (project/user) [project]: "), "project", SCOPES, "scope");
         const harness = args.harness ??
-            selectValue(await session.question("Harness (both/claude/codex) [both]: "), "both", HARNESSES, "harness");
+            selectHarness(await session.question(`Harness (${HARNESS_IDS.join(",")}): `));
         const profiles = args.profiles.length > 0
             ? args.profiles
-            : selectProfiles(await session.question("Profiles (core,advisory,guardrails) [core]: "));
+            : selectProfiles(await session.question("Profiles (core,advisory,guardrails,loop) [core]: "));
         return {
             ...args,
             scope,

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

@@ -1,4 +1,17 @@
 import { AgentOpsError } from "../../fs/paths.js";
+const CLAUDE_LOOP_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop"
+];
+const CLAUDE_HOOK_MARKER = "--managed-by=agent-ops";
+const CLAUDE_LOOP_LAUNCHER = "${CLAUDE_PROJECT_DIR}/.claude/hooks/agent-ops-loop.sh";
 export function claudeSettingsTarget(scope) {
     return scope === "project"
         ? {
@@ -10,14 +23,6 @@ export function claudeSettingsTarget(scope) {
             requiresWorkspaceTrust: false
         };
 }
-export function claudeRoutingBlock() {
-    return [
-        "## Loop Engineering",
-        "",
-        "Load `.agent-ops/CLAUDE.md` as concise project context.",
-        ""
-    ].join("\n");
-}
 function commandHook(event, runtimePath) {
     return {
         type: "command",
@@ -26,7 +31,7 @@ function commandHook(event, runtimePath) {
             runtimePath,
             "claude",
             event,
-            "--managed-by=agent-ops"
+            CLAUDE_HOOK_MARKER
         ],
         timeout: 30
     };
@@ -37,6 +42,25 @@ function matcherGroup(event, runtimePath) {
         hooks: [commandHook(event, runtimePath)]
     };
 }
+function loopMatcherGroup(event) {
+    return {
+        ...(event === "PreToolUse" || event === "PermissionRequest"
+            ? { matcher: "Bash" }
+            : {}),
+        hooks: [
+            {
+                type: "command",
+                command: "bash",
+                args: [
+                    CLAUDE_LOOP_LAUNCHER,
+                    event,
+                    CLAUDE_HOOK_MARKER
+                ],
+                timeout: 30
+            }
+        ]
+    };
+}
 export function buildClaudeHookSettings(capabilities, runtimePath) {
     if (runtimePath.length === 0 ||
         runtimePath.length > 4096 ||
@@ -44,11 +68,18 @@ export function buildClaudeHookSettings(capabilities, runtimePath) {
         throw new AgentOpsError("CLAUDE_HOOK_PATH_INVALID", "Claude hook runtime path is invalid.");
     }
     const hooks = {};
-    if (capabilities.includes("lifecycle-summary")) {
-        hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
+    if (capabilities.includes("project-loop")) {
+        for (const event of CLAUDE_LOOP_EVENTS) {
+            hooks[event] = [loopMatcherGroup(event)];
+        }
     }
-    if (capabilities.includes("command-policy")) {
-        hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
+    else {
+        if (capabilities.includes("lifecycle-summary")) {
+            hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
+        }
+        if (capabilities.includes("command-policy")) {
+            hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
+        }
     }
     if (capabilities.includes("optional-stop-verify")) {
         hooks.Stop = [matcherGroup("Stop", runtimePath)];
@@ -58,19 +89,26 @@ export function buildClaudeHookSettings(capabilities, runtimePath) {
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isOwnedHandler(handler) {
-    if (!isRecord(handler) ||
-        handler.command !== "node" ||
-        !Array.isArray(handler.args)) {
+/**
+ * Matches only the two command shapes agent-ops actually generates. This is
+ * reused by installation inspection so a foreign hook cannot masquerade as
+ * ours merely by carrying the marker string.
+ */
+export function isClaudeManagedHandler(handler) {
+    if (!isRecord(handler) || !Array.isArray(handler.args)) {
         return false;
     }
-    return handler.args[3] === "--managed-by=agent-ops";
+    return ((handler.command === "node" &&
+        handler.args[3] === CLAUDE_HOOK_MARKER) ||
+        (handler.command === "bash" &&
+            handler.args[0] === CLAUDE_LOOP_LAUNCHER &&
+            handler.args[2] === CLAUDE_HOOK_MARKER));
 }
 function withoutOwnedHandlers(value) {
     if (!isRecord(value) || !Array.isArray(value.hooks)) {
         return value;
     }
-    const hooks = value.hooks.filter((handler) => !isOwnedHandler(handler));
+    const hooks = value.hooks.filter((handler) => !isClaudeManagedHandler(handler));
     return hooks.length === 0 ? null : { ...value, hooks };
 }
 function hookRecord(settings) {

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

@@ -1,8 +1,41 @@
 export const CLAUDE_SUPPORTED_EVENTS = [
     "SessionStart",
+    "UserPromptSubmit",
     "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop",
     "Stop"
 ];
 export function claudeNonInteractiveTrust(printMode) {
     return printMode ? "dialog-skipped" : "interactive-dialog";
 }
+export const CLAUDE_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "lifecycle-summary",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        surfaceId: "claude-settings",
+        support: "supported",
+        runtimeFailure: "fail-open"
+    },
+    {
+        capability: "command-policy",
+        normalizedEvent: "command",
+        nativeEvent: "PreToolUse",
+        surfaceId: "claude-settings",
+        support: "supported",
+        runtimeFailure: "fail-closed"
+    },
+    {
+        capability: "optional-stop-verify",
+        normalizedEvent: "stop",
+        nativeEvent: "Stop",
+        surfaceId: "claude-settings",
+        support: "supported",
+        runtimeFailure: "fail-open"
+    }
+];

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

@@ -6,6 +6,13 @@ function json(value) {
     };
 }
 export function claudeHookOutput(event, result) {
+    const denialReason = result.remedy === undefined ? result.code : `${result.code}: ${result.remedy}`;
+    if (event === "Stop" && result.evidence !== undefined) {
+        return json({
+            systemMessage: `agent-ops: ${result.code}`,
+            evidence: result.evidence
+        });
+    }
     if (result.action === "continue" && result.status === "PASS") {
         return { exitCode: 0, stdout: "", stderr: "" };
     }
@@ -14,16 +21,10 @@ export function claudeHookOutput(event, result) {
             hookSpecificOutput: {
                 hookEventName: "PreToolUse",
                 permissionDecision: "deny",
-                permissionDecisionReason: result.code
+                permissionDecisionReason: denialReason
             }
         });
     }
-    if (event === "Stop" && result.action === "block") {
-        return json({
-            decision: "block",
-            reason: result.code
-        });
-    }
     return json({
         systemMessage: `agent-ops: ${result.code}`
     });

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

@@ -0,0 +1,70 @@
+export const CLAUDE_SURFACE_IDS = {
+    settings: "claude-settings",
+    projectLocal: "project-local",
+    userSettings: "user-settings",
+    plugin: "plugin"
+};
+export function claudeSurfaces(scope) {
+    if (scope === "project") {
+        return [
+            {
+                id: CLAUDE_SURFACE_IDS.settings,
+                path: ".claude/settings.json",
+                scope: "project",
+                access: "managed-default",
+                representation: "json"
+            },
+            {
+                id: CLAUDE_SURFACE_IDS.projectLocal,
+                path: ".claude/settings.local.json",
+                scope: "project",
+                access: "managed-opt-in",
+                representation: "json"
+            },
+            {
+                id: CLAUDE_SURFACE_IDS.userSettings,
+                path: "~/.claude/settings.json",
+                scope: "external",
+                access: "inspect-only",
+                representation: "json"
+            },
+            {
+                id: CLAUDE_SURFACE_IDS.plugin,
+                path: "~/.claude/plugins",
+                scope: "external",
+                access: "inspect-only",
+                representation: "javascript"
+            }
+        ];
+    }
+    return [
+        {
+            id: CLAUDE_SURFACE_IDS.settings,
+            path: ".claude/settings.json",
+            scope: "user",
+            access: "managed-default",
+            representation: "json"
+        },
+        {
+            id: CLAUDE_SURFACE_IDS.projectLocal,
+            path: "project/.claude/settings.local.json",
+            scope: "external",
+            access: "inspect-only",
+            representation: "json"
+        },
+        {
+            id: CLAUDE_SURFACE_IDS.userSettings,
+            path: "project/.claude/settings.json",
+            scope: "external",
+            access: "inspect-only",
+            representation: "json"
+        },
+        {
+            id: CLAUDE_SURFACE_IDS.plugin,
+            path: "~/.claude/plugins",
+            scope: "external",
+            access: "inspect-only",
+            representation: "javascript"
+        }
+    ];
+}

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

@@ -1,10 +1,37 @@
 import { AgentOpsError } from "../../fs/paths.js";
-const COMMAND_PREFIX = "agent-ops hook codex ";
+export const CODEX_MANAGED_MARKER = "--managed-by=agent-ops";
+const CODEX_LOOP_EVENTS = [
+    "SessionStart",
+    "UserPromptSubmit",
+    "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop"
+];
+/**
+ * Releases up to 0.1.4 registered a bare `agent-ops` command resolved through
+ * PATH. Detection still recognizes it so an update replaces it instead of
+ * leaving the hijackable handler behind.
+ */
+const LEGACY_COMMAND_PREFIX = "agent-ops hook codex ";
 function isRecord(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function commandHook(event) {
-    const command = `${COMMAND_PREFIX}${event}`;
+function assertRuntimePath(runtimePath) {
+    if (runtimePath.length === 0 ||
+        runtimePath.length > 4096 ||
+        runtimePath.includes("\0") ||
+        // The command is a single shell string, so a quote would break the
+        // argument boundary the surrounding quotes establish.
+        runtimePath.includes('"')) {
+        throw new AgentOpsError("CODEX_HOOK_PATH_INVALID", "Codex hook runtime path is invalid.");
+    }
+}
+function commandHook(event, runtimePath) {
+    const command = `node "${runtimePath}" codex ${event} ${CODEX_MANAGED_MARKER}`;
     return {
         type: "command",
         command,
@@ -13,10 +40,27 @@ function commandHook(event) {
         statusMessage: `Running agent-ops ${event}`
     };
 }
-function matcherGroup(event) {
+function matcherGroup(event, runtimePath) {
     return {
         ...(event === "PreToolUse" ? { matcher: "^Bash$" } : {}),
-        hooks: [commandHook(event)]
+        hooks: [commandHook(event, runtimePath)]
+    };
+}
+function loopMatcherGroup(event) {
+    const command = `bash "$(git rev-parse --show-toplevel)/.codex/hooks/agent-ops-loop.sh" ${event} ${CODEX_MANAGED_MARKER}`;
+    return {
+        ...(event === "PreToolUse" || event === "PermissionRequest"
+            ? { matcher: "^Bash$" }
+            : {}),
+        hooks: [
+            {
+                type: "command",
+                command,
+                commandWindows: command,
+                timeout: 30,
+                statusMessage: `Running agent-ops ${event}`
+            }
+        ]
     };
 }
 export function codexHookTarget(scope) {
@@ -26,26 +70,35 @@ export function codexHookTarget(scope) {
         requiresProjectTrust: scope === "project"
     };
 }
-export function buildCodexHookConfig(capabilities) {
+export function buildCodexHookConfig(capabilities, runtimePath) {
+    assertRuntimePath(runtimePath);
     const hooks = {};
-    if (capabilities.includes("lifecycle-summary")) {
-        hooks.SessionStart = [matcherGroup("SessionStart")];
+    if (capabilities.includes("project-loop")) {
+        for (const event of CODEX_LOOP_EVENTS) {
+            hooks[event] = [loopMatcherGroup(event)];
+        }
     }
-    if (capabilities.includes("command-policy")) {
-        hooks.PreToolUse = [matcherGroup("PreToolUse")];
+    else {
+        if (capabilities.includes("lifecycle-summary")) {
+            hooks.SessionStart = [matcherGroup("SessionStart", runtimePath)];
+        }
+        if (capabilities.includes("command-policy")) {
+            hooks.PreToolUse = [matcherGroup("PreToolUse", runtimePath)];
+        }
     }
     if (capabilities.includes("optional-stop-verify")) {
-        hooks.Stop = [matcherGroup("Stop")];
+        hooks.Stop = [matcherGroup("Stop", runtimePath)];
     }
     return {
-        description: "Portable agent-ops lifecycle hooks.",
+        description: "agent-ops lifecycle hooks.",
         hooks
     };
 }
 function isOwnedHandler(hook) {
     return (isRecord(hook) &&
         typeof hook.command === "string" &&
-        hook.command.startsWith(COMMAND_PREFIX));
+        (hook.command.includes(CODEX_MANAGED_MARKER) ||
+            hook.command.startsWith(LEGACY_COMMAND_PREFIX)));
 }
 function withoutOwnedHandlers(value) {
     if (!isRecord(value) || !Array.isArray(value.hooks)) {

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

@@ -1,8 +1,41 @@
 export const CODEX_SUPPORTED_EVENTS = [
     "SessionStart",
+    "UserPromptSubmit",
     "PreToolUse",
+    "PermissionRequest",
+    "PostToolUse",
+    "PreCompact",
+    "PostCompact",
+    "SubagentStart",
+    "SubagentStop",
     "Stop"
 ];
 export function codexMatcherSupport(event) {
     return event === "PreToolUse" ? "tool-name" : "unsupported";
 }
+export const CODEX_CAPABILITY_REGISTRATIONS = [
+    {
+        capability: "lifecycle-summary",
+        normalizedEvent: "session-start",
+        nativeEvent: "SessionStart",
+        surfaceId: "codex-hooks",
+        support: "supported",
+        runtimeFailure: "fail-open"
+    },
+    {
+        capability: "command-policy",
+        normalizedEvent: "command",
+        nativeEvent: "PreToolUse",
+        surfaceId: "codex-hooks",
+        support: "unknown",
+        runtimeFailure: "native-unknown"
+    },
+    {
+        capability: "optional-stop-verify",
+        normalizedEvent: "stop",
+        nativeEvent: "Stop",
+        surfaceId: "codex-hooks",
+        support: "unsupported",
+        runtimeFailure: "fail-open"
+    }
+];

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

@@ -1,6 +1,16 @@
 export const CODEX_NON_ZERO_EXIT_BEHAVIOR = "UNKNOWN";
 export const CODEX_PRE_TOOL_BLOCKING = "UNKNOWN";
 export function codexHookOutput(event, result) {
+    if (event === "Stop" && result.evidence !== undefined) {
+        return {
+            exitCode: 0,
+            stdout: JSON.stringify({
+                continue: true,
+                systemMessage: `agent-ops: ${result.code}`,
+                evidence: result.evidence
+            })
+        };
+    }
     if (result.action === "continue" && result.status === "PASS") {
         return { exitCode: 0, stdout: "" };
     }

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

@@ -0,0 +1,12 @@
+export const CODEX_SURFACE_ID = "codex-hooks";
+export function codexSurfaces(scope) {
+    return [
+        {
+            id: CODEX_SURFACE_ID,
+            path: ".codex/hooks.json",
+            scope,
+            access: "managed-default",
+            representation: "json"
+        }
+    ];
+}