@astrosheep/keiyaku 4.6.7 → 4.6.9

package/build/src/settlement/holder.js

@@ -4,20 +4,26 @@ import { contractId } from "../core/facts/types.js";
 import { GIT_REF, updateGitTree, updateRefsAtomically, writeBlob, writeStateCommit } from "../git/repository.js";
 import { confirmPrivateStatePublication } from "../git/private-state-seat.js";
 import { withGitTargetedReadObservation, } from "../git/read-observation.js";
-import { parseTaskId } from "../task/identity.js";
-import { acquireTaskSettlementFence } from "./fence.js";
+import { parseDebtId } from "../debt/identity.js";
+import { acquireDebtSettlementFence } from "./fence.js";
+// The private persisted spelling predates the product rename. Keep its bytes
+// and path stable so an existing held association still settles after upgrade.
 const HOLDER_ROOT = "settlement/task-holders";
 const HOLDER_PREFIX = `${HOLDER_ROOT}/`;
 const HOLDER_SUFFIX = ".json";
-export function taskHolderObservationSelection() {
+export function debtHolderObservationSelection() {
     return { subtrees: [HOLDER_ROOT] };
 }
-function holderPath(taskId) {
-    const digest = createHash("sha256").update(taskId).digest("hex");
+function storedIdentity(debtId) {
+    return `task/${debtId.slice("debt/".length)}`;
+}
+function holderPath(debtId) {
+    const digest = createHash("sha256").update(storedIdentity(debtId)).digest("hex");
     return `${HOLDER_PREFIX}${digest}${HOLDER_SUFFIX}`;
 }
 function canonicalBytes(holder) {
-    return Buffer.from(`${JSON.stringify(holder)}\n`);
+    const { version, debtId, contractId, disposition } = holder;
+    return Buffer.from(`${JSON.stringify({ version, taskId: storedIdentity(debtId), contractId, disposition })}\n`);
 }
 function corruption(message, cause) {
     throw new AuthorityCorruptionError(message, cause === undefined ? {} : { cause });
@@ -27,67 +33,67 @@ function decodeHolder(path, bytes) {
     try {
         const text = Buffer.from(bytes).toString("utf8");
         if (!text.endsWith("\n") || text.slice(0, -1).includes("\n"))
-            corruption(`TaskHolder is not one canonical JSON line: ${path}`);
+            corruption(`DebtHolder is not one canonical JSON line: ${path}`);
         value = JSON.parse(text);
     }
     catch (error) {
         if (error instanceof AuthorityCorruptionError)
             throw error;
-        return corruption(`invalid TaskHolder JSON: ${path}`, error);
+        return corruption(`invalid DebtHolder JSON: ${path}`, error);
     }
     if (typeof value !== "object" || value === null || Array.isArray(value))
-        corruption(`TaskHolder must be an object: ${path}`);
+        corruption(`DebtHolder must be an object: ${path}`);
     const record = value;
     const keys = Object.keys(record);
     if (keys.length !== 4 || keys.some((key) => !["version", "taskId", "contractId", "disposition"].includes(key))) {
-        corruption(`TaskHolder has invalid fields: ${path}`);
+        corruption(`DebtHolder has invalid fields: ${path}`);
     }
     if (record.version !== 1)
-        corruption(`TaskHolder version must be 1: ${path}`);
-    if (typeof record.taskId !== "string")
-        corruption(`TaskHolder taskId is invalid: ${path}`);
+        corruption(`DebtHolder version must be 1: ${path}`);
+    if (typeof record.taskId !== "string" || !record.taskId.startsWith("task/"))
+        corruption(`DebtHolder identity is invalid: ${path}`);
     if (typeof record.contractId !== "string")
-        corruption(`TaskHolder contractId is invalid: ${path}`);
-    let taskId;
+        corruption(`DebtHolder contractId is invalid: ${path}`);
+    let debtId;
     let owner;
     try {
-        parseTaskId(record.taskId);
-        taskId = record.taskId;
+        debtId = `debt/${record.taskId.slice("task/".length)}`;
+        parseDebtId(debtId);
         owner = contractId(record.contractId);
     }
     catch (error) {
-        return corruption(`TaskHolder identity is invalid: ${path}`, error);
+        return corruption(`DebtHolder identity is invalid: ${path}`, error);
     }
     if (record.disposition !== "held" && record.disposition !== "released") {
-        corruption(`TaskHolder disposition is invalid: ${path}`);
+        corruption(`DebtHolder disposition is invalid: ${path}`);
     }
-    const holder = { version: 1, taskId, contractId: owner, disposition: record.disposition };
-    if (holderPath(taskId) !== path)
-        corruption(`TaskHolder path does not match taskId: ${path}`);
+    const holder = { version: 1, debtId, contractId: owner, disposition: record.disposition };
+    if (holderPath(debtId) !== path)
+        corruption(`DebtHolder path does not match debtId: ${path}`);
     if (!Buffer.from(canonicalBytes(holder)).equals(Buffer.from(bytes)))
-        corruption(`TaskHolder bytes are not canonical: ${path}`);
+        corruption(`DebtHolder bytes are not canonical: ${path}`);
     return holder;
 }
-function projectTaskHolders(holders) {
+function projectDebtHolders(holders) {
     const projection = new Map();
     for (const holder of holders) {
         if (projection.has(holder.contractId)) {
-            corruption(`Contract has multiple current TaskHolders: ${holder.contractId}`);
+            corruption(`Contract has multiple current DebtHolders: ${holder.contractId}`);
         }
         projection.set(holder.contractId, holder);
     }
     return projection;
 }
 function update(holder) {
-    return { path: holderPath(holder.taskId), bytes: canonicalBytes(holder) };
+    return { path: holderPath(holder.debtId), bytes: canonicalBytes(holder) };
 }
-export function claimTaskHolder(taskId, owner) {
-    return update({ version: 1, taskId, contractId: owner, disposition: "held" });
+export function claimDebtHolder(debtId, owner) {
+    return update({ version: 1, debtId, contractId: owner, disposition: "held" });
 }
 function detail(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function finishTaskHolderAdmission(taskId, result, close) {
+function finishDebtHolderAdmission(debtId, result, close) {
     try {
         close();
         return { kind: "completed", result };
@@ -95,11 +101,11 @@ function finishTaskHolderAdmission(taskId, result, close) {
     catch (error) {
         if (result.kind !== "accepted")
             throw error;
-        return { kind: "accepted-release-failed", result, taskId, diagnostic: detail(error) };
+        return { kind: "accepted-release-failed", result, debtId, diagnostic: detail(error) };
     }
 }
-export async function admitWithTaskHolderFence(repository, taskId, action) {
-    const held = await acquireTaskSettlementFence(repository, taskId);
+export async function admitWithDebtHolderFence(repository, debtId, action) {
+    const held = await acquireDebtSettlementFence(repository, debtId);
     let result;
     try {
         result = await action();
@@ -113,19 +119,19 @@ export async function admitWithTaskHolderFence(repository, taskId, action) {
         }
         throw error;
     }
-    return finishTaskHolderAdmission(taskId, result, () => held.close());
+    return finishDebtHolderAdmission(debtId, result, () => held.close());
 }
-export async function releaseTaskHolder(channel, observation, owner) {
-    const current = (await readTaskHolderProjectionFromDecision(channel, observation)).get(owner) ?? null;
+export async function releaseDebtHolder(channel, observation, owner) {
+    const current = (await readDebtHolderProjectionFromDecision(channel, observation)).get(owner) ?? null;
     return current === null || current.disposition !== "held" ? null : update({ ...current, disposition: "released" });
 }
 async function releasedHolderIsCurrent(repository, channel, owner, expected) {
-    const current = (await observeTaskHolderProjection(repository, channel)).get(owner) ?? null;
+    const current = (await observeDebtHolderProjection(repository, channel)).get(owner) ?? null;
     return current?.disposition === "released" && Buffer.from(canonicalBytes(current)).equals(expected);
 }
 /** Publish the released holder against the same frozen observation that decided the release. */
-export async function publishTaskHolderRelease(repository, channel, observation, owner, seat) {
-    const release = await releaseTaskHolder(channel, observation, owner);
+export async function publishDebtHolderRelease(repository, channel, observation, owner, seat) {
+    const release = await releaseDebtHolder(channel, observation, owner);
     if (release === null)
         return { kind: "not-held" };
     const tree = await updateGitTree(repository, observation.admission.snapshot.tree, new Map([[release.path, { oid: await writeBlob(repository, release.bytes) }]]));
@@ -133,7 +139,7 @@ export async function publishTaskHolderRelease(repository, channel, observation,
         repository,
         tree,
         parent: observation.admission.snapshot.commit,
-        message: `release held Task completion: ${owner}`,
+        message: `release held Debt completion: ${owner}`,
     });
     const publication = await updateRefsAtomically(repository, [
         {
@@ -154,10 +160,10 @@ export async function publishTaskHolderRelease(repository, channel, observation,
         kind: "non-published",
         diagnostic: publication.kind === "non-published"
             ? detail(publication.error)
-            : "Task holder release publication state is unknown",
+            : "Debt holder release publication state is unknown",
     };
 }
-export async function readTaskHolderProjectionFromDecision(channel, observation) {
+export async function readDebtHolderProjectionFromDecision(channel, observation) {
     const read = {
         snapshot: observation.admission.snapshot,
         readBlobs: async (oids) => {
@@ -168,29 +174,29 @@ export async function readTaskHolderProjectionFromDecision(channel, observation)
                     blobs.set(oid, object);
                 else {
                     if (object.type !== "blob")
-                        corruption(`TaskHolder Git object is not a blob: ${oid}`);
+                        corruption(`DebtHolder Git object is not a blob: ${oid}`);
                     blobs.set(oid, { kind: "present", bytes: object.bytes });
                 }
             }
             return blobs;
         },
     };
-    return projectTaskHolders(await readTaskHoldersAt(read));
+    return projectDebtHolders(await readDebtHoldersAt(read));
 }
-function observeTaskHolderProjection(repository, channel) {
-    return withGitTargetedReadObservation(repository, channel, taskHolderObservationSelection(), readTaskHolderProjectionAt);
+function observeDebtHolderProjection(repository, channel) {
+    return withGitTargetedReadObservation(repository, channel, debtHolderObservationSelection(), readDebtHolderProjectionAt);
 }
-async function heldTaskForContract(repository, channel, owner) {
-    const holder = (await observeTaskHolderProjection(repository, channel)).get(owner) ?? null;
-    return holder?.disposition === "held" ? holder.taskId : null;
+async function heldDebtForContract(repository, channel, owner) {
+    const holder = (await observeDebtHolderProjection(repository, channel)).get(owner) ?? null;
+    return holder?.disposition === "held" ? holder.debtId : null;
 }
-export async function releaseTaskHolderWithFence(repository, channel, owner, action) {
-    const taskId = await heldTaskForContract(repository, channel, owner);
-    return taskId === null
+export async function releaseDebtHolderWithFence(repository, channel, owner, action) {
+    const debtId = await heldDebtForContract(repository, channel, owner);
+    return debtId === null
         ? { kind: "completed", result: await action() }
-        : admitWithTaskHolderFence(repository, taskId, action);
+        : admitWithDebtHolderFence(repository, debtId, action);
 }
-export async function readTaskHoldersAt(observation) {
+export async function readDebtHoldersAt(observation) {
     const entries = [...observation.snapshot.paths].filter(([path, entry]) => path.startsWith(HOLDER_PREFIX) && entry.type === "blob");
     const blobs = await observation.readBlobs(entries.map(([, entry]) => entry.oid));
     const holders = [];
@@ -198,26 +204,26 @@ export async function readTaskHoldersAt(observation) {
     for (const [path, entry] of observation.snapshot.paths) {
         if (path === HOLDER_ROOT) {
             if (entry.type !== "tree")
-                corruption(`TaskHolder authority root is not a tree: ${path}`);
+                corruption(`DebtHolder authority root is not a tree: ${path}`);
             continue;
         }
         if (!path.startsWith(HOLDER_PREFIX))
             continue;
         if (!path.endsWith(HOLDER_SUFFIX))
-            corruption(`unexpected TaskHolder authority path: ${path}`);
+            corruption(`unexpected DebtHolder authority path: ${path}`);
         if (entry.type !== "blob")
-            corruption(`TaskHolder path is not a blob: ${path}`);
+            corruption(`DebtHolder path is not a blob: ${path}`);
         const result = blobs.get(entry.oid);
         if (result?.kind !== "present")
-            corruption(`missing TaskHolder Git object: ${path}`);
+            corruption(`missing DebtHolder Git object: ${path}`);
         const holder = decodeHolder(path, result.bytes);
-        if (seen.has(holder.taskId))
-            corruption(`duplicate TaskHolder identity: ${holder.taskId}`);
-        seen.add(holder.taskId);
+        if (seen.has(holder.debtId))
+            corruption(`duplicate DebtHolder identity: ${holder.debtId}`);
+        seen.add(holder.debtId);
         holders.push(holder);
     }
-    return holders.sort((left, right) => Buffer.compare(Buffer.from(left.taskId), Buffer.from(right.taskId)));
+    return holders.sort((left, right) => Buffer.compare(Buffer.from(left.debtId), Buffer.from(right.debtId)));
 }
-export async function readTaskHolderProjectionAt(observation) {
-    return projectTaskHolders(await readTaskHoldersAt(observation));
+export async function readDebtHolderProjectionAt(observation) {
+    return projectDebtHolders(await readDebtHoldersAt(observation));
 }

package/build/src/settlement/settle.d.ts

@@ -5,19 +5,19 @@ import type { GitDecodeChannel } from "../git/read-observation.js";
 import type { Effect } from "../git/reconcile.js";
 import { type GitRepository } from "../git/process.js";
 export declare const settlementActionSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"task">;
-    taskId: z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>;
+    kind: z.ZodLiteral<"debt">;
+    debtId: z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>;
     action: z.ZodLiteral<"done">;
 }, z.core.$strict>;
 export type SettlementAction = z.infer<typeof settlementActionSchema>;
 export declare const settlementLagSchema: z.ZodObject<{
     kind: z.ZodLiteral<"settlement-failed">;
     surface: z.ZodEnum<{
-        task: "task";
-        "task-holder": "task-holder";
+        debt: "debt";
+        "debt-holder": "debt-holder";
     }>;
     contractId: z.ZodPipe<z.ZodString, z.ZodTransform<ContractId, string>>;
-    taskId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`task/${string}`, string>>>;
+    debtId: z.ZodOptional<z.ZodPipe<z.ZodString, z.ZodTransform<`debt/${string}`, string>>>;
     path: z.ZodOptional<z.ZodString>;
     diagnostic: z.ZodString;
 }, z.core.$strict>;

package/build/src/settlement/settle.js

@@ -1,24 +1,24 @@
 import { contractIdSchema } from "../git/identity.js";
 import { z } from "zod";
-import { taskIdSchema } from "../task/identity.js";
+import { debtIdSchema } from "../debt/identity.js";
 import { observeContractsForAdmissionAt } from "../git/observe.js";
 import { appendPrivateStateSeatClose, withPrivateStatePublicationSeat, } from "../git/private-state-seat.js";
 import { GitPlumbingError } from "../git/process.js";
 import { SqliteTransactionLockError } from "../coordination/sqlite-transaction-lock.js";
 import { AuthorityCorruptionError } from "../core/facts/errors.js";
-import { settleTask } from "../task/operations.js";
-import { publishTaskHolderRelease, readTaskHolderProjectionFromDecision, taskHolderObservationSelection, } from "./holder.js";
-import { acquireTaskSettlementFence } from "./fence.js";
+import { settleDebt } from "../debt/operations.js";
+import { publishDebtHolderRelease, readDebtHolderProjectionFromDecision, debtHolderObservationSelection, } from "./holder.js";
+import { acquireDebtSettlementFence } from "./fence.js";
 import { World } from "../world.js";
 export const settlementActionSchema = z
-    .object({ kind: z.literal("task"), taskId: taskIdSchema, action: z.literal("done") })
+    .object({ kind: z.literal("debt"), debtId: debtIdSchema, action: z.literal("done") })
     .strict();
 export const settlementLagSchema = z
     .object({
     kind: z.literal("settlement-failed"),
-    surface: z.enum(["task-holder", "task"]),
+    surface: z.enum(["debt-holder", "debt"]),
     contractId: contractIdSchema,
-    taskId: taskIdSchema.optional(),
+    debtId: debtIdSchema.optional(),
     path: z
         .string()
         .refine((value) => value.trim() !== "")
@@ -36,10 +36,10 @@ function operational(error) {
 function diagnostic(error) {
     return error instanceof Error ? error.message : String(error);
 }
-function taskFailure(result) {
+function debtFailure(result) {
     return result.kind === "retry"
-        ? `Task settlement requires retry: ${result.reason}`
-        : `Task settlement refused: ${JSON.stringify(result.refusal)}`;
+        ? `Debt settlement requires retry: ${result.reason}`
+        : `Debt settlement refused: ${JSON.stringify(result.refusal)}`;
 }
 function recordLag(input, lag) {
     input.lags.push(lag);
@@ -53,11 +53,11 @@ async function observeApplicableHolder(input) {
     const { repository, channel, candidate } = input;
     let observation;
     try {
-        observation = await observeContractsForAdmissionAt(repository, channel, [candidate.id], taskHolderObservationSelection());
+        observation = await observeContractsForAdmissionAt(repository, channel, [candidate.id], debtHolderObservationSelection());
         const state = observation.journals.get(candidate.id)?.state ?? null;
         if (state === null || state.terminal?.kind !== "claimed")
             return null;
-        const holder = (await readTaskHolderProjectionFromDecision(channel, observation)).get(candidate.id) ?? null;
+        const holder = (await readDebtHolderProjectionFromDecision(channel, observation)).get(candidate.id) ?? null;
         return holder?.disposition === "held" ? holder : null;
     }
     catch (error) {
@@ -65,15 +65,15 @@ async function observeApplicableHolder(input) {
             throw error;
         recordLag(input, {
             kind: "settlement-failed",
-            surface: "task-holder",
+            surface: "debt-holder",
             contractId: candidate.id,
             diagnostic: diagnostic(error),
         });
         return null;
     }
 }
-async function completeHeldTask(input) {
-    const { repository, candidate, taskId } = input;
+async function completeHeldDebt(input) {
+    const { repository, candidate, debtId } = input;
     let world;
     try {
         world = await World.at(repository.primaryWorktree);
@@ -83,38 +83,38 @@ async function completeHeldTask(input) {
             throw error;
         recordLag(input, {
             kind: "settlement-failed",
-            surface: "task",
+            surface: "debt",
             contractId: candidate.id,
-            taskId,
+            debtId,
             diagnostic: diagnostic(error),
         });
         return false;
     }
     let result;
     try {
-        result = await settleTask(world, taskId);
+        result = await settleDebt(world, debtId);
     }
     catch (error) {
         if (!operational(error))
             throw error;
         recordLag(input, {
             kind: "settlement-failed",
-            surface: "task",
+            surface: "debt",
             contractId: candidate.id,
-            taskId,
+            debtId,
             diagnostic: diagnostic(error),
         });
         return false;
     }
     if (result.kind === "changed")
-        recordAction(input, { kind: "task", taskId, action: "done" });
+        recordAction(input, { kind: "debt", debtId, action: "done" });
     if (result.kind === "changed" && result.cleanup !== undefined) {
         for (const detail of result.cleanup.diagnostics) {
             recordLag(input, {
                 kind: "settlement-failed",
-                surface: "task",
+                surface: "debt",
                 contractId: candidate.id,
-                taskId,
+                debtId,
                 diagnostic: detail,
             });
         }
@@ -123,32 +123,32 @@ async function completeHeldTask(input) {
         return true;
     recordLag(input, {
         kind: "settlement-failed",
-        surface: "task",
+        surface: "debt",
         contractId: candidate.id,
-        taskId,
-        diagnostic: taskFailure(result),
+        debtId,
+        diagnostic: debtFailure(result),
     });
     return false;
 }
-async function releaseHeldTaskHolder(input) {
-    const { repository, channel, candidate, seatClose, taskId } = input;
+async function releaseHeldDebtHolder(input) {
+    const { repository, channel, candidate, seatClose, debtId } = input;
     try {
         const outcome = await withPrivateStatePublicationSeat(repository, async (seat) => {
-            const observation = await observeContractsForAdmissionAt(repository, channel, [candidate.id], taskHolderObservationSelection());
+            const observation = await observeContractsForAdmissionAt(repository, channel, [candidate.id], debtHolderObservationSelection());
             const state = observation.journals.get(candidate.id)?.state ?? null;
             if (state === null || state.terminal?.kind !== "claimed")
                 return "inert";
-            const holder = (await readTaskHolderProjectionFromDecision(channel, observation)).get(candidate.id) ?? null;
-            if (holder === null || holder.disposition !== "held" || holder.taskId !== taskId)
+            const holder = (await readDebtHolderProjectionFromDecision(channel, observation)).get(candidate.id) ?? null;
+            if (holder === null || holder.disposition !== "held" || holder.debtId !== debtId)
                 return "inert";
-            const publication = await publishTaskHolderRelease(repository, channel, observation, candidate.id, seat);
+            const publication = await publishDebtHolderRelease(repository, channel, observation, candidate.id, seat);
             if (publication.kind === "non-published") {
                 recordLag(input, {
                     kind: "settlement-failed",
-                    surface: "task-holder",
+                    surface: "debt-holder",
                     contractId: candidate.id,
-                    taskId,
-                    diagnostic: `Task holder release requires retry: ${publication.diagnostic}`,
+                    debtId,
+                    diagnostic: `Debt holder release requires retry: ${publication.diagnostic}`,
                 });
                 return "held";
             }
@@ -165,51 +165,51 @@ async function releaseHeldTaskHolder(input) {
             throw error;
         recordLag(input, {
             kind: "settlement-failed",
-            surface: "task-holder",
+            surface: "debt-holder",
             contractId: candidate.id,
-            taskId,
+            debtId,
             diagnostic: diagnostic(error),
         });
         return "held";
     }
 }
-async function settleTasks(input) {
+async function settleDebts(input) {
     const { repository, channel, candidate, lags, seatClose } = input;
     const hint = await observeApplicableHolder(input);
     if (hint === null)
         return false;
-    const taskId = hint.taskId;
+    const debtId = hint.debtId;
     let fence;
     try {
-        fence = await acquireTaskSettlementFence(repository, taskId);
+        fence = await acquireDebtSettlementFence(repository, debtId);
     }
     catch (error) {
         if (!operational(error))
             throw error;
         recordLag(input, {
             kind: "settlement-failed",
-            surface: "task",
+            surface: "debt",
             contractId: candidate.id,
-            taskId,
+            debtId,
             diagnostic: diagnostic(error),
         });
         return true;
     }
     let failure;
-    let taskSettled = false;
+    let debtSettled = false;
     let holderDisposition = null;
     try {
         const holder = await observeApplicableHolder(input);
-        if (holder === null || holder.taskId !== taskId)
+        if (holder === null || holder.debtId !== debtId)
             return false;
-        taskSettled = await completeHeldTask({ ...input, taskId });
-        if (!taskSettled)
+        debtSettled = await completeHeldDebt({ ...input, debtId });
+        if (!debtSettled)
             return true;
-        holderDisposition = await releaseHeldTaskHolder({
+        holderDisposition = await releaseHeldDebtHolder({
             repository,
             channel,
             candidate,
-            taskId,
+            debtId,
             lags,
             seatClose,
             ...(input.progress === undefined ? {} : { progress: input.progress }),
@@ -229,15 +229,15 @@ async function settleTasks(input) {
                 if (failure === undefined)
                     throw error;
             }
-            else if (!taskSettled && failure === undefined)
+            else if (!debtSettled && failure === undefined)
                 throw error;
             // Post-release fence teardown is custodial residue, not an owed holder publication.
             if (holderDisposition !== "released") {
                 recordLag(input, {
                     kind: "settlement-failed",
-                    surface: "task-holder",
+                    surface: "debt-holder",
                     contractId: candidate.id,
-                    taskId,
+                    debtId,
                     diagnostic: diagnostic(error),
                 });
             }
@@ -258,7 +258,7 @@ async function settleObserved(input) {
     const candidate = input.state;
     if (candidate.terminal?.kind === "claimed") {
         try {
-            await settleTasks({
+            await settleDebts({
                 repository: input.repository,
                 channel: input.channel,
                 candidate,
@@ -273,7 +273,7 @@ async function settleObserved(input) {
                 throw error;
             recordLag({ candidate, lags, ...(input.progress === undefined ? {} : { progress: input.progress }) }, {
                 kind: "settlement-failed",
-                surface: "task",
+                surface: "debt",
                 contractId: candidate.id,
                 diagnostic: diagnostic(error),
             });

package/package.json

@@ -1,11 +1,15 @@
 {
   "name": "@astrosheep/keiyaku",
-  "version": "4.6.7",
+  "version": "4.6.9",
   "workspaces": [
-    "plugins/square"
+    "plugins/square",
+    "plugins/paseo/forwarder"
   ],
   "files": [
-    "build"
+    "build",
+    "plugins/pi",
+    "plugins/paseo/plugin",
+    "skills"
   ],
   "main": "./build/src/index.js",
   "types": "./build/src/index.d.ts",
@@ -29,7 +33,7 @@
   },
   "scripts": {
     "release": "npm run test:release && npm version patch && npm publish",
-    "build": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('build', { recursive: true, force: true })\" && tsc -p tsconfig.json && npm run build --workspace @astrosheep/keiyaku-plugin-square && node scripts/copy-plugins.js && node scripts/build-windows-launcher.js && node --input-type=module -e \"import { chmodSync } from 'node:fs'; chmodSync('build/src/cli/index.js', 0o755)\"",
+    "build": "node --input-type=module -e \"import { rmSync } from 'node:fs'; rmSync('build', { recursive: true, force: true })\" && tsc -p tsconfig.json && npm run build --workspace @astrosheep/keiyaku-plugin-square && npm run build --workspace @astrosheep/keiyaku-plugin-paseo && node scripts/copy-plugins.js && node scripts/build-windows-launcher.js && node --input-type=module -e \"import { chmodSync } from 'node:fs'; chmodSync('build/src/cli/index.js', 0o755)\"",
     "prepack": "node scripts/verify-package.js",
     "postpack": "node scripts/verify-package.js",
     "harness:version": "node scripts/update-harness-version.js",
@@ -61,8 +65,10 @@
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "^1.0.0",
+    "@getpaseo/plugin": "0.11.2",
     "@types/cross-spawn": "^6.0.6",
     "@types/node": "^25.0.0",
+    "@types/ws": "^8.18.2",
     "@typescript-eslint/parser": "^8.66.0",
     "eslint": "^9.39.5",
     "knip": "^6.31.0",
@@ -73,11 +79,15 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@anthropic-ai/claude-agent-sdk": "^0.3.226",
-    "@astrosheep/keiyaku-plugin-square": "0.1.8",
-    "@astrosheep/square": "^0.3.70",
-    "@opencode-ai/sdk": "1.18.3",
+    "@astrosheep/keiyaku-plugin-paseo": "0.1.0",
+    "@astrosheep/keiyaku-plugin-square": "0.1.9",
+    "@astrosheep/square": "^0.3.79",
+    "@getpaseo/client": "0.11.2",
+    "@getpaseo/protocol": "0.11.2",
+    "@opencode/client": "2.0.20",
     "cross-spawn": "^7.0.6",
     "diff": "^8.0.4",
+    "undici": "8.10.2",
     "yaml": "^2.9.0",
     "zod": "^4.5.2"
   },
@@ -91,10 +101,10 @@
   ],
   "pi": {
     "extensions": [
-      "./build/plugins/pi/keiyaku.ts"
+      "./plugins/pi/keiyaku.ts"
     ],
     "skills": [
-      "./build/skills"
+      "./skills"
     ]
   },
   "author": "",

package/plugins/paseo/plugin/index.server.ts

@@ -0,0 +1,17 @@
+import type { PluginServerContext } from "@getpaseo/plugin/server";
+import { createProvider } from "./server/provider.js";
+import { createSdkTransport } from "./server/sdk.js";
+import { attach } from "./server/attach.js";
+import { attachRpc } from "./shared/attach-rpc.js";
+import { refreshRpc } from "./shared/refresh-rpc.js";
+
+export default function contribute(server: PluginServerContext) {
+  const transport = createSdkTransport();
+  const mirror = createProvider(transport);
+  server.registerProvider(mirror.provider);
+  server.handle(refreshRpc, (input) => mirror.refresh(input));
+  server.handle(attachRpc, (input, context) => attach(input, context, mirror.sync));
+  return async () => {
+    try { await mirror.close(); } finally { await transport.close(); }
+  };
+}