@astrosheep/keiyaku 2.9.3 → 2.9.5

package/build/core/status/ledger-batch.js

@@ -0,0 +1,158 @@
+import { wrapGitError, runGitProcess } from "../../git/core.js";
+import { GitStreamingBatchFramingError, GitStreamingBatchResponseEndedError, openGitStreamingBatch, } from "../../git/streaming-batch.js";
+import { parseLedgerEntryCommitMessage } from "../entry.js";
+import { ACTIVE_LEDGER_REF_PREFIX, } from "../ledger.js";
+const MAX_LEDGER_COMMIT_BYTES = 1024 * 1024;
+async function runStatusGit(cwd, args) {
+    const result = await runGitProcess(cwd, args);
+    if (result.error || result.status !== 0) {
+        throw wrapGitError(args.join(" "), {
+            message: result.error?.message
+                ?? `git exited with status ${result.status ?? "unknown"}`,
+            stderr: result.stderr,
+            stdout: result.stdout,
+        }, cwd);
+    }
+    return Buffer.from(result.stdout, "utf8");
+}
+async function queryBatchObject(batch, expression) {
+    const record = await batch.request(expression, {
+        maxContentBytes: MAX_LEDGER_COMMIT_BYTES,
+    });
+    if (record.kind === "missing" || record.kind === "ambiguous") {
+        throw new Error(`[git cat-file ${expression}] object is ${record.kind === "missing" ? "missing" : "ambiguous"}`);
+    }
+    return {
+        oid: record.record.oid,
+        type: record.record.type,
+        content: record.record.content,
+    };
+}
+function parseCommitObject(object) {
+    if (object.type !== "commit") {
+        throw new Error(`git cat-file expected commit ${object.oid}, received ${object.type}`);
+    }
+    const content = object.content.toString("utf8");
+    const messageStart = content.indexOf("\n\n");
+    if (messageStart < 0)
+        throw new Error(`git commit ${object.oid} has no message separator`);
+    const parents = [];
+    for (const line of content.slice(0, messageStart).split("\n")) {
+        if (!line.startsWith("parent "))
+            continue;
+        const parent = line.slice("parent ".length);
+        if (!/^[0-9a-f]{40,64}$/.test(parent)) {
+            throw new Error(`git commit ${object.oid} has an invalid parent header`);
+        }
+        parents.push(parent);
+    }
+    return { oid: object.oid, parents, message: content.slice(messageStart + 2) };
+}
+function parseLedgerRefs(output) {
+    return output
+        .toString("utf8")
+        .split(/\r?\n/)
+        .filter((ref) => ref.startsWith(ACTIVE_LEDGER_REF_PREFIX))
+        .map((ref) => ({ contractId: ref.slice(ACTIVE_LEDGER_REF_PREFIX.length), ref }));
+}
+async function readLedgerFromBatch(batch, ref, commits) {
+    const headObject = await queryBatchObject(batch, `${ref.ref}^{commit}`);
+    const head = parseCommitObject(headObject);
+    commits.set(head.oid, Promise.resolve(head));
+    const ordered = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const visit = async (oid) => {
+        if (visited.has(oid))
+            return;
+        if (visiting.has(oid))
+            throw new Error(`git ledger ancestry contains a cycle at ${oid}`);
+        visiting.add(oid);
+        let pending = commits.get(oid);
+        if (!pending) {
+            pending = queryBatchObject(batch, oid).then(parseCommitObject);
+            commits.set(oid, pending);
+        }
+        const commit = await pending;
+        for (const parent of commit.parents)
+            await visit(parent);
+        visiting.delete(oid);
+        visited.add(oid);
+        ordered.push(commit);
+    };
+    await visit(head.oid);
+    return {
+        contractId: ref.contractId,
+        ref: ref.ref,
+        head: head.oid,
+        entries: ordered.map((commit) => parseLedgerEntryCommitMessage(commit.message)),
+    };
+}
+/**
+ * Read the aggregate status ledger snapshot with at most two Git processes:
+ * ref-name discovery and one framed, streaming object session.
+ */
+export async function readStatusLedgers(cwd) {
+    const refOutput = await runStatusGit(cwd, [
+        "for-each-ref",
+        "--sort=refname",
+        "--format=%(refname)",
+        ACTIVE_LEDGER_REF_PREFIX,
+    ]);
+    const refs = parseLedgerRefs(refOutput);
+    if (refs.length === 0)
+        return [];
+    const batch = openGitStreamingBatch(cwd);
+    const commits = new Map();
+    const results = [];
+    let readError;
+    try {
+        for (let index = 0; index < refs.length; index += 1) {
+            const ref = refs[index];
+            try {
+                results.push(await readLedgerFromBatch(batch, ref, commits));
+            }
+            catch (error) {
+                const diagnostic = error instanceof Error ? error : new Error(String(error));
+                results.push({ id: ref.contractId, error: diagnostic });
+                // Framing and mid-frame EOF both destroy the batch channel; isolate remaining refs.
+                if (error instanceof GitStreamingBatchFramingError
+                    || error instanceof GitStreamingBatchResponseEndedError) {
+                    const isolationReason = error instanceof GitStreamingBatchResponseEndedError
+                        ? "response ended"
+                        : "malformed frame";
+                    for (const pending of refs.slice(index + 1)) {
+                        results.push({
+                            id: pending.contractId,
+                            error: new Error(`git cat-file batch terminated after ${isolationReason}: ${diagnostic.message}`),
+                        });
+                    }
+                    break;
+                }
+            }
+        }
+    }
+    catch (error) {
+        readError = error;
+    }
+    try {
+        const close = await batch.close();
+        if (!close.aborted && (close.timedOut || close.signal || close.code !== 0)) {
+            throw wrapGitError("cat-file --batch", {
+                message: close.timedOut
+                    ? "git timed out"
+                    : close.signal
+                        ? `git exited from signal ${close.signal}`
+                        : `git exited with status ${close.code ?? "unknown"}`,
+                stderr: close.stderr.toString("utf8"),
+            }, cwd);
+        }
+    }
+    catch (error) {
+        if (!readError)
+            readError = error;
+    }
+    if (readError)
+        throw readError;
+    return results;
+}

package/build/core/status/reconciliation.js

@@ -1,6 +1,6 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
-import { createGit } from "../../git/core.js";
+import { createGit, parseRevListOutput, wrapGitError } from "../../git/core.js";
 import { stableRepoRoot } from "../worktree-path.js";
 function isClaimReceipt(value) {
     if (!value || typeof value !== "object")
@@ -51,7 +51,13 @@ export async function computeClaimReconciliation(cwd, defaultBranch) {
     if (receiptLines.length === 0)
         return null;
     const git = createGit(cwd);
-    const firstParentHistory = (await git.raw(["rev-list", "--first-parent", defaultBranch.head])).trim().split("\n").filter(Boolean);
+    let firstParentHistory;
+    try {
+        firstParentHistory = parseRevListOutput(await git.raw(["rev-list", "--first-parent", defaultBranch.head]));
+    }
+    catch (error) {
+        throw wrapGitError(`rev-list --first-parent ${defaultBranch.head}`, error, cwd);
+    }
     const firstParentSet = new Set(firstParentHistory);
     let baselineIndex = -1;
     for (let index = receiptLines.length - 1; index >= 0; index -= 1) {
@@ -70,10 +76,10 @@ export async function computeClaimReconciliation(cwd, defaultBranch) {
         return line.record?.kind === "baseline" ? [{ line: line.line, reason: "non-chain" }] : [];
     });
     // Only records after the latest valid baseline belong to this fence window.
+    // Intentional degrade: rev-list failure yields empty segments plus non-chain receipt issues.
     let revList;
     try {
-        const output = await git.raw(["rev-list", "--first-parent", "--reverse", `${baseline.head}..${defaultBranch.head}`]);
-        revList = output.trim().split("\n").filter((h) => h.length > 0);
+        revList = parseRevListOutput(await git.raw(["rev-list", "--first-parent", "--reverse", `${baseline.head}..${defaultBranch.head}`]));
     }
     catch {
         return {

package/build/core/stored-agent-event.js

@@ -1,17 +1,21 @@
 import { activityEventBodySchema, AGENT_EVENT_TEXT_MAX_CHARS, AGENT_UNKNOWN_PAYLOAD_MAX_CHARS, EXEC_EVENT_BUFFER_HARD_CAP, } from "../agents/harness/index.js";
 import { isSubagentProvider } from "../keiyaku.js";
-const FAIL_CODES = new Set(["SUBAGENT_TIMEOUT", "SUBAGENT_NON_ZERO_EXIT", "SUBAGENT_SPAWN_ERROR", "SUBAGENT_EXEC_ERROR", "SUBAGENT_PROVIDER_UNAVAILABLE", "PROJECTION_STATE_ERROR"]);
+const FAIL_CODES = new Set(["SUBAGENT_TIMEOUT", "SUBAGENT_TRANSPORT_ERROR", "SUBAGENT_POLICY_BUDGET", "SUBAGENT_NON_ZERO_EXIT", "SUBAGENT_SPAWN_ERROR", "SUBAGENT_EXEC_ERROR", "SUBAGENT_PROVIDER_UNAVAILABLE", "PROJECTION_STATE_ERROR"]);
 const KNOWN = new Set(["message", "unknown", "activity", "thought", "plan", "turn", "usage", "warning", "diagnostic", "truncation", "done", "fail"]);
 const record = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 const finite = (value) => typeof value === "number" && Number.isFinite(value);
+const nonNegativeFinite = (value) => finite(value) && value >= 0;
 const optionalString = (value, key) => value[key] === undefined || typeof value[key] === "string";
 const nonNegativeSafeInteger = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
 const safeIntegerOrNull = (value) => value === null || (typeof value === "number" && Number.isSafeInteger(value));
 function isValidStoredWarning(warning) {
+    if (warning.reason === "rate-limit") {
+        return warning.state === "exhausted" && Object.keys(warning).length === 2;
+    }
     if (warning.reason === "retry") {
         return nonNegativeSafeInteger(warning.attempt)
             && nonNegativeSafeInteger(warning.maxRetries)
-            && nonNegativeSafeInteger(warning.retryDelayMs)
+            && nonNegativeFinite(warning.retryDelayMs)
             && safeIntegerOrNull(warning.errorStatus);
     }
     if (warning.reason === "refusal" || warning.reason === "overload") {

package/build/core/task/board.js

@@ -1,6 +1,5 @@
 import { FlowError } from "../../flow-error.js";
-import { TASK_ID } from "./validation.js";
-const TASK_READ_ID = /^k-[0-9a-f]{7,12}$/;
+import { isTaskId } from "./validation.js";
 function compareText(left, right) {
     return left < right ? -1 : left > right ? 1 : 0;
 }
@@ -60,6 +59,30 @@ function cycleComponents(tasks) {
             visit(id);
     return cycles;
 }
+function parentCycleComponents(tasks) {
+    const cycles = [];
+    const visited = new Set();
+    for (const start of [...tasks.keys()].sort()) {
+        if (visited.has(start))
+            continue;
+        const path = [];
+        const positions = new Map();
+        let current = start;
+        while (current !== null && tasks.has(current) && !visited.has(current)) {
+            const prior = positions.get(current);
+            if (prior !== undefined) {
+                cycles.push(new Set(path.slice(prior)));
+                break;
+            }
+            positions.set(current, path.length);
+            path.push(current);
+            current = tasks.get(current).parent;
+        }
+        for (const id of path)
+            visited.add(id);
+    }
+    return cycles;
+}
 /** Derive the complete storage-neutral board from domain records. */
 export function buildTaskBoardFromDocuments(documents) {
     const diseases = [];
@@ -91,6 +114,17 @@ export function buildTaskBoardFromDocuments(documents) {
             candidates.delete(id);
         }
     }
+    for (const component of parentCycleComponents(candidates)) {
+        const relatedIds = [...component].sort();
+        for (const id of relatedIds) {
+            diseases.push({
+                code: "parent_cycle",
+                message: `task ${id} participates in a parent cycle`,
+                id,
+                relatedIds,
+            });
+        }
+    }
     let changed = true;
     while (changed) {
         changed = false;
@@ -129,6 +163,7 @@ export function buildTaskBoardFromDocuments(documents) {
             parent: task.parent,
             from: [...task.from],
             createdAt: task.createdAt,
+            ...(task.updatedAt === undefined ? {} : { updatedAt: task.updatedAt }),
             creator: task.creator,
             ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
             ...(task.contractId === undefined ? {} : { contractId: task.contractId }),
@@ -148,9 +183,11 @@ export function resolveTaskReadId(board, input) {
     return resolveTaskId(board, input);
 }
 export function resolveTaskId(board, input) {
-    if (!TASK_READ_ID.test(input)) {
+    if (!isTaskId(input)) {
         throw new FlowError("INVALID_TARGET", `invalid task id '${input}'`);
     }
+    if (board.byId.has(input))
+        return input;
     const matches = board.tasks
         .map((task) => task.id)
         .filter((id) => id.startsWith(input))
@@ -163,7 +200,7 @@ export function resolveTaskId(board, input) {
     return matches[0];
 }
 export function requireCanonicalTaskId(input) {
-    if (!TASK_ID.test(input)) {
+    if (!isTaskId(input)) {
         throw new FlowError("INVALID_TARGET", "task mutations require a canonical full task id");
     }
     return input;

package/build/core/task/commands.js

@@ -1,6 +1,8 @@
 import { FlowError } from "../../flow-error.js";
+import { IdentifierSlugError, normalizeIdentifierSlug, SUFFIXABLE_IDENTIFIER_SLUG_MAX_UTF8_BYTES, } from "../identifier-slug.js";
 import { requireCanonicalTaskId, requireHealthy, resolveTaskId, } from "./board.js";
 import { dateTimestamp, invalid, nonblank, } from "./validation.js";
+import { advancedTaskUpdatedAt } from "./model.js";
 export async function readTaskBoard(repository) {
     return repository.read();
 }
@@ -14,15 +16,17 @@ function documentFromView(view) {
         parent: view.parent,
         from: [...view.from],
         createdAt: view.createdAt,
+        ...(view.updatedAt === undefined ? {} : { updatedAt: view.updatedAt }),
         creator: view.creator,
         ...(view.startedAt === undefined ? {} : { startedAt: view.startedAt }),
         ...(view.contractId === undefined ? {} : { contractId: view.contractId }),
         body: view.body,
     };
 }
-function replaceDocument(document) {
+function replaceDocument(document, subject) {
     return {
         replacements: [document],
+        subject,
         select(resulting) {
             const value = resulting.byId.get(document.id);
             if (!value)
@@ -43,6 +47,16 @@ function resolveMutationIds(board, ids) {
 export async function createTask(repository, input, deps) {
     nonblank("title", input.title);
     nonblank("creator", input.creator);
+    let baseId;
+    try {
+        baseId = normalizeIdentifierSlug(input.title, SUFFIXABLE_IDENTIFIER_SLUG_MAX_UTF8_BYTES);
+    }
+    catch (error) {
+        if (error instanceof IdentifierSlugError) {
+            throw new FlowError("INVALID_TARGET", `task title ${error.message}`, { cause: error });
+        }
+        throw error;
+    }
     const pri = input.pri ?? 2;
     if (!Number.isInteger(pri) || pri < 0 || pri > 3)
         invalid("task priority must be an integer from 0 through 3");
@@ -55,19 +69,14 @@ export async function createTask(repository, input, deps) {
         const from = resolveMutationIds(board, input.from ?? []);
         if (new Set(from).size !== from.length)
             invalid("task from edges must be unique");
-        let id;
-        for (let attempt = 0; attempt < 32; attempt += 1) {
-            const bytes = deps.randomBytes(6);
-            if (bytes.byteLength !== 6)
-                throw new FlowError("INTERNAL_STATE", "randomBytes(6) must return exactly 6 bytes");
-            const candidate = `k-${Buffer.from(bytes).toString("hex")}`;
-            if (!board.byId.has(candidate)) {
-                id = candidate;
-                break;
+        let id = baseId;
+        for (let ordinal = 2; board.byId.has(id); ordinal += 1) {
+            if (!Number.isSafeInteger(ordinal)) {
+                throw new FlowError("INTERNAL_STATE", `task id collision ordinal exceeded the safe integer range for ${baseId}`);
             }
+            id = `${baseId}-${ordinal}`;
         }
-        if (!id)
-            throw new FlowError("CONCURRENT_MODIFICATION", "could not allocate a unique task id after 32 attempts");
+        const now = deps.now();
         const document = {
             id,
             title: input.title,
@@ -76,14 +85,15 @@ export async function createTask(repository, input, deps) {
             needs,
             parent,
             from,
-            createdAt: dateTimestamp("createdAt", deps.now()),
+            createdAt: dateTimestamp("createdAt", now),
+            updatedAt: dateTimestamp("updatedAt", now),
             creator: input.creator,
             body: input.body ?? "",
         };
-        return replaceDocument(document);
+        return replaceDocument(document, `Add task ${id}`);
     });
 }
-export async function updateTask(repository, fullIdValue, patch) {
+export async function updateTask(repository, fullIdValue, patch, now = new Date()) {
     const hasChange = Object.values(patch).some((value) => value !== undefined);
     if (!hasChange)
         throw new FlowError("EMPTY_PARAM", "task update requires at least one change");
@@ -112,18 +122,21 @@ export async function updateTask(repository, fullIdValue, patch) {
         if (JSON.stringify(document) === JSON.stringify(documentFromView(current))) {
             throw new FlowError("EMPTY_PARAM", "task update requires at least one change");
         }
-        return replaceDocument(document);
+        document.updatedAt = advancedTaskUpdatedAt(current, now);
+        return replaceDocument(document, `Update task ${id}`);
     });
 }
-async function transition(repository, fullIdValue, apply) {
+async function transition(repository, fullIdValue, apply, subject, now) {
     return repository.mutate((board) => {
         requireHealthy(board);
         const id = fullIdValue === undefined
             ? selectSoleInProgress(board).id
             : resolveTaskId(board, fullIdValue);
-        const document = documentFromView(requireExisting(board, id));
+        const current = requireExisting(board, id);
+        const document = documentFromView(current);
         apply(document);
-        return replaceDocument(document);
+        document.updatedAt = advancedTaskUpdatedAt(current, now);
+        return replaceDocument(document, subject(id));
     });
 }
 function rejectBound(document, action = "state") {
@@ -141,18 +154,18 @@ export async function startTask(repository, fullId, now) {
             invalid(`task ${document.id} is ${document.state}, not open`);
         document.state = "in_progress";
         document.startedAt = dateTimestamp("startedAt", now);
-    });
+    }, (id) => `Start task ${id}`, now);
 }
-export async function stopTask(repository, fullId) {
+export async function stopTask(repository, fullId, now = new Date()) {
     return transition(repository, fullId, (document) => {
         rejectBound(document);
         if (document.state !== "in_progress")
             invalid(`task ${document.id} is ${document.state}, not in_progress`);
         document.state = "open";
         delete document.startedAt;
-    });
+    }, (id) => `Stop task ${id}`, now);
 }
-export async function doneTask(repository, fullId) {
+export async function doneTask(repository, fullId, now = new Date()) {
     return transition(repository, fullId, (document) => {
         rejectBound(document);
         if (document.state !== "open" && document.state !== "in_progress") {
@@ -160,9 +173,9 @@ export async function doneTask(repository, fullId) {
         }
         document.state = "done";
         delete document.startedAt;
-    });
+    }, (id) => `Done task ${id}`, now);
 }
-export async function dropTask(repository, fullId) {
+export async function dropTask(repository, fullId, now = new Date()) {
     return transition(repository, fullId, (document) => {
         rejectBound(document, "drop");
         if (document.state !== "open" && document.state !== "in_progress") {
@@ -170,7 +183,7 @@ export async function dropTask(repository, fullId) {
         }
         document.state = "drop";
         delete document.startedAt;
-    });
+    }, (id) => `Drop task ${id}`, now);
 }
 export function selectSoleInProgress(board) {
     const candidates = board.tasks.filter((task) => task.state === "in_progress");
@@ -184,7 +197,7 @@ export function selectSoleInProgress(board) {
 }
 /** Reopen task pointers whose contract authority has disappeared. The caller
  * supplies the ledger fact; this operation itself remains storage-neutral. */
-export async function rollbackOrphanTaskPointers(repository, contractIds) {
+export async function rollbackOrphanTaskPointers(repository, contractIds, now = new Date()) {
     const before = await repository.read();
     const orphans = before.tasks
         .filter((task) => task.contractId !== undefined && !contractIds.has(task.contractId))
@@ -199,13 +212,17 @@ export async function rollbackOrphanTaskPointers(repository, contractIds) {
                 return [];
             const document = documentFromView(current);
             document.state = "open";
+            document.updatedAt = advancedTaskUpdatedAt(current, now);
             delete document.startedAt;
             delete document.contractId;
             return [document];
         });
         if (replacements.length === 0)
             throw new FlowError("CONCURRENT_MODIFICATION", "task pointers changed while doctor was reconciling them");
-        return { replacements, select: () => undefined };
+        const subject = replacements.length === 1
+            ? `Clear orphan contract pointer from task ${replacements[0].id}`
+            : `Clear orphan contract pointers from ${replacements.length} tasks`;
+        return { replacements, subject, select: () => undefined };
     });
     return orphans;
 }

package/build/core/task/document.js

@@ -9,6 +9,7 @@ const FIELD_ORDER = [
     "parent",
     "from",
     "createdAt",
+    "updatedAt",
     "creator",
     "startedAt",
     "contractId",
@@ -134,6 +135,8 @@ export function parseTaskDocument(source) {
     if (from.includes(id))
         invalid("task field 'from' must not reference itself");
     const createdAt = canonicalTimestamp("createdAt", values.get("createdAt"));
+    const updatedValue = values.get("updatedAt");
+    const updatedAt = updatedValue === undefined ? undefined : canonicalTimestamp("updatedAt", updatedValue);
     const creator = nonblank("creator", values.get("creator"));
     const startedValue = values.get("startedAt");
     const contractValue = values.get("contractId");
@@ -154,6 +157,7 @@ export function parseTaskDocument(source) {
         parent,
         from,
         createdAt,
+        ...(updatedAt === undefined ? {} : { updatedAt }),
         creator,
         ...(startedAt === undefined ? {} : { startedAt }),
         ...(contractId === undefined ? {} : { contractId }),
@@ -174,6 +178,7 @@ function serializeUnchecked(document) {
         parent: document.parent,
         from: document.from,
         createdAt: document.createdAt,
+        ...(document.updatedAt === undefined ? {} : { updatedAt: document.updatedAt }),
         creator: document.creator,
     };
     if (document.startedAt !== undefined)

package/build/core/task/index.js

@@ -0,0 +1,12 @@
+/**
+ * Public surface for the task package.
+ * 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 { resolveTaskCreator } from "./task-git-actor.js";
+export { openTaskCommandRepository, readTaskDoctor, taskCommandContractId, } from "./task-git-runtime.js";
+export { openTaskStore } 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/model.js

@@ -1 +1,8 @@
-export {};
+export function taskUpdatedAt(task) {
+    return task.updatedAt ?? task.createdAt;
+}
+export function advancedTaskUpdatedAt(task, observed) {
+    const observedMs = observed instanceof Date ? observed.getTime() : Date.parse(observed);
+    const priorMs = Date.parse(taskUpdatedAt(task));
+    return new Date(Math.max(observedMs, priorMs + 1)).toISOString();
+}