@kylecheng3146/agent-ops 0.1.4 → 0.1.6

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

@@ -1,21 +1,33 @@
-import { normalizeClaudeHookInput } from "../../../../runtime/src/adapters/claude/input.js";
-import { claudeHookOutput } from "../../../../runtime/src/adapters/claude/output.js";
-import { normalizeCodexHookInput } from "../../../../runtime/src/adapters/codex/input.js";
-import { codexHookOutput } from "../../../../runtime/src/adapters/codex/output.js";
+import { runLifecycleAdvisory } from "../../../../runtime/src/hooks/advisory.js";
 import { dispatchHookEvent } from "../../../../runtime/src/hooks/dispatch.js";
-import { resolveProfiles } from "../../../../runtime/src/install/profiles.js";
+import { resolveCapabilities } from "../../../../runtime/src/install/profiles.js";
+import { harnessDescriptor } from "../../../../runtime/src/install/harness.js";
 export const HOOK_EVENTS = [
     "SessionStart",
     "PreToolUse",
     "Stop"
 ];
+/**
+ * Keep adapter normalization at the command boundary so exceptional hook
+ * paths use the same native-event interpretation as normal dispatch.
+ */
+export function normalizeHookInput(harness, input) {
+    try {
+        return harnessDescriptor(harness).runtime.normalizeInput(input);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Hooks are advisory infrastructure: every failure path stays fail-open with
  * exit code 0 so a broken toolkit can never wedge the harness.
  */
 export async function runHookCommand(options) {
     try {
-        const { capabilities } = resolveProfiles(options.config.profiles);
+        const { capabilities } = options.config.profiles.length === 0
+            ? { capabilities: [] }
+            : resolveCapabilities(options.config);
         let input;
         try {
             input = JSON.parse(options.stdin);
@@ -23,18 +35,23 @@ export async function runHookCommand(options) {
         catch {
             return { exitCode: 0, stdout: "", stderr: "" };
         }
-        const event = options.harness === "claude"
-            ? normalizeClaudeHookInput(input)
-            : normalizeCodexHookInput(input);
-        const result = await dispatchHookEvent(event, {
+        const descriptor = harnessDescriptor(options.harness);
+        const normalized = normalizeHookInput(options.harness, input);
+        if (normalized === null) {
+            return { exitCode: 0, stdout: "", stderr: "" };
+        }
+        const stopRegistration = descriptor.control.registrations.find(({ capability }) => capability === "optional-stop-verify");
+        const stopVerification = options.stopVerification !== undefined &&
+            stopRegistration?.support !== "unsupported"
+            ? options.stopVerification
+            : undefined;
+        const result = await dispatchHookEvent(normalized, {
             capabilities,
-            trusted: options.trusted
+            trusted: options.trusted,
+            advisory: options.advisory ?? runLifecycleAdvisory,
+            ...(stopVerification === undefined ? {} : { stopVerification })
         });
-        if (options.harness === "claude") {
-            return claudeHookOutput(options.event, result);
-        }
-        const codex = codexHookOutput(options.event, result);
-        return { exitCode: 0, stdout: codex.stdout, stderr: "" };
+        return descriptor.runtime.formatOutput(options.event, result);
     }
     catch {
         return { exitCode: 0, stdout: "", stderr: "" };

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

@@ -3,6 +3,7 @@ import { createInstallPlan } from "../../../../runtime/src/install/plan.js";
 import { applyInstallPlan } from "../../../../runtime/src/install/apply.js";
 import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
+import { toPublicInstallPlan } from "../public-plan.js";
 export function formatInstallPlan(plan) {
     const hooks = plan.manifest.hooks ?? [];
     return formatOperationPlan({
@@ -18,7 +19,7 @@ export function formatInstallPlan(plan) {
                     ...hooks.map((hook) => `  - ${hook.harness}: ${hook.path} (${hook.events.join(", ")})`)
                 ])
         ],
-        operations: plan.operations
+        operations: toPublicInstallPlan(plan).operations
     });
 }
 function appliedMessage(plan) {
@@ -36,7 +37,7 @@ function initError(code, message, plan) {
     return {
         code,
         status: "error",
-        data: { applied: false, plan, message },
+        data: { applied: false, plan: toPublicInstallPlan(plan), message },
         errors: [{ code, message }]
     };
 }
@@ -59,12 +60,15 @@ export async function runInitCommand(options) {
             : { toolkitVersion: options.toolkitVersion }),
         ...(options.hookRuntimePath === undefined
             ? {}
-            : { hookRuntimePath: options.hookRuntimePath })
+            : { hookRuntimePath: options.hookRuntimePath }),
+        ...((options.hookTargets ?? args.hookTargets) === undefined
+            ? {}
+            : { hookTargets: options.hookTargets ?? args.hookTargets })
     });
     if (args.dryRun) {
         return okEnvelope("INIT_PLAN_READY", {
             applied: false,
-            plan,
+            plan: toPublicInstallPlan(plan),
             message: "Installation plan calculated; no files were written.",
             text: formatInstallPlan(plan)
         });
@@ -80,7 +84,7 @@ export async function runInitCommand(options) {
     await applyInstallPlan(options.root, plan);
     return okEnvelope("INIT_APPLIED", {
         applied: true,
-        plan,
+        plan: toPublicInstallPlan(plan),
         message: appliedMessage(plan)
     });
 }

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

@@ -2,8 +2,12 @@ import { buildReviewPacket } from "../../../../runtime/src/review/packet.js";
 import { runIndependentReview } from "../../../../runtime/src/review/runner.js";
 import { resolveReviewRole } from "../../../../runtime/src/review/roles.js";
 import { okEnvelope } from "../output.js";
+/**
+ * Review runs against one harness. Argument parsing already rejects a
+ * multi-harness selection here, so the first entry is the whole selection.
+ */
 function harness(value) {
-    return value === "claude" ? "claude" : "codex";
+    return value?.[0] ?? "codex";
 }
 export async function runReviewCommand(options) {
     const ids = options.args.criteria ?? [];

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

@@ -1,6 +1,7 @@
 import { applyUninstallPlan, createUninstallPlan } from "../../../../runtime/src/install/uninstall.js";
 import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
+import { toPublicUninstallPlan } from "../public-plan.js";
 function formatUninstallPlan(plan) {
     return formatOperationPlan({
         title: "Uninstall plan",
@@ -13,14 +14,14 @@ function formatUninstallPlan(plan) {
                     `Harness: ${plan.manifest.harness}`
                 ])
         ],
-        operations: plan.operations
+        operations: toPublicUninstallPlan(plan).operations
     });
 }
 function uninstallError(code, message, plan) {
     return {
         code,
         status: "error",
-        data: { applied: false, plan, message },
+        data: { applied: false, plan: toPublicUninstallPlan(plan), message },
         errors: [{ code, message }]
     };
 }
@@ -29,14 +30,14 @@ export async function runUninstallCommand(options) {
     if (!plan.installed) {
         return okEnvelope("UNINSTALL_NOT_INSTALLED", {
             applied: false,
-            plan,
+            plan: toPublicUninstallPlan(plan),
             message: "No managed installation exists."
         });
     }
     if (options.args.dryRun) {
         return okEnvelope("UNINSTALL_PLAN_READY", {
             applied: false,
-            plan,
+            plan: toPublicUninstallPlan(plan),
             message: "Uninstall plan calculated; no files were changed.",
             text: formatUninstallPlan(plan)
         });
@@ -51,7 +52,7 @@ export async function runUninstallCommand(options) {
     await applyUninstallPlan(options.root, plan);
     return okEnvelope("UNINSTALL_APPLIED", {
         applied: true,
-        plan,
+        plan: toPublicUninstallPlan(plan),
         message: "Managed installation content was removed."
     });
 }

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

@@ -1,25 +1,27 @@
 import { applyUpdatePlan, createUpdatePlan } from "../../../../runtime/src/install/update.js";
 import { okEnvelope } from "../output.js";
 import { formatOperationPlan } from "../plan-output.js";
+import { toPublicUpdatePlan } from "../public-plan.js";
 export function formatUpdatePlan(plan) {
     return formatOperationPlan({
         title: "Update plan",
         metadata: [
             `Target version: ${plan.targetVersion}`,
+            `Harness: ${plan.installation.harness.join(", ")}`,
             `Schema migrations: ${plan.migrationSteps.length === 0
                 ? "none"
                 : plan.migrationSteps
                     .map(({ fromVersion, toVersion }) => `${fromVersion} -> ${toVersion}`)
                     .join(", ")}`
         ],
-        operations: plan.installation.operations
+        operations: toPublicUpdatePlan(plan).installation.operations
     });
 }
 function updateError(code, message, plan) {
     return {
         code,
         status: "error",
-        data: { applied: false, plan, message },
+        data: { applied: false, plan: toPublicUpdatePlan(plan), message },
         errors: [{ code, message }]
     };
 }
@@ -27,20 +29,29 @@ export async function runUpdateCommand(options) {
     const plan = await createUpdatePlan({
         root: options.root,
         adapters: options.adapters,
+        ...(options.args.harness === undefined
+            ? {}
+            : { harness: options.args.harness }),
         ...(options.registry === undefined
             ? {}
             : { registry: options.registry }),
         ...(options.targetVersion === undefined
             ? {}
             : { targetVersion: options.targetVersion }),
+        ...(options.toolkitVersion === undefined
+            ? {}
+            : { toolkitVersion: options.toolkitVersion }),
         ...(options.hookRuntimePath === undefined
             ? {}
-            : { hookRuntimePath: options.hookRuntimePath })
+            : { hookRuntimePath: options.hookRuntimePath }),
+        ...((options.hookTargets ?? options.args.hookTargets) === undefined
+            ? {}
+            : { hookTargets: options.hookTargets ?? options.args.hookTargets })
     });
     if (options.args.dryRun) {
         return okEnvelope("UPDATE_PLAN_READY", {
             applied: false,
-            plan,
+            plan: toPublicUpdatePlan(plan),
             message: "Update plan calculated; no files were changed.",
             text: formatUpdatePlan(plan)
         });
@@ -55,7 +66,7 @@ export async function runUpdateCommand(options) {
     await applyUpdatePlan(options.root, plan);
     return okEnvelope("UPDATE_APPLIED", {
         applied: true,
-        plan,
+        plan: toPublicUpdatePlan(plan),
         message: `Managed installation updated to ${plan.targetVersion}.`
     });
 }

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

@@ -1,16 +1,22 @@
 import { execFileSync } from "node:child_process";
 import { homedir } from "node:os";
 import { join } from "node:path";
+import { calculateConfigHash } from "../../../runtime/src/config/hash.js";
+import { sha256 } from "../../../runtime/src/fs/hash.js";
 import { loadConfigFile } from "../../../runtime/src/config/load.js";
 import { mergeConfigLayers } from "../../../runtime/src/config/merge.js";
-import { sha256 } from "../../../runtime/src/fs/hash.js";
 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: 1,
+    schemaVersion: 2,
     profiles: [],
     verification: { commands: [] },
+    features: {
+        stopVerification: {
+            enabled: false
+        }
+    },
     pathMappings: [],
     securityExceptions: []
 };
@@ -73,6 +79,66 @@ export async function loadEffectiveConfig(root, scope) {
     }
     return mergeConfigLayers(layers);
 }
+/**
+ * Classifies only configuration that can participate in a project hook. The
+ * regular command loader intentionally keeps its throwing contract so CLI
+ * commands continue to surface configuration errors to the human.
+ */
+export async function loadProjectHookConfig(root) {
+    const home = process.env.AGENT_OPS_HOME ?? homedir();
+    const userPath = join(home, ".agent-ops", "config.json");
+    const projectPath = join(root, ".agent-ops", "config.json");
+    const layers = [defaultConfigLayer()];
+    let project;
+    try {
+        project = await loadOptionalConfig(projectPath);
+    }
+    catch {
+        return { kind: "invalid", path: projectPath };
+    }
+    if (project === null && projectPath === userPath) {
+        return { kind: "absent", config: DEFAULT_CONFIG };
+    }
+    if (projectPath !== userPath) {
+        try {
+            const user = await loadOptionalConfig(userPath);
+            if (user !== null) {
+                layers.push({
+                    source: "user",
+                    sourcePath: user.sourcePath,
+                    config: user.config
+                });
+            }
+        }
+        catch {
+            // A user-level error cannot make a project with no own config deny a
+            // tool call, but it remains a classified failure for an installed
+            // project that does own a config.
+            return project === null
+                ? { kind: "absent", config: DEFAULT_CONFIG }
+                : { kind: "invalid", path: userPath };
+        }
+    }
+    if (project === null) {
+        try {
+            return { kind: "absent", config: mergeConfigLayers(layers).config };
+        }
+        catch {
+            return { kind: "absent", config: DEFAULT_CONFIG };
+        }
+    }
+    layers.push({
+        source: "project",
+        sourcePath: project.sourcePath,
+        config: project.config
+    });
+    try {
+        return { kind: "loaded", config: mergeConfigLayers(layers).config };
+    }
+    catch {
+        return { kind: "invalid", path: projectPath };
+    }
+}
 export function repositoryRemoteUrl(root) {
     try {
         return execFileSync("git", ["config", "--get", "remote.origin.url"], {
@@ -91,7 +157,7 @@ export async function repositoryTrust(root, config, cliVersion) {
         const binding = await calculateTrustBinding({
             repositoryPath: root,
             remoteUrl: repositoryRemoteUrl(root),
-            configHash: sha256(JSON.stringify(config)),
+            configHash: calculateConfigHash(config),
             runtimeHash: sha256(cliVersion)
         });
         return (await new FileTrustStore(state.trustStore, state.anchorDirectory).status(binding)).status;

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

@@ -1,7 +1,22 @@
-import { runHookCommand, HOOK_EVENTS } from "./commands/hook.js";
-import { loadEffectiveConfig, repositoryTrust } from "./context.js";
-const HARNESSES = new Set(["codex", "claude"]);
+import { execFile as execFileCallback } from "node:child_process";
+import { constants } from "node:fs";
+import { lstat, open } from "node:fs/promises";
+import { join } from "node:path";
+import { promisify } from "node:util";
+import { calculateConfigHash } from "../../../runtime/src/config/hash.js";
+import { parseInstallManifest, PROJECT_MANIFEST_PATH } from "../../../runtime/src/fs/manifest.js";
+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 { 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";
+import { loadProjectHookConfig, repositoryTrust } from "./context.js";
+const HARNESSES = new Set(HARNESS_IDS);
 const MAX_HOOK_INPUT_BYTES = 1024 * 1024;
+const MAX_HOOK_MANIFEST_BYTES = 1024 * 1024;
+const execFile = promisify(execFileCallback);
 async function readStdin(stream) {
     const chunks = [];
     let total = 0;
@@ -17,35 +32,235 @@ async function readStdin(stream) {
     }
     return Buffer.concat(chunks, total).toString("utf8");
 }
+function parseInput(source) {
+    try {
+        return JSON.parse(source);
+    }
+    catch {
+        return null;
+    }
+}
+function writeHookOutput(io, output) {
+    if (output.stdout.length > 0) {
+        io.writeStdout(output.stdout);
+    }
+    if (output.stderr.length > 0) {
+        io.writeStderr(output.stderr);
+    }
+}
+function failOpenOutput(harness, event) {
+    return harnessDescriptor(harness).runtime.formatOutput(event, {
+        action: "continue",
+        status: "PASS",
+        code: "HOOK_FAIL_OPEN"
+    });
+}
+async function readInstalledManifestForHarness(root, harness) {
+    try {
+        const path = await resolveContainedPath(root, PROJECT_MANIFEST_PATH);
+        const before = await lstat(path, { bigint: true });
+        if (!before.isFile() ||
+            before.size > BigInt(MAX_HOOK_MANIFEST_BYTES)) {
+            return false;
+        }
+        const handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+        try {
+            const opened = await handle.stat({ bigint: true });
+            const resolvedAgain = await resolveContainedPath(root, PROJECT_MANIFEST_PATH);
+            const after = await lstat(resolvedAgain, { bigint: true });
+            if (!opened.isFile() ||
+                opened.size > BigInt(MAX_HOOK_MANIFEST_BYTES) ||
+                after.dev !== before.dev ||
+                after.ino !== before.ino) {
+                return false;
+            }
+            const chunks = [];
+            let totalBytes = 0;
+            while (totalBytes <= MAX_HOOK_MANIFEST_BYTES) {
+                const chunk = Buffer.alloc(Math.min(64 * 1024, MAX_HOOK_MANIFEST_BYTES + 1 - totalBytes));
+                const { bytesRead } = await handle.read(chunk, 0, chunk.length, null);
+                if (bytesRead === 0) {
+                    return parseInstallManifest(Buffer.concat(chunks, totalBytes).toString("utf8")).harness.includes(harness);
+                }
+                chunks.push(chunk.subarray(0, bytesRead));
+                totalBytes += bytesRead;
+            }
+            return false;
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    catch {
+        return false;
+    }
+}
+async function hookConfigOutcome(root, loadConfig) {
+    if (loadConfig === undefined) {
+        return await loadProjectHookConfig(root);
+    }
+    try {
+        return { kind: "loaded", config: await loadConfig(root) };
+    }
+    catch {
+        return {
+            kind: "invalid",
+            path: join(root, ".agent-ops", "config.json")
+        };
+    }
+}
+async function invalidConfigOutput(options) {
+    const descriptor = harnessDescriptor(options.harness);
+    const normalized = normalizeHookInput(options.harness, options.input);
+    if (normalized === null) {
+        return failOpenOutput(options.harness, options.event);
+    }
+    if (options.event !== "PreToolUse" ||
+        normalized.event !== "command" ||
+        !(await readInstalledManifestForHarness(options.root, options.harness))) {
+        return failOpenOutput(options.harness, options.event);
+    }
+    const registration = descriptor.control.registrations.find(({ nativeEvent, normalizedEvent }) => nativeEvent === options.event && normalizedEvent === normalized.event);
+    if (registration === undefined || registration.runtimeFailure === "fail-open") {
+        return failOpenOutput(options.harness, options.event);
+    }
+    if (options.harness === "opencode" &&
+        registration.runtimeFailure === "fail-closed") {
+        // The generated OpenCode plugin already turns an unavailable runtime into
+        // its documented blocking error. Keep that contract in the shim.
+        return undefined;
+    }
+    const remedy = `Fix ${redactSecrets(options.configPath)}, or set AGENT_OPS_DISABLE=1 in your shell to temporarily disable agent-ops.`;
+    return descriptor.runtime.formatRuntimeFailure(options.event, registration.capability, remedy);
+}
+function defaultGitRunner(root) {
+    return {
+        run: async (args) => {
+            try {
+                const result = await execFile("git", [...args], {
+                    cwd: root,
+                    encoding: "buffer"
+                });
+                return {
+                    exitCode: 0,
+                    stdout: result.stdout
+                };
+            }
+            catch (error) {
+                const failure = error;
+                return {
+                    exitCode: failure.status ?? 1,
+                    stdout: failure.stdout ?? new Uint8Array()
+                };
+            }
+        }
+    };
+}
+function stopVerificationOptions(input) {
+    const nativeRecursion = input.harness === "claude" &&
+        claudeStopRecursionMarker(input.rawInput);
+    const recursionActive = nativeRecursion || process.env[STOP_VERIFICATION_ENV] === "1";
+    const configHash = calculateConfigHash(input.config);
+    return {
+        confirmedConfig: true,
+        trusted: input.trusted,
+        scopeMapped: true,
+        recursionMarker: recursionActive,
+        configHash,
+        verify: async () => await new StopVerificationService({
+            root: input.root,
+            config: input.config,
+            trusted: input.trusted,
+            gitRunner: input.gitRunner,
+            processRunner: input.processRunner,
+            recursionActive,
+            configHash
+        }).verify()
+    };
+}
+function shouldBuildStopVerification(harness, event, config, rawInput) {
+    if (event !== "Stop" || !config.features.stopVerification.enabled) {
+        return false;
+    }
+    let normalized;
+    try {
+        normalized = harnessDescriptor(harness).runtime.normalizeInput(rawInput);
+    }
+    catch {
+        return false;
+    }
+    if (normalized.event !== "stop") {
+        return false;
+    }
+    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.
  */
-export async function runHookProcess(argv, io, cliVersion) {
+export async function runHookProcess(argv, io, cliVersion, dependencies = {}) {
     const [harness, event] = argv;
     if (harness === undefined ||
         !HARNESSES.has(harness) ||
         event === undefined ||
         !HOOK_EVENTS.includes(event)) {
-        io.writeStderr("Usage: agent-ops hook <codex|claude> <SessionStart|PreToolUse|Stop>\n");
+        io.writeStderr(`Usage: agent-ops hook <${HARNESS_IDS.join("|")}> <SessionStart|PreToolUse|Stop>\n`);
         return 0;
     }
     try {
-        const root = process.cwd();
-        const config = (await loadEffectiveConfig(root, "project")).config;
+        const root = dependencies.root ?? process.cwd();
+        const harnessId = harness;
+        const hookEvent = event;
+        if (process.env.AGENT_OPS_DISABLE === "1") {
+            writeHookOutput(io, failOpenOutput(harnessId, hookEvent));
+            return 0;
+        }
+        const rawInput = await readStdin(io.stdin);
+        const parsedInput = parseInput(rawInput);
+        const configOutcome = await hookConfigOutcome(root, dependencies.loadConfig);
+        if (configOutcome.kind === "invalid") {
+            const output = await invalidConfigOutput({
+                root,
+                harness: harnessId,
+                event: hookEvent,
+                input: parsedInput,
+                configPath: configOutcome.path
+            });
+            if (output !== undefined) {
+                writeHookOutput(io, output);
+            }
+            return 0;
+        }
+        const config = configOutcome.config;
+        const trustStatus = dependencies.trust === undefined
+            ? await repositoryTrust(root, config, cliVersion)
+            : await dependencies.trust(root, config, cliVersion);
+        const trusted = trustStatus === "TRUSTED";
+        const gitRunner = dependencies.gitRunner ?? defaultGitRunner(root);
+        const processRunner = dependencies.processRunner ?? new NodeVerificationProcessRunner();
+        const stopVerification = shouldBuildStopVerification(harnessId, event, config, parsedInput)
+            ? stopVerificationOptions({
+                harness: harness,
+                rawInput: parsedInput,
+                root,
+                config,
+                trusted,
+                gitRunner,
+                processRunner
+            })
+            : undefined;
         const output = await runHookCommand({
             harness: harness,
-            event: event,
-            stdin: await readStdin(io.stdin),
+            event: hookEvent,
+            stdin: rawInput,
             config,
-            trusted: (await repositoryTrust(root, config, cliVersion)) === "TRUSTED"
+            trusted,
+            ...(dependencies.advisory === undefined
+                ? {}
+                : { advisory: dependencies.advisory }),
+            ...(stopVerification === undefined ? {} : { stopVerification })
         });
-        if (output.stdout.length > 0) {
-            io.writeStdout(output.stdout);
-        }
-        if (output.stderr.length > 0) {
-            io.writeStderr(output.stderr);
-        }
+        writeHookOutput(io, output);
     }
     catch {
         // ponytail: fail-open by design; hook failures stay invisible to the harness.

package/dist/packages/cli/src/loop-entry.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+// Entry point used only by the generated project-local loop launchers.
+import { runLoopProcess } from "./codex-loop-process.js";
+process.exitCode = await runLoopProcess(process.argv.slice(2), {
+    stdin: process.stdin,
+    writeStdout: (value) => process.stdout.write(value),
+    writeStderr: (value) => process.stderr.write(value)
+});

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

@@ -18,10 +18,15 @@ export function formatOperationPlan(options) {
     for (const operation of options.operations) {
         lines.push(`- ${operation.kind} ${escapeTerminalText(operation.path)}`, `  expected: ${operation.expectedHash ?? "<absent>"}`);
         if (operation.kind === "write") {
-            lines.push("  content:", ...operation.content
-                .replace(/\n$/u, "")
-                .split("\n")
-                .map((line) => `    ${escapeTerminalText(line)}`));
+            if ("contentHash" in operation) {
+                lines.push(`  content: <opaque ${escapeTerminalText(operation.contentHash)}>`, `  summary: ${escapeTerminalText(operation.summary)}`);
+            }
+            else {
+                lines.push("  content:", ...operation.content
+                    .replace(/\n$/u, "")
+                    .split("\n")
+                    .map((line) => `    ${escapeTerminalText(line)}`));
+            }
         }
     }
     return `${lines.join("\n")}\n`;