@astrosheep/keiyaku 2.8.4 → 2.9.0

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

@@ -0,0 +1,86 @@
+import { requireHealthy } from "./task/board.js";
+import { parseTaskDocument, serializeTaskDocument } from "./task/document.js";
+import { buildTaskSourceBoard } from "./task/source-board.js";
+function taskBoardFromSourceBoard(sourceBoard) {
+    const tasks = sourceBoard.tasks.map((task) => ({
+        id: task.id,
+        title: task.title,
+        state: task.state,
+        pri: task.pri,
+        needs: [...task.needs],
+        parent: task.parent,
+        from: [...task.from],
+        createdAt: task.createdAt,
+        creator: task.creator,
+        ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
+        ...(task.contractId === undefined ? {} : { contractId: task.contractId }),
+        body: task.body,
+        blocks: [...task.blocks],
+        blocked: task.blocked,
+        releasedNeeds: [...task.releasedNeeds],
+    }));
+    return {
+        tasks,
+        diseases: sourceBoard.diseases.map((disease) => ({
+            code: disease.code,
+            message: disease.message,
+            ...(disease.id === undefined ? {} : { id: disease.id }),
+            ...(disease.relatedIds === undefined ? {} : { relatedIds: [...disease.relatedIds] }),
+        })),
+        byId: new Map(tasks.map((task) => [task.id, task])),
+    };
+}
+export function prepareTaskDocumentReplacements(sources, replacements) {
+    const serialized = replacements.map((document) => ({
+        id: document.id,
+        text: serializeTaskDocument(document),
+    }));
+    const replacementIds = new Set(serialized.map((replacement) => replacement.id));
+    const paths = new Map();
+    const retained = sources.filter((source) => {
+        try {
+            const id = parseTaskDocument(source).id;
+            paths.set(id, source.path);
+            return !replacementIds.has(id);
+        }
+        catch {
+            // Malformed sources remain quarantined and visible to the resulting board.
+            return true;
+        }
+    });
+    const replacementSources = serialized.map((replacement) => ({
+        path: paths.get(replacement.id) ?? `${replacement.id}.md`,
+        text: replacement.text,
+    }));
+    const resultingSources = [...retained, ...replacementSources];
+    const board = taskBoardFromSourceBoard(buildTaskSourceBoard(resultingSources));
+    requireHealthy(board);
+    return {
+        sources: resultingSources,
+        writes: serialized,
+        board,
+    };
+}
+function mutationPlan(sources, mutation) {
+    const prepared = prepareTaskDocumentReplacements(sources, mutation.replacements);
+    return {
+        writes: prepared.writes,
+        value: mutation.select(prepared.board),
+    };
+}
+export function taskRepositoryFromStore(store) {
+    return {
+        read: async () => taskBoardFromSourceBoard(buildTaskSourceBoard(await store.read())),
+        mutate: async (apply) => store.mutate(async (sources) => mutationPlan(sources, await apply(taskBoardFromSourceBoard(buildTaskSourceBoard(sources))))),
+    };
+}
+export function taskRepositoryFromLockedBoard(transaction) {
+    return {
+        read: async () => taskBoardFromSourceBoard(buildTaskSourceBoard(transaction.sources)),
+        mutate: async (apply) => {
+            const plan = mutationPlan(transaction.sources, await apply(taskBoardFromSourceBoard(buildTaskSourceBoard(transaction.sources))));
+            await transaction.replace(plan.writes);
+            return plan.value;
+        },
+    };
+}

package/build/core/task-store.js

@@ -0,0 +1 @@
+export {};

package/build/core/task-worktree.js

@@ -0,0 +1,51 @@
+import { FlowError } from "../flow-error.js";
+function documentFacts(task) {
+    return JSON.stringify({
+        id: task.id,
+        title: task.title,
+        state: task.state,
+        pri: task.pri,
+        needs: [...task.needs],
+        parent: task.parent,
+        from: [...task.from],
+        createdAt: task.createdAt,
+        creator: task.creator,
+        ...(task.startedAt === undefined ? {} : { startedAt: task.startedAt }),
+        ...(task.contractId === undefined ? {} : { contractId: task.contractId }),
+        body: task.body,
+    });
+}
+function isNeedsAppend(prior, next) {
+    return next.needs.length > prior.needs.length
+        && prior.needs.every((need, index) => next.needs[index] === need)
+        && new Set(next.needs).size === next.needs.length
+        && documentFacts(prior) === documentFacts({ ...next, needs: prior.needs });
+}
+export function validateTaskWorktreeMutation(before, replacements, after, contractId) {
+    const existing = new Map(before.tasks.map((task) => [task.id, task]));
+    const bound = before.tasks.filter((task) => task.contractId === contractId);
+    for (const replacement of replacements) {
+        const prior = existing.get(replacement.id);
+        if (!prior)
+            continue;
+        const next = after.byId.get(replacement.id);
+        if (bound.length === 1 && prior.id === bound[0].id && next && isNeedsAppend(prior, next))
+            continue;
+        throw new FlowError("UNSUPPORTED_POLICY", `task ${replacement.id} is not yours; this checkout is bound to contract ${contractId}`);
+    }
+}
+export function withTaskWorktreePolicy(repository, contractId) {
+    return {
+        read: repository.read.bind(repository),
+        mutate: async (apply) => repository.mutate(async (before) => {
+            const mutation = await apply(before);
+            return {
+                replacements: mutation.replacements,
+                select(after) {
+                    validateTaskWorktreeMutation(before, mutation.replacements, after, contractId);
+                    return mutation.select(after);
+                },
+            };
+        }),
+    };
+}

package/build/core/task.js

@@ -0,0 +1,4 @@
+export { parseTaskDocument, serializeTaskDocument, } from "./task/document.js";
+export { resolveTaskReadId, } from "./task/board.js";
+export { buildTaskBoard } from "./task/source-board.js";
+export { readTaskBoard, createTask, updateTask, startTask, stopTask, doneTask, dropTask, selectSoleInProgress, rollbackOrphanTaskPointers, } from "./task/commands.js";

package/build/core/transcripts.js

@@ -1,7 +1,7 @@
 import { randomBytes } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot_v2.js";
+import { parseResolvedAkumaLaunchSnapshot, } from "../agents/launch-snapshot/model.js";
 import { resolvePersistedSubagentSession } from "../agents/session.js";
 import { isErrnoException } from "../errno.js";
 import { FlowError, requireText } from "../flow-error.js";
@@ -13,6 +13,8 @@ import { parseExecutionCoordinates } from "./execution-coordinate.js";
 import { createUlid } from "./ids.js";
 import { parseToAST } from "./markdown/parser.js";
 import { isResponseArtifactId, RESPONSE_ARTIFACT_ID_RE } from "./response-artifact-id.js";
+import { getResponseArtifactCatalog, } from "./response-artifact-catalog.js";
+import { assertExactFields, assertNonBlankString, isPlainRecord, } from "./validation.js";
 export { isResponseArtifactId, RESPONSE_ARTIFACT_ID_RE } from "./response-artifact-id.js";
 const RESPONSE_HISTORY_SLUG_MAX_LENGTH = 24;
 const RESPONSE_HISTORY_SESSION_KEY = "session";
@@ -30,43 +32,30 @@ const RESUMABLE_RESPONSE_HEADINGS = Object.values(RESPONSE_ARTIFACT_HEADINGS);
 function artifactError(locator, field, reason) {
     return new FlowError("INVALID_RESPONSE_PATH", `Invalid response artifact '${locator}': field '${field}' ${reason}.`);
 }
-function isRecord(value) {
-    return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-function assertExactFields(value, required, locator, prefix) {
-    for (const field of required) {
-        if (!(field in value))
-            throw artifactError(locator, `${prefix}.${field}`, "is missing");
-    }
-    const allowed = new Set(required);
-    const unknown = Object.keys(value).filter((field) => !allowed.has(field)).sort()[0];
-    if (unknown !== undefined)
-        throw artifactError(locator, `${prefix}.${unknown}`, "is unknown");
-}
-function nonBlank(value, locator, field) {
-    if (typeof value !== "string" || value.trim() === "")
-        throw artifactError(locator, field, "must be a non-blank string");
+function artifactInvalid(locator) {
+    return (field, reason) => artifactError(locator, field, reason);
 }
 /** The sole durable provenance parser. */
 export function parseResponseArtifactProvenance(value, locator) {
-    if (!isRecord(value))
+    const invalid = artifactInvalid(locator);
+    if (!isPlainRecord(value))
         throw artifactError(locator, "provenance", "must be an object");
-    assertExactFields(value, ["artifactId", "authority", "binding", "evidence"], locator, "provenance");
-    nonBlank(value.artifactId, locator, "provenance.artifactId");
+    assertExactFields(value, ["artifactId", "authority", "binding", "evidence"], [], "provenance", invalid);
+    assertNonBlankString(value.artifactId, "provenance.artifactId", invalid);
     if (!RESPONSE_ARTIFACT_ID_RE.test(value.artifactId)) {
         throw artifactError(locator, "provenance.artifactId", "must be rsp_ followed by a ULID");
     }
     const { authority, binding } = parseExecutionCoordinates(value.authority, value.binding, (field, reason) => artifactError(locator, `provenance.${field}`, reason));
-    if (!isRecord(value.evidence))
+    if (!isPlainRecord(value.evidence))
         throw artifactError(locator, "provenance.evidence", "must be an object");
     if (authority.kind === "repository") {
-        assertExactFields(value.evidence, ["branch", "commit"], locator, "provenance.evidence");
-        nonBlank(value.evidence.branch, locator, "provenance.evidence.branch");
-        nonBlank(value.evidence.commit, locator, "provenance.evidence.commit");
+        assertExactFields(value.evidence, ["branch", "commit"], [], "provenance.evidence", invalid);
+        assertNonBlankString(value.evidence.branch, "provenance.evidence.branch", invalid);
+        assertNonBlankString(value.evidence.commit, "provenance.evidence.commit", invalid);
         return { artifactId: value.artifactId, authority, binding, evidence: { branch: value.evidence.branch, commit: value.evidence.commit } };
     }
-    assertExactFields(value.evidence, ["workdir"], locator, "provenance.evidence");
-    nonBlank(value.evidence.workdir, locator, "provenance.evidence.workdir");
+    assertExactFields(value.evidence, ["workdir"], [], "provenance.evidence", invalid);
+    assertNonBlankString(value.evidence.workdir, "provenance.evidence.workdir", invalid);
     if (!path.isAbsolute(value.evidence.workdir)) {
         throw artifactError(locator, "provenance.evidence.workdir", "must be an absolute path");
     }
@@ -130,6 +119,15 @@ export async function persistResponseHistory(input) {
     const responsePath = path.join(historyDir, `${fileStamp}_${input.tool.toUpperCase()}_${slug(input.title ?? "", input.tool)}.md`);
     await fs.mkdir(historyDir, { recursive: true });
     await fs.writeFile(responsePath, buildMarkdown(input, iso, provenance), "utf8");
+    try {
+        getResponseArtifactCatalog()?.register({
+            id: artifactId,
+            stableRoot: await fs.realpath(input.cwd),
+        });
+    }
+    catch {
+        // The catalog is a disposable read model; the persisted artifact remains truth.
+    }
     return { artifactId, responsePath: path.relative(input.cwd, responsePath) };
 }
 function detectTool(document) {
@@ -206,43 +204,30 @@ export async function readResponseArtifact(input) {
         }
     }
     const subagentName = frontmatter.subagent_name?.trim() || undefined;
-    const storageRoot = path.resolve(path.dirname(absolutePath), "..", "..");
+    const storageRoot = await fs.realpath(path.resolve(path.dirname(absolutePath), "..", ".."));
     return { artifactId: provenance.artifactId, responsePath: path.relative(input.cwd, absolutePath), absolutePath, storageRoot, provenance, tool, ...(session ? { session } : {}), ...(launchSnapshot ? { launchSnapshot } : {}), ...(subagentName ? { subagentName } : {}) };
 }
-export async function locateResponseArtifact(input) {
-    const carry = (error) => {
-        throw attachAddressCarrier(error, input.attempt);
-    };
-    let identity;
-    try {
-        identity = requireText("artifactId", input.artifactId);
-    }
-    catch (error) {
-        return carry(error);
-    }
-    if (!isResponseArtifactId(identity)) {
-        return carry(new FlowError("INVALID_RESPONSE_PATH", `${identity} is not a response artifact handle; revive expects an artifact id`));
-    }
-    const historyDir = path.join(input.cwd, RESPONSE_HISTORY_DIR);
+async function findResponseArtifactAtRoot(input) {
+    const physicalHistoryDir = path.join(input.stableRoot, RESPONSE_HISTORY_DIR);
+    const historyDir = path.join(input.displayRoot ?? input.stableRoot, RESPONSE_HISTORY_DIR);
     let names;
     try {
-        names = await fs.readdir(historyDir);
+        names = await fs.readdir(physicalHistoryDir);
     }
     catch (error) {
-        if (isErrnoException(error) && error.code === "ENOENT") {
-            return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`));
-        }
-        return carry(error);
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return { kind: "missing" };
+        return input.carry(error);
     }
     let match;
     for (const name of names.filter((candidate) => candidate.endsWith(".md")).sort()) {
         const responsePath = path.join(RESPONSE_HISTORY_DIR, name);
         let document;
         try {
-            document = await fs.readFile(path.join(input.cwd, responsePath), "utf8");
+            document = await fs.readFile(path.join(input.stableRoot, responsePath), "utf8");
         }
         catch (error) {
-            return carry(error);
+            return input.carry(error);
         }
         const encoded = parseToAST(document).frontmatter?.entries?.[RESPONSE_HISTORY_PROVENANCE_KEY];
         if (encoded === undefined)
@@ -254,26 +239,123 @@ export async function locateResponseArtifact(input) {
         catch {
             continue;
         }
-        if (!isRecord(indexed) || indexed.artifactId !== identity)
+        if (!isPlainRecord(indexed) || indexed.artifactId !== input.artifactId)
             continue;
         let parsed;
         try {
-            parsed = await readResponseArtifact({ cwd: input.cwd, responsePath });
+            parsed = await readResponseArtifact({ cwd: input.stableRoot, responsePath });
         }
         catch (error) {
-            return carry(error);
+            return input.carry(error);
         }
         if (!parsed)
             continue;
         if (match) {
-            return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact identity '${identity}' is duplicated in ${historyDir}.`));
+            return input.carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact identity '${input.artifactId}' is duplicated in ${historyDir}.`));
         }
         match = parsed;
     }
-    if (!match) {
-        return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`));
+    return match ? { kind: "found", artifact: match } : { kind: "missing" };
+}
+function observeCatalogArtifact(catalog, artifact) {
+    try {
+        catalog?.touch({ id: artifact.artifactId, stableRoot: artifact.storageRoot });
+    }
+    catch {
+        // Artifact observation remains authoritative when the disposable catalog is unavailable.
+    }
+}
+export async function reconcileResponseArtifactCatalog(stableRoot) {
+    const catalog = getResponseArtifactCatalog();
+    if (!catalog)
+        return;
+    const physicalRoot = await fs.realpath(stableRoot);
+    const historyDir = path.join(physicalRoot, RESPONSE_HISTORY_DIR);
+    let names;
+    try {
+        names = await fs.readdir(historyDir);
+    }
+    catch (error) {
+        if (isErrnoException(error) && error.code === "ENOENT")
+            return;
+        throw error;
     }
-    return match;
+    for (const name of names.filter((candidate) => candidate.endsWith(".md")).sort()) {
+        try {
+            const artifact = await readResponseArtifact({
+                cwd: physicalRoot,
+                responsePath: path.join(RESPONSE_HISTORY_DIR, name),
+            });
+            if (artifact)
+                catalog.register({ id: artifact.artifactId, stableRoot: artifact.storageRoot });
+        }
+        catch {
+            // Reconciliation observes valid local artifacts only; it never repairs artifact truth.
+        }
+    }
+}
+export async function locateResponseArtifact(input) {
+    const carry = (error) => {
+        throw attachAddressCarrier(error, input.attempt);
+    };
+    let identity;
+    try {
+        identity = requireText("artifactId", input.artifactId);
+    }
+    catch (error) {
+        return carry(error);
+    }
+    if (!isResponseArtifactId(identity)) {
+        return carry(new FlowError("INVALID_RESPONSE_PATH", `${identity} is not a response artifact handle; revive expects an artifact id`));
+    }
+    let physicalLocalRoot;
+    try {
+        physicalLocalRoot = await fs.realpath(input.cwd);
+    }
+    catch (error) {
+        if (!isErrnoException(error) || error.code !== "ENOENT")
+            return carry(error);
+        physicalLocalRoot = path.resolve(input.cwd);
+    }
+    const local = await findResponseArtifactAtRoot({
+        stableRoot: physicalLocalRoot,
+        displayRoot: input.cwd,
+        artifactId: identity,
+        carry,
+    });
+    const catalog = getResponseArtifactCatalog();
+    if (local.kind === "found") {
+        observeCatalogArtifact(catalog, local.artifact);
+        return local.artifact;
+    }
+    let cataloged;
+    try {
+        cataloged = catalog?.lookup(identity);
+    }
+    catch {
+        cataloged = undefined;
+    }
+    if (cataloged) {
+        const catalogedRoot = cataloged.stableRoot;
+        const remote = await findResponseArtifactAtRoot({
+            stableRoot: catalogedRoot,
+            artifactId: identity,
+            carry,
+        });
+        if (remote.kind === "found") {
+            observeCatalogArtifact(catalog, remote.artifact);
+            return remote.artifact;
+        }
+        try {
+            catalog?.removeDead({ id: identity, stableRoot: catalogedRoot });
+        }
+        catch {
+            // Dead-row cleanup is best-effort; the physical lookup result owns the error.
+        }
+        return carry(new FlowError("INVALID_RESPONSE_PATH", `${identity} not found at cataloged root ${catalogedRoot}`));
+    }
+    const historyDir = path.join(input.cwd, RESPONSE_HISTORY_DIR);
+    return carry(new FlowError("INVALID_RESPONSE_PATH", `Response artifact '${identity}' was not found in ${historyDir}.`));
 }
 export function requireResumableArtifact(artifact) {
     if (!artifact.session)

package/build/core/validation.js

@@ -0,0 +1,17 @@
+export function isPlainRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function assertExactFields(value, required, optional, prefix, invalid) {
+    for (const field of required) {
+        if (!(field in value))
+            throw invalid(prefix ? `${prefix}.${field}` : field, "is missing");
+    }
+    const allowed = new Set([...required, ...optional]);
+    const unknown = Object.keys(value).filter((field) => !allowed.has(field)).sort()[0];
+    if (unknown !== undefined)
+        throw invalid(prefix ? `${prefix}.${unknown}` : unknown, "is unknown");
+}
+export function assertNonBlankString(value, field, invalid) {
+    if (typeof value !== "string" || value.trim() === "")
+        throw invalid(field, "must be a non-blank string");
+}

package/build/core/verdict.js

@@ -1,8 +1,8 @@
 import { FlowError } from "../flow-error.js";
 import { claimContract } from "./claim.js";
 import { activeLedgerRef, appendWithRetry, readLedger } from "./ledger.js";
-import { assertClaimQueueHead, queueMembership, readQueueReadModel } from "./queue_v2.js";
-import { deriveContractState } from "./status.js";
+import { assertClaimQueueHead, queueMembership, readQueueReadModel } from "./queue.js";
+import { deriveContractState } from "./status/lifecycle.js";
 function latestVerdict(entries) {
     for (let index = entries.length - 1; index >= 0; index -= 1) {
         const entry = entries[index];

package/build/core/worktree-path.js

@@ -4,7 +4,7 @@ import { FlowError } from "../flow-error.js";
 import { createGit, wrapGitError } from "../git/core.js";
 import { readLedger } from "./ledger.js";
 import { listContractIds } from "./ledger.js";
-import { deriveContractState, isTerminalState } from "./status.js";
+import { deriveContractState, isTerminalState } from "./status/lifecycle.js";
 export function findBindEntry(entries) {
     return entries.find((entry) => entry.kind === "bind");
 }
@@ -94,11 +94,11 @@ export async function findContractWorktreePath(cwd, contractId) {
     return (await findContractWorktree(cwd, contractId)).path;
 }
 /**
- * Resolve the active commission presented by an engine-owned contract
- * worktree containing cwd. Ordinary repository directories and arbitrary
- * worktrees never present a commission address.
+ * Resolve the contract id for an engine-owned bound worktree containing cwd.
+ * Matches the canonical bind place path and worktree workspace only; ledger
+ * terminal state is optional so residual worktrees after cleanup still bind.
  */
-export async function contractPresentedByWorktree(cwd) {
+async function contractIdForEngineOwnedWorktree(cwd, options) {
     const stableRoot = await stableRepoRoot(cwd);
     const canonicalCwd = await fs.realpath(cwd);
     for (const worktree of await listWorktrees(stableRoot)) {
@@ -107,7 +107,9 @@ export async function contractPresentedByWorktree(cwd) {
             continue;
         const contractId = worktree.branch.slice(branchPrefix.length);
         const ledger = await readLedger(stableRoot, contractId);
-        if (!ledger || isTerminalState(deriveContractState(ledger.entries)))
+        if (!ledger)
+            continue;
+        if (options.requireActive && isTerminalState(deriveContractState(ledger.entries)))
             continue;
         const bind = findBindEntry(ledger.entries);
         if (!bind || bind.data.workspace !== "worktree")
@@ -128,6 +130,22 @@ export async function contractPresentedByWorktree(cwd) {
     }
     return undefined;
 }
+/**
+ * Resolve the active commission presented by an engine-owned contract
+ * worktree containing cwd. Ordinary repository directories and arbitrary
+ * worktrees never present a commission address.
+ */
+export async function contractPresentedByWorktree(cwd) {
+    return contractIdForEngineOwnedWorktree(cwd, { requireActive: true });
+}
+/**
+ * Resolve the contract bound by an engine-owned worktree containing cwd,
+ * including when the ledger is already terminal. Task CLI contract context
+ * uses this residual binding; call/addressing keep active-only presentation.
+ */
+export async function contractBoundByEngineWorktree(cwd) {
+    return contractIdForEngineOwnedWorktree(cwd, { requireActive: false });
+}
 export async function cleanupContractWorkspace(cwd, contractId) {
     const stableRoot = await stableRepoRoot(cwd);
     const git = createGit(stableRoot);

package/build/flow-error.js

@@ -1,4 +1,5 @@
-import { ACTOR_IDENTITY, SETTINGS_FILE } from "./keiyaku.js";
+import { ACTOR_IDENTITY, SETTINGS_PATH_SEGMENTS } from "./keiyaku-constants.js";
+const SETTINGS_DISPLAY_PATH = SETTINGS_PATH_SEGMENTS.join("/");
 const DEFAULT_HINT_CONTEXT = {
     bindToolName: "bind",
     arcToolName: "arc",
@@ -63,7 +64,7 @@ function resolveFlowErrorHint(code, context) {
         case "INVALID_CLOSE_INTENT":
             return "Invalid close intent. Valid values are `CLAIM` and `FORFEIT`.";
         case "INVALID_SETTINGS":
-            return `Fix invalid configuration in \`${SETTINGS_FILE}\` and retry.`;
+            return `Fix invalid configuration in \`${SETTINGS_DISPLAY_PATH}\` and retry.`;
         case "INVALID_EFFORT_OVERRIDE":
             return "Choose an effort value declared by the selected Akuma's effortOptions.";
         case "CONCURRENT_MODIFICATION":

package/build/generated/version.js

@@ -1,2 +1,2 @@
 // Auto-generated by scripts/generate-version.mjs
-export const VERSION = "2.8.4";
+export const VERSION = "2.8.5";

package/build/git/commits.js

@@ -1,5 +1,8 @@
 import { FlowError } from "../flow-error.js";
 import { createGit, wrapGitError } from "./core.js";
+export function shortCommitHash(hash) {
+    return hash.slice(0, 12);
+}
 export async function resolveCommitRef(cwd, ref) {
     const git = createGit(cwd);
     try {

package/build/git/diff/parsers.js

@@ -1,17 +1,4 @@
-import { Buffer } from "node:buffer";
-const DIFF_GIT_HEADER_PREFIX = "diff --git ";
 const DIFF_TRUNCATED_MARKER = "...[truncated]";
-const GIT_QUOTED_PATH_ESCAPES = {
-    '"': 34,
-    "\\": 92,
-    a: 7,
-    b: 8,
-    f: 12,
-    n: 10,
-    r: 13,
-    t: 9,
-    v: 11,
-};
 export function splitDiffByFile(content) {
     const sections = [];
     let current = [];
@@ -94,87 +81,6 @@ export function isMissingBaseRevisionError(err) {
         text.includes("unknown revision or path not in the working tree") ||
         text.includes("ambiguous argument"));
 }
-function unescapeQuotedDiffPath(value) {
-    const bytes = [];
-    for (let index = 0; index < value.length; index += 1) {
-        const char = value[index];
-        if (char !== "\\") {
-            bytes.push(...Buffer.from(char ?? "", "utf8"));
-            continue;
-        }
-        const escaped = value[index + 1];
-        if (escaped === undefined) {
-            bytes.push(92);
-            continue;
-        }
-        if (escaped >= "0" && escaped <= "7") {
-            let octal = escaped;
-            let cursor = index + 2;
-            while (cursor < value.length && octal.length < 3) {
-                const digit = value[cursor];
-                if (digit === undefined || digit < "0" || digit > "7")
-                    break;
-                octal += digit;
-                cursor += 1;
-            }
-            bytes.push(Number.parseInt(octal, 8));
-            index = cursor - 1;
-            continue;
-        }
-        const decoded = GIT_QUOTED_PATH_ESCAPES[escaped];
-        if (decoded !== undefined) {
-            bytes.push(decoded);
-            index += 1;
-            continue;
-        }
-        bytes.push(...Buffer.from(escaped, "utf8"));
-        index += 1;
-    }
-    return Buffer.from(bytes).toString("utf8");
-}
-function readDiffHeaderToken(line, startIndex) {
-    let index = startIndex;
-    while (index < line.length && line[index] === " ") {
-        index += 1;
-    }
-    if (index >= line.length)
-        return null;
-    if (line[index] !== '"') {
-        let endIndex = index;
-        while (endIndex < line.length && line[endIndex] !== " ") {
-            endIndex += 1;
-        }
-        return {
-            value: line.slice(index, endIndex),
-            nextIndex: endIndex,
-        };
-    }
-    let endIndex = index + 1;
-    let escaped = false;
-    while (endIndex < line.length) {
-        const char = line[endIndex];
-        if (!escaped && char === '"') {
-            return {
-                value: unescapeQuotedDiffPath(line.slice(index + 1, endIndex)),
-                nextIndex: endIndex + 1,
-            };
-        }
-        escaped = !escaped && char === "\\";
-        endIndex += 1;
-    }
-    return null;
-}
-export function parseDiffPathFromHeader(diffGitLine) {
-    if (!diffGitLine.startsWith(DIFF_GIT_HEADER_PREFIX))
-        return null;
-    const aPart = readDiffHeaderToken(diffGitLine, DIFF_GIT_HEADER_PREFIX.length);
-    if (!aPart)
-        return null;
-    const bPart = readDiffHeaderToken(diffGitLine, aPart.nextIndex)?.value ?? "";
-    if (!bPart.startsWith("b/"))
-        return null;
-    return bPart.slice(2);
-}
 export function totalJoinedLength(blocks) {
     if (blocks.length === 0)
         return 0;

package/build/index.js

@@ -6,7 +6,9 @@ import { ENV_KEYS } from "./config/env-keys.js";
 import { logErrorWithCause } from "./telemetry/logger.js";
 import { runProjectionGenerationRuntime } from "./core/projection-generation-runtime.js";
 import { renderCliHelp, runCliCommand } from "./cli/index.js";
+import { installCliOutputStreamErrorPolicy } from "./cli/output-stream-error-policy.js";
 import { assertSubagentCliCommandAllowed } from "./cli/subagent-guard.js";
+installCliOutputStreamErrorPolicy(process.stdout, process.stderr);
 const packageVersion = VERSION;
 function findCliCwd(args) {
     for (let index = 0; index < args.length; index += 1) {

package/build/keiyaku-constants.js

@@ -0,0 +1,2 @@
+export const ACTOR_IDENTITY = "Akuma";
+export const SETTINGS_PATH_SEGMENTS = [".keiyaku", "settings.json"];