javi-forge 1.35.1 → 1.37.0

package/dist/commands/codex-hooks.js

@@ -0,0 +1,106 @@
+/**
+ * `javi-forge hooks <install|doctor|repair> codex` — console-only renderer for
+ * the Codex PreToolUse guard library (agent-agnostic slice 2). It wires the
+ * install/doctor/repair lib fns to human output + exit codes; it adds NO new
+ * security logic and never touches `runTransaction`/secure-fs directly.
+ *
+ * Doctor exit code follows the effective-execution verdict (runnable → 0,
+ * blocked → 1, inconclusive → 2), independent of any component health — the same
+ * honest-execution contract as the Claude renderer. The UNTRUSTED state is a
+ * `blocked` verdict (an untrusted Codex hook is silently skipped), so a fresh
+ * install correctly reports blocked until the user grants trust.
+ */
+import { doctorCodexPreToolUse, installCodexPreToolUse, repairCodexPreToolUse, } from "../lib/codex-hook-manager.js";
+function renderWarnings(warnings, log) {
+    if (warnings.length === 0)
+        return;
+    log("warnings:");
+    for (const w of warnings)
+        log(`  ${w}`);
+}
+function renderMutation(verb, result, log, logError) {
+    if (result.ok) {
+        log(`${verb} codex: ok`);
+        if (result.changed.length > 0) {
+            log("changed:");
+            for (const p of result.changed)
+                log(`  ${p}`);
+        }
+        else {
+            log("changed: nothing (already up to date)");
+        }
+        log(`trust: ${result.report.trust.state}`);
+        if (result.report.trust.state === "untrusted") {
+            log(`  → ${result.report.trust.grantCommand}`);
+        }
+        renderWarnings(result.warnings, log);
+        return 0;
+    }
+    logError(`${verb} codex: refused`);
+    for (const e of result.errors)
+        logError(`  ${e}`);
+    renderWarnings(result.warnings, log);
+    return 1;
+}
+function renderDoctor(report, log) {
+    log(`doctor codex: ${report.healthy ? "healthy" : "unhealthy"}`);
+    if (report.platformSupport)
+        log(`  platform-support: ${report.platformSupport.state} — ${report.platformSupport.guidance}`);
+    log(`  hooks.json: ${report.hooksJson.state}`);
+    log(`  config:    [features] hooks=${report.config.featuresHooks} (readable: ${report.config.readable})`);
+    log(`  trust:     ${report.trust.state}`);
+    log(`  asset:     ${report.asset.state}`);
+    log(`  node:      ${report.node.version ?? "unavailable"} (min-satisfied: ${report.node.satisfiesMinimum})`);
+    const onPath = report.nodeOnPath;
+    const onPathDetail = onPath.status === "resolved"
+        ? ` ${onPath.version}`
+        : onPath.status === "unknown"
+            ? ` — ${onPath.detail}`
+            : "";
+    log(`  node-on-PATH: ${onPath.status}${onPathDetail} (heuristic: this process' PATH)`);
+    log(`  execution: ${report.execution.status}`);
+    if (report.execution.blockers.length > 0) {
+        log("  blockers:");
+        for (const b of report.execution.blockers)
+            log(`    - ${b}`);
+    }
+    if (report.execution.unknownSources.length > 0) {
+        log("  unknown-sources:");
+        for (const u of report.execution.unknownSources)
+            log(`    - ${u}`);
+    }
+    if (report.execution.residual.length > 0) {
+        log("  execution-residual:");
+        for (const r of report.execution.residual)
+            log(`    - ${r}`);
+    }
+    if (report.remediation.length > 0) {
+        log("  remediation:");
+        for (const r of report.remediation)
+            log(`    - ${r}`);
+    }
+    if (report.execution.status === "blocked")
+        return 1;
+    if (report.execution.status === "inconclusive")
+        return 2;
+    return 0;
+}
+export async function runCodexHookCommand(sub, _cwd, opts, deps = {}) {
+    const log = deps.log ?? ((m) => console.log(m));
+    const logError = deps.logError ?? ((m) => console.error(m));
+    const install = deps.install ?? installCodexPreToolUse;
+    const doctor = deps.doctor ?? doctorCodexPreToolUse;
+    const repair = deps.repair ?? repairCodexPreToolUse;
+    // Codex config is user-global (~/.codex). `cwd` is accepted for CLI symmetry
+    // with the Claude command; the home dir is what the manager operates on.
+    const home = deps.homeDir;
+    if (sub === "install") {
+        return renderMutation("install", await install(home), log, logError);
+    }
+    if (sub === "repair") {
+        const result = await repair(home, { force: opts.force === true });
+        return renderMutation("repair", result, log, logError);
+    }
+    return renderDoctor(await doctor(home), log);
+}
+//# sourceMappingURL=codex-hooks.js.map

