@astrosheep/keiyaku 4.5.6 → 4.5.7

package/build/integrations/marketplace/plugins/keiyaku/opencode.js

@@ -1,7 +1,7 @@
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
-const skills = ["keiyaku", "keiyaku-task", "keiyaku-bind", "keiyaku-workflow", "keiyaku-akuma"]
+const skills = ["keiyaku", "keiyaku-task", "keiyaku-bind", "keiyaku-workflow", "keiyaku-akuma", "keiyaku-babysit"]
   .map((name) => fileURLToPath(new URL(`./skills/${name}/SKILL.md`, import.meta.url)));
 
 export default {

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku/SKILL.md

@@ -14,6 +14,7 @@ read `<command> --help` before using flags.
 - A Contract is delivery authority; see `keiyaku-bind` to author and bind one,
   then `keiyaku-workflow` for the remaining lifecycle.
 - An Akuma is a callable worker; see `keiyaku-akuma`.
+- A long-running multi-lane goal needs coordination; see `keiyaku-babysit`.
 
 Settings owns named gate bundles. Omitting `--gates` selects `gates.default`,
 or freezes `["reviewed"]` when that entry is absent. `--gates <name,...>`

package/build/integrations/marketplace/plugins/keiyaku/skills/keiyaku-babysit/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: keiyaku-babysit
+description: Babysit a long-running multi-lane goal — a room of lanes that advance on their own, call for you on their schedule, and hold each other up while you are busy being productive.
+---
+
+# keiyaku-babysit
+
+A goal big enough to babysit is a room full of wards: kei in delivery,
+Akuma working, reviews pending, a caller owing a decision, an external
+dependency due someday. Each lane advances on its own once set moving;
+each calls for you when it chooses; a lane left waiting on you holds up
+the lanes behind it. There is one of you. The hard part is where your
+next ten minutes go.
+
+## You did not hand it off. You booked yourself.
+
+Handing a lane to a worker felt lighter, didn't it. What you actually
+did was schedule your own future: a question to answer, a return to
+verify, a review to start, a delivery to make — all arriving when the
+lane is ready, never when you are. While absorbed anywhere, every lane
+reaching such a moment stops dead and waits, billing the goal by the
+minute. Price attention by delay cost, not work importance: the
+two-minute answer an Akuma is stalled on outranks an hour of brilliant
+work in your hands, because your hour happens later and the stall does
+not un-happen. Yes, even though your work is more interesting.
+
+## The sweep
+
+Several lanes calling at once? How flattering. Take them in order of
+what your delay costs, never the order you prefer:
+
+1. Unblock anyone stopped and waiting on you: a question, hand-off, or
+   review only you can start. It will take minutes; it has cost hours.
+2. Verify returns, starting with the one other lanes build on. An
+   unverified return cannot close its lane, and every lane treating it
+   as settled builds on your unchecked assumption. If two returns can
+   interact, read both before settling either.
+3. Tell lanes what changed. A settled result that invalidates a running
+   lane's premise gets relayed before your own work; silence manufactures
+   rework.
+4. Then, and only then, your own lane. It survived waiting.
+
+Sweep at the seams: before a long stretch, when a lane returns something
+material, and when you hand a new lane out. Not on a timer. A quiet lane
+is not a content lane: quiet is working, stuck, or waiting on you, and
+you cannot tell which from your chair. Go look; reading progress into
+silence is astrology, not babysitting.
+
+## Productive absorption
+
+Neglect does not have to look like thrashing on a dead end. Real neglect
+looks like you, deeply satisfied, making excellent progress on one ward
+while the room goes unswept: an Akuma holding a one-line question for
+two hours, a finished return nobody dares build on because you never
+checked it, a caller decision request composed in your head and sent
+nowhere. The test is not "am I being productive" — you are. Is any
+lane's due care older than the work in your hands?
+
+## The critical path decides ties
+
+Two lanes call, both claims valid? Serve the critical path. Hand out
+critical-path work first, too: the side lane is tempting because it is
+easier to specify, and easy-to-specify is how goals die surrounded by
+finished side quests. Re-derive the path after every settled result; a
+delivered kei or fresh blocker can promote a background lane.
+
+## Only you can see the whole room
+
+Task records dependencies between tasks; nothing records that an Akuma
+waits on your answer, a review waits on a worktree, or the caller owes a
+lane a decision. That wait-graph lives in exactly one place: your head.
+It is what the sweep walks. When it outgrows your head — it will — park
+the waits in task notes. The map may degrade to paper, never to memory
+you merely trust. Wards answer at different speeds — Akuma in minutes,
+reviewers in hours, callers and external dependencies in geological
+time — so ask the slow ones when the question is knowable, not urgent.
+Shape a caller request as a decision with evidence, not a pile of raw
+results.
+
+## Release a blocked lane, keep the goal
+
+Lane blocked beyond your reach? Write the blocker into its task where
+the next sweep will see it, and release the lane. Hovering beside a
+blocker you cannot move is decoration, not diligence. The note makes
+releasing different from abandoning. Exception: a blocker gating the
+critical path with nothing else runnable is the job — press on it, split
+it into its own task or kei, or take it to the caller now.
+
+## Tired babysitters skip the checking
+
+Under load you cut verification depth first: diffs skimmed, gates
+assumed, "done" believed because the worker sounded confident. The
+goal's quality becomes the shabbiest check you accepted while busy.
+For a risky return, delegate an independent review: minutes spent, bar
+kept. Accepting it unread is free today and costs a later lane its
+premise.
+
+## Steer early, with the existing verbs
+
+Evidence changed the delivery? Amend the kei. Evidence obsoleted it?
+Abandon and bind a new one. Discovery deserves its own lane? Make it a
+task. Now, not "after this stretch": every lane keeps spending against
+the old contract until you speak.
+
+## Boundaries
+
+Babysitting is a method, not a role: no new identity, permission, ledger,
+status, id, lifecycle, fixed cadence, numeric threshold, or mandatory
+Task+kei+Akuma bundle. Task is optional planning and dependency memory;
+each kei stays one bounded delivery; Akuma is one ward among the
+entities you watch, not the definition of the job. Commands live with
+their owners — keiyaku-task, keiyaku-bind, keiyaku-workflow,
+keiyaku-akuma — this skill says when to reach for them, never how they
+work.

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

@@ -40,8 +40,8 @@ export type TellResult = Readonly<{
     wake: TellWake;
 }>;
 export type TellWakeRuntime = Readonly<{
-    observeHeart(paths: AkumaPaths, signal: AbortSignal): Promise<AsyncGenerator<void>>;
     spawn(paths: AkumaPaths): Promise<OwnedProcess>;
+    schedule?(milliseconds: number, signal: AbortSignal): Promise<void>;
 }>;
 type BodyRuntime = Readonly<{
     now(): string;

package/build/src/akuma/body.js

@@ -3,13 +3,14 @@ import { fileURLToPath } from "node:url";
 import { abortableDelay } from "./abort.js";
 import { BodySupervisor } from "./body-supervisor.js";
 import { driveTurn, turnRecipe } from "./turn-drive.js";
-import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, readNonterminalRequests, watchHeart, } from "./heart/index.js";
+import { HeldAkumaLeash, breakBody, endTurn, finishBodyIfIdle, heartExists, isHeartAbsent, readHeart, readNonterminalRequests, } from "./heart/index.js";
 import { worldRootForAkumaPaths } from "./identity.js";
 import { keiyakuSquarePath } from "../world.js";
 import { resolveProviderExecution } from "./providers/index.js";
 import { clearBodyRequestTransport, settleBodyRequests, } from "./request-serve.js";
 import { spawnDetachedProcess, } from "../runtime/proc/run.js";
 const LEASH_RETRY_MS = 100;
+const WAKE_REREAD_MS = 100;
 export const LEASH_HELD_EXIT = 75;
 export { CONTROL_RESPONSE_MS } from "./body-supervisor.js";
 function missing(error) {
@@ -296,8 +297,8 @@ export async function runAkumaBody(launch, upstream) {
     return await driveAkumaBody(launch, undefined, { ...defaultRuntime(), upstream });
 }
 const DIRECT_TELL_WAKE = {
-    observeHeart: watchHeart,
     spawn: async (paths) => await spawnAkumaBody({ paths, refuseIfHeld: true }),
+    schedule: abortableDelay,
 };
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
@@ -321,61 +322,47 @@ function failedChild(exit) {
         child: { code: exit.code, signal: exit.signal, log: exit.log },
     };
 }
-async function awaitWake(paths, tellId, after, child, changed) {
-    let nextChange = changed.next();
+async function awaitWake(paths, tellId, after, child, schedule) {
     for (;;) {
         const settled = await settledWake(paths, tellId, after);
         if (settled !== null) {
             child.release();
             return settled;
         }
-        const winner = await Promise.race([
-            nextChange.then(({ done }) => ({ kind: done ? "closed" : "changed" }), (error) => ({ kind: "observer-failed", error })),
-            child.exited.then((exit) => ({ kind: "exited", exit })),
-        ]);
-        if (winner.kind === "changed") {
-            nextChange = changed.next();
-            continue;
+        const timerController = new AbortController();
+        const timer = schedule(WAKE_REREAD_MS, timerController.signal).then(() => ({ kind: "timer" }));
+        let winner;
+        try {
+            winner = await Promise.race([child.exited.then((exit) => ({ kind: "exited", exit })), timer]);
         }
+        catch (error) {
+            timerController.abort();
+            await timer.catch(() => undefined);
+            throw error;
+        }
+        if (winner.kind === "timer")
+            continue;
+        timerController.abort();
+        await timer.catch(() => undefined);
         const final = await settledWake(paths, tellId, after);
         if (final !== null) {
             child.release();
             return final;
         }
-        if (winner.kind === "exited") {
-            return winner.exit.code === LEASH_HELD_EXIT ? { kind: "held" } : failedChild(winner.exit);
-        }
-        try {
-            await child.terminate();
-        }
-        catch (error) {
-            /* Termination rejection leaves physical custody unresolved; release it deliberately. */
-            child.release();
-            return { kind: "failed", diagnostic: diagnostic(error) };
-        }
-        return winner.kind === "observer-failed"
-            ? { kind: "failed", diagnostic: diagnostic(winner.error) }
-            : { kind: "failed", diagnostic: "Heart observer closed" };
+        return winner.exit.code === LEASH_HELD_EXIT ? { kind: "held" } : failedChild(winner.exit);
     }
 }
 async function wakePendingTells(paths, tellId, runtime) {
-    const watching = new AbortController();
-    let changed;
     try {
-        changed = await runtime.observeHeart(paths, watching.signal);
         const beforeHeart = await readHeart(paths);
         if (tellId === undefined && beforeHeart.pending.length === 0)
             return null;
         const before = beforeHeart.latestBody?.sequence ?? 0;
-        return await awaitWake(paths, tellId, before, await runtime.spawn(paths), changed);
+        return await awaitWake(paths, tellId, before, await runtime.spawn(paths), runtime.schedule ?? abortableDelay);
     }
     catch (error) {
         return { kind: "failed", diagnostic: diagnostic(error) };
     }
-    finally {
-        watching.abort();
-        await changed?.return(undefined);
-    }
 }
 export async function wakeRecordedTell(paths, tellId, runtime = DIRECT_TELL_WAKE) {
     return {

package/build/src/akuma/heart/index.d.ts

@@ -3,8 +3,8 @@ import type { BodyEnd, BodyFact, ForkPoint, HeartSnapshot, KillFact, SealFact, S
 export type { CallFact } from "./facts.js";
 import type { ActivityFact } from "./rows.js";
 import { type ActivityFactSlice } from "./timeline.js";
-export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, watchHeart, } from "./storage.js";
-export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
+export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
+export { admitRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
 export type { AkumaLife, AkumaOrigin, BodyEnd, BodyFact, HeartSnapshot, ForkPoint, KillEvidence, KillFact, LeashProbe, PauseFact, RequestFact, RequestInput, RequestRecipe, UpstreamRequestService, SealFact, SessionFact, Soul, StopFact, TellFact, TellDelivery, TellDeliveryInput, TellReceiptInput, TurnEndFact, TurnFact, TurnOutcome, TurnStartFact, } from "./facts.js";
 export type { ResumeCoordinate } from "../coordinate.js";

package/build/src/akuma/heart/index.js

@@ -4,8 +4,8 @@ import { insertTellDeliveryFact, insertTellFact, insertTellReceiptFact, pendingT
 import { activityFactSlice, lastActivityAt as readLastActivityAt, pruneActivityFacts, } from "./timeline.js";
 import { isHeartAbsent, readSealFromLeash, readTransaction, transaction, withHeart, withReadOnlyHeart, } from "./storage.js";
 import { soulFact } from "./soul.js";
-export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, watchHeart, } from "./storage.js";
-export { admitRequest, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
+export { HeartAbsentError, HeldAkumaLeash, classifyHeartSchema, initializeHeart, isHeartAbsent, probeLeash, } from "./storage.js";
+export { admitRequest, isRequestInputConflict, readNonterminalRequests, readRequest, refuseRequest, reserveRequest, serveRequest, serveUpstreamRequest, voidRequest, } from "./request-authority.js";
 export { life, lifeAt } from "./facts.js";
 const ACTIVITY_LIMIT = 5_000;
 export async function readSoul(paths) {

package/build/src/akuma/heart/request-authority.d.ts

@@ -1,5 +1,6 @@
 import type { AkuId, AkumaPaths } from "../identity.js";
 import type { RequestFact, RequestInput, UpstreamRequestService } from "./facts.js";
+export declare function isRequestInputConflict(error: unknown): error is Error;
 export declare function admitRequest(paths: AkumaPaths, input: RequestInput & Readonly<{
     admittedAt: string;
 }>): Promise<RequestFact>;

package/build/src/akuma/heart/request-authority.js

@@ -3,6 +3,16 @@ import { transaction, withHeart } from "./storage.js";
 import { soulFact } from "./soul.js";
 import { clipAllowedActions } from "../allowed.js";
 import { requestPayloadJson } from "./request-rows.js";
+// This stays out of the public Heart index: only transport service projects it as a refusal.
+class RequestInputConflictError extends Error {
+    constructor(id) {
+        super(`Akuma request ${id} reused different input`);
+        this.name = "RequestInputConflictError";
+    }
+}
+export function isRequestInputConflict(error) {
+    return error instanceof RequestInputConflictError;
+}
 export async function admitRequest(paths, input) {
     return await withHeart(paths, (heart) => transaction(heart, () => {
         const soul = soulFact(heart);
@@ -33,7 +43,7 @@ export async function admitRequest(paths, input) {
             fact.id !== normalized.id ||
             fact.action !== normalized.action ||
             requestPayloadJson(fact) !== requestPayloadJson(normalized)) {
-            throw new Error(`Akuma request ${input.id} reused different input`);
+            throw new RequestInputConflictError(input.id);
         }
         return fact;
     }));

package/build/src/akuma/heart/storage.d.ts

@@ -2,7 +2,6 @@ import { DatabaseSync } from "node:sqlite";
 import type { AkumaPaths } from "../identity.js";
 import type { BodyFact, LeashProbe, SessionFact, Soul, StopFact, TellFact } from "./facts.js";
 import { sealFact } from "./rows.js";
-export declare function watchHeart(paths: AkumaPaths, signal: AbortSignal): Promise<AsyncGenerator<void>>;
 export declare class HeartAbsentError extends Error {
     readonly path: string;
     constructor(path: string, options?: ErrorOptions);

package/build/src/akuma/heart/storage.js

@@ -1,7 +1,5 @@
 import { DatabaseSync } from "node:sqlite";
-import { watch as watchDirectory } from "node:fs";
 import { lstat } from "node:fs/promises";
-import { basename, dirname } from "node:path";
 import { pathToFileURL } from "node:url";
 import { HEART_SCHEMA, LEASH_SCHEMA, assertHeartSchemaVersion, assertLeashSchemaVersion, heartSchemaIsCurrent, } from "./schema.js";
 import { deletePauseControl, deleteStopControl, insertBodyFact, insertKillFact, insertSealFact, insertSessionFact, killFactForBody, latestBodyFact, latestKillFact, markBodyHung, sealExists, sealFact, stopFact, } from "./rows.js";
@@ -10,58 +8,6 @@ import { pruneActivityFacts } from "./timeline.js";
 import { insertSoulFact, soulFact } from "./soul.js";
 const ACTIVITY_LIMIT = 5_000;
 const SQLITE_CANTOPEN = 14;
-export async function watchHeart(paths, signal) {
-    const heart = basename(paths.heart);
-    let changed = false;
-    let failure;
-    let wake;
-    // fs.watch opens the directory synchronously. Its throw is therefore the
-    // observer's ready/failure boundary, before a waker can spawn a child.
-    const watcher = watchDirectory(dirname(paths.heart), { signal }, (_event, filename) => {
-        const name = filename?.toString();
-        if (name === undefined || name === heart || name === `${heart}-wal`) {
-            changed = true;
-            wake?.();
-        }
-    });
-    watcher.on("error", (error) => {
-        failure = error;
-        wake?.();
-    });
-    const abort = () => {
-        wake?.();
-        watcher.close();
-    };
-    signal.addEventListener("abort", abort, { once: true });
-    return (async function* () {
-        try {
-            for (;;) {
-                if (changed) {
-                    changed = false;
-                    yield;
-                    continue;
-                }
-                if (failure !== undefined)
-                    throw failure;
-                if (signal.aborted)
-                    return;
-                await new Promise((resolve) => {
-                    wake = resolve;
-                });
-                wake = undefined;
-            }
-        }
-        catch (error) {
-            if (signal.aborted && error.name === "AbortError")
-                return;
-            throw error;
-        }
-        finally {
-            signal.removeEventListener("abort", abort);
-            watcher.close();
-        }
-    })();
-}
 export class HeartAbsentError extends Error {
     path;
     constructor(path, options) {

package/build/src/akuma/publication.js

@@ -127,6 +127,60 @@ async function takeLeashUntil(paths, deadline) {
         await abortableDelay(Math.min(POLL_MS, Math.max(0, deadline - performance.now())));
     }
 }
+async function takeLeash(paths) {
+    for (;;) {
+        const leash = await HeldAkumaLeash.try(paths);
+        if (leash !== null)
+            return leash;
+        await abortableDelay(POLL_MS);
+    }
+}
+async function allocatedSoul(allocated) {
+    const soul = await readSoul(allocated.paths);
+    if (soul === null)
+        throw new Error("Akuma birth settled without a soul");
+    if (soul.id !== allocated.id)
+        throw new Error("Akuma birth returned a different identity");
+    return soul;
+}
+async function awaitConfirmation(result) {
+    try {
+        await result;
+    }
+    catch {
+        await new Promise(() => { });
+    }
+}
+async function settleCancelledLaunch(allocated, owned, cancellation) {
+    if ((await readSoul(allocated.paths)) !== null) {
+        await allocatedSoul(allocated);
+        return "born";
+    }
+    await awaitConfirmation(owned.terminate());
+    await awaitConfirmation(owned.exited);
+    if ((await readSoul(allocated.paths)) !== null) {
+        await allocatedSoul(allocated);
+        return "born";
+    }
+    const leash = await takeLeash(allocated.paths);
+    let outcome;
+    try {
+        outcome = await leash.sealIfUnborn(allocated.paths, {
+            evidence: diagnostic(cancellation),
+            at: new Date().toISOString(),
+        });
+    }
+    finally {
+        leash.release();
+    }
+    if (outcome === "born") {
+        await allocatedSoul(allocated);
+        return "born";
+    }
+    if ((await readSeal(allocated.paths)) === null)
+        throw new Error("Akuma birth settled without a seal");
+    return "sealed";
+}
 async function awaitAsleepBirth(paths) {
     const leash = await takeLeashUntil(paths, performance.now() + BIRTH_TIMEOUT_MS);
     if (leash === null)
@@ -174,25 +228,33 @@ export async function birthAkuma(input) {
 }
 export async function launchAkuma(input) {
     const { allocated } = input;
-    let owned;
+    let owned = undefined;
     try {
         input.signal?.throwIfAborted();
         owned = await input.launch(allocated);
-        try {
-            input.signal?.throwIfAborted();
-            const soul = await awaitBirth(allocated.paths, owned ?? undefined, input.signal);
-            if (soul.id !== allocated.id)
-                throw new Error("Akuma birth returned a different identity");
-            if (input.awaitAsleep === true)
-                await awaitAsleepBirth(allocated.paths);
-            return allocated;
-        }
-        finally {
-            owned?.release();
-        }
+        input.signal?.throwIfAborted();
+        const soul = await awaitBirth(allocated.paths, owned ?? undefined, input.signal);
+        if (soul.id !== allocated.id)
+            throw new Error("Akuma birth returned a different identity");
+        if (input.awaitAsleep === true)
+            await awaitAsleepBirth(allocated.paths);
+        owned?.release();
+        return allocated;
     }
     catch (error) {
+        if (owned !== undefined && input.signal?.aborted && error === input.signal.reason) {
+            const outcome = await settleCancelledLaunch(allocated, owned, error);
+            if (outcome === "born") {
+                if (input.awaitAsleep === true)
+                    await awaitAsleepBirth(allocated.paths);
+                owned.release();
+                return allocated;
+            }
+            owned.release();
+            throw error;
+        }
         await sealLocalFailure(allocated, error);
+        owned?.release();
         throw error;
     }
 }

package/build/src/akuma/request-lifecycle.js

@@ -4,7 +4,7 @@ import { abortableDelay } from "./abort.js";
 import { HeldAkumaLeash, readNonterminalRequests, readSoul, serveRequest, voidRequest, } from "./heart/index.js";
 import { pathsForAkuId } from "./identity.js";
 import { BIRTH_TIMEOUT_MS } from "./publication.js";
-import { atomicJson, decodeClaim, receiptPath } from "./request-wire.js";
+import { decodeClaim } from "./request-wire.js";
 const POLL_MS = 100;
 export class BodyRequestPump {
     input;
@@ -52,19 +52,14 @@ export class BodyRequestPump {
                     continue;
                 }
                 if (!this.admissionClosed) {
-                    try {
-                        await this.serveClaim({
-                            directory: this.directory,
-                            transportId,
-                            claim,
-                            ...this.input,
-                            signal: this.executionSignal.signal,
-                            admissionOpen: () => !this.admissionClosed,
-                        });
-                    }
-                    catch (error) {
-                        await projectTransportFailure(this.directory, transportId, claim, error);
-                    }
+                    await this.serveClaim({
+                        directory: this.directory,
+                        transportId,
+                        claim,
+                        ...this.input,
+                        signal: this.executionSignal.signal,
+                        admissionOpen: () => !this.admissionClosed,
+                    });
                 }
                 this.handled.add(transportId);
             }
@@ -107,14 +102,6 @@ async function requestFiles(directory) {
         throw error;
     }
 }
-async function projectTransportFailure(directory, transportId, claim, error) {
-    await atomicJson(receiptPath(directory, transportId), {
-        id: claim.id,
-        action: claim.action,
-        state: "refused",
-        diagnostic: error instanceof Error ? error.message : String(error),
-    });
-}
 function matchingRequestOrigin(soul, parent, id) {
     return soul.origin.kind === "request" && soul.origin.parent === parent && soul.origin.requestId === id;
 }

package/build/src/akuma/request-serve.js

@@ -1,4 +1,4 @@
-import { admitRequest, readRequest, refuseRequest, reserveRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
+import { admitRequest, isRequestInputConflict, readRequest, refuseRequest, reserveRequest, serveRequest as serveChildRequest, serveUpstreamRequest, voidRequest, } from "./heart/index.js";
 import { worldRootForAkumaPaths } from "./identity.js";
 import { publishAkuma } from "./publication.js";
 import { atomicJson, canonicalAkuId, decodeRecipe, receiptPath, } from "./request-wire.js";
@@ -244,8 +244,23 @@ export async function serveRequest(input) {
         ? await serveCall({ ...input, claim: input.claim })
         : await serveUpstream({ ...input, claim: input.claim });
 }
+async function serveTransportClaim(input) {
+    try {
+        await serveRequest(input);
+    }
+    catch (error) {
+        if (!isRequestInputConflict(error))
+            throw error;
+        await atomicJson(receiptPath(input.directory, input.transportId), {
+            id: input.claim.id,
+            action: input.claim.action,
+            state: "refused",
+            diagnostic: error.message,
+        });
+    }
+}
 export class BodyRequestPump extends LifecycleBodyRequestPump {
     static async open(input) {
-        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveRequest(claim)));
+        return (await LifecycleBodyRequestPump.openWithService(input, async (claim) => await serveTransportClaim(claim)));
     }
 }

package/build/src/cli/commands/task-invoke.d.ts

@@ -1,10 +1,10 @@
-import { type BlockedTaskList, type TaskBatchResult, type TaskCompositionResult, type TaskDecompositionTree, type TaskDetail, type TaskDoctorReport, type TaskList, type TaskMutationResult, type TaskNamespaceResult, type TaskQueryResult, type TaskUpdateResult } from "../../task/index.js";
+import { type BlockedTaskList, type TaskBatchResult, type TaskCompositionResult, type TaskDecompositionTree, type TaskDetail, type TaskDoctorReport, type TaskList, type TaskMutationResult, type TaskContextResult, type TaskQueryResult, type TaskUpdateResult } from "../../task/index.js";
 import type { ParsedTaskCommand } from "./task.js";
 import type { WorldRoot } from "../../world.js";
 export type TaskShowResult = TaskDetail | readonly TaskDetail[] | Extract<TaskMutationResult, {
     kind: "refused";
 }>;
-export type TaskInvocationResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskShowResult | TaskList | BlockedTaskList | TaskQueryResult | TaskDecompositionTree | TaskDoctorReport | TaskNamespaceResult | TaskWorldObservation;
+export type TaskInvocationResult = TaskMutationResult | TaskUpdateResult | TaskBatchResult | TaskCompositionResult | TaskShowResult | TaskList | BlockedTaskList | TaskQueryResult | TaskDecompositionTree | TaskDoctorReport | TaskContextResult | TaskWorldObservation;
 type TaskWorldRead = TaskList | BlockedTaskList | TaskQueryResult | TaskDoctorReport;
 export type TaskWorldObservation = Readonly<{
     kind: "present";
@@ -23,6 +23,8 @@ type TaskInput = Readonly<{
     context: Readonly<{
         directory: string;
         boundary: string;
+        writeRoot?: string;
+        managed?: boolean;
     }>;
     establish(): Promise<WorldRoot>;
     readStdin(): Promise<string>;