@akagilnc/pi-workflow-roles 0.1.3999 → 0.1.4021

package/dist/acp-host/production-host.js

@@ -2702,6 +2702,7 @@ var init_host_descriptions = __esm({
     });
     HEADLESS_HOST_DESCRIPTIONS = Object.freeze({
       "claude": Object.freeze({
+        protocol: "claude-print",
         binaryFromHome: Object.freeze([".local", "bin", "claude"]),
         sessionBindingFile: "claude-headless-session.json",
         fixedArgs: Object.freeze([
@@ -2727,6 +2728,15 @@ var init_host_descriptions = __esm({
         mcpConfigFlag: "--mcp-config",
         sessionIdFlag: "--session-id",
         resumeFlag: "--resume"
+      }),
+      /**
+       * Codex headless (#646). Binary under operator home; auth stays in CODEX_HOME.
+       * Argv/parse/schema-close are codex-exec helpers — not Claude flag mapping.
+       */
+      "codex": Object.freeze({
+        protocol: "codex-exec",
+        binaryFromHome: Object.freeze([".local", "bin", "codex"]),
+        sessionBindingFile: "codex-headless-session.json"
       })
     });
   }

package/dist/headless-host/description.js

@@ -1,16 +1,22 @@
 /**
- * One headless CLI host description (#645 / #752).
- * Every host-specific value the generic headless adapter needs — binary, argv
- * shape, session binding — is data here; lifecycle stays one copy so #646 codex
- * is another row, not a fork.
+ * Headless CLI host descriptions (#645 / #646 / #752).
+ * Shared lifecycle owns spawn/bind/close; each protocol owns argv + parse shape.
+ * Claude print-mode and codex exec differ enough that #752 host-specific
+ * assembly lives here as sibling helpers — not a third unified abstraction.
  */
 import { join } from "node:path";
+export function isClaudePrintDescription(description) {
+    return description.protocol === "claude-print";
+}
+export function isCodexExecDescription(description) {
+    return description.protocol === "codex-exec";
+}
 /** Absolute agent binary for one operator home. */
 export function resolveHeadlessBinary(description, operatorHome) {
     return join(operatorHome, ...description.binaryFromHome);
 }
 /**
- * Build one headless CLI argv for a single process turn.
+ * Build one Claude print-mode argv for a single process turn.
  * Shape: `<promptFlag> <prompt> <fixedArgs…> <system/schema/mcp/model/effort/session…>`.
  */
 export function headlessTurnArgs(options) {
@@ -41,6 +47,311 @@ export function headlessTurnArgs(options) {
     }
     return args;
 }
+/**
+ * TOML string literal for `codex -c key=<value>` (values are TOML-parsed).
+ * Double-quoted form; escapes backslash and quote only.
+ */
+function codexTomlString(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+/** TOML array of strings for `-c key=["a","b"]`. */
+function codexTomlStringArray(values) {
+    return `[${values.map(codexTomlString).join(",")}]`;
+}
+/** TOML inline table of string→string for `-c key={a="b"}`. */
+function codexTomlStringTable(entries) {
+    const parts = Object.entries(entries).map(([key, value]) => `${key}=${codexTomlString(value)}`);
+    return `{${parts.join(",")}}`;
+}
+/**
+ * Free-form JSON leaf for Type.Unknown under Codex strict transport.
+ * Strict rejects bare untyped nodes and root-level additionalProperties:true;
+ * a $defs anyOf of JSON values (with nested additionalProperties as $ref)
+ * is accepted and keeps array/object receipts expressible (navigator candidates).
+ * Package code still does not validate or reject the receipt against schema.
+ */
+const CODEX_JSON_VALUE_DEF = "codexJsonValue";
+const CODEX_JSON_VALUE_REF = `#/$defs/${CODEX_JSON_VALUE_DEF}`;
+const CODEX_JSON_VALUE_SCHEMA = Object.freeze({
+    anyOf: Object.freeze([
+        Object.freeze({ type: "string" }),
+        Object.freeze({ type: "number" }),
+        Object.freeze({ type: "boolean" }),
+        Object.freeze({ type: "null" }),
+        Object.freeze({ type: "array", items: Object.freeze({ $ref: CODEX_JSON_VALUE_REF }) }),
+        Object.freeze({
+            type: "object",
+            properties: Object.freeze({}),
+            required: Object.freeze([]),
+            additionalProperties: Object.freeze({ $ref: CODEX_JSON_VALUE_REF }),
+        }),
+    ]),
+});
+/**
+ * Derive a Codex/OpenAI-strict transport schema from the package open schema.
+ * Legal open schema is untouched; this is a host-only transmission projection
+ * (#646 / 0057 法意 / 0054 strict): every object closes, every property is
+ * required, and only originally-optional fields become a null union (official
+ * guidance: emulate optional via type|null). Originally-required fields stay
+ * non-nullable. Nested open-tool anyOf wrappers are flattened so every branch
+ * carries `type`. Type.Unknown / description-only leaves become a free JSON
+ * $ref. Package code still does not validate or reject the receipt.
+ */
+export function closeJsonSchemaForCodex(schema) {
+    const closed = closeSchemaNode(schema);
+    const existingDefs = isPlainObject(closed.$defs)
+        ? closed.$defs
+        : {};
+    return {
+        ...closed,
+        $defs: {
+            ...existingDefs,
+            [CODEX_JSON_VALUE_DEF]: CODEX_JSON_VALUE_SCHEMA,
+        },
+    };
+}
+/** Shared plain-object guard for headless host schema/event reduction. */
+export function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/** Pure null leaf only — composite type|null is stripped in-leaf, not dropped whole. */
+function isPureNullTypeSchema(value) {
+    if (!isPlainObject(value))
+        return false;
+    if (value.type === "null")
+        return true;
+    if (Array.isArray(value.type) && value.type.length > 0 && value.type.every((t) => t === "null")) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Within a leaf, remove null members from type arrays.
+ * Required edges keep the non-null type(s); optional edges re-add null once.
+ */
+function stripNullFromLeafType(leaf) {
+    if (!isPlainObject(leaf) || !Array.isArray(leaf.type))
+        return leaf;
+    const nonNull = leaf.type.filter((t) => t !== "null");
+    if (nonNull.length === leaf.type.length)
+        return leaf;
+    if (nonNull.length === 0)
+        return { ...leaf, type: "null" };
+    if (nonNull.length === 1)
+        return { ...leaf, type: nonNull[0] };
+    return { ...leaf, type: nonNull };
+}
+/**
+ * Flatten nested anyOf wrappers into concrete leaf schemas.
+ * Open-tool unions often wrap leaves in description-only anyOf shells that
+ * lack `type`; strict structured output rejects those intermediate nodes.
+ */
+function flattenUnionLeaves(schema) {
+    if (!isPlainObject(schema))
+        return [schema];
+    if (Array.isArray(schema.anyOf)) {
+        return schema.anyOf.flatMap(flattenUnionLeaves);
+    }
+    return [schema];
+}
+/** Drop pure-null leaves after in-leaf null stripping; optional edges re-add null once. */
+function nonNullLeaves(schema) {
+    return flattenUnionLeaves(schema)
+        .map(stripNullFromLeafType)
+        .filter((leaf) => !isPureNullTypeSchema(leaf));
+}
+/**
+ * Property edge under strict transport.
+ * Required → closed non-null leaf(s). Optional → closed leaf(s) + null.
+ */
+function closePropertySchema(schema, optional) {
+    const leaves = nonNullLeaves(schema).map(closeSchemaNode);
+    if (leaves.length === 0)
+        return { type: "null" };
+    if (!optional) {
+        return leaves.length === 1 ? leaves[0] : { anyOf: leaves };
+    }
+    return { anyOf: [...leaves, { type: "null" }] };
+}
+/**
+ * Strict generators require every schema node to declare `type` (or a $ref).
+ * Type.Unknown / description-only leaves → free JSON $ref (not string): array
+ * and object receipts stay expressible under --output-schema.
+ */
+function ensureTypedLeaf(schema) {
+    if (schema.type !== undefined)
+        return schema;
+    if (typeof schema.$ref === "string")
+        return schema;
+    if (isPlainObject(schema.properties) || schema.additionalProperties !== undefined) {
+        return { ...schema, type: "object" };
+    }
+    if (schema.items !== undefined) {
+        return { ...schema, type: "array" };
+    }
+    if (schema.const !== undefined) {
+        const value = schema.const;
+        if (value === null)
+            return { ...schema, type: "null" };
+        if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+            return { ...schema, type: typeof value };
+        }
+    }
+    if (Array.isArray(schema.enum) && schema.enum.length > 0) {
+        const sample = schema.enum.find((item) => item !== null);
+        if (typeof sample === "string" || typeof sample === "number" || typeof sample === "boolean") {
+            return { ...schema, type: typeof sample };
+        }
+    }
+    // Free JSON via $defs. $ref must stand alone (strict rejects sibling keys).
+    return { $ref: CODEX_JSON_VALUE_REF };
+}
+function originalRequiredNames(node) {
+    if (!Array.isArray(node.required))
+        return new Set();
+    return new Set(node.required.filter((item) => typeof item === "string"));
+}
+function closeSchemaNode(node) {
+    if (!isPlainObject(node))
+        return node;
+    // Already a ref (free-JSON leaf or pre-existing) — do not retype.
+    if (typeof node.$ref === "string")
+        return node;
+    // Union node: flatten then close each concrete leaf (do not keep untyped shells).
+    if (Array.isArray(node.anyOf)) {
+        const leaves = nonNullLeaves(node).map(closeSchemaNode);
+        if (leaves.length === 0)
+            return { type: "null" };
+        if (leaves.length === 1)
+            return leaves[0];
+        return { anyOf: leaves };
+    }
+    let out = { ...node };
+    if (node.items !== undefined) {
+        out.items = closeSchemaNode(node.items);
+    }
+    if (isPlainObject(node.$defs)) {
+        out.$defs = Object.fromEntries(Object.entries(node.$defs).map(([key, value]) => [key, closeSchemaNode(value)]));
+    }
+    const hasProperties = isPlainObject(node.properties);
+    const isObjectType = node.type === "object"
+        || (Array.isArray(node.type) && node.type.includes("object"))
+        || hasProperties
+        || node.additionalProperties !== undefined;
+    if (hasProperties) {
+        const props = node.properties;
+        const wasRequired = originalRequiredNames(node);
+        const closedProps = {};
+        const required = [];
+        for (const [name, propSchema] of Object.entries(props)) {
+            required.push(name);
+            closedProps[name] = closePropertySchema(propSchema, !wasRequired.has(name));
+        }
+        out.properties = closedProps;
+        out.required = required;
+        out.additionalProperties = false;
+        if (out.type === undefined)
+            out.type = "object";
+        // Object nodes must not also carry residual anyOf from the open copy.
+        delete out.anyOf;
+    }
+    else if (isObjectType) {
+        out.additionalProperties = false;
+        if (!Array.isArray(out.required))
+            out.required = [];
+        if (out.type === undefined)
+            out.type = "object";
+    }
+    else {
+        out = ensureTypedLeaf(out);
+    }
+    return out;
+}
+/**
+ * Project shared-envelope MCP rows into `codex -c mcp_servers.<name>.*` argv pairs.
+ * Dot-path + TOML values per official config-advanced; spawn argv (no shell).
+ */
+function stringEnvironment(value) {
+    const entries = Array.isArray(value)
+        ? value.flatMap((item) => {
+            if (!isPlainObject(item) || typeof item.name !== "string" || typeof item.value !== "string")
+                return [];
+            return [[item.name, item.value]];
+        })
+        : isPlainObject(value)
+            ? Object.entries(value).filter((entry) => typeof entry[1] === "string")
+            : [];
+    return entries.length === 0 ? undefined : Object.fromEntries(entries);
+}
+function codexMcpConfigArgs(mcpServers) {
+    const args = [];
+    for (const row of mcpServers) {
+        const name = typeof row.name === "string" ? row.name : undefined;
+        const command = typeof row.command === "string" ? row.command : undefined;
+        if (name === undefined || name === "" || command === undefined || command === "")
+            continue;
+        const prefix = `mcp_servers.${name}`;
+        // required=true: fail the exec if the AK relay cannot handshake (official:
+        // required MCP init failure exits with error). Without it, a silent drop
+        // would hide a broken intermediate-tool channel (#646 须真跑证②).
+        args.push("-c", `${prefix}.command=${codexTomlString(command)}`);
+        args.push("-c", `${prefix}.required=true`);
+        if (Array.isArray(row.args) && row.args.every((item) => typeof item === "string")) {
+            args.push("-c", `${prefix}.args=${codexTomlStringArray(row.args)}`);
+        }
+        const env = stringEnvironment(row.env);
+        if (env !== undefined) {
+            args.push("-c", `${prefix}.env=${codexTomlStringTable(env)}`);
+        }
+    }
+    return args;
+}
+/**
+ * Build one `codex exec` / `codex exec resume` argv (#646).
+ * New: `exec --approve-for-me … prompt`.
+ * Resume: `exec --approve-for-me resume <thread_id> … prompt`.
+ * Approval stays on the parent command so new and resumed turns use Codex's
+ * automatic review with its workspace-write sandbox.
+ */
+export function codexTurnArgs(options) {
+    // Parent-command flag must precede the resume subcommand.
+    const args = ["exec", "--approve-for-me"];
+    if (options.session.kind === "resume") {
+        args.push("resume", options.session.id);
+    }
+    // JSONL event stream: thread_id + final agent_message + turn.completed/failed.
+    args.push("--json");
+    // Operator config/MCP off; auth still uses CODEX_HOME (official).
+    // Project/system config and AGENTS.md have no official suppression switch.
+    args.push("--ignore-user-config", "--ignore-rules");
+    const roots = (options.writableRoots ?? []).filter((root) => root !== "");
+    if (roots.length > 0) {
+        // Resume has no --add-dir; the config key keeps extra roots available on both paths.
+        args.push("-c", `sandbox_workspace_write.writable_roots=${codexTomlStringArray(roots)}`);
+        if (options.session.kind === "new") {
+            for (const root of roots) {
+                args.push("--add-dir", root);
+            }
+        }
+    }
+    args.push("-c", `model_instructions_file=${codexTomlString(options.systemPromptPath)}`);
+    args.push("--output-schema", options.outputSchemaPath);
+    args.push(...codexMcpConfigArgs(options.mcpServers));
+    if (options.model !== undefined && options.model !== "") {
+        args.push("-m", options.model);
+    }
+    if (options.effort !== undefined && options.effort !== "") {
+        args.push("-c", `model_reasoning_effort=${codexTomlString(options.effort)}`);
+    }
+    if (options.skipGitRepoCheck === true) {
+        args.push("--skip-git-repo-check");
+    }
+    // Prompt last as positional. `--` stops option parsing so a leading `-`
+    // (markdown lists, pasted flags, rulings) is not eaten by clap (codex tip:
+    // "use '-- -s'"). Same for new and resume — both end here.
+    args.push("--", options.prompt);
+    return args;
+}
 /**
  * Project shared-envelope MCP server rows into Claude `--mcp-config` JSON.
  * Env stays a plain object (Claude CLI shape); ACP rows use `{name,value}[]`.
@@ -55,22 +366,9 @@ export function headlessMcpConfigDocument(mcpServers) {
         const entry = { command };
         if (Array.isArray(row.args))
             entry.args = row.args;
-        if (Array.isArray(row.env)) {
-            const env = {};
-            for (const item of row.env) {
-                if (typeof item !== "object" || item === null)
-                    continue;
-                const record = item;
-                if (typeof record.name === "string" && typeof record.value === "string") {
-                    env[record.name] = record.value;
-                }
-            }
-            if (Object.keys(env).length > 0)
-                entry.env = env;
-        }
-        else if (typeof row.env === "object" && row.env !== null && !Array.isArray(row.env)) {
-            entry.env = row.env;
-        }
+        const env = stringEnvironment(row.env);
+        if (env !== undefined)
+            entry.env = env;
         servers[name] = entry;
     }
     return Object.freeze({ mcpServers: Object.freeze(servers) });