package/dist/commands/init.d.ts

@@ -1,3 +1,4 @@
+import { type PlatformSupport } from "../lib/platform-support.js";
 import type { InitOptions } from "../types/index.js";
 import type { StepCallback } from "./init/types.js";
 /**
@@ -6,5 +7,12 @@ import type { StepCallback } from "./init/types.js";
  *
  * Pure dispatch: every step lives in src/commands/init/steps/.
  */
-export declare function initProject(options: InitOptions, onStep: StepCallback): Promise<void>;
+export type InitProjectResult = {
+    ok: true;
+} | {
+    ok: false;
+    refusalCode: string;
+    platformSupport: PlatformSupport;
+};
+export declare function initProject(options: InitOptions, onStep: StepCallback): Promise<InitProjectResult>;
 //# sourceMappingURL=init.d.ts.map

package/dist/commands/init.js

@@ -1,4 +1,5 @@
 import { ensureDirExists } from "../lib/common.js";
+import { resolvePlatformSupport, } from "../lib/platform-support.js";
 import { stepAgentSkills } from "./init/steps/agent-skills.js";
 import { stepAISync } from "./init/steps/ai-sync.js";
 import { stepCITemplate, stepDependabot } from "./init/steps/ci.js";
@@ -15,13 +16,15 @@ import { stepMemory } from "./init/steps/memory.js";
 import { stepMock } from "./init/steps/mock.js";
 import { stepSDD } from "./init/steps/sdd.js";
 import { stepSecurityHooks } from "./init/steps/security.js";
-/**
- * Main init orchestrator: bootstraps a project with CI, git hooks,
- * memory module, AI config sync, SDD, ghagga, and friends.
- *
- * Pure dispatch: every step lives in src/commands/init/steps/.
- */
 export async function initProject(options, onStep) {
+    const platformSupport = resolvePlatformSupport(process.platform);
+    if (platformSupport) {
+        return {
+            ok: false,
+            refusalCode: platformSupport.refusalCode,
+            platformSupport,
+        };
+    }
     const { projectDir, dryRun } = options;
     // Ensure project directory exists before any steps
     if (!dryRun && projectDir) {
@@ -47,5 +50,6 @@ export async function initProject(options, onStep) {
     await stepLocalAi(ctx);
     await stepAgentSkills(ctx);
     await stepManifest(ctx);
+    return { ok: true };
 }
 //# sourceMappingURL=init.js.map

package/dist/lib/__fixtures__/claude-hook-ownership.d.ts

@@ -24,6 +24,12 @@ export declare const LEGACY_FILE_SHA256 = "b4638222ecddc2daac6ec3339596d853a6269
 export declare const MANAGED_MATCHER = "Bash|PowerShell|Read|Write|Edit";
 /** Single project-local MJS argument, kept as a literal placeholder path. */
 export declare const MANAGED_ASSET_ARG = "${CLAUDE_PROJECT_DIR}/.claude/hooks/javi-forge-skillguard-pre-tool-use.mjs";
+/**
+ * The agent selector the install writer appends after the asset path. The runtime
+ * fails closed without it (no agent config = cannot know what to protect), so it is
+ * part of the managed command shape and the canonical settings identity.
+ */
+export declare const MANAGED_AGENT_ARG = "--agent=claude";
 /** Exact asset filename under `.claude/hooks/`. */
 export declare const ASSET_NAME = "javi-forge-skillguard-pre-tool-use.mjs";
 /** Exact first-line comment marking the managed asset. */

package/dist/lib/__fixtures__/claude-hook-ownership.js

@@ -25,6 +25,12 @@ export const LEGACY_FILE_SHA256 = "b4638222ecddc2daac6ec3339596d853a626906bbd123
 export const MANAGED_MATCHER = "Bash|PowerShell|Read|Write|Edit";
 /** Single project-local MJS argument, kept as a literal placeholder path. */
 export const MANAGED_ASSET_ARG = "${CLAUDE_PROJECT_DIR}/.claude/hooks/javi-forge-skillguard-pre-tool-use.mjs";
+/**
+ * The agent selector the install writer appends after the asset path. The runtime
+ * fails closed without it (no agent config = cannot know what to protect), so it is
+ * part of the managed command shape and the canonical settings identity.
+ */
+export const MANAGED_AGENT_ARG = "--agent=claude";
 /** Exact asset filename under `.claude/hooks/`. */
 export const ASSET_NAME = "javi-forge-skillguard-pre-tool-use.mjs";
 /** Exact first-line comment marking the managed asset. */
@@ -44,7 +50,7 @@ export function managedHandler(assetSha = SAMPLE_ASSET_SHA256) {
     return {
         type: "command",
         command: "node",
-        args: [MANAGED_ASSET_ARG],
+        args: [MANAGED_ASSET_ARG, MANAGED_AGENT_ARG],
         timeout: 30,
         statusMessage: managedStatusMessage(assetSha),
     };

package/dist/lib/agent-adapter.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Agent adapter registry (agent-agnostic slice 2). One descriptor per host
+ * (`claude`, `codex`) capturing the per-agent facts the SkillGuard installer and
+ * doctor need: config paths, the protected managed set, the project-root source,
+ * the settings-schema validator (SHARED — both hosts use the identical hooks
+ * schema), the managed marker, the deny protocol, and the trust model.
+ *
+ * This descriptor is additive: Codex is routed through it, while Claude keeps its
+ * existing, byte-identical runtime path (the descriptor only DESCRIBES Claude; it
+ * does not change how the Claude command executes). The CLI dispatch decides the
+ * valid `hooks <sub> <agent>` target set through `isAgentId` (backed by the
+ * `AGENT_ADAPTERS` keys) — this registry is the single source of agent truth, and
+ * a new agent added here cannot be silently dropped: the dispatch's command-loader
+ * map is typed `Record<AgentId, …>`, so omitting a loader is a compile error.
+ */
+import { validateSettingsShape } from "./claude-hook-settings.js";
+export type AgentId = "claude" | "codex";
+export type TrustState = "trusted" | "untrusted" | "unknown";
+export interface TrustDescriptor {
+    /** Detect whether the installed hook is TRUSTED from the host config text. */
+    detect(configText: string, hooksFile: string): TrustState;
+    /** The exact step a human runs to grant trust (no non-interactive path exists). */
+    grantCommand(hooksFile: string): string;
+}
+export interface AgentAdapter {
+    id: AgentId;
+    /** Resolve the two host config files from a base dir (project root or home). */
+    configPaths(baseDir: string): {
+        hooksFile: string;
+        settingsFile: string;
+    };
+    /** Relative protected paths the guard refuses writes to (from AGENT_CONFIGS). */
+    managedSet: readonly string[];
+    /** Project-root source: an env var, or null → the envelope `cwd` (Codex). */
+    projectDir: {
+        envVar: string | null;
+    };
+    /** SHARED settings-schema validator — the hooks container shape is identical. */
+    settingsSchema: typeof validateSettingsShape;
+    /** The managed asset marker for this host. */
+    marker: string;
+    /** Deny protocol emitted by the shared `.mjs` — the same on both hosts. */
+    emitDeny: "exit2+stderr";
+    /** Hook-trust model, or null when the host has none (Claude). */
+    trust: TrustDescriptor | null;
+}
+export declare const claudeAdapter: AgentAdapter;
+export declare const codexAdapter: AgentAdapter;
+export declare const AGENT_ADAPTERS: Record<AgentId, AgentAdapter>;
+/**
+ * Whether a raw CLI token names a known agent adapter. Backed by the
+ * `AGENT_ADAPTERS` registry so there is ONE source deciding valid targets: adding
+ * an adapter to the registry automatically widens the accepted CLI set.
+ */
+export declare function isAgentId(value: unknown): value is AgentId;
+//# sourceMappingURL=agent-adapter.d.ts.map

package/dist/lib/agent-adapter.js

@@ -0,0 +1,88 @@
+/**
+ * Agent adapter registry (agent-agnostic slice 2). One descriptor per host
+ * (`claude`, `codex`) capturing the per-agent facts the SkillGuard installer and
+ * doctor need: config paths, the protected managed set, the project-root source,
+ * the settings-schema validator (SHARED — both hosts use the identical hooks
+ * schema), the managed marker, the deny protocol, and the trust model.
+ *
+ * This descriptor is additive: Codex is routed through it, while Claude keeps its
+ * existing, byte-identical runtime path (the descriptor only DESCRIBES Claude; it
+ * does not change how the Claude command executes). The CLI dispatch decides the
+ * valid `hooks <sub> <agent>` target set through `isAgentId` (backed by the
+ * `AGENT_ADAPTERS` keys) — this registry is the single source of agent truth, and
+ * a new agent added here cannot be silently dropped: the dispatch's command-loader
+ * map is typed `Record<AgentId, …>`, so omitting a loader is a compile error.
+ */
+import path from "node:path";
+import { ASSET_NAME } from "./__fixtures__/claude-hook-ownership.js";
+import { validateSettingsShape } from "./claude-hook-settings.js";
+import { codexConfigPaths, codexTrustGrantCommand, hasCodexTrustEntry, } from "./codex-hook-manager.js";
+const CLAUDE_MANAGED_SET = [
+    ".claude/settings.json",
+    ".claude/settings.local.json",
+    ".claude/CLAUDE.md",
+    "CLAUDE.md",
+    ".javi-forge/ci.yaml",
+    ".claude/hooks/",
+    ".claude/agents/",
+    ".claude/skills/",
+];
+const CODEX_MANAGED_SET = [
+    ".codex/hooks.json",
+    ".claude/settings.json",
+    ".claude/settings.local.json",
+    ".claude/CLAUDE.md",
+    "CLAUDE.md",
+    ".javi-forge/ci.yaml",
+    ".claude/hooks/",
+    ".claude/agents/",
+    ".claude/skills/",
+];
+export const claudeAdapter = {
+    id: "claude",
+    configPaths(projectDir) {
+        return {
+            hooksFile: path.join(projectDir, ".claude", "hooks", ASSET_NAME),
+            settingsFile: path.join(projectDir, ".claude", "settings.json"),
+        };
+    },
+    managedSet: CLAUDE_MANAGED_SET,
+    projectDir: { envVar: "CLAUDE_PROJECT_DIR" },
+    settingsSchema: validateSettingsShape,
+    marker: "// javi-forge-managed: claude-pretooluse v1",
+    emitDeny: "exit2+stderr",
+    trust: null,
+};
+export const codexAdapter = {
+    id: "codex",
+    configPaths(homeDir) {
+        const paths = codexConfigPaths(homeDir);
+        return { hooksFile: paths.hooksFile, settingsFile: paths.configFile };
+    },
+    managedSet: CODEX_MANAGED_SET,
+    projectDir: { envVar: null },
+    settingsSchema: validateSettingsShape,
+    marker: "// javi-forge-managed: codex-pretooluse v1",
+    emitDeny: "exit2+stderr",
+    trust: {
+        detect(configText, hooksFile) {
+            return hasCodexTrustEntry(configText, hooksFile)
+                ? "trusted"
+                : "untrusted";
+        },
+        grantCommand: codexTrustGrantCommand,
+    },
+};
+export const AGENT_ADAPTERS = {
+    claude: claudeAdapter,
+    codex: codexAdapter,
+};
+/**
+ * Whether a raw CLI token names a known agent adapter. Backed by the
+ * `AGENT_ADAPTERS` registry so there is ONE source deciding valid targets: adding
+ * an adapter to the registry automatically widens the accepted CLI set.
+ */
+export function isAgentId(value) {
+    return typeof value === "string" && Object.hasOwn(AGENT_ADAPTERS, value);
+}
+//# sourceMappingURL=agent-adapter.js.map

package/dist/lib/claude-hook-manager.d.ts

@@ -8,6 +8,7 @@
  * Slice-3 seams — Slice 3 GROWS this file, it does not relocate this code.
  */
 import { type ClaudeHookComponentState, type SettingsClassification, type SettingsIdentityManifest } from "./claude-hook-settings.js";
+import { type PlatformSupport } from "./platform-support.js";
 import { type AclCapability, type SpawnFn } from "./secure-fs-posix.js";
 import { type PlatformSecureFs } from "./secure-fs-transaction.js";
 declare const COVERAGE: readonly ["Bash", "PowerShell", "Read", "Write", "Edit"];
@@ -29,6 +30,7 @@ export interface ClaudeHookAssetClassification {
 }
 export interface ClaudeHookDoctorReport {
     healthy: boolean;
+    platformSupport?: PlatformSupport;
     settings: {
         state: ClaudeHookComponentState;
         version?: number;
@@ -207,8 +209,9 @@ export declare function doctorClaudePreToolUse(projectDir: string, options?: {
     execution?: ExecutionProbeEnv;
     /** Injectable read-only ACL capability probe (defaults to the real one). */
     aclProbe?: () => Promise<AclCapability>;
+    platform?: NodeJS.Platform;
 }): Promise<ClaudeHookDoctorReport>;
-export interface ClaudeHookMutationResult {
+interface ClaudeHookMutationResultWithReport {
     ok: boolean;
     changed: string[];
     backups: string[];
@@ -220,7 +223,19 @@ export interface ClaudeHookMutationResult {
      * which is strictly worse than an exec-form guard that may not resolve.
      */
     warnings: string[];
+    lifecycleRefusal?: never;
+}
+interface ClaudeHookLifecycleRefusal {
+    ok: false;
+    changed: string[];
+    backups: string[];
+    errors: string[];
+    warnings: string[];
+    /** The lifecycle gate refused before any doctor or installed-state probe. */
+    lifecycleRefusal: PlatformSupport;
+    report?: never;
 }
+export type ClaudeHookMutationResult = ClaudeHookMutationResultWithReport | ClaudeHookLifecycleRefusal;
 /** Injectable deps so tests drive `_run` with a fake `PlatformSecureFs`. */
 export interface ClaudeHookRunDeps {
     secureFs?: PlatformSecureFs | null;
@@ -236,6 +251,7 @@ export interface ClaudeHookRunDeps {
     aclProbe?: () => Promise<AclCapability>;
     /** Injectable node-on-PATH heuristic, shared by the warning and the report. */
     nodeProbe?: () => Promise<NodeOnPathProbe>;
+    doctor?: typeof doctorClaudePreToolUse;
 }
 /** Internal deps-taking entry; tests drive it with a fake `PlatformSecureFs`. */
 export declare function _run(projectDir: string, mode: "install" | "repair", options: {

package/dist/lib/claude-hook-manager.js

@@ -14,7 +14,8 @@ import os from "node:os";
 import path from "node:path";
 import { CLAUDE_HOOK_ASSETS_DIR } from "../constants.js";
 import { ASSET_MANAGED_MARKER, ASSET_NAME, } from "./__fixtures__/claude-hook-ownership.js";
-import { buildManagedContainer, classifySettingsEntry, isPlainObject, LEGACY_FILE_SHA256, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX, planForceReplace, planLegacyCohortExcision, planManagedClaudeHookMerge, scanExecutionFlags, } from "./claude-hook-settings.js";
+import { buildManagedContainer, classifySettingsEntry, isPlainObject, LEGACY_FILE_SHA256, MANAGED_AGENT_ARG, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX, planForceReplace, planLegacyCohortExcision, planManagedClaudeHookMerge, scanExecutionFlags, } from "./claude-hook-settings.js";
+import { resolvePlatformSupport, } from "./platform-support.js";
 import { safeReadFile } from "./safe-read.js";
 import { ACL_DETAIL, probeAclCapability, selectSecureFs, } from "./secure-fs-posix.js";
 import { runTransaction, } from "./secure-fs-transaction.js";
@@ -174,8 +175,9 @@ function settingsSignals(value, classification, currentAssetSha) {
     const commandShapeExact = handler.type === "command" &&
         handler.command === "node" &&
         Array.isArray(args) &&
-        args.length === 1 &&
+        args.length === 2 &&
         args[0] === MANAGED_ASSET_ARG &&
+        args[1] === MANAGED_AGENT_ARG &&
         handler.timeout === 30;
     let assetSettingsConsistent = false;
     if (typeof handler.statusMessage === "string" &&
@@ -536,7 +538,9 @@ export async function doctorClaudePreToolUse(projectDir, options) {
         execution.blockers.some((blocker) => blocker.startsWith("guard:"))) {
         remediation.add(aclRemediation);
     }
+    const platformSupport = resolvePlatformSupport(options?.platform ?? process.platform);
     return {
+        ...(platformSupport ? { platformSupport } : {}),
         healthy,
         settings: {
             state: settings.state,
@@ -711,8 +715,20 @@ function serializeSettings(container) {
 }
 /** Internal deps-taking entry; tests drive it with a fake `PlatformSecureFs`. */
 export async function _run(projectDir, mode, options, deps) {
-    const manifest = deps.manifest ?? (await readManifest());
     const platform = deps.platform ?? process.platform;
+    const platformSupport = resolvePlatformSupport(platform);
+    if (platformSupport) {
+        return {
+            ok: false,
+            changed: [],
+            backups: [],
+            errors: [platformSupport.refusalCode],
+            warnings: [platformSupport.guidance],
+            lifecycleRefusal: platformSupport,
+        };
+    }
+    const doctorFn = deps.doctor ?? doctorClaudePreToolUse;
+    const manifest = deps.manifest ?? (await readManifest());
     const secureFs = deps.secureFs !== undefined ? deps.secureFs : selectSecureFs(platform);
     const clock = deps.clock ?? (() => new Date());
     const nonce = deps.nonce ?? (() => randomBytes(4).toString("hex"));
@@ -724,7 +740,7 @@ export async function _run(projectDir, mode, options, deps) {
     // report, so the run never spawns `node --version` twice and the warning, the
     // report row and the verdict can never disagree about the same PATH.
     const nodeOnPath = await (deps.nodeProbe ?? probeNodeOnPath)();
-    const doctor = () => doctorClaudePreToolUse(projectDir, {
+    const doctor = () => doctorFn(projectDir, {
         manifest,
         aclProbe: deps.aclProbe,
         execution: { nodeProbe: async () => nodeOnPath },

package/dist/lib/claude-hook-settings.d.ts

@@ -8,8 +8,8 @@
  * removal/merge PLANNING only. Identity is always recomputed from observed
  * structure; a marker only claims ownership, it never proves it.
  */
-import { ASSET_SHA_PLACEHOLDER, LEGACY_FILE_SHA256, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX } from "./__fixtures__/claude-hook-ownership.js";
-export { ASSET_SHA_PLACEHOLDER, LEGACY_FILE_SHA256, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX, };
+import { ASSET_SHA_PLACEHOLDER, LEGACY_FILE_SHA256, MANAGED_AGENT_ARG, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX } from "./__fixtures__/claude-hook-ownership.js";
+export { ASSET_SHA_PLACEHOLDER, LEGACY_FILE_SHA256, MANAGED_AGENT_ARG, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX, };
 /** The nine independent component states (identical for asset and settings). */
 export type ClaudeHookComponentState = "absent" | "managed-current" | "released-outdated" | "exact-legacy" | "edited-managed" | "foreign" | "symlink" | "non-regular" | "malformed";
 /** A released settings-entry identity: version plus placeholder-normalized hash. */
@@ -149,7 +149,7 @@ export declare function planManagedClaudeHookMerge(parsed: unknown, currentAsset
 export interface ManagedHandler {
     type: "command";
     command: "node";
-    args: [string];
+    args: [string, string];
     timeout: number;
     statusMessage: string;
 }

package/dist/lib/claude-hook-settings.js

@@ -9,8 +9,8 @@
  * structure; a marker only claims ownership, it never proves it.
  */
 import { createHash } from "node:crypto";
-import { ASSET_SHA_PLACEHOLDER, LEGACY_COHORT, LEGACY_FILE_SHA256, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX, } from "./__fixtures__/claude-hook-ownership.js";
-export { ASSET_SHA_PLACEHOLDER, LEGACY_FILE_SHA256, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX, };
+import { ASSET_SHA_PLACEHOLDER, LEGACY_COHORT, LEGACY_FILE_SHA256, MANAGED_AGENT_ARG, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX, } from "./__fixtures__/claude-hook-ownership.js";
+export { ASSET_SHA_PLACEHOLDER, LEGACY_FILE_SHA256, MANAGED_AGENT_ARG, MANAGED_ASSET_ARG, MANAGED_MATCHER, MANAGED_STATUS_PREFIX, };
 // Shape helpers
 export function isPlainObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -443,7 +443,7 @@ export function buildManagedContainer(currentAssetSha) {
                         {
                             type: "command",
                             command: "node",
-                            args: [MANAGED_ASSET_ARG],
+                            args: [MANAGED_ASSET_ARG, MANAGED_AGENT_ARG],
                             timeout: MANAGED_TIMEOUT,
                             statusMessage: `${MANAGED_STATUS_PREFIX}${currentAssetSha}`,
                         },