@zaip-ai/cli 6.3.0 → 7.5.0

package/dist/services/agent-guidance-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-guidance-types.d.ts","sourceRoot":"","sources":["../../src/services/agent-guidance-types.ts"],"names":[],"mappings":"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"}

package/dist/services/agent-guidance-types.js

@@ -0,0 +1,4 @@
+import { createHash } from "node:crypto";
+import { parse } from "yaml";
+import { codexModelConfig, codexModelInstructions } from "./codex-model-policy.js";
+//# sourceMappingURL=agent-guidance-types.js.map

package/dist/services/agent-guidance-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-guidance-types.js","sourceRoot":"","sources":["../../src/services/agent-guidance-types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC;AAC7B,OAAO,EAAE,gBAAgB,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC"}

package/dist/services/catalog-toml.d.ts

@@ -0,0 +1,4 @@
+export declare function tomlString(value: string): string;
+export declare function tomlArray(values: readonly string[]): string;
+export declare function tomlMultiline(value: string): string;
+//# sourceMappingURL=catalog-toml.d.ts.map

package/dist/services/catalog-toml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-toml.d.ts","sourceRoot":"","sources":["../../src/services/catalog-toml.ts"],"names":[],"mappings":"AAAA,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEhD;AAED,wBAAgB,SAAS,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAE3D;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/dist/services/catalog-toml.js

@@ -0,0 +1,10 @@
+export function tomlString(value) {
+    return JSON.stringify(value);
+}
+export function tomlArray(values) {
+    return `[${values.map(tomlString).join(", ")}]`;
+}
+export function tomlMultiline(value) {
+    return `"""\n${value.replaceAll('"""', '\\"\\"\\"')}\n"""`;
+}
+//# sourceMappingURL=catalog-toml.js.map

package/dist/services/catalog-toml.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-toml.js","sourceRoot":"","sources":["../../src/services/catalog-toml.ts"],"names":[],"mappings":"AAAA,MAAM,UAAU,UAAU,CAAC,KAAa;IACtC,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED,MAAM,UAAU,SAAS,CAAC,MAAyB;IACjD,OAAO,IAAI,MAAM,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC;AAClD,CAAC;AAED,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAO,QAAQ,KAAK,CAAC,UAAU,CAAC,KAAK,EAAE,WAAW,CAAC,OAAO,CAAC;AAC7D,CAAC"}

package/dist/services/catalog-write-scope.d.ts

@@ -0,0 +1,4 @@
+export declare function catalogWriteScopeInstructions(agent: {
+    readonly write_scopes: readonly string[];
+}, declaredPermissionAllowed: boolean): readonly string[];
+//# sourceMappingURL=catalog-write-scope.d.ts.map

package/dist/services/catalog-write-scope.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-write-scope.d.ts","sourceRoot":"","sources":["../../src/services/catalog-write-scope.ts"],"names":[],"mappings":"AAEA,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE;IAAE,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAA;CAAE,EACnD,yBAAyB,EAAE,OAAO,GACjC,SAAS,MAAM,EAAE,CAcnB"}

package/dist/services/catalog-write-scope.js

@@ -0,0 +1,18 @@
+// Portable rendering only. Each host supplies its resolved permission; this
+// helper never grants authority or resolves a Task writer claim.
+export function catalogWriteScopeInstructions(agent, declaredPermissionAllowed) {
+    const declared = agent.write_scopes.length > 0 && declaredPermissionAllowed;
+    return [
+        `Write scopes: ${declared ? "declared-write-scope" : agent.write_scopes.join(", ") || "read-only"}.`,
+        ...(declared
+            ? [
+                `Catalog layout hints (routing only, never grants): ${agent.write_scopes.join(", ")}.`,
+                "Before writing, resolve the real repository structure and exact scopes from the authenticated Task writer claim and bounded delegation. Missing authority blocks writing; catalog paths and this profile never create a Task grant. Preserve capabilities, read-only roles and every explicit deny.",
+            ]
+            : []),
+        agent.write_scopes.length === 0
+            ? "This role is read-only. Do not create, modify, move, or delete workspace files."
+            : "The Codex host grants workspace-write at the workspace boundary, not per-path. Treat the declared write scopes as mandatory: do not modify files outside them; report any required expansion to the parent before writing.",
+    ];
+}
+//# sourceMappingURL=catalog-write-scope.js.map

package/dist/services/catalog-write-scope.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog-write-scope.js","sourceRoot":"","sources":["../../src/services/catalog-write-scope.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,iEAAiE;AACjE,MAAM,UAAU,6BAA6B,CAC3C,KAAmD,EACnD,yBAAkC;IAElC,MAAM,QAAQ,GAAG,KAAK,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,IAAI,yBAAyB,CAAC;IAC5E,OAAO;QACL,iBAAiB,QAAQ,CAAC,CAAC,CAAC,sBAAsB,CAAC,CAAC,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,WAAW,GAAG;QACpG,GAAG,CAAC,QAAQ;YACV,CAAC,CAAC;gBACE,sDAAsD,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG;gBACtF,qSAAqS;aACtS;YACH,CAAC,CAAC,EAAE,CAAC;QACP,KAAK,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC;YAC7B,CAAC,CAAC,iFAAiF;YACnF,CAAC,CAAC,4NAA4N;KACjO,CAAC;AACJ,CAAC"}

package/dist/services/claude-settings-overlay.d.ts

@@ -0,0 +1,4 @@
+/** Claude settings are consumer-owned; only ZAIP metadata and absent defaults migrate. */
+export declare function reconcileClaudeSettings(current: string, generated: string): string;
+export declare function isReconciledClaudeSettings(current: string, generated: string): boolean;
+//# sourceMappingURL=claude-settings-overlay.d.ts.map

package/dist/services/claude-settings-overlay.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-settings-overlay.d.ts","sourceRoot":"","sources":["../../src/services/claude-settings-overlay.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAsClF;AAED,wBAAgB,0BAA0B,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAMtF"}

package/dist/services/claude-settings-overlay.js

@@ -0,0 +1,58 @@
+/** Claude settings are consumer-owned; only ZAIP metadata and absent defaults migrate. */
+export function reconcileClaudeSettings(current, generated) {
+    const local = object(current);
+    const expected = object(generated);
+    let changed = false;
+    for (const [key, value] of Object.entries(expected)) {
+        if (key === "_zaip_managed") {
+            if (local[key] !== value) {
+                local[key] = value;
+                changed = true;
+            }
+        }
+        else if (!Object.hasOwn(local, key)) {
+            Object.defineProperty(local, key, {
+                value,
+                enumerable: true,
+                writable: true,
+                configurable: true,
+            });
+            changed = true;
+        }
+    }
+    const permissions = local.permissions;
+    if (permissions === null || typeof permissions !== "object" || Array.isArray(permissions))
+        throw new Error("Cannot migrate .claude/settings.json: permissions must be an object");
+    const entries = permissions;
+    for (const key of ["allow", "deny"]) {
+        if (!Object.hasOwn(entries, key)) {
+            entries[key] = [];
+            changed = true;
+        }
+        if (!Array.isArray(entries[key]) ||
+            entries[key].some((item) => typeof item !== "string"))
+            throw new Error(`Cannot migrate .claude/settings.json: permissions.${key} must be a list of strings`);
+    }
+    return changed ? `${JSON.stringify(local, null, 2)}\n` : current;
+}
+export function isReconciledClaudeSettings(current, generated) {
+    try {
+        return reconcileClaudeSettings(current, generated) === current;
+    }
+    catch {
+        return false;
+    }
+}
+function object(source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch {
+        throw new Error("Cannot migrate .claude/settings.json: invalid JSON; file preserved");
+    }
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))
+        throw new Error("Cannot migrate .claude/settings.json: expected an object; file preserved");
+    return parsed;
+}
+//# sourceMappingURL=claude-settings-overlay.js.map

package/dist/services/claude-settings-overlay.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claude-settings-overlay.js","sourceRoot":"","sources":["../../src/services/claude-settings-overlay.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,MAAM,UAAU,uBAAuB,CAAC,OAAe,EAAE,SAAiB;IACxE,MAAM,KAAK,GAAG,MAAM,CAAC,OAAO,CAAC,CAAC;IAC9B,MAAM,QAAQ,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IACnC,IAAI,OAAO,GAAG,KAAK,CAAC;IACpB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QACpD,IAAI,GAAG,KAAK,eAAe,EAAE,CAAC;YAC5B,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,KAAK,EAAE,CAAC;gBACzB,KAAK,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;gBACnB,OAAO,GAAG,IAAI,CAAC;YACjB,CAAC;QACH,CAAC;aAAM,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,GAAG,CAAC,EAAE,CAAC;YACtC,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE;gBAChC,KAAK;gBACL,UAAU,EAAE,IAAI;gBAChB,QAAQ,EAAE,IAAI;gBACd,YAAY,EAAE,IAAI;aACnB,CAAC,CAAC;YACH,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;IACH,CAAC;IACD,MAAM,WAAW,GAAG,KAAK,CAAC,WAAW,CAAC;IACtC,IAAI,WAAW,KAAK,IAAI,IAAI,OAAO,WAAW,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC;QACvF,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;IACzF,MAAM,OAAO,GAAG,WAAsC,CAAC;IACvD,KAAK,MAAM,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,EAAE,CAAC;QACpC,IAAI,CAAC,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,EAAE,CAAC;YACjC,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC;YAClB,OAAO,GAAG,IAAI,CAAC;QACjB,CAAC;QACD,IACE,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;YAC5B,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,IAAa,EAAE,EAAE,CAAC,OAAO,IAAI,KAAK,QAAQ,CAAC;YAE9D,MAAM,IAAI,KAAK,CACb,qDAAqD,GAAG,4BAA4B,CACrF,CAAC;IACN,CAAC;IACD,OAAO,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC;AACnE,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAC,OAAe,EAAE,SAAiB;IAC3E,IAAI,CAAC;QACH,OAAO,uBAAuB,CAAC,OAAO,EAAE,SAAS,CAAC,KAAK,OAAO,CAAC;IACjE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,KAAK,CAAC;IACf,CAAC;AACH,CAAC;AAED,SAAS,MAAM,CAAC,MAAc;IAC5B,IAAI,MAAe,CAAC;IACpB,IAAI,CAAC;QACH,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC9B,CAAC;IAAC,MAAM,CAAC;QACP,MAAM,IAAI,KAAK,CAAC,oEAAoE,CAAC,CAAC;IACxF,CAAC;IACD,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;QACxE,MAAM,IAAI,KAAK,CAAC,0EAA0E,CAAC,CAAC;IAC9F,OAAO,MAAiC,CAAC;AAC3C,CAAC"}

package/dist/services/client-selection.d.ts

@@ -0,0 +1,17 @@
+export interface AdapterClients {
+    codex: boolean;
+    claude: boolean;
+}
+export declare const CLAUDE_SETTINGS = "{\n  \"permissions\": {\n    \"allow\": [],\n    \"deny\": []\n  }\n}\n";
+export declare function readGuidanceClients(filesystem: {
+    exists(path: string): Promise<boolean>;
+    readText(path: string): Promise<string>;
+}): Promise<AdapterClients>;
+/** Missing legacy selection means Codex; existing booleans are never inferred from files. */
+export declare function parseAdapterClients(source?: string): AdapterClients;
+export declare function readProjectClientSource(root: string): Promise<string | undefined>;
+export declare function readAdapterClients(root: string): Promise<AdapterClients>;
+export declare function parseLegacyAdapterClients(source: string): AdapterClients;
+/** Ignore disabled projections without deleting or adopting their existing customizations. */
+export declare function isClientAdapterEnabled(path: string, clients: AdapterClients): boolean;
+//# sourceMappingURL=client-selection.d.ts.map

package/dist/services/client-selection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-selection.d.ts","sourceRoot":"","sources":["../../src/services/client-selection.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,eAAO,MAAM,eAAe,4EAAsE,CAAC;AAEnG,wBAAsB,mBAAmB,CAAC,UAAU,EAAE;IACpD,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;CACzC,GAAG,OAAO,CAAC,cAAc,CAAC,CAO1B;AAED,6FAA6F;AAC7F,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,cAAc,CAenE;AAED,wBAAsB,uBAAuB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,CAEvF;AAUD,wBAAsB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,cAAc,CAAC,CAK9E;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,MAAM,GAAG,cAAc,CAOxE;AAED,8FAA8F;AAC9F,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,cAAc,GAAG,OAAO,CAKrF"}

package/dist/services/client-selection.js

@@ -0,0 +1,67 @@
+import { readFile } from "node:fs/promises";
+import { resolve } from "node:path";
+import { parse } from "yaml";
+import { assertSafeDestination } from "./transactional-files.js";
+export const CLAUDE_SETTINGS = `{\n  "permissions": {\n    "allow": [],\n    "deny": []\n  }\n}\n`;
+export async function readGuidanceClients(filesystem) {
+    const path = ".agents/config/project.yaml";
+    if (await filesystem.exists(path))
+        return parseAdapterClients(await filesystem.readText(path));
+    const legacy = ".agents/manifest.yaml";
+    return (await filesystem.exists(legacy))
+        ? parseLegacyAdapterClients(await filesystem.readText(legacy))
+        : parseAdapterClients();
+}
+/** Missing legacy selection means Codex; existing booleans are never inferred from files. */
+export function parseAdapterClients(source) {
+    const value = source === undefined ? undefined : parse(source);
+    if (value !== undefined && (value === null || typeof value !== "object" || Array.isArray(value)))
+        throw new Error("Invalid project configuration for client selection");
+    const clients = value?.clients;
+    if (clients === undefined)
+        return { codex: true, claude: false };
+    if (clients === null || typeof clients !== "object" || Array.isArray(clients))
+        throw new Error("Invalid clients: expected explicit boolean choices");
+    const selected = clients;
+    if (Object.keys(selected).some((key) => !["codex", "claude"].includes(key)))
+        throw new Error("Invalid clients: unknown client");
+    for (const key of ["codex", "claude"])
+        if (selected[key] !== undefined && typeof selected[key] !== "boolean")
+            throw new Error(`Invalid clients.${key}: expected boolean`);
+    return { codex: selected.codex ?? true, claude: selected.claude ?? false };
+}
+export async function readProjectClientSource(root) {
+    return readSelectionSource(root, ".agents/config/project.yaml");
+}
+async function readSelectionSource(root, path) {
+    await assertSafeDestination(root, path);
+    return readFile(resolve(root, path), "utf8").catch((error) => {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    });
+}
+export async function readAdapterClients(root) {
+    const source = await readProjectClientSource(root);
+    if (source !== undefined)
+        return parseAdapterClients(source);
+    const legacy = await readSelectionSource(root, ".agents/manifest.yaml");
+    return legacy === undefined ? parseAdapterClients() : parseLegacyAdapterClients(legacy);
+}
+export function parseLegacyAdapterClients(source) {
+    const value = parse(source);
+    if (value?.schema_version !== 1)
+        throw new Error("Invalid legacy manifest client selection");
+    const agents = value.agents === undefined ? ["codex"] : value.agents;
+    if (!Array.isArray(agents) || agents.some((agent) => !["codex", "claude"].includes(agent)))
+        throw new Error("Invalid legacy manifest agents");
+    return { codex: agents.includes("codex"), claude: agents.includes("claude") };
+}
+/** Ignore disabled projections without deleting or adopting their existing customizations. */
+export function isClientAdapterEnabled(path, clients) {
+    for (const client of ["codex", "claude"])
+        if (path.startsWith(`.${client}/`) || path.startsWith(`.agents/config/clients/${client}/`))
+            return clients[client];
+    return path !== "CLAUDE.md";
+}
+//# sourceMappingURL=client-selection.js.map

package/dist/services/client-selection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-selection.js","sourceRoot":"","sources":["../../src/services/client-selection.ts"],"names":[],"mappings":"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"}

package/dist/services/codex-conversation-lifecycle-hook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"codex-conversation-lifecycle-hook.d.ts","sourceRoot":"","sources":["../../src/services/codex-conversation-lifecycle-hook.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iCAAiC,QAgS7C,CAAC"}
+{"version":3,"file":"codex-conversation-lifecycle-hook.d.ts","sourceRoot":"","sources":["../../src/services/codex-conversation-lifecycle-hook.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,iCAAiC,QA2S7C,CAAC"}

package/dist/services/codex-conversation-lifecycle-hook.js

@@ -76,7 +76,7 @@ async function terminal(path) {
     // The live Stop belongs to the current tail, not hundreds of MB of earlier
     // turns. Authenticate the first session row, then align a bounded tail scan.
     // Explicit historical replay retains the full resumable scan when no cursor exists.
-    if (!same && !replay && sig.size > maxReadBytes) {
+    if (!same && (!replay || automatic) && sig.size > maxReadBytes) {
       const header = await bytes(h, 0, readChunkBytes), end = header.indexOf(10);
       if (end < 0) throw new Error("transcript_session_header_too_large");
       const first = header.subarray(0, end + 1);
@@ -158,7 +158,7 @@ function gitWorktrees() {
 async function selectWorkspace(correlationKey, worktrees) {
   const matches = [];
   for (const candidate of worktrees.slice(0, 256)) {
-    const correlation = parse(await readFile(resolve(candidate, ".local/codex-telemetry-spool/v1/correlations", correlationKey + ".json"), "utf8").catch(() => ""));
+    const correlation = parse(await readFile(resolve(candidate, ".agents/private/state/codex-telemetry-spool/v1/correlations", correlationKey + ".json"), "utf8").catch(() => ""));
     if (correlation?.schema_version === 1 && correlation.thread_id === session && correlation.turn_id === turn && correlation.agent_path === null && typeof correlation.run_id === "string") matches.push(candidate);
   }
   if (matches.length > 1) throw new Error("workspace_correlation_ambiguous");
@@ -169,6 +169,10 @@ async function selectWorkspace(correlationKey, worktrees) {
 }
 try {
   if (event?.hook_event_name !== "Stop" || !session || !turn || !text(event.cwd)) { reply(); process.exit(0); }
+  if (!replay) activation?.recordLifecycleIngress?.(hookRoot, event, await activation?.hookPolicies?.(hookRoot));
+  const canonicalCwd = activation?.canonicalHookCwd?.(event.cwd);
+  if (!canonicalCwd) { reply(); process.exit(0); }
+  event.cwd = canonicalCwd;
   // Automatic recovery is already bound to one canonical workspace by intake.
   // Never discover another worktree or manufacture a historical Conversation.
   const worktrees = automatic ? [hookRoot] : await gitWorktrees();
@@ -176,11 +180,15 @@ try {
   if (!worktrees.some(candidate => inside(event.cwd, candidate))) { reply(); process.exit(0); }
   const correlationKey = hash(JSON.stringify(["codex", session, turn, null, null]));
   root = automatic ? hookRoot : await selectWorkspace(correlationKey, worktrees);
-  local = resolve(root, ".local/hooks");
+  local = resolve(root, ".agents/private/state/hooks");
   const policy = await activation?.hookPolicies?.(root) ?? { governance: false, tracking: false, diagnostic: "policy_module_unavailable" };
   activation?.recordPolicyDiagnostic?.(root, policy);
   trackingEnabled = policy.tracking;
   governanceEnabled = policy.governance;
+  // Persist the native invocation before expensive observation replay or closure.
+  // A host timeout must not erase activation; pending is never closure proof.
+  // Recovery is not a native event and must never manufacture activation.
+  if (!replay && governanceEnabled) activation?.recordActivation(root, event, "pending");
   if (!replay && policy.tracking) activation?.recordHookObservation?.(root, event, policy.governance);
   if (policy.tracking) activation?.replayHookObservations?.(root);
   if (!policy.governance) { reply(); process.exit(0); }
@@ -211,7 +219,7 @@ try {
     for (const delay of automatic ? [0] : [0, 250, 750]) { if (delay) await new Promise(r => setTimeout(r, delay)); status = await terminal(transcriptPath); if (status) break; }
     if (!status) throw new Error("transcript_pending");
     const cli = resolve(root, ".agents/runtime/bin/zaip.mjs");
-    const correlation = parse(await readFile(resolve(root, ".local/codex-telemetry-spool/v1/correlations", correlationKey + ".json"), "utf8").catch(() => ""));
+    const correlation = parse(await readFile(resolve(root, ".agents/private/state/codex-telemetry-spool/v1/correlations", correlationKey + ".json"), "utf8").catch(() => ""));
     let intake;
     if (correlation?.schema_version === 1 && correlation.thread_id === session && correlation.turn_id === turn && correlation.agent_path === null && typeof correlation.run_id === "string") {
       intake = { run: { run_id: correlation.run_id }, task: correlation.task_id === null ? null : { id: correlation.task_id } };
@@ -235,18 +243,21 @@ try {
     if (automatic && intake.task !== null &&
         (!outcome.finalization_decision || (outcome.finalization_decision.outcome === "completed" && outcome.finalization_barrier?.satisfied !== true)))
       throw new Error("closure_gates_pending");
-    if (intake.task !== null && status === "completed") {
+    // Completed/cancelled Tasks cannot recover. Their authenticated terminal
+    // result already proves closure; an advisory ledger query must not undo it.
+    const settledTask = intake.task === null ? null : outcome.reconciliation.tasks.find(task => task.id === intake.task.id);
+    if (intake.task !== null && status === "completed" && !["completed", "cancelled"].includes(settledTask.status)) {
       const shown = await call(cli, ["task", "recovery-status", intake.task.id], transcriptPath);
       const recovery = parse(shown.out);
       if (shown.code !== 0 || recovery?.task_id !== intake.task.id || typeof recovery.task_status !== "string") throw new Error("task_state_pending");
       if (["executing", "verifying"].includes(recovery.task_status)) throw new Error("owned_task_active");
       if (["blocked", "failed"].includes(recovery.task_status) && recovery.policy === "legacy_or_unmigrated" && recovery.operation === null) {
-        receipt.recovery = { task_id: intake.task.id };
-        throw new Error("owned_task_unmetered");
+        // Canonical closure is already proved. Recovery eligibility is advisory;
+        // it must not turn a blocked terminal Task into a pending Stop receipt.
+        receipt.recovery = { task_id: intake.task.id, reason: "owned_task_unmetered" };
       }
       if (["blocked", "failed"].includes(recovery.task_status) && ["attempt", "replan", "reconcile"].includes(recovery.operation) && recovery.policy === "frozen_autonomy_v1" && Number.isSafeInteger(recovery.progress?.attempts) && (recovery.progress?.total_replans === null || Number.isSafeInteger(recovery.progress?.total_replans))) {
-        receipt.recovery = { task_id: intake.task.id, operation: recovery.operation, progress: { attempts: recovery.progress.attempts, total_replans: recovery.progress.total_replans } };
-        throw new Error("owned_task_recoverable");
+        receipt.recovery = { task_id: intake.task.id, reason: "owned_task_recoverable", operation: recovery.operation, progress: { attempts: recovery.progress.attempts, total_replans: recovery.progress.total_replans } };
       }
     }
     closureVerified = true; receipt.error = null;

package/dist/services/codex-conversation-lifecycle-hook.js.map

@@ -1 +1 @@
-{"version":3,"file":"codex-conversation-lifecycle-hook.js","sourceRoot":"","sources":["../../src/services/codex-conversation-lifecycle-hook.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iCAAiC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgS1D,CAAC"}
+{"version":3,"file":"codex-conversation-lifecycle-hook.js","sourceRoot":"","sources":["../../src/services/codex-conversation-lifecycle-hook.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,iCAAiC,GAAG,MAAM,CAAC,GAAG,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2S1D,CAAC"}

package/dist/services/codex-git-publication-template.d.ts

@@ -0,0 +1,2 @@
+export declare const CODEX_GIT_PUBLICATION: string;
+//# sourceMappingURL=codex-git-publication-template.d.ts.map

package/dist/services/codex-git-publication-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-git-publication-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-git-publication-template.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,qBAAqB,QAoHjC,CAAC"}

package/dist/services/codex-git-publication-template.js

@@ -0,0 +1,120 @@
+import { CODEX_RELEASE_PUBLICATION } from "./codex-release-publication-template.js";
+// One emitted module owns Git parsing and the exact reviewed runner interfaces.
+export const CODEX_GIT_PUBLICATION = String.raw `export function createGitPublication({ tokenizeLiteralCommand, gitInvocation, deny }) {
+${CODEX_RELEASE_PUBLICATION}
+function isGitSshMetadataRead(arguments_) {
+  const args = [...arguments_];
+  const seen = new Set();
+  while (["--local", "--show-origin"].includes(args[0])) {
+    if (seen.has(args[0])) return false;
+    seen.add(args.shift());
+  }
+  return args.length === 2 && args[0] === "--get" && args[1] === "core.sshCommand";
+}
+
+function reviewedGitPublisherInvocation(command) {
+  const tokens = tokenizeLiteralCommand(command);
+  if (!tokens || !/^(?:node|node\.exe)$/i.test(tokens[0] ?? "")) return null;
+  const script = tokens[1];
+  const catalog = reviewedLocalCatalogPublisher(script, tokens);
+  if (catalog) return catalog;
+  const staging = reviewedStageInputsPublisher(script, tokens);
+  if (staging) return staging;
+  const consumer = reviewedConsumerPublisher(script, tokens);
+  if (consumer) return consumer;
+  const framework = reviewedFrameworkPublisher(script, tokens);
+  if (framework) return framework;
+  const contract = ".agents/skills/zaip-skill-github-deploy/scripts/deploy-contract.mjs";
+  const publisher = ".agents/skills/zaip-skill-github-deploy/scripts/guarded-commits.mjs";
+  if (![contract, publisher].includes(script)) return null;
+  const allowed = new Set(["--repository", "--request-file", "--plan-file", "--authorization-run", "--condition-task", "--condition-validation", "--condition-run", "--scope",
+    ...(script === publisher ? ["--sha", "--branch", "--remote", "--checks-file", "--evidence-map-file", "--local-catalog-receipt-file", "--dry-run"] : [])]);
+  const values = new Map();
+  for (let index = 2; index < tokens.length; index++) {
+    const flag = tokens[index];
+    if (!allowed.has(flag) || values.has(flag)) deny("Unreviewed publication runner arguments; use its exact candidate-bound interface.");
+    if (flag === "--dry-run") { values.set(flag, true); continue; }
+    const value = tokens[++index];
+    if (!value || value.startsWith("--")) deny("Publication runner argument value is missing.");
+    values.set(flag, value);
+  }
+  if (values.get("--repository") !== "." || !/^RUN-[A-Z0-9-]+$/.test(values.get("--authorization-run") ?? values.get("--condition-run") ?? ""))
+    deny("Publication runner requires the current repository and its exact observed source Run.");
+  for (const flag of ["--request-file", ...(script === publisher ? ["--plan-file", "--checks-file"] : [])])
+    if (!values.has(flag)) deny("Publication runner requires exact request, plan and check locators.");
+  for (const [flag, value] of values) if (flag.endsWith("-file") &&
+      (typeof value !== "string" || !/^\.local\/[A-Za-z0-9_./-]+\.(?:json|txt|md)$/.test(value) || value.split("/").includes("..")))
+    deny("Publication runner metadata must use literal repository-local .local paths.");
+  if (values.has("--remote") && values.get("--remote") !== "origin") deny("Only the contract-bound origin remote is authorized.");
+  if (values.has("--scope") && !["frontend", "backend", "framework"].includes(values.get("--scope"))) deny("Unsupported publication scope.");
+  if (script === publisher && (!/^(?:[a-f0-9]{40}|[a-f0-9]{64})$/.test(values.get("--sha") ?? "") ||
+      !/^[A-Za-z0-9][A-Za-z0-9._/-]*$/.test(values.get("--branch") ?? "") || values.get("--branch").includes("..")))
+    deny("Publication runner requires one full immutable candidate SHA and literal branch.");
+  return { script, values };
+}
+
+async function validateGitPublication(command) {
+  const tokens = tokenizeLiteralCommand(command);
+  if (tokens !== null) {
+    const launcher = tokens[0]?.toLowerCase();
+    if (((launcher === "env" || launcher === "command") && /^git(?:\.exe)?$/i.test(tokens[1] ?? "")) ||
+        (/^(?:Set-Alias|New-Alias)$/i.test(launcher ?? "") && tokens.slice(1).some(token => /^git(?:\.exe)?$/i.test(token))))
+      deny("Indirect Git execution is blocked; use a single literal command.");
+  } else if (/(?:^|[;&|\r\n])\s*(?:(?:&\s*)?(?:['"]git(?:\.exe)?['"]|\(\s*['"]git(?:\.exe)?['"]\s*\))|(?:env|command)\s+git(?:\.exe)?\b)/i.test(command) ||
+      /&\s*\(\s*Get-Command\s+git(?:\.exe)?\b/i.test(command) ||
+      /(?:^|[\s;&|])&\s*\$[A-Za-z_]/i.test(command) || /\b(?:Set-Alias|New-Alias)\b[^\r\n;]*\bgit\b/i.test(command)) {
+    deny("Indirect Git execution is blocked; use a single literal command.");
+  }
+  if (tokens === null && /\(\s*git(?:\.exe)?\b/i.test(command)) {
+    deny("Nested Git execution is blocked; use a single literal command.");
+  }
+  if (tokens === null) {
+    if (/(?:^|[;&|\r\n(])\s*git(?:\.exe)?\b/i.test(command)) {
+      deny("Git commands must be a single literal command; separate commands before requesting execution.");
+    }
+    return;
+  }
+  const invocation = gitInvocation(tokens, deny);
+  if (invocation === null) return;
+  const { subcommand, arguments: arguments_ } = invocation;
+  if (subcommand === "commit" && arguments_.some((value) => /^(?:--amend|--no-verify|-n)/i.test(value))) {
+    deny("Commit history rewrites and hook bypasses are blocked.");
+  }
+  if (subcommand === "push" && arguments_.some((value) => /^(?:--force(?:-with-lease|-if-includes)?|-f|--mirror|--delete|--all)$/i.test(value))) {
+    deny("Force, mirror, bulk, and deletion pushes are blocked.");
+  }
+  if (["clean", "reset", "restore", "checkout"].includes(subcommand)) {
+    deny("Destructive Git state changes are blocked.");
+  }
+  if (["branch", "tag"].includes(subcommand) && arguments_.some((value) => /^-d/i.test(value))) {
+    deny("Destructive Git state changes are blocked.");
+  }
+  if (subcommand === "fetch" && arguments_.some((value) => /^--(?:all|prune|prune-tags)$/i.test(value))) {
+    deny("Bulk or pruning fetches are outside the bounded deploy flow.");
+  }
+  if (subcommand === "add") {
+    const broad = arguments_.some((value) => /^(?:-A|--all|-u|\.)$/i.test(value));
+    const force = arguments_.some((value) => /^(?:--force|-f)$/i.test(value));
+    if (broad) deny("Broad Git staging is blocked; authorized deploy commits require explicit pathspecs.");
+    if (force) deny("Force-adding or explicitly staging credential-like files is blocked.");
+  }
+  if (
+    subcommand === "remote" &&
+    ["add", "set-url", "remove", "rename"].includes(arguments_[0]?.toLowerCase())
+  ) {
+    deny("Remote, SSH, and credential configuration changes are blocked.");
+  }
+  if (
+    subcommand === "config" &&
+    arguments_.some((value) => /(?:sshcommand|credential|url\.)/i.test(value) || /^(?:--get-regexp|--get-all|--list|-l)$/.test(value)) &&
+    !isGitSshMetadataRead(arguments_)
+  ) {
+    deny("Remote, SSH, and credential configuration changes are blocked.");
+  }
+  if (subcommand !== "push") return;
+  deny("Direct Git push has no candidate-bound publication contract. Use the reviewed guarded publisher with the exact authorized repository, SHA and destination; a Task writer claim is not publication authority.");
+}
+return { reviewedGitPublisherInvocation, validateGitPublication };
+}
+`;
+//# sourceMappingURL=codex-git-publication-template.js.map

package/dist/services/codex-git-publication-template.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-git-publication-template.js","sourceRoot":"","sources":["../../src/services/codex-git-publication-template.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,yCAAyC,CAAC;AACpF,gFAAgF;AAChF,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC,GAAG,CAAA;EAC7C,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmH1B,CAAC"}

package/dist/services/codex-github-setup-template.d.ts

@@ -0,0 +1,3 @@
+export declare const CODEX_GITHUB_SETUP: string;
+export declare const CODEX_GITHUB_SETUP_MODULE: string;
+//# sourceMappingURL=codex-github-setup-template.d.ts.map

package/dist/services/codex-github-setup-template.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex-github-setup-template.d.ts","sourceRoot":"","sources":["../../src/services/codex-github-setup-template.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,kBAAkB,QAoK9B,CAAC;AAEF,eAAO,MAAM,yBAAyB,QAQrC,CAAC"}