@astrosheep/keiyaku 4.0.6 → 4.1.1

package/build/src/akuma/nuke.js

@@ -1,9 +1,10 @@
-import { lstat, readdir, rm } from "node:fs/promises";
+import { lstat, readdir, rm, rmdir } from "node:fs/promises";
+import { dirname, join } from "node:path";
 import { nukeAliases } from "../alias/index.js";
 import { CONTROL_RESPONSE_MS } from "./body.js";
-import { HeldAkumaLeash, readHeart, readKill, requestStop, } from "./heart/index.js";
-import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot, } from "./identity.js";
-const POLL_MS = 25;
+import { HeldAkumaLeash, readHeart, readKill, requestStop } from "./heart/index.js";
+import { akuIdFromDirectoryName, akumaPaths, akumaRunRoot } from "./identity.js";
+const POLL_MS = 100;
 async function hasAkumaCustody(paths) {
     try {
         const value = await lstat(paths.heart);
@@ -25,7 +26,7 @@ async function takeLeashUntil(paths, deadline) {
             return leash;
         if (performance.now() >= deadline)
             return null;
-        await wait(POLL_MS);
+        await wait(Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
     }
 }
 async function stopRunningAkuma(entry) {
@@ -36,11 +37,11 @@ async function stopRunningAkuma(entry) {
     try {
         if (request.kind === "already-killed" || request.kind === "already-stopped")
             return leash;
-        if (await readKill(entry.paths, request.body.sequence) !== null)
+        if ((await readKill(entry.paths, request.body.sequence)) !== null)
             return leash;
         const current = await readHeart(entry.paths);
         if (current.latestBody?.sequence !== request.body.sequence) {
-            if (await readKill(entry.paths, request.body.sequence) !== null)
+            if ((await readKill(entry.paths, request.body.sequence)) !== null)
                 return leash;
             throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
         }
@@ -48,7 +49,7 @@ async function stopRunningAkuma(entry) {
             await leash.clearStop(entry.paths);
             throw new Error(`Akuma ${entry.id} could not be stopped: untidy`);
         }
-        if (await leash.settleStop(entry.paths, request.body.sequence) === null) {
+        if ((await leash.settleStop(entry.paths, request.body.sequence)) === null) {
             throw new Error(`Akuma ${entry.id} could not be stopped: unavailable`);
         }
         return leash;
@@ -58,22 +59,112 @@ async function stopRunningAkuma(entry) {
         throw error;
     }
 }
-async function removeRegularFile(path) {
+async function removeKnownRegularFile(path) {
     try {
         const value = await lstat(path);
-        if (value.isFile() && !value.isSymbolicLink())
-            await rm(path, { force: true });
+        if (!value.isFile() || value.isSymbolicLink())
+            throw new Error(`Akuma custody is not a regular file: ${path}`);
+        await rm(path, { force: true });
     }
     catch (error) {
         if (error.code !== "ENOENT")
             throw error;
     }
 }
+async function removeEmptyDirectory(path) {
+    try {
+        await rmdir(path);
+    }
+    catch (error) {
+        if (error.code !== "ENOENT" && error.code !== "ENOTEMPTY")
+            throw error;
+    }
+}
+function isRequestSequenceName(name) {
+    const sequence = Number(name);
+    return /^\d+$/u.test(name) && Number.isSafeInteger(sequence) && String(sequence) === name;
+}
+const UUID_V4 = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+function isRequestArtifactName(name) {
+    const match = /^(.*)\.(?:request|receipt)\.json$/u.exec(name);
+    return match !== null && UUID_V4.test(match[1]);
+}
+async function removeKnownRequestFile(path) {
+    try {
+        const value = await lstat(path);
+        if (!value.isFile() || value.isSymbolicLink())
+            return;
+        await rm(path, { force: true });
+    }
+    catch (error) {
+        if (error.code !== "ENOENT")
+            throw error;
+    }
+}
+async function removeKnownRequestChannel(path) {
+    try {
+        const value = await lstat(path);
+        if (!value.isDirectory() || value.isSymbolicLink())
+            throw new Error(`Akuma custody is not a directory: ${path}`);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
+    }
+    for (const name of await readdir(path)) {
+        if (!isRequestSequenceName(name))
+            continue;
+        const sequenceDir = join(path, name);
+        try {
+            const sequence = await lstat(sequenceDir);
+            if (!sequence.isDirectory() || sequence.isSymbolicLink())
+                continue;
+            for (const child of await readdir(sequenceDir)) {
+                if (isRequestArtifactName(child))
+                    await removeKnownRequestFile(join(sequenceDir, child));
+            }
+            await removeEmptyDirectory(sequenceDir);
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+    }
+    await removeEmptyDirectory(path);
+}
 async function removeAkumaEntry(entry) {
-    for (const path of [entry.paths.heart, entry.paths.log,
-        `${entry.paths.heart}-wal`, `${entry.paths.heart}-shm`]) {
-        await removeRegularFile(path);
+    await removeKnownRequestChannel(entry.paths.requests);
+    for (const path of [
+        entry.paths.log,
+        `${entry.paths.heart}-wal`,
+        `${entry.paths.heart}-shm`,
+        `${entry.paths.leash}-wal`,
+        `${entry.paths.leash}-shm`,
+        entry.paths.leash,
+        entry.paths.heart,
+    ]) {
+        await removeKnownRegularFile(path);
+    }
+    await removeEmptyDirectory(entry.paths.directory);
+}
+async function removeEmptyAkumaRunRoot(world) {
+    const runRoot = akumaRunRoot(world);
+    let names;
+    try {
+        names = await readdir(runRoot);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return;
+        throw error;
     }
+    if (names.some((name) => name !== ".gitignore"))
+        return;
+    if (names.includes(".gitignore"))
+        await removeKnownRegularFile(join(runRoot, ".gitignore"));
+    await removeEmptyDirectory(runRoot);
+    await removeEmptyDirectory(dirname(runRoot));
 }
 async function nukeAkumaEntries(world) {
     const runRoot = akumaRunRoot(world);
@@ -136,6 +227,7 @@ export async function stopAkuma(world) {
                 await nukeAliases(world);
                 for (const entry of entries)
                     await removeAkumaEntry(entry);
+                await removeEmptyAkumaRunRoot(world);
             }
             finally {
                 for (const leash of held.reverse())

package/build/src/akuma/projection.d.ts

@@ -173,18 +173,20 @@ export type TurnLedger = Readonly<{
 /** Fold the retained fact timeline into Turn-owned rows without inventing provider facts. */
 export declare function projectTurns(facts: readonly TimelineFact[], retained?: RetainedWindow): TurnLedger;
 /** Split one nonnegative ordinary allowance into newest tail first, then pre-tail voice. */
-export declare function ordinarySnapshotBudget(ordinaryBudget: number): Readonly<{
+export declare function ordinarySnapshotBudget(ordinaryBudget?: number): Readonly<{
     tail: number;
     voice: number;
 }>;
-/** Count selected ordinary rows; active tools and pending tells stay outside this total. */
-export declare function ordinarySelectedCount(snapshot: ActivitySnapshot): number;
 /** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
-export declare function selectSnapshot(ledger: TurnLedger, budget?: Readonly<{
-    tail: number;
-    voice?: number;
-}>): ActivitySnapshot;
-/** Apply the one snapshot policy used by every public observation consumer. */
-export declare function selectActivitySnapshot(facts: readonly TimelineFact[]): ActivitySnapshot;
+export declare function selectSnapshot(ledger: TurnLedger, input: Readonly<{
+    aperture: "monitoring" | "receipt";
+    budget?: Readonly<{
+        tail: number;
+        voice?: number;
+    }>;
+}>): Readonly<{
+    snapshot: ActivitySnapshot;
+    ordinaryCount: number;
+}>;
 export declare function selectHistory(ledger: TurnLedger, cursor: HistoryCursor): HistoryPage;
 export {};

package/build/src/akuma/projection.js

@@ -15,12 +15,24 @@ function toolKey(turnSequence, id) {
 }
 function narrationRow(fact, event) {
     if (event.type === "assistant") {
-        return { kind: "said", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: event.text,
-            ...(event.truncated === true ? { truncated: true } : {}) };
+        return {
+            kind: "said",
+            sequence: fact.sequence,
+            turnSequence: fact.turnSequence,
+            at: fact.at,
+            text: event.text,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        };
     }
     if (event.type === "thought" || event.type === "note") {
-        return { kind: event.type, sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: event.text,
-            ...(event.truncated === true ? { truncated: true } : {}) };
+        return {
+            kind: event.type,
+            sequence: fact.sequence,
+            turnSequence: fact.turnSequence,
+            at: fact.at,
+            text: event.text,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        };
     }
     return null;
 }
@@ -43,7 +55,16 @@ function projectToolEvent(rows, running, fact, event, phase) {
     const index = running.get(key);
     const started = index === undefined ? undefined : rows[index];
     if (started?.kind !== "tool") {
-        rows.push({ kind: "tool", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, name: event.name, call: event.call, state: event.result, ...(event.truncated === true ? { truncated: true } : {}) });
+        rows.push({
+            kind: "tool",
+            sequence: fact.sequence,
+            turnSequence: fact.turnSequence,
+            at: fact.at,
+            name: event.name,
+            call: event.call,
+            state: event.result,
+            ...(event.truncated === true ? { truncated: true } : {}),
+        });
         return;
     }
     const durationMs = duration(started.at, fact.at);
@@ -118,13 +139,25 @@ export function projectTurns(facts, retained = {
     };
     for (const fact of facts) {
         if (fact.kind === "turn-start") {
-            const turn = { kind: "turn", sequence: fact.sequence, turnSequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.startedAt };
+            const turn = {
+                kind: "turn",
+                sequence: fact.sequence,
+                turnSequence: fact.sequence,
+                bodySequence: fact.bodySequence,
+                at: fact.startedAt,
+            };
             const projected = { phase: "open", turn, rows: [], running: new Map() };
             state.turns.push(projected);
             state.turnsBySequence.set(turn.turnSequence, projected);
         }
         else if (fact.kind === "turn-end") {
-            const outcome = { kind: "outcome", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.completedAt, outcome: fact.outcome };
+            const outcome = {
+                kind: "outcome",
+                sequence: fact.sequence,
+                turnSequence: fact.turnSequence,
+                at: fact.completedAt,
+                outcome: fact.outcome,
+            };
             const turn = state.turnsBySequence.get(fact.turnSequence);
             if (turn === undefined)
                 state.orphanOutcomes.push(outcome);
@@ -135,7 +168,13 @@ export function projectTurns(facts, retained = {
             }
         }
         else if (fact.kind === "call") {
-            const row = { kind: "call", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: fact.body };
+            const row = {
+                kind: "call",
+                sequence: fact.sequence,
+                turnSequence: fact.turnSequence,
+                at: fact.at,
+                text: fact.body,
+            };
             const turn = state.turnsBySequence.get(fact.turnSequence);
             if (turn === undefined)
                 state.orphanRows.push(row);
@@ -143,7 +182,15 @@ export function projectTurns(facts, retained = {
                 turn.rows.push(row);
         }
         else if (fact.kind === "tell") {
-            state.tells.push({ kind: "tell", sequence: fact.sequence, at: fact.recordedAt, tellId: fact.id, text: fact.body, state: fact.state, deliveries: fact.deliveries });
+            state.tells.push({
+                kind: "tell",
+                sequence: fact.sequence,
+                at: fact.recordedAt,
+                tellId: fact.id,
+                text: fact.body,
+                state: fact.state,
+                deliveries: fact.deliveries,
+            });
         }
         else {
             projectActivityEvent(state, fact);
@@ -159,12 +206,15 @@ export function projectTurns(facts, retained = {
     const frontier = turns.at(-1);
     const openTurn = frontier?.kind === "open" ? frontier : undefined;
     const latestOutcome = rows.findLast((row) => row.kind === "outcome");
-    return { rows, turns, retained, ...(openTurn === undefined ? {} : { openTurn }), ...(latestOutcome === undefined ? {} : { latestOutcome }) };
-}
-function entries(rows) {
-    return rows.map((row) => ({ kind: "row", row }));
+    return {
+        rows,
+        turns,
+        retained,
+        ...(openTurn === undefined ? {} : { openTurn }),
+        ...(latestOutcome === undefined ? {} : { latestOutcome }),
+    };
 }
-function openEntries(ledger, window, selected) {
+function assembleEntries(ledger, window, selected) {
     const windowRows = new Set(window);
     const result = [];
     let hidden = 0;
@@ -183,34 +233,20 @@ function openEntries(ledger, window, selected) {
             continue;
         flushGap();
         if (row.kind !== "turn" && row.kind !== "outcome" && !(row.kind === "tool" && row.state === "unsettled")) {
-            result.push({ kind: "row", row });
+            result.push({ kind: "row", row: row });
         }
     }
     flushGap();
     return result;
 }
+const DEFAULT_ORDINARY = DEFAULT_TAIL + DEFAULT_VOICE;
 /** Split one nonnegative ordinary allowance into newest tail first, then pre-tail voice. */
-export function ordinarySnapshotBudget(ordinaryBudget) {
+export function ordinarySnapshotBudget(ordinaryBudget = DEFAULT_ORDINARY) {
     const tail = Math.min(DEFAULT_TAIL, Math.max(0, ordinaryBudget));
     return { tail, voice: Math.min(DEFAULT_VOICE, Math.max(0, ordinaryBudget) - tail) };
 }
-/** Count selected ordinary rows; active tools and pending tells stay outside this total. */
-export function ordinarySelectedCount(snapshot) {
-    return snapshot.entries.reduce((count, entry) => {
-        if (entry.kind !== "row")
-            return count;
-        if (entry.row.kind === "tool" && entry.row.state === "active")
-            return count;
-        if (entry.row.kind === "tell" && entry.row.state === "pending")
-            return count;
-        return count + 1;
-    }, 0);
-}
 function isSuccessfulFileChange(row) {
-    return row.kind === "tool"
-        && typeof row.state === "object"
-        && row.state.status === "ok"
-        && row.call.kind === "fileChange";
+    return (row.kind === "tool" && typeof row.state === "object" && row.state.status === "ok" && row.call.kind === "fileChange");
 }
 function flattenReportedChanges(rows) {
     return rows.flatMap((row) => {
@@ -238,49 +274,70 @@ function frontierReportedChanges(ledger) {
     const closed = ledger.turns.findLast((turn) => turn.kind === "closed");
     return closed === undefined ? EMPTY_REPORTED : summarizeReportedChanges(closed.rows);
 }
+function isPendingTell(row) {
+    return row.kind === "tell" && row.state === "pending";
+}
+function isToldTell(row) {
+    return row.kind === "tell" && row.state === "told";
+}
+function isActiveTool(row) {
+    return row.kind === "tool" && row.state === "active";
+}
 /** Select one current Turn, one latest outcome, or no focus; pending tells stay actionable. */
-export function selectSnapshot(ledger, budget = { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE }) {
+export function selectSnapshot(ledger, input) {
+    const budget = input.budget ?? { tail: DEFAULT_TAIL, voice: DEFAULT_VOICE };
     if (ledger.turns.length === 0 && !ledger.rows.some((row) => row.kind === "tell")) {
-        return { kind: "unborn", entries: [], omitted: 0, ...EMPTY_REPORTED };
+        return { snapshot: { kind: "unborn", entries: [], omitted: 0, ...EMPTY_REPORTED }, ordinaryCount: 0 };
     }
-    const pending = ledger.rows.filter((row) => row.kind === "tell" && row.state === "pending");
+    const pending = ledger.rows.filter(isPendingTell);
+    const latestTold = input.aperture === "monitoring" ? ledger.rows.findLast(isToldTell) : undefined;
+    const pins = latestTold === undefined ? pending : [...pending, latestTold];
     const reported = frontierReportedChanges(ledger);
     if (ledger.openTurn !== undefined) {
         const window = ledger.openTurn.rows;
-        const active = window.filter((row) => row.kind === "tool" && row.state === "active");
-        const ordinary = window.filter((row) => !(row.kind === "tool" && row.state === "active"));
+        const pinSet = new Set([...window.filter(isActiveTool), ...pins]);
+        const ordinary = window.filter((row) => !pinSet.has(row));
         const tailCount = Math.max(0, budget.tail);
         const tail = tailCount === 0 ? [] : ordinary.slice(-tailCount);
         const tailSet = new Set(tail);
         const voiceCount = Math.max(0, budget.voice ?? DEFAULT_VOICE);
-        const voiceCandidates = ordinary
-            .filter((row) => !tailSet.has(row) && (row.kind === "said" || row.kind === "thought"));
+        const voiceCandidates = ordinary.filter((row) => !tailSet.has(row) && (row.kind === "said" || row.kind === "thought"));
         const voice = voiceCount === 0 ? [] : voiceCandidates.slice(-voiceCount);
-        const selected = new Set([...tail, ...voice, ...active, ...pending]);
+        const selected = new Set([...pinSet, ...tail, ...voice]);
         const omitted = window.filter((row) => !selected.has(row)).length;
-        return { kind: "open", turn: ledger.openTurn.turn, entries: openEntries(ledger, window, selected), omitted, ...reported };
+        return {
+            snapshot: {
+                kind: "open",
+                turn: ledger.openTurn.turn,
+                entries: assembleEntries(ledger, window, selected),
+                omitted,
+                ...reported,
+            },
+            ordinaryCount: tail.length + voice.length,
+        };
     }
     return {
-        kind: "idle",
-        ...(ledger.latestOutcome === undefined ? {} : { outcome: ledger.latestOutcome }),
-        entries: entries(pending),
-        omitted: 0,
-        ...reported,
+        snapshot: {
+            kind: "idle",
+            ...(ledger.latestOutcome === undefined ? {} : { outcome: ledger.latestOutcome }),
+            entries: assembleEntries(ledger, [], new Set(pins)),
+            omitted: 0,
+            ...reported,
+        },
+        ordinaryCount: 0,
     };
 }
-/** Apply the one snapshot policy used by every public observation consumer. */
-export function selectActivitySnapshot(facts) {
-    return selectSnapshot(projectTurns(facts));
-}
 export function selectHistory(ledger, cursor) {
     const eligible = ledger.rows.filter((row) => cursor.before !== undefined
         ? row.sequence < cursor.before
-        : cursor.since !== undefined ? row.sequence > cursor.since : true);
+        : cursor.since !== undefined
+            ? row.sequence > cursor.since
+            : true);
     const rows = cursor.since !== undefined ? eligible.slice(0, cursor.limit) : eligible.slice(-cursor.limit);
     const omitted = Math.max(0, eligible.length - rows.length);
     const historyLost = cursor.since !== undefined
-        ? (ledger.rows[0] !== undefined && ledger.rows[0].sequence > cursor.since + 1)
-        : (ledger.retained.lowestRetained !== null && ledger.retained.lowestRetained > 1 && omitted === 0);
+        ? ledger.rows[0] !== undefined && ledger.rows[0].sequence > cursor.since + 1
+        : ledger.retained.lowestRetained !== null && ledger.retained.lowestRetained > 1 && omitted === 0;
     return {
         rows,
         omitted,

package/build/src/akuma/provider-recipe.d.ts

@@ -1,9 +1,11 @@
+export type SystemPromptMode = "append" | "replace";
 export type ProviderOptions = Readonly<{
     model?: string;
     effort?: string;
     readonly?: true;
     network?: "disabled" | "enabled";
     systemPrompt?: string;
+    systemPromptMode?: SystemPromptMode;
 }>;
 export type ReadonlyRestraint = Readonly<{
     enforcement: "native";

package/build/src/akuma/provider-recipe.js

@@ -34,12 +34,22 @@ export function decodeProviderOptions(value) {
         throw new TypeError("provider option network must be disabled, enabled");
     }
     const systemPrompt = optionText(options, "systemPrompt", "allow");
+    const systemPromptMode = options.systemPromptMode;
+    if (systemPromptMode !== undefined) {
+        if (systemPromptMode !== "append" && systemPromptMode !== "replace") {
+            throw new TypeError("provider option systemPromptMode must be append, replace");
+        }
+        if (systemPrompt === undefined) {
+            throw new TypeError("provider option systemPromptMode requires systemPrompt");
+        }
+    }
     return Object.freeze({
         ...(model === undefined ? {} : { model }),
         ...(effort === undefined ? {} : { effort }),
         ...(options.readonly === undefined ? {} : { readonly: true }),
         ...(network === undefined ? {} : { network }),
         ...(systemPrompt === undefined ? {} : { systemPrompt }),
+        ...(systemPromptMode === undefined ? {} : { systemPromptMode }),
     });
 }
 export function decodeReadonlyRestraint(value) {
@@ -49,15 +59,20 @@ export function decodeReadonlyRestraint(value) {
     if (restraint.enforcement === "native") {
         return Object.freeze({ enforcement: "native" });
     }
-    if (restraint.enforcement === "none"
-        && typeof restraint.diagnostic === "string" && restraint.diagnostic.trim().length > 0) {
+    if (restraint.enforcement === "none" &&
+        typeof restraint.diagnostic === "string" &&
+        restraint.diagnostic.trim().length > 0) {
         return Object.freeze({ enforcement: "none", diagnostic: restraint.diagnostic });
     }
     throw new TypeError("readonly restraint must be native or none with a diagnostic");
 }
 function providerKind(value) {
-    return value === "acp" || value === "claude-agent-sdk" || value === "codex-app-server" || value === "grok-build"
-        || value === "opencode-sdk" || value === "pi";
+    return (value === "acp" ||
+        value === "claude-agent-sdk" ||
+        value === "codex-app-server" ||
+        value === "grok-build" ||
+        value === "opencode-sdk" ||
+        value === "pi");
 }
 export function decodeProviderRecipe(input) {
     const value = record(input);
@@ -68,7 +83,8 @@ export function decodeProviderRecipe(input) {
     }
     if (!providerKind(value.kind))
         throw new TypeError("provider execution has unknown kind");
-    if (value.executable !== undefined && (typeof value.executable !== "string" || value.executable.trim().length === 0)) {
+    if (value.executable !== undefined &&
+        (typeof value.executable !== "string" || value.executable.trim().length === 0)) {
         throw new TypeError("provider execution executable must be a nonblank string");
     }
     const config = value.config === undefined ? undefined : record(value.config);