@astrosheep/keiyaku 2.9.8 → 2.9.9

package/build/cli/render/wait.js

@@ -1,29 +1,8 @@
-import { formatTimelineDuration, renderProjectionActivity, renderProjectionActivitySummary, } from "./projection-activity.js";
+import { formatTimelineDuration, renderPendingProjectionTell, renderProjectionActivity, } from "./projection-activity.js";
 import { displayColumns, resolveLineColumns, truncateColumns } from "./line-width.js";
 import { formatTellCommand, projectionRejoinHintLines, textResponse } from "./shared.js";
 import { renderTerminalFailureFace } from "./terminal-failure.js";
 const WAIT_HEADER_MAX_COLUMNS = 60;
-const WAIT_BODY_MAX_ROWS = 10;
-const WAIT_ROW_PRIORITY = {
-    "end-anchor": 100,
-    "storage-diagnostic": 90,
-    diagnostic: 90,
-    tell: 80,
-    summary: 70,
-    activity: 60,
-    plan: 55,
-    liveness: 50,
-    silence: 65,
-    file: 20,
-};
-/** One owner admits every wait-body row, then restores presentation order. */
-export function selectWaitBodyRows(rows, limit = WAIT_BODY_MAX_ROWS) {
-    const selected = rows
-        .slice()
-        .sort((left, right) => WAIT_ROW_PRIORITY[right.kind] - WAIT_ROW_PRIORITY[left.kind] || left.order - right.order)
-        .slice(0, limit);
-    return selected.sort((left, right) => left.order - right.order);
-}
 function shortAddress(projectionId) {
     return /\/([0-9a-f]{8})$/.exec(projectionId)?.[1] ?? projectionId;
 }
@@ -70,12 +49,23 @@ function waitHeader(projectionId, akuma, snapshot, outputColumns) {
     const dashCount = Math.max(1, maxColumns - displayColumns(`${prefix}  ${state}`));
     return `${prefix} ${"─".repeat(dashCount)} ${state}`;
 }
-function pendingTellLines(snapshot, maxColumns) {
-    return snapshot.tells.window.map((tell) => {
-        const age = Math.max(0, snapshot.observedAtMs - Date.parse(tell.createdAt));
-        const fixed = `${"".padStart(5)}│ ${"tell".padEnd(7)} `;
-        const suffix = ` · undelivered ${formatTimelineDuration(Number.isFinite(age) ? age : 0)}`;
-        return `${fixed}${truncateColumns(`“${tell.text}”`, Math.max(0, maxColumns - displayColumns(fixed) - displayColumns(suffix)))}${suffix}`;
+function pendingTellRows(snapshot, maxColumns, orderOffset) {
+    return snapshot.tells.window.map((tell, index) => ({
+        line: renderPendingProjectionTell(tell, {
+            anchorMs: snapshot.observedAtMs,
+            maxColumns,
+        }),
+        at: tell.createdAt,
+        order: orderOffset + index,
+    }));
+}
+function orderFlowRows(rows) {
+    return rows.slice().sort((left, right) => {
+        const leftAt = Date.parse(left.at ?? "");
+        const rightAt = Date.parse(right.at ?? "");
+        const safeLeft = Number.isFinite(leftAt) ? leftAt : Number.POSITIVE_INFINITY;
+        const safeRight = Number.isFinite(rightAt) ? rightAt : Number.POSITIVE_INFINITY;
+        return safeLeft - safeRight || left.order - right.order;
     });
 }
 function ledgerHint(projectionId, snapshot) {
@@ -142,14 +132,13 @@ function unknownResponse(projectionId, akuma, snapshot, maxColumns) {
         anchorMs: snapshot.observedAtMs,
         state: "unknown",
         showPlan: false,
+        showSilence: false,
+        showTerminalFiles: false,
         ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
         maxColumns,
+        leadingOmittedCount: snapshot.activity.omittedSettledCount,
     });
-    const historicalLines = selectWaitBodyRows(rendered.lines.map((line, index) => ({
-        kind: rendered.rowKinds[index] ?? "activity",
-        line,
-        order: index,
-    }))).map((row) => row.line.replace(/[┆├]/, "│"));
+    const historicalLines = rendered.lines.map((line) => line.replace(/[┆├]/, "│"));
     return {
         ...textResponse([
             `? ${akuma} · projection: ${projectionId} · unknown`,
@@ -216,43 +205,32 @@ export function buildWaitResponse(projectionId, result, options = {}) {
     if (state === "returned") {
         return returnedResponse(projectionId, result);
     }
-    const tells = pendingTellLines(snapshot, maxColumns);
-    const summary = ["running", "stalled", "unknown"].includes(state)
-        ? renderProjectionActivitySummary(snapshot.activity, {
-            state,
-            ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
-            maxColumns,
-        })
-        : undefined;
     const rendered = renderProjectionActivity(snapshot.activity, {
         anchorMs: snapshot.observedAtMs,
         state,
-        showPlan: state === "running",
+        showPlan: false,
+        showSilence: false,
+        showTerminalFiles: false,
         ...(snapshot.workspaceRoot ? { workspaceRoot: snapshot.workspaceRoot } : {}),
         maxColumns,
+        leadingOmittedCount: snapshot.activity.omittedSettledCount,
     });
-    let order = 0;
-    const bodyPlan = [];
-    for (const diagnostic of snapshot.eventDiagnostics ?? []) {
-        bodyPlan.push({ kind: "storage-diagnostic", line: `‼ ${diagnostic.kind} · ${diagnostic.detail}`, order: order++ });
-    }
-    rendered.lines.forEach((line, index) => {
-        bodyPlan.push({ kind: rendered.rowKinds[index] ?? "activity", line, order: order++ });
-    });
-    for (const line of tells)
-        bodyPlan.push({ kind: "tell", line, order: order++ });
-    if (rendered.lines.length === 0 && tells.length === 0 && state === "running") {
-        bodyPlan.push({ kind: "liveness", line: "   not a word out of it yet — idle", order: order++ });
-    }
-    if (!rendered.hasEndAnchor && summary) {
-        bodyPlan.push({ kind: "summary", line: summary, order: order++ });
-    }
-    const bodyLines = selectWaitBodyRows(bodyPlan).map((row) => truncateColumns(row.line, maxColumns));
-    const lines = [waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns), ...bodyLines];
-    const pendingTellCount = snapshot.tells.totals.undelivered;
-    if (pendingTellCount > 0) {
-        lines.push(`${pendingTellCount} tell${pendingTellCount === 1 ? "" : "s"} undelivered`);
-    }
+    const diagnosticLines = (snapshot.eventDiagnostics ?? [])
+        .map((diagnostic) => `‼ ${diagnostic.kind} · ${diagnostic.detail}`);
+    const activityRows = rendered.lines.map((line, index) => ({
+        line,
+        at: rendered.rowAts[index],
+        order: index,
+    }));
+    const flowLines = orderFlowRows([
+        ...activityRows,
+        ...pendingTellRows(snapshot, maxColumns, activityRows.length),
+    ]).map((row) => truncateColumns(row.line, maxColumns));
+    const lines = [
+        waitHeader(projectionId, result.pact.akuma, snapshot, maxColumns),
+        ...diagnosticLines,
+        ...flowLines,
+    ];
     const nextActions = state === "running" && options.runningActions === false
         ? []
         : nextActionLines(options.alias ?? projectionId, result, state);

package/build/config/env-keys.js

@@ -27,7 +27,7 @@ const ENV_KEY_ENTRIES = [
     { key: ENV_KEYS.AGENT_OVERRIDE, defaultValue: "", description: "Override default agent name", category: "subagent" },
     { key: ENV_KEYS.DISABLE_SUBAGENT_SPAWN, defaultValue: "0", description: "Disable subprocess subagent spawning when set to 1", category: "subagent" },
     { key: ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS, defaultValue: "300000", description: "Subagent provider-ingress idle timeout in milliseconds", category: "subagent" },
-    { key: ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS, defaultValue: "3600000", description: "Subagent absolute execution policy budget in milliseconds", category: "subagent" },
+    { key: ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS, defaultValue: "0", description: "Subagent absolute execution policy budget in milliseconds; 0 disables it", category: "subagent" },
     { key: ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "Codex runtime output/diagnostics capture cap", category: "subagent" },
     { key: ENV_KEYS.CLAUDE_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "Claude runtime output/diagnostics capture cap", category: "subagent" },
     { key: ENV_KEYS.OPENCODE_EXEC_MAX_CAPTURE_CHARS, defaultValue: "200000", description: "OpenCode runtime output/diagnostics capture cap", category: "subagent" },

package/build/config/env.js

@@ -141,7 +141,7 @@ const subagentSchema = z.object({
     nameOverride: z.string().default(getEnvDefaultValue(ENV_KEYS.AGENT_OVERRIDE)).transform((value) => value.trim()),
     disableSpawn: booleanFlagEnv(ENV_KEYS.DISABLE_SUBAGENT_SPAWN),
     execIdleTimeoutMs: positiveIntEnv(ENV_KEYS.SUBAGENT_EXEC_IDLE_TIMEOUT_MS),
-    execMaxDurationMs: positiveIntEnv(ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS),
+    execMaxDurationMs: nonNegativeIntEnv(ENV_KEYS.SUBAGENT_EXEC_MAX_DURATION_MS),
 });
 const codexSchema = z.object({
     execMaxCaptureChars: positiveIntEnv(ENV_KEYS.CODEX_EXEC_MAX_CAPTURE_CHARS),

package/build/core/projection/generation/projection-generation-execution.js

@@ -26,6 +26,12 @@ function requirePositiveSafeInteger(value, field) {
     }
     return value;
 }
+function requireNonNegativeSafeInteger(value, field) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new Error(`generation launch ${field} must be a non-negative safe integer`);
+    }
+    return value;
+}
 function parseLaunchInputs(launch) {
     const raw = launch.facts.inputs;
     if (!isObject(raw))
@@ -58,7 +64,7 @@ function parseLaunchInputs(launch) {
         ...(context ? { context } : {}),
         launchSnapshot,
         idleTimeoutMs: requirePositiveSafeInteger(raw.idleTimeoutMs, "idleTimeoutMs"),
-        executionTimeoutMs: requirePositiveSafeInteger(raw.executionTimeoutMs, "executionTimeoutMs"),
+        executionTimeoutMs: requireNonNegativeSafeInteger(raw.executionTimeoutMs, "executionTimeoutMs"),
         persistProjectionResponse: raw.persistProjectionResponse,
         ...(raw.session ? { session: raw.session } : {}),
         ...(resumePath ? { resumePath } : {}),

package/build/core/projection/projection-activity.js

@@ -211,6 +211,7 @@ export function foldAgentActivity(events) {
     settled.sort((left, right) => left.order - right.order);
     pinned.sort((left, right) => left.order - right.order);
     const window = settled.slice(-AGENT_ACTIVITY_WINDOW_SIZE);
+    const omittedSettledCount = Math.max(0, settled.length - window.length);
     const visibleOrders = [...window, ...pinned].map((row) => row.order);
     const relevantTurns = visibleOrders.length === 0
         ? turns.slice(-1)
@@ -232,6 +233,7 @@ export function foldAgentActivity(events) {
     }
     return {
         window,
+        omittedSettledCount,
         pinned,
         timeline,
         ledgerActivities,

package/build/core/projection/projection-status.js

@@ -6,7 +6,7 @@ import { readProjectionAlias } from "./projection-alias.js";
 import { ProjectionStateError } from "../atomic-publish.js";
 import { foldPublicProjectionActivity, } from "./projection-activity.js";
 import { readProjectionIdentity } from "./projection-identity.js";
-import { readProjectionTellCounts } from "./tell/store.js";
+import { readPendingTellWindow, readProjectionTellCounts } from "./tell/store.js";
 import { ProjectionGenerationStoreError, } from "./generation/store.js";
 import { PROJECTION_ADOPTION_TIMEOUT_MS } from "./generation/projection-generation-launcher.js";
 import { observeProjectionLifeSnapshot, } from "./projection-life-observer.js";
@@ -169,6 +169,7 @@ function readIdentityFacts(projectionDir, diagnostics) {
             pid: identity.pid,
             akuma: identity.akuma,
             provider: identity.provider,
+            binding: identity.binding,
             mintedAt: identity.mintedAt,
             workspaceRoot: identity.workspaceRoot,
         };
@@ -176,18 +177,18 @@ function readIdentityFacts(projectionDir, diagnostics) {
     catch (error) {
         if (isErrnoException(error) && error.code === "ENOENT") {
             diagnostics.push({ kind: "missing-identity", detail: "heart identity missing" });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
+            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
         }
         if (error instanceof ProjectionGenerationStoreError) {
             diagnostics.push({ kind: "invalid-identity", detail: error.message });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
+            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
         }
         if (error instanceof ProjectionStateError) {
             diagnostics.push({ kind: "invalid-identity", detail: error.message });
-            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
+            return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
         }
         diagnostics.push({ kind: "unreadable-identity", detail: `heart identity unreadable: ${String(error)}` });
-        return { identity: null, pid: undefined, akuma: undefined, provider: undefined, mintedAt: undefined, workspaceRoot: undefined };
+        return { identity: null, pid: undefined, akuma: undefined, provider: undefined, binding: undefined, mintedAt: undefined, workspaceRoot: undefined };
     }
 }
 function readHeartTellCounts(projectionDir, diagnostics) {
@@ -203,6 +204,22 @@ function readHeartTellCounts(projectionDir, diagnostics) {
         return emptyTellCounts();
     }
 }
+function readPendingTells(projectionDir, diagnostics) {
+    try {
+        // Kanshi is an operator surface: unconsumed tells are actionable facts, not
+        // a count to hide behind. This is one heart read and does not enumerate a
+        // second projection topology.
+        return readPendingTellWindow(projectionDir, Number.MAX_SAFE_INTEGER).window;
+    }
+    catch (error) {
+        if (error instanceof ProjectionGenerationStoreError || error instanceof ProjectionStateError) {
+            diagnostics.push({ kind: "unreadable-tells", detail: error.message });
+            return [];
+        }
+        diagnostics.push({ kind: "unreadable-tells", detail: `heart tells unreadable: ${String(error)}` });
+        return [];
+    }
+}
 function readStoredEvents(projectionDir, executionId, diagnostics) {
     let content;
     let truncated = false;
@@ -322,6 +339,7 @@ function readProjectionRow(summary, nowMs, readDetails) {
     if (snapshot.compatibility === "incompatible") {
         return {
             id,
+            observedAtMs: nowMs,
             ...(alias ? { alias } : {}),
             state: "incompatible",
             observation: snapshot,
@@ -335,6 +353,7 @@ function readProjectionRow(summary, nowMs, readDetails) {
             ?? "projection identity could not be observed";
         return {
             id,
+            observedAtMs: nowMs,
             ...(alias ? { alias } : {}),
             state: "unknown",
             observation: {
@@ -354,6 +373,9 @@ function readProjectionRow(summary, nowMs, readDetails) {
     const tellCounts = readDetails
         ? readHeartTellCounts(projectionDir, diagnostics)
         : emptyTellCounts();
+    const pendingTells = readDetails
+        ? readPendingTells(projectionDir, diagnostics)
+        : [];
     const activityFacts = readDetails
         ? readActivityFacts(projectionDir, life.executionId, nowMs, diagnostics, typeof adoptedAt === "string" && Number.isFinite(adoptedAtMs) ? adoptedAt : identityFacts.mintedAt)
         : {};
@@ -377,11 +399,13 @@ function readProjectionRow(summary, nowMs, readDetails) {
         : undefined;
     return {
         id,
+        observedAtMs: nowMs,
         ...(alias ? { alias } : {}),
         state,
         observation: { compatibility: "current", lifecycle: life },
         akuma: identityFacts.akuma,
         provider: identityFacts.provider,
+        binding: identityFacts.binding,
         pid: identityFacts.pid,
         mintedAt: identityFacts.mintedAt,
         ...(terminalAt ? { terminalAt } : {}),
@@ -391,6 +415,7 @@ function readProjectionRow(summary, nowMs, readDetails) {
         ...(displayAgeMs !== undefined ? { activityAgeMs: displayAgeMs } : {}),
         ...(terminalFailure ? { terminalFailure } : {}),
         tellCounts,
+        ...(pendingTells.length > 0 ? { pendingTells } : {}),
         diagnostics,
     };
 }
@@ -433,7 +458,7 @@ function readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs) {
     const akumaDir = path.join(root, akuma);
     const hexes = readProjectionTopologyEntries(akumaDir);
     if (!hexes)
-        return [];
+        return null;
     const summaries = [];
     for (const hex of hexes) {
         const id = `${akuma}/${hex}`;
@@ -465,10 +490,17 @@ export async function readOperationalProjectionStatusBoard(cwd, nowMs) {
     for (const akuma of akumas) {
         if (akuma.startsWith("."))
             continue;
-        summaries.push(...readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs));
+        const scoped = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs);
+        // Seeing an entry and then being unable to observe its namespace is not an
+        // observable zero. Keep the whole aggregate surface unavailable.
+        if (scoped === null)
+            return null;
+        summaries.push(...scoped);
     }
     const rows = summaries.map((summary) => readProjectionRow(summary, nowMs, requiresProjectionStatusDetails(summary.state)));
-    return rows.length > 0 ? prioritizeProjectionStatusRows(rows) : null;
+    // A published root is an observable surface even when it currently has no
+    // rows. The caller must distinguish that fact from an unavailable root.
+    return prioritizeProjectionStatusRows(rows);
 }
 export async function readExactProjectionStatus(cwd, nowMs, projectionId) {
     if (!isProjectionId(projectionId))
@@ -511,7 +543,10 @@ export async function readAkumaNonterminalProjectionStatus(cwd, nowMs, akuma) {
         throw error;
     }
     const aliases = await readProjectionStatusAliases(cwd, root);
-    const rows = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs)
+    const summaries = readAkumaProjectionStatusSummaries(root, akuma, aliases, nowMs);
+    if (summaries === null)
+        return null;
+    const rows = summaries
         .filter(isNonterminalProjectionStatusSummary)
         .map((summary) => readProjectionRow(summary, nowMs, true))
         .sort(compareProjectionStatusRows);

package/build/core/status/board.js

@@ -26,11 +26,9 @@ function timestampAge(timestamp, now) {
 export function deriveTaskStatusSummary(board, now) {
     const eligible = board.tasks.filter((task) => !task.contractId && (task.state === "open" || task.state === "in_progress"));
     const inProgress = eligible.filter((task) => task.state === "in_progress").length;
-    const topTasks = [
-        ...eligible.filter((task) => task.state === "in_progress").sort(compareTaskStatusRows),
-        ...eligible.filter((task) => task.state === "open" && !task.blocked).sort(compareTaskStatusRows),
-    ]
-        .slice(0, 5)
+    const topTasks = eligible
+        .filter((task) => task.state === "in_progress")
+        .sort(compareTaskStatusRows)
         .map((task) => {
         const updatedAt = taskUpdatedAt(task);
         return {
@@ -47,14 +45,12 @@ export function deriveTaskStatusSummary(board, now) {
     });
     const ready = eligible.filter((task) => task.state === "open" && !task.blocked).length;
     const blocked = eligible.filter((task) => task.state === "open" && task.blocked).length;
-    if (board.tasks.length === 0 && board.diseases.length === 0)
-        return undefined;
     return {
-        total: board.tasks.length,
+        total: eligible.length,
         inProgress,
         ready,
         blocked,
-        omitted: inProgress + ready - topTasks.length,
+        omitted: ready + blocked,
         topTasks,
         diseases: board.diseases,
     };
@@ -199,6 +195,8 @@ export async function readKanshiBoard(cwd, now, opts) {
             : await readExactProjectionStatus(cwd, now, opts.projectionId);
         return {
             contracts: [],
+            contractsObservable: false,
+            commissionPlaces: new Map(),
             projections: opts?.projectionId === undefined
                 ? await readOperationalProjectionStatusBoard(cwd, now)
                 : exactProjection ? { rows: [exactProjection] } : null,
@@ -206,7 +204,8 @@ export async function readKanshiBoard(cwd, now, opts) {
             diseases: loadedSettings.diseases,
             claimReconciliation: null,
             targetFilter,
-            ...(tasks ? { tasks } : {}),
+            // Task and contract boards are repository organs; a non-repository cwd
+            // cannot truthfully turn their absence into a zero count.
         };
     }
     // Status is a pure reader: use the same resolver, but retain its ability to
@@ -237,6 +236,7 @@ export async function readKanshiBoard(cwd, now, opts) {
         })();
     }), defaultBranch);
     const contracts = [];
+    const commissionPlaces = new Map();
     // Readable-ledger commission targets retained for post-assembly filter only.
     const derivedTargetById = new Map();
     for (const item of ledgers) {
@@ -261,6 +261,7 @@ export async function readKanshiBoard(cwd, now, opts) {
             continue;
         }
         const bind = findBindEntry(item.entries);
+        commissionPlaces.set(item.contractId, bind?.data.place ?? null);
         derivedTargetById.set(item.contractId, commissionTarget(item.entries)?.ref);
         const base = latestBase(item.entries);
         const state = deriveContractState(item.entries);
@@ -334,6 +335,8 @@ export async function readKanshiBoard(cwd, now, opts) {
         : await readExactProjectionStatus(cwd, now, opts.projectionId);
     return {
         contracts: filteredContracts,
+        contractsObservable: true,
+        commissionPlaces,
         projections: opts?.projectionId === undefined
             ? await readOperationalProjectionStatusBoard(cwd, now)
             : exactProjection ? { rows: [exactProjection] } : null,

package/build/core/task/settlement-git.js

@@ -72,7 +72,7 @@ export async function createTaskMutationCommit(input) {
             ], undefined, env);
         }
         const tree = (await git(input.cwd, ["write-tree"], undefined, env)).trim();
-        const parentTree = (await git(input.cwd, ["rev-parse", `${input.parent}^{tree}`])).trim();
+        const parentTree = (await git(input.cwd, ["show", "-s", "--format=%T", input.parent])).trim();
         if (tree === parentTree)
             return input.parent;
         return (await git(input.cwd, ["commit-tree", tree, "-p", input.parent, "-m", input.subject])).trim();
@@ -354,7 +354,7 @@ export async function findAcceptedLandingCommit(input) {
             delivery: input.delivery,
             sources,
         });
-        const actualTree = (await git(input.cwd, ["rev-parse", `${commit}^{tree}`])).trim();
+        const actualTree = (await git(input.cwd, ["show", "-s", "--format=%T", commit])).trim();
         if (actualTree === expectedTree)
             return commit;
     }

package/build/generated/version.js

@@ -1,3 +1,3 @@
 // Generated into build output by scripts/build.mjs
-export const VERSION = "2.9.8";
-export const GIT_HASH = "c9cfce1";
+export const VERSION = "2.9.9";
+export const GIT_HASH = "79df272";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "2.9.8",
+  "version": "2.9.9",
   "description": "CLI for running iterative keiyaku workflows with Codex subagents.",
   "license": "MIT",
   "type": "module",