@astrosheep/keiyaku 2.9.8 → 2.9.10

package/build/cli/render/wait.js

@@ -1,29 +1,7 @@
-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 { coreTextResponse, 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;
 }
@@ -56,8 +34,7 @@ function projectionIdentityParts(projectionId) {
     const match = /^(.*)\/([0-9a-f]{8})$/.exec(projectionId);
     return match ? { slug: match[1], shortId: match[2] } : { slug: "", shortId: projectionId };
 }
-function waitHeader(projectionId, akuma, snapshot, outputColumns) {
-    const maxColumns = Math.min(WAIT_HEADER_MAX_COLUMNS, outputColumns);
+function waitHeader(projectionId, akuma, snapshot, maxColumns) {
     const state = waitStateText(snapshot);
     const identity = projectionIdentityParts(projectionId);
     // Slug often mirrors the Akuma name; print once when they are the same fact.
@@ -70,12 +47,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 +130,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,50 +203,39 @@ 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);
     if (nextActions.length > 0)
         lines.push("");
     lines.push(...nextActions);
-    const response = textResponse(lines.join("\n"));
+    const response = coreTextResponse(lines.join("\n"), result);
     if (snapshot.phase === "dismissed")
         return { ...response, exitCode: 130 };
     if (["failed", "lost", "startup-timeout", "unknown"].includes(snapshot.phase)) {

package/build/cli/subagent-guard.js

@@ -1,4 +1,4 @@
-const SUBAGENT_SAFE_COMMANDS = new Set(["status", "log", "guide", "dump-env", "wait"]);
+const SUBAGENT_SAFE_COMMANDS = new Set(["status", "history", "log", "guide", "dump-env", "wait"]);
 const SUBAGENT_SAFE_FLAGS = new Set(["--help", "-h", "--version"]);
 function isSubagentSafeCommand(args) {
     if (args.length === 0)

package/build/cli/types.js

@@ -1 +1 @@
-export const TASK_SUBCOMMANDS = ["add", "show", "ls", "log", "start", "stop", "done", "drop", "update", "doctor"];
+export const TASK_SUBCOMMANDS = ["add", "show", "ls", "log", "start", "stop", "hold", "resume", "done", "drop", "update", "doctor"];

package/build/config/env-keys.js

@@ -22,18 +22,20 @@ export const ENV_KEYS = {
     REVIEW_ENABLED: "KEIYAKU_REVIEW_ENABLED",
     REVIEW_MIN_LINES: "KEIYAKU_REVIEW_MIN_LINES",
     REVIEW_RESUME_SESSION: "KEIYAKU_REVIEW_RESUME_SESSION",
+    AMENDMENT_WARNING_THRESHOLD: "KEIYAKU_AMENDMENT_WARNING_THRESHOLD",
 };
 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" },
     { key: ENV_KEYS.REVIEW_ENABLED, defaultValue: "1", description: "Run the reviewer gate when set to 1", category: "workflow" },
     { key: ENV_KEYS.REVIEW_MIN_LINES, defaultValue: "200", description: "Minimum changed lines required before running the reviewer gate", category: "workflow" },
     { key: ENV_KEYS.REVIEW_RESUME_SESSION, defaultValue: "1", description: "Resume reviewer sessions from the prior persisted response path when set to 1", category: "workflow" },
+    { key: ENV_KEYS.AMENDMENT_WARNING_THRESHOLD, defaultValue: "5", description: "Advisory amendment-count threshold for open contracts", category: "workflow" },
     { key: ENV_KEYS.DEBUG_LOG_PATH, defaultValue: "", description: "Optional debug log output file path", category: "debug" },
     { key: ENV_KEYS.TEST_SILENT, defaultValue: "0", description: "Suppress progress logs during tests when set to 1", category: "debug" },
     { key: ENV_KEYS.GIT_TIMEOUT_MS, defaultValue: "15000", description: "Git command timeout in milliseconds", category: "git" },

package/build/config/env.js

@@ -95,6 +95,22 @@ function positiveIntEnv(key) {
         }
     });
 }
+function strictPositiveIntEnv(key) {
+    return z
+        .string()
+        .default(getEnvDefaultValue(key))
+        .transform((value, ctx) => {
+        const trimmed = value.trim();
+        const parsed = Number(trimmed);
+        if (/^\d+$/.test(trimmed) && Number.isSafeInteger(parsed) && parsed > 0)
+            return parsed;
+        ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            message: `${key} must be a positive integer, received '${value}'.`,
+        });
+        return z.NEVER;
+    });
+}
 function parseNonNegativeInt(value, key) {
     const trimmed = value.trim();
     const parsed = Number.parseInt(trimmed, 10);
@@ -141,7 +157,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),
@@ -166,6 +182,9 @@ const reviewSchema = z.object({
     minLines: nonNegativeIntEnv(ENV_KEYS.REVIEW_MIN_LINES),
     resumeSession: booleanFlagEnv(ENV_KEYS.REVIEW_RESUME_SESSION),
 });
+const amendmentWarningSchema = z.object({
+    threshold: strictPositiveIntEnv(ENV_KEYS.AMENDMENT_WARNING_THRESHOLD),
+});
 const terminalSchema = z.object({
     noColor: z.string().optional(),
     forceColor: z.string().optional(),
@@ -188,6 +207,7 @@ const envSchema = z
     [ENV_KEYS.REVIEW_ENABLED]: z.string().optional(),
     [ENV_KEYS.REVIEW_MIN_LINES]: z.string().optional(),
     [ENV_KEYS.REVIEW_RESUME_SESSION]: z.string().optional(),
+    [ENV_KEYS.AMENDMENT_WARNING_THRESHOLD]: z.string().optional(),
     NO_COLOR: z.string().optional(),
     FORCE_COLOR: z.string().optional(),
     TERM: z.string().optional(),
@@ -222,6 +242,9 @@ const envSchema = z
         minLines: rawEnv[ENV_KEYS.REVIEW_MIN_LINES],
         resumeSession: rawEnv[ENV_KEYS.REVIEW_RESUME_SESSION],
     }),
+    amendmentWarning: amendmentWarningSchema.parse({
+        threshold: rawEnv[ENV_KEYS.AMENDMENT_WARNING_THRESHOLD],
+    }),
     terminal: terminalSchema.parse({
         noColor: rawEnv.NO_COLOR,
         forceColor: rawEnv.FORCE_COLOR,

package/build/config/settings/schema.js

@@ -55,8 +55,10 @@ const gateCommandSchema = z
 const gateSchema = z
     .object({
     commands: z.array(gateCommandSchema).optional(),
+    timeoutMs: z.number().int("timeoutMs must be an integer.").min(1).max(3_600_000).optional(),
 })
-    .strict();
+    .strict()
+    .transform((value) => ({ ...value, timeoutMs: value.timeoutMs ?? 300_000 }));
 const WORKTREE_BOOTSTRAP_DEFAULT_TIMEOUT_MS = 300_000;
 const WORKTREE_BOOTSTRAP_MIN_TIMEOUT_MS = 1;
 const WORKTREE_BOOTSTRAP_MAX_TIMEOUT_MS = 3_600_000;

package/build/core/address-carrier.js

@@ -0,0 +1,89 @@
+import * as path from "node:path";
+import { FlowError } from "../flow-error.js";
+const ADDRESS_CARRIER = Symbol.for("keiyaku.address-carrier");
+export class AddressResolutionError extends FlowError {
+    attempt;
+    constructor(code, message, attempt, options) {
+        super(code, message, options);
+        this.name = "AddressResolutionError";
+        this.attempt = attempt;
+    }
+}
+class AddressedFlowError extends FlowError {
+    [ADDRESS_CARRIER];
+    constructor(error, carrier) {
+        super(error.code, error.message, {
+            cause: error,
+            review: error.review,
+            facts: error.facts,
+        });
+        this.name = error.name;
+        this[ADDRESS_CARRIER] = carrier;
+    }
+}
+class AddressedError extends Error {
+    [ADDRESS_CARRIER];
+    constructor(error, carrier) {
+        super(error instanceof Error ? error.message : String(error), { cause: error });
+        this.name = error instanceof Error ? error.name : "Error";
+        this[ADDRESS_CARRIER] = carrier;
+    }
+}
+export function attachAddressCarrier(error, carrier) {
+    if (addressCarrierFromError(error))
+        return error;
+    return error instanceof FlowError
+        ? new AddressedFlowError(error, carrier)
+        : new AddressedError(error, carrier);
+}
+export function addressCarrierFromError(error) {
+    const seen = new Set();
+    let current = error;
+    while (((typeof current === "object" && current !== null) || typeof current === "function") && !seen.has(current)) {
+        seen.add(current);
+        if (current instanceof AddressResolutionError)
+            return current.attempt;
+        const addressed = current;
+        if (addressed[ADDRESS_CARRIER])
+            return addressed[ADDRESS_CARRIER];
+        current = addressed.cause;
+    }
+    return undefined;
+}
+export async function withResolvedAddress(address, operation) {
+    try {
+        return await operation();
+    }
+    catch (error) {
+        throw attachAddressCarrier(error, address);
+    }
+}
+export function buildResolutionAttempt(input) {
+    return {
+        repo: input.repo,
+        workdir: path.resolve(input.workdir),
+        expected: "commission",
+        ...(input.spelling ? { spelling: input.spelling } : {}),
+        ...(input.actual !== undefined ? { actual: input.actual } : {}),
+        candidates: [...(input.candidates ?? [])],
+        inference: [...(input.inference ?? [])],
+    };
+}
+export function buildObjectResolutionAttempt(input) {
+    return {
+        repo: input.repo,
+        workdir: path.resolve(input.workdir),
+        expected: input.expected,
+        supplied: input.supplied,
+        ...(input.actual !== undefined ? { actual: input.actual } : {}),
+        ...(input.scope ? { scope: input.scope } : {}),
+        candidates: [...(input.candidates ?? [])],
+        inference: [...(input.inference ?? [])],
+    };
+}
+export function buildArtifactResolutionAttempt(input) {
+    return {
+        ...buildObjectResolutionAttempt({ ...input, expected: "artifact" }),
+        expected: "artifact",
+    };
+}