@astrosheep/keiyaku 2.9.6 → 2.9.7

package/build/core/projection/tell/store.js

@@ -1,7 +1,6 @@
 import { ProjectionStateError, randomHex8 } from "../../atomic-publish.js";
-import { withRead, withWrite } from "./database.js";
-import { assertTellIdRandomHex, originalFromRow, parseFence, requireExecutionId, submittedFromRow, } from "./model.js";
-const PENDING_TELL_LIMIT = 10_000;
+import { withRead, withReadSnapshot, withWrite } from "./database.js";
+import { assertTellIdRandomHex, originalFromRow, PENDING_PROJECTION_TELL_STATES, parseFence, requireExecutionId, submittedFromRow, } from "./model.js";
 function selectTell(database, tellId) {
     return database.prepare(`
     SELECT
@@ -26,6 +25,77 @@ export function listTellIds(projectionDirectory, state) {
       ORDER BY tell_id
     `).all(state).map((row) => row.tell_id));
 }
+/** List continuation fence metadata without loading operator tell bodies. */
+export function listTellMetadataFromDatabase(database, states) {
+    const placeholders = states.map(() => "?").join(", ");
+    return database.prepare(`
+    SELECT tell_id, state, execution_id, effort
+    FROM projection_tells
+    WHERE state IN (${placeholders})
+    ORDER BY tell_id
+  `).all(...states).map((row) => ({
+        tellId: row.tell_id,
+        state: row.state,
+        ...(row.execution_id ? { executionId: row.execution_id } : {}),
+        ...(row.effort ? { effort: row.effort } : {}),
+    }));
+}
+/** List continuation fence metadata without loading operator tell bodies. */
+export function listTellMetadata(projectionDirectory, states) {
+    return withRead(projectionDirectory, (database) => listTellMetadataFromDatabase(database, states));
+}
+export function readPendingTellWindowFromDatabase(database, limit) {
+    if (!Number.isSafeInteger(limit) || limit < 0) {
+        throw new ProjectionStateError("pending tell window limit must be a non-negative safe integer");
+    }
+    const pendingPlaceholders = PENDING_PROJECTION_TELL_STATES.map(() => "?").join(", ");
+    const total = database.prepare(`
+    SELECT COUNT(*) AS count
+    FROM projection_tells
+    WHERE state IN (${pendingPlaceholders})
+  `).get(...PENDING_PROJECTION_TELL_STATES);
+    const rows = database.prepare(`
+    SELECT tell_id, text, created_at, state
+    FROM projection_tells
+    WHERE state IN (${pendingPlaceholders})
+    ORDER BY tell_id
+    LIMIT ?
+  `).all(...PENDING_PROJECTION_TELL_STATES, limit);
+    return {
+        totals: { undelivered: Number(total.count) },
+        window: rows.map((row) => ({ tellId: row.tell_id, text: row.text, createdAt: row.created_at, state: row.state })),
+    };
+}
+export function readPendingTellWindow(projectionDirectory, limit) {
+    return withReadSnapshot(projectionDirectory, (database) => readPendingTellWindowFromDatabase(database, limit));
+}
+/** Whether a failed successor fence still retains delivered mail for replay. */
+export function hasRetainedDeliveredTellFromDatabase(database, retainedFence) {
+    if (retainedFence.length === 0)
+        return false;
+    const statement = database.prepare(`
+    SELECT 1
+    FROM projection_tells
+    WHERE tell_id = ? AND state = 'delivered'
+    LIMIT 1
+  `);
+    return retainedFence.some((tellId) => statement.get(tellId) !== undefined);
+}
+export function hasRetainedDeliveredTell(projectionDirectory, retainedFence) {
+    return withRead(projectionDirectory, (database) => hasRetainedDeliveredTellFromDatabase(database, retainedFence));
+}
+/** Whether interrupted replay has any delivered tell left to return to inbox. */
+export function hasDeliveredTellFromDatabase(database, executionId) {
+    return database.prepare(`
+    SELECT 1
+    FROM projection_tells
+    WHERE state = 'delivered' AND execution_id = ?
+    LIMIT 1
+  `).get(executionId) !== undefined;
+}
+export function hasDeliveredTell(projectionDirectory, executionId) {
+    return withRead(projectionDirectory, (database) => hasDeliveredTellFromDatabase(database, executionId));
+}
 export function readTellOriginal(projectionDirectory, state, tellId) {
     return withRead(projectionDirectory, (database) => {
         const row = selectTell(database, tellId);
@@ -49,14 +119,6 @@ export function writeInboxTell(projectionDirectory, text, nowMs, options) {
     }
     const tellId = `${nowMs}-${assertTellIdRandomHex((options?.randomHex ?? randomHex8)())}`;
     return withWrite(projectionDirectory, (database) => {
-        const pending = database.prepare(`
-      SELECT COUNT(*) AS count
-      FROM projection_tells
-      WHERE state IN ('inbox', 'inflight', 'submitted', 'delivered')
-    `).get();
-        if (Number(pending.count) >= PENDING_TELL_LIMIT) {
-            throw new ProjectionStateError(`projection has reached the ${PENDING_TELL_LIMIT} pending tell limit`);
-        }
         try {
             database.prepare(`
         INSERT INTO projection_tells (
@@ -123,6 +185,31 @@ export function claimFencedTells(projectionDirectory, fence, executionId) {
                 claimed.push(tellId);
                 continue;
             }
+            if (row.state === "submitted" || row.state === "delivered") {
+                const submitted = submittedFromRow(row);
+                if (submitted.executionId === owner) {
+                    throw new ProjectionStateError(`submitted tell belongs to current execution: ${tellId}`);
+                }
+                const replayedFrom = [
+                    ...(submitted.replayedFrom ?? []),
+                    { executionId: submitted.executionId, fence: submitted.fence },
+                ];
+                const result = database.prepare(`
+          UPDATE projection_tells
+          SET
+            state = 'inflight',
+            execution_id = NULL,
+            fence_json = NULL,
+            replayed_from_json = ?,
+            delivered_at = NULL
+          WHERE tell_id = ? AND state = ?
+        `).run(JSON.stringify(replayedFrom), tellId, row.state);
+                if (Number(result.changes) !== 1) {
+                    throw new ProjectionStateError(`generation tell fence member changed while claiming: ${tellId}`);
+                }
+                claimed.push(tellId);
+                continue;
+            }
             if (row.state === "consumed" && row.execution_id === owner)
                 continue;
             throw new ProjectionStateError(`generation tell fence member is not claimable: ${tellId}`);
@@ -152,7 +239,7 @@ export function markTellSubmitted(projectionDirectory, tellId, fields) {
         state = 'submitted',
         execution_id = ?,
         fence_json = ?,
-        replayed_from_json = ?
+        replayed_from_json = COALESCE(?, replayed_from_json)
       WHERE tell_id = ? AND state = 'inflight'
     `).run(executionId, JSON.stringify(fence), replayedFrom.length > 0 ? JSON.stringify(replayedFrom) : null, tellId);
     });
@@ -190,12 +277,13 @@ export function readProjectionTellCounts(projectionDirectory) {
 }
 export function snapshotPendingTells(projectionDirectory) {
     return withRead(projectionDirectory, (database) => {
+        const pendingPlaceholders = PENDING_PROJECTION_TELL_STATES.map(() => "?").join(", ");
         const rows = database.prepare(`
       SELECT tell_id, effort
       FROM projection_tells
-      WHERE state IN ('inbox', 'inflight', 'submitted', 'delivered')
+      WHERE state IN (${pendingPlaceholders})
       ORDER BY tell_id
-    `).all();
+    `).all(...PENDING_PROJECTION_TELL_STATES);
         const effort = rows.reduce((selected, row) => row.effort ?? selected, undefined);
         return {
             tellIds: rows.map((row) => row.tell_id),
@@ -203,44 +291,3 @@ export function snapshotPendingTells(projectionDirectory) {
         };
     });
 }
-export function demoteSubmittedTellsForReplay(projectionDirectory, executionId) {
-    const currentExecutionId = requireExecutionId(executionId);
-    return withWrite(projectionDirectory, (database) => {
-        const rows = database.prepare(`
-      SELECT
-        tell_id,
-        text,
-        created_at,
-        effort,
-        state,
-        execution_id,
-        fence_json,
-        replayed_from_json,
-        delivered_at
-      FROM projection_tells
-      WHERE state IN ('submitted', 'delivered')
-      ORDER BY tell_id
-    `).all();
-        for (const row of rows) {
-            const submitted = submittedFromRow(row);
-            if (submitted.executionId === currentExecutionId) {
-                throw new ProjectionStateError(`submitted tell belongs to current execution: ${row.tell_id}`);
-            }
-            const replayedFrom = [
-                ...(submitted.replayedFrom ?? []),
-                { executionId: submitted.executionId, fence: submitted.fence },
-            ];
-            database.prepare(`
-        UPDATE projection_tells
-        SET
-          state = 'inflight',
-          execution_id = NULL,
-          fence_json = NULL,
-          replayed_from_json = ?,
-          delivered_at = NULL
-        WHERE tell_id = ? AND state IN ('submitted', 'delivered')
-      `).run(JSON.stringify(replayedFrom), row.tell_id);
-        }
-        return rows.map((row) => row.tell_id);
-    });
-}

package/build/core/registry.js

@@ -1,7 +1,7 @@
 import { FlowError } from "../flow-error.js";
 import { createGit, wrapGitError } from "../git/core.js";
 import { readLedger } from "./ledger.js";
-import { appendRefLogWithRetry } from "./ref-log.js";
+import { appendRefLogWithRetry, readRefLog } from "./ref-log.js";
 import { patternsOverlap, scopePathEvidence } from "./scope.js";
 import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 export const REGISTRY_REF = "refs/keiyaku/registry";
@@ -39,11 +39,9 @@ async function activeRegistrations(cwd, entries) {
     }
     return active;
 }
-export async function registerScope(cwd, input) {
-    let overlaps = [];
-    let trackedPaths;
+async function trackedRepositoryPaths(cwd) {
     try {
-        trackedPaths = (await createGit(cwd).raw(["ls-files", "-z"]))
+        return (await createGit(cwd).raw(["ls-files", "-z"]))
             .split("\0")
             .filter(Boolean)
             .sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
@@ -51,76 +49,91 @@ export async function registerScope(cwd, input) {
     catch (error) {
         throw wrapGitError("ls-files -z", error, cwd);
     }
-    const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, async (entries) => {
-        const nextOverlaps = [];
-        const active = await activeRegistrations(cwd, entries);
-        if (input.exclusive && active.length > 0) {
-            const blocking = active.find((existing) => existing.contract !== input.contractId) ?? active[0];
-            throw new FlowError("ACTIVE_KEIYAKU_EXISTS", `exclusive bind rejected: active contract ${blocking.contract} already exists`);
+}
+async function scopeRegistrationAdmission(cwd, input, entries, trackedPaths) {
+    const nextOverlaps = [];
+    const active = await activeRegistrations(cwd, entries);
+    if (input.exclusive && active.length > 0) {
+        const blocking = active.find((existing) => existing.contract !== input.contractId) ?? active[0];
+        throw new FlowError("ACTIVE_KEIYAKU_EXISTS", `exclusive bind rejected: active contract ${blocking.contract} already exists`);
+    }
+    for (const existing of active) {
+        if (existing.contract === input.contractId)
+            continue;
+        if (existing.tree === input.tree) {
+            throw new FlowError("ACTIVE_KEIYAKU_EXISTS", [
+                `tree is already occupied by active contract ${existing.contract}`,
+                `Run \`keiyaku forfeit @${existing.contract}\` to free this tree.`,
+            ].join(" "));
         }
-        for (const existing of active) {
-            if (existing.contract === input.contractId)
+        const [nextEvidence, existingEvidence] = await Promise.all([
+            scopePathEvidence(cwd, input.scope, trackedPaths),
+            scopePathEvidence(cwd, existing.scope, trackedPaths),
+        ]);
+        const existingByPath = new Map(existingEvidence.map((evidence) => [evidence.path, evidence]));
+        const concreteByPatterns = new Map();
+        for (const next of nextEvidence) {
+            const prior = existingByPath.get(next.path);
+            if (!next.matched || !prior?.matched || !next.decisivePattern || !prior.decisivePattern)
                 continue;
-            if (existing.tree === input.tree) {
-                throw new FlowError("ACTIVE_KEIYAKU_EXISTS", [
-                    `tree is already occupied by active contract ${existing.contract}`,
-                    `Run \`keiyaku forfeit @${existing.contract}\` to free this tree.`,
-                ].join(" "));
-            }
-            const [nextEvidence, existingEvidence] = await Promise.all([
-                scopePathEvidence(cwd, input.scope, trackedPaths),
-                scopePathEvidence(cwd, existing.scope, trackedPaths),
-            ]);
-            const existingByPath = new Map(existingEvidence.map((evidence) => [evidence.path, evidence]));
-            const concreteByPatterns = new Map();
-            for (const next of nextEvidence) {
-                const prior = existingByPath.get(next.path);
-                if (!next.matched || !prior?.matched || !next.decisivePattern || !prior.decisivePattern)
-                    continue;
-                const key = `${next.decisivePattern.index}:${prior.decisivePattern.index}`;
-                const group = concreteByPatterns.get(key) ?? {
-                    next: next.decisivePattern.pattern,
-                    existing: prior.decisivePattern.pattern,
-                    paths: [],
-                };
-                group.paths.push(next.path);
-                concreteByPatterns.set(key, group);
-            }
-            for (const concrete of concreteByPatterns.values()) {
-                const preview = concrete.paths.slice(0, SCOPE_OVERLAP_PATH_PREVIEW_LIMIT);
-                nextOverlaps.push({
-                    contracts: [input.contractId, existing.contract],
-                    patterns: [concrete.next, concrete.existing],
-                    kind: "concrete",
-                    paths: {
-                        preview,
-                        count: concrete.paths.length,
-                        truncated: preview.length < concrete.paths.length,
-                    },
-                });
-            }
-            for (const nextPattern of input.scope) {
-                for (const existingPattern of existing.scope) {
-                    if (patternsOverlap(nextPattern, existingPattern)) {
-                        const [nextPatternEvidence, existingPatternEvidence] = await Promise.all([
-                            scopePathEvidence(cwd, [nextPattern], trackedPaths),
-                            scopePathEvidence(cwd, [existingPattern], trackedPaths),
-                        ]);
-                        const existingPatternByPath = new Map(existingPatternEvidence.map((evidence) => [evidence.path, evidence]));
-                        const hasCurrentWitness = nextPatternEvidence.some((evidence) => (evidence.matched && existingPatternByPath.get(evidence.path)?.matched));
-                        if (!hasCurrentWitness) {
-                            nextOverlaps.push({
-                                contracts: [input.contractId, existing.contract],
-                                patterns: [nextPattern, existingPattern],
-                                kind: "potential",
-                                paths: { preview: [], count: 0, truncated: false },
-                            });
-                        }
+            const key = `${next.decisivePattern.index}:${prior.decisivePattern.index}`;
+            const group = concreteByPatterns.get(key) ?? {
+                next: next.decisivePattern.pattern,
+                existing: prior.decisivePattern.pattern,
+                paths: [],
+            };
+            group.paths.push(next.path);
+            concreteByPatterns.set(key, group);
+        }
+        for (const concrete of concreteByPatterns.values()) {
+            const preview = concrete.paths.slice(0, SCOPE_OVERLAP_PATH_PREVIEW_LIMIT);
+            nextOverlaps.push({
+                contracts: [input.contractId, existing.contract],
+                patterns: [concrete.next, concrete.existing],
+                kind: "concrete",
+                paths: {
+                    preview,
+                    count: concrete.paths.length,
+                    truncated: preview.length < concrete.paths.length,
+                },
+            });
+        }
+        for (const nextPattern of input.scope) {
+            for (const existingPattern of existing.scope) {
+                if (patternsOverlap(nextPattern, existingPattern)) {
+                    const [nextPatternEvidence, existingPatternEvidence] = await Promise.all([
+                        scopePathEvidence(cwd, [nextPattern], trackedPaths),
+                        scopePathEvidence(cwd, [existingPattern], trackedPaths),
+                    ]);
+                    const existingPatternByPath = new Map(existingPatternEvidence.map((evidence) => [evidence.path, evidence]));
+                    const hasCurrentWitness = nextPatternEvidence.some((evidence) => (evidence.matched && existingPatternByPath.get(evidence.path)?.matched));
+                    if (!hasCurrentWitness) {
+                        nextOverlaps.push({
+                            contracts: [input.contractId, existing.contract],
+                            patterns: [nextPattern, existingPattern],
+                            kind: "potential",
+                            paths: { preview: [], count: 0, truncated: false },
+                        });
                     }
                 }
             }
         }
-        overlaps = nextOverlaps;
+    }
+    return nextOverlaps;
+}
+/** Read-only bind admission: validate exclusivity and classify scope overlap. */
+export async function previewScopeRegistration(cwd, input) {
+    const [entries, trackedPaths] = await Promise.all([
+        readRefLog(cwd, REGISTRY_REF, parseRegistryEntry),
+        trackedRepositoryPaths(cwd),
+    ]);
+    return await scopeRegistrationAdmission(cwd, input, entries, trackedPaths);
+}
+export async function registerScope(cwd, input) {
+    let overlaps = [];
+    const trackedPaths = await trackedRepositoryPaths(cwd);
+    const result = await appendRefLogWithRetry(cwd, REGISTRY_REF, registrySubject, parseRegistryEntry, async (entries) => {
+        overlaps = await scopeRegistrationAdmission(cwd, input, entries, trackedPaths);
         return {
             v: 1,
             kind: "register",

package/build/core/scope.js

@@ -38,17 +38,17 @@ export function isBlankScopePatternLine(line) {
 }
 /** Parse Keiyaku's source-line Scope opener, not a normalized Markdown node. */
 export function parseScopeFenceOpening(line) {
-    const match = line.match(/^(`{3,})$/);
-    return match ? { length: match[1].length } : null;
+    const match = line.match(/^(`{3,}|~{3,})$/);
+    return match ? { delimiter: match[1][0], length: match[1].length } : null;
 }
-/** Keiyaku closer: column-zero backticks, at least opener length, then whitespace. */
+/** Keiyaku closer: matching column-zero delimiter, at least opener length, then whitespace. */
 export function isScopeFenceClosing(line, fence) {
-    const match = line.match(/^(`+)[ \t]*$/);
-    return Boolean(match && match[1].length >= fence.length);
+    const match = line.match(/^(`+|~+)[ \t]*$/);
+    return Boolean(match && match[1][0] === fence.delimiter && match[1].length >= fence.length);
 }
 function fencedScopeError(heading, detail) {
     return new FlowError("INVALID_KEIYAKU_DRAFT", `${heading} must contain exactly one fenced gitignore-subset block; ${detail}. ` +
-        `Paste-ready canonical example:\n\n${heading}\n\`\`\`\nfoo\nbar\n\`\`\``);
+        `Paste-ready canonical example:\n\n${heading}\n~~~\nfoo\nbar\n~~~`);
 }
 /** Validate and normalize the one fenced block that constitutes a Scope body. */
 export function validateScopeFragmentLines(lines, options) {
@@ -152,14 +152,14 @@ export function markdownSourceSections(markdown) {
         return { ...heading, end: next?.start ?? markdown.length };
     });
 }
-/** Render canonical Scope bytes with a fence that content cannot close. */
+/** Render canonical Scope bytes with a tilde fence that content cannot close. */
 export function renderScopeFragment(patterns) {
     let longestRun = 0;
     for (const pattern of patterns) {
-        for (const run of pattern.match(/`+/g) ?? [])
+        for (const run of pattern.match(/~+/g) ?? [])
             longestRun = Math.max(longestRun, run.length);
     }
-    const fence = "`".repeat(Math.max(3, longestRun + 1));
+    const fence = "~".repeat(Math.max(3, longestRun + 1));
     return `${fence}\n${patterns.join("\n")}\n${fence}`;
 }
 /**

package/build/core/task/index.js

@@ -3,10 +3,10 @@
  * Only symbols required by current external consumers are re-exported.
  * Package-internal modules must import each other directly, not through this file.
  */
-export { reconcileTaskForfeit, settleTaskBoardForBind, settleTaskBoardForLanding, } from "./task-contract.js";
+export { previewTaskBoardForBind, reconcileTaskForfeit, settleTaskBoardForBind, settleTaskBoardForLanding, } from "./task-contract.js";
 export { resolveTaskCreator } from "./task-git-actor.js";
 export { openTaskCommandRepository, readTaskDoctor, taskCommandContractId, } from "./task-git-runtime.js";
-export { openTaskStore } from "./task-git-store.js";
+export { openTaskStore, readTaskHistory } from "./task-git-store.js";
 export { taskRepositoryFromStore } from "./task-store-repository.js";
 export { isTaskId } from "./validation.js";
 export { buildTaskTree, createTask, doneTask, dropTask, parseTaskDocument, readTaskBoard, resolveTaskReadId, serializeTaskDocument, startTask, stopTask, updateTask, deriveTaskDisplay, selectTaskList, taskUpdatedAt, advancedTaskUpdatedAt, } from "./task.js";

package/build/core/task/task-contract.js

@@ -7,6 +7,24 @@ import { buildTaskSourceBoard } from "./source-board.js";
 import { composeLandingTree, containsCommit, createLandingCommit, createTaskBoardCommit, findAcceptedLandingCommit, publishTaskMutationCommit, inspectCurrentBranch, publishForwardTaskBoardCommit, reconcileTaskPathsetIndex, refHead, taskContractAtCommit, taskSettlementOwnershipAtCommit, taskSourcesAtCommit, taskWritesFromSources, trackedTaskPaths, updateBranch, updateTargetRef, } from "./settlement-git.js";
 import { contractPointerDocument, doneTaskReplacements, reopenedTaskDocument, requireHealthySettlementBoard, requireSettledTask, selectReadyTasksForBind, tasksForContract, } from "./settlement-policy.js";
 import { stableRepoRoot } from "../worktree-path.js";
+/**
+ * Read the same healthy task board and run the same ready-task selector as bind
+ * under the task admission lock, without replacing sources or publishing.
+ */
+export async function previewTaskBoardForBind(input) {
+    await requireGitRepository(input.cwd, "task bind");
+    return await withLockHeldTaskBoard(input.cwd, async (transaction) => {
+        if (transaction.location.mode !== "git") {
+            if (transaction.location.capability === "unavailable") {
+                assertGitObservation({ capability: "unavailable" }, "task bind");
+            }
+            throw new FlowError("NOT_GIT_REPO", "task bind requires Git task storage");
+        }
+        const repository = taskRepositoryFromLockedBoard(transaction);
+        const board = requireHealthySettlementBoard(await repository.read());
+        return { tasks: input.taskIds === undefined ? [] : selectReadyTasksForBind(board, input.taskIds) };
+    });
+}
 function sourcePath(root, source) {
     return source.path.slice(root.length + 1).split("\\").join("/");
 }

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

@@ -105,6 +105,29 @@ export async function locateTaskBoard(cwd, runGitProbe = defaultRunGit) {
 function taskDirectory(board) {
     return path.join(board.root, ".keiyaku", "tasks");
 }
+const TASK_HISTORY_FORMAT = "%aI%x00%an%x00%s";
+function taskHistoryPath(taskId) {
+    return `.keiyaku/tasks/${taskId}.md`;
+}
+function parseTaskHistory(output) {
+    const fields = output.split("\0");
+    if (fields.at(-1) !== "") {
+        throw new FlowError("INTERNAL_STATE", "task history returned an incomplete record");
+    }
+    fields.pop();
+    if (fields.length % 3 !== 0) {
+        throw new FlowError("INTERNAL_STATE", "task history returned an incomplete record");
+    }
+    const entries = [];
+    for (let index = 0; index < fields.length; index += 3) {
+        entries.push({
+            timestamp: fields[index],
+            actor: fields[index + 1],
+            subject: fields[index + 2],
+        });
+    }
+    return entries;
+}
 function assertKeiyakuDirectory(board) {
     const keiyakuDirectory = path.join(board.root, ".keiyaku");
     const stat = lstatIfPresent(keiyakuDirectory);
@@ -201,6 +224,33 @@ export async function inspectTaskLock(cwd) {
         closeQuietly(database);
     }
 }
+/** Read the current hub branch's task-specific Git history without acquiring the task lock. */
+export async function readTaskHistory(cwd, taskId, deps = {}) {
+    if (!isTaskId(taskId)) {
+        throw new FlowError("INVALID_TARGET", `task history requires a canonical task id: ${taskId}`);
+    }
+    const board = await locateTaskBoard(cwd, deps.runGit);
+    if (board.mode !== "git") {
+        throw new FlowError("NOT_GIT_REPO", "task history is available only in a Git repository");
+    }
+    const result = await (deps.runGit ?? defaultRunGit)(board.root, [
+        "log",
+        "-z",
+        "--topo-order",
+        "--reverse",
+        `--format=${TASK_HISTORY_FORMAT}`,
+        "--",
+        taskHistoryPath(taskId),
+    ]);
+    if (result.error) {
+        throw new FlowError("INTERNAL_STATE", `cannot read task history: ${result.error.message}`, { cause: result.error });
+    }
+    if (result.status !== 0) {
+        const detail = result.stderr.trim() || `exit ${String(result.status)}`;
+        throw new FlowError("INTERNAL_STATE", `cannot read task history: ${detail}`);
+    }
+    return parseTaskHistory(result.stdout);
+}
 export function atomicReplaceTaskFile(filePath, text, _deps) {
     const directory = path.dirname(filePath);
     fs.mkdirSync(directory, { recursive: true });

package/build/generated/version.js

@@ -1,3 +1,3 @@
 // Generated into build output by scripts/build.mjs
-export const VERSION = "2.9.6";
-export const GIT_HASH = "cb7f9ef";
+export const VERSION = "2.9.7";
+export const GIT_HASH = "e0169c3";

package/package.json

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

package/skills/keiyaku-akuma/SKILL.md

@@ -30,6 +30,8 @@ keiyaku call NAME --detach "do the thing"     # fire and forget; note the projec
 keiyaku call NAME - < prompt.md               # long prompt: literal `-` reads stdin
 keiyaku wait <proj-id>                        # join a running one; prints its activity
 keiyaku wait <proj-id> --timeout 5m           # peek for 5m; timeout = snapshot, not death
+keiyaku wait <proj-a> <proj-b> --any          # return when the first member finishes
+keiyaku wait <proj-a> <proj-b> --all          # return when every member finishes
 keiyaku tell <proj-id> [--wait DURATION] <BODY|-> # optionally tell, then bounded-join
 keiyaku revive rsp_XXXX "continue..."         # new run continuing from a record
 keiyaku kill <proj-id>                        # stop it; record survives, revive still works
@@ -50,10 +52,18 @@ Use `keiyaku akuma view NAME` to inspect the resolved source and configuration.
 - Omit tell's bracketed `--wait DURATION` option for silent success: exit 0,
   zero output. Supply it to perform the ordinary bounded join after acceptance.
   Silence **is** the receipt — do not re-send. Effects show up in `wait`/`status`.
+- `tell --interrupt` is intentionally destructive. On an active runner, silent
+  success means the tell and interrupt intent are durable; provider stop and
+  successor wake continue asynchronously under the same projection id. Idle or
+  terminal state uses ordinary tell plus wake and reports its typed wake error.
 - Body is required for `call`/`tell`. Literal `-` selects stdin; unselected
   piped bytes are ignored and cannot change an argv body.
 - A `--wait`/`--timeout` expiry prints a live snapshot and exits 0 — the run continues; rejoin with `wait` anytime.
 - `wait` is repeatable: on a finished run it shows the final transcript again.
+- Supervise multiple projections with one plural `wait`. Choose `--any` to
+  handle the first terminal member and refill its lane; choose `--all` only for
+  final batch convergence. Keep foreground waits blocking; if bounded, use one
+  operationally meaningful timeout instead of repeated short-timeout polling.
 
 ## Occasional flags