@astrosheep/keiyaku 4.5.12 → 4.5.13

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

@@ -24,20 +24,29 @@ function tellDeliveries(database, id) {
         ? { turnSequence: row.turn_sequence, route: row.route, deliveredAt: row.delivered_at }
         : { turnSequence: row.turn_sequence, route: row.route, receipt: row.receipt, deliveredAt: row.delivered_at });
 }
+function tellBinding(database, id) {
+    const row = database
+        .prepare("SELECT turn_sequence, bound_at FROM tell_bindings WHERE tell_id = ?")
+        .get(id);
+    return row === undefined ? undefined : { turnSequence: row.turn_sequence, boundAt: row.bound_at };
+}
 function decodeTellRow(database, row) {
+    const binding = tellBinding(database, row.id);
     return {
         kind: "tell",
         sequence: row.sequence,
         id: row.id,
         body: row.body,
+        ...(row.schema_json === null ? {} : { schemaJson: row.schema_json }),
         state: row.state,
         recordedAt: row.recorded_at,
         deliveries: tellDeliveries(database, row.id),
+        ...(binding === undefined ? {} : { binding }),
     };
 }
 export function decodeTellAtSequence(database, sequence) {
     const row = database
-        .prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+        .prepare(`SELECT sequence, id, body, schema_json, recorded_at, ${tellStateSql} AS state
     FROM tells WHERE sequence = ?`)
         .get(sequence);
     if (row === undefined)
@@ -47,13 +56,13 @@ export function decodeTellAtSequence(database, sequence) {
 export function insertTellFact(database, tell) {
     const sequence = Number(database.prepare("INSERT INTO timeline(kind) VALUES ('tell')").run().lastInsertRowid);
     database
-        .prepare("INSERT INTO tells(id, sequence, body, recorded_at) VALUES (?, ?, ?, ?)")
-        .run(tell.id, sequence, tell.body, tell.recordedAt);
+        .prepare("INSERT INTO tells(id, sequence, body, schema_json, recorded_at) VALUES (?, ?, ?, ?, ?)")
+        .run(tell.id, sequence, tell.body, tell.schemaJson ?? null, tell.recordedAt);
     return sequence;
 }
 export function tellFact(database, id) {
     const row = database
-        .prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+        .prepare(`SELECT sequence, id, body, schema_json, recorded_at, ${tellStateSql} AS state
     FROM tells WHERE id = ?`)
         .get(id);
     return row === undefined ? null : decodeTellRow(database, row);
@@ -90,7 +99,7 @@ export function tellIdsForFence(database, turnSequence, fence) {
 }
 export function pendingTellFacts(database) {
     const rows = database
-        .prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state FROM tells
+        .prepare(`SELECT sequence, id, body, schema_json, recorded_at, ${tellStateSql} AS state FROM tells
     WHERE ${tellStateSql} = 'pending' ORDER BY sequence`)
         .all();
     return rows.map((row) => decodeTellRow(database, row));
@@ -182,3 +191,37 @@ export function insertUndeliveredTellReceipts(database, tellIds, at) {
         });
     }
 }
+export function insertTellBindingFact(database, input) {
+    const result = database
+        .prepare("INSERT OR IGNORE INTO tell_bindings(tell_id, turn_sequence, bound_at) VALUES (?, ?, ?)")
+        .run(input.tellId, input.turnSequence, input.boundAt);
+    const row = database
+        .prepare("SELECT turn_sequence FROM tell_bindings WHERE tell_id = ?")
+        .get(input.tellId);
+    if (row === undefined || (result.changes === 0 && row.turn_sequence !== input.turnSequence)) {
+        throw new Error(`tell ${input.tellId} is already bound to a different Turn`);
+    }
+}
+export function drainPendingTells(pending) {
+    const unbound = pending.filter((tell) => tell.binding === undefined);
+    if (unbound.length === 0)
+        return [];
+    const first = unbound[0];
+    const drained = [first];
+    for (const tell of unbound.slice(1)) {
+        if (tell.schemaJson !== undefined)
+            break;
+        drained.push(tell);
+    }
+    return drained;
+}
+export function openBoundTurns(database, bodySequence) {
+    return database
+        .prepare(`SELECT DISTINCT turns.sequence AS sequence
+    FROM turns
+    JOIN tell_bindings ON tell_bindings.turn_sequence = turns.sequence
+    WHERE turns.body_sequence = ? AND turns.end_sequence IS NULL
+    ORDER BY turns.sequence`)
+        .all(bodySequence)
+        .map((row) => row.sequence);
+}

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

@@ -49,7 +49,7 @@ export function pruneActivityFacts(database, limit) {
 function turn(database, sequence) {
     const row = database
         .prepare(`SELECT sequence, body_sequence, started_at, end_sequence, outcome,
-    history_id, session_json, answer, diagnostic, completed_at FROM turns WHERE sequence = ?`)
+    history_id, session_json, answer, answer_json, schema_json, diagnostic, completed_at FROM turns WHERE sequence = ?`)
         .get(sequence);
     if (row === undefined)
         throw new Error(`Akuma timeline references missing Turn ${sequence}`);
@@ -57,11 +57,17 @@ function turn(database, sequence) {
 }
 function turnStart(database, sequence) {
     const row = database
-        .prepare("SELECT sequence, body_sequence, started_at FROM turns WHERE sequence = ?")
+        .prepare("SELECT sequence, body_sequence, started_at, schema_json FROM turns WHERE sequence = ?")
         .get(sequence);
     if (row === undefined)
         throw new Error(`Akuma timeline references missing Turn ${sequence}`);
-    return { kind: "turn-start", sequence: row.sequence, bodySequence: row.body_sequence, startedAt: row.started_at };
+    return {
+        kind: "turn-start",
+        sequence: row.sequence,
+        bodySequence: row.body_sequence,
+        startedAt: row.started_at,
+        ...(row.schema_json === null ? {} : { schemaJson: row.schema_json }),
+    };
 }
 function decodeTimelineRow(database, row) {
     if (row.kind === "turn-start")

package/build/src/akuma/projection.js

@@ -192,9 +192,9 @@ export const activitySnapshotSchema = z.union([
 ]);
 function publicOutcome(turnSequence, outcome) {
     const historyId = `turn/${turnSequence}`;
-    return outcome.kind === "answered"
-        ? { kind: "answered", historyId, answer: outcome.answer }
-        : { kind: "failed", historyId, diagnostic: outcome.diagnostic };
+    if (outcome.kind === "answered")
+        return { kind: "answered", historyId, answer: outcome.answer };
+    return { kind: "failed", historyId, diagnostic: outcome.diagnostic };
 }
 export function selectExactHistory(rows, id) {
     const outcome = rows.find((row) => row.kind === "outcome" && row.outcome.historyId === id);

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

@@ -172,6 +172,7 @@ export type DriveInput = Readonly<{
     requests: Readonly<{
         dir: string;
     }>;
+    schemaJson?: string;
 }>;
 export type ProviderOptionAdmission = Readonly<{
     kind: "admitted";

package/build/src/akuma/providers/claude/index.js

@@ -86,6 +86,9 @@ function claudeQueryOptions(input, execution, abortController) {
                     : { type: "preset", preset: "claude_code", append: input.options.systemPrompt },
             }),
         ...(input.session.kind === "fresh" ? {} : { resume: claudeSessionId(input.session.coordinate) }),
+        ...(input.schemaJson === undefined
+            ? {}
+            : { outputFormat: { type: "json_schema", schema: JSON.parse(input.schemaJson) } }),
     };
 }
 async function forkClaude(load, execution, input) {

package/build/src/akuma/providers/codex-app-server/index.js

@@ -95,6 +95,7 @@ async function admitTurn(server, input, state, events, config) {
         ...(input.options.effort === undefined ? {} : { effort: input.options.effort }),
         approvalPolicy: "never",
         sandboxPolicy: sandbox(input.cwd, input.options, input.requests),
+        ...(input.schemaJson === undefined ? {} : { outputSchema: JSON.parse(input.schemaJson) }),
     }));
 }
 async function forkCodex(execution, input, custody) {

package/build/src/akuma/providers/pi/index.js

@@ -79,7 +79,13 @@ async function createPiSession(sdk, execution, input) {
 }
 async function runPiPrompt(native, input, events, state, settle) {
     try {
-        await native.prompt([input.body, ...input.launchTells.map((tell) => tell.text)].join("\n\n"));
+        const prompt = [input.body, ...input.launchTells.map((tell) => tell.text)].filter((part) => part.length > 0).join("\n\n");
+        const schemaPrompt = input.schemaJson === undefined
+            ? prompt
+            : [prompt, "Respond with JSON matching this JSON Schema and no other text:", input.schemaJson]
+                .filter((part) => part.length > 0)
+                .join("\n\n");
+        await native.prompt(schemaPrompt);
         let result;
         if (state.aborting)
             result = { kind: "failed", diagnostic: "Pi session aborted" };

package/build/src/akuma/turn-drive.d.ts

@@ -25,6 +25,7 @@ export type DriveTurnInput = Readonly<{
     body: string;
     call?: string;
     launchTells: readonly TellFact[];
+    schemaJson?: string;
     supervisor: BodySupervisor;
     runtimeSpawn(launch: AkumaCallRequestChildLaunch): Promise<OwnedProcess | void>;
     world: import("../world.js").WorldRoot;

package/build/src/akuma/turn-drive.js

@@ -1,6 +1,6 @@
 import { abortableDelay } from "./abort.js";
 /* eslint-disable max-lines-per-function -- Turn setup and consumption each preserve one ordered lifecycle transaction. */
-import { appendActivity, beginTurn, breakBody, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
+import { appendActivity, beginTurn, bindTellsToTurn, breakBody, drainPendingTells, heartExists, readHeart, recordSession, recordTellDeliveries, recordTellReceipt, } from "./heart/index.js";
 import { encodeAgentEvent, } from "./provider.js";
 import { akumaCallRequestCommands } from "./call-request.js";
 import { BodyRequestPump } from "./request-serve.js";
@@ -70,11 +70,21 @@ async function startTurnDrive(input) {
     const { cwd, options, session } = await turnRecipe(input.paths, input.soul);
     if (session !== undefined && input.adapter.resume === undefined)
         return { kind: "resume-unsupported" };
+    const boundTells = drainPendingTells(input.launchTells);
+    const schemaJson = input.schemaJson ?? boundTells.find((tell) => tell.schemaJson !== undefined)?.schemaJson;
     const turn = await beginTurn(input.paths, {
         bodySequence: input.bodySequence,
         startedAt: input.now(),
         ...(input.call === undefined ? {} : { call: input.call }),
+        ...(schemaJson === undefined ? {} : { schemaJson }),
     });
+    if (boundTells.length > 0) {
+        await bindTellsToTurn(input.paths, {
+            turnSequence: turn.sequence,
+            tellIds: boundTells.map((tell) => tell.id),
+            boundAt: input.now(),
+        });
+    }
     const { world, paths, soul: parent, runtimeSpawn: spawn, externalCommands } = input;
     const commands = composeRequestCommands(akumaCallRequestCommands({ world, paths, parent, spawn }), externalCommands);
     const requests = await BodyRequestPump.open({
@@ -99,11 +109,12 @@ async function startTurnDrive(input) {
     });
     const driveInput = {
         body: input.body,
-        launchTells: input.launchTells.map((tell) => ({ id: tell.id, text: tell.body })),
+        launchTells: boundTells.map((tell) => ({ id: tell.id, text: tell.body })),
         cwd,
         options,
         signal: driveController.signal,
         requests: { dir: requests.directory },
+        ...(schemaJson === undefined ? {} : { schemaJson }),
     };
     const attempt = session === undefined
         ? input.adapter.start({ ...driveInput, session: { kind: "fresh" } })
@@ -123,8 +134,8 @@ async function startTurnDrive(input) {
             }
             return { kind: "stopped" };
         }
-        if (input.launchTells.length > 0)
-            await recordTellDeliveries(input.paths, input.launchTells.map((tell) => ({
+        if (boundTells.length > 0)
+            await recordTellDeliveries(input.paths, boundTells.map((tell) => ({
                 tellId: tell.id,
                 route: "launch",
                 turnSequence: turn.sequence,
@@ -228,13 +239,14 @@ function observeCompletionFailure(drive) {
 async function submitPendingLiveTells(writers, pending, attempted, tellLive) {
     const { input, turnSequence, drive, writeWitness, mayWrite } = writers;
     for (const tell of pending) {
-        if (attempted.has(tell.id))
+        if (attempted.has(tell.id) || tell.schemaJson !== undefined)
             continue;
         attempted.add(tell.id);
         const outcome = await writeWitness(async () => {
             const submission = await tellLive({ id: tell.id, text: tell.body });
             if (!mayWrite() || submission.kind === "turn-ended")
                 return "turn-ended";
+            await bindTellsToTurn(input.paths, { turnSequence, tellIds: [tell.id], boundAt: input.now() });
             await recordTellDeliveries(input.paths, [
                 {
                     tellId: tell.id,
@@ -263,7 +275,9 @@ async function stopActiveDrive(input, active) {
     }
 }
 function hasUnattemptedTell(liveTells, tellPump, pending, attempted) {
-    return liveTells && tellPump === null && pending.some((tell) => !attempted.has(tell.id));
+    return (liveTells &&
+        tellPump === null &&
+        pending.some((tell) => !attempted.has(tell.id) && tell.schemaJson === undefined));
 }
 async function settleCompletion(result, session, active) {
     try {
@@ -278,7 +292,7 @@ async function consumeTurnDrive(input, active) {
     const { turnSequence, drive, requests, resume } = active;
     let heart = input.supervisor.current();
     let turnSession = resume;
-    const attempted = new Set(input.launchTells.map((tell) => tell.id));
+    const attempted = new Set(drainPendingTells(input.launchTells).map((tell) => tell.id));
     const writeWitness = serializeEffects();
     let writesOpen = true;
     const mayWrite = () => writesOpen && !input.supervisor.signal.aborted;

package/build/src/kanshi/read.js

@@ -9,8 +9,9 @@ import { readTaskHolderProjectionAt } from "../settlement/holder.js";
 import { observeCurrentPhysicalIssue } from "../protocol/read/observation.js";
 import { readContractBoard, readContractCatalogue } from "../protocol/read/status.js";
 import { withGitDecodeChannel, withGitReadObservation } from "../git/read-observation.js";
+import { decodeContractDocument } from "../body/decode.js";
+import { assertRegionPattern } from "../body/region.js";
 import { readDocuments } from "../protocol/read/documents.js";
-import { readRegionDeclarations, validateRegionPatterns } from "../library/region.js";
 import { contractId } from "../core/facts/types.js";
 import { selectKanshi, selectRegion } from "./select.js";
 import { FLEET_SNAPSHOT_ROWS, FLEET_VISIBLE_ROWS } from "./fleet.js";
@@ -42,6 +43,21 @@ function exactKeys(value, allowed, label) {
         if (!allowed.includes(key))
             throw new TypeError(`kanshi ${label} has unknown field: ${key}`);
 }
+function validateRegionPatterns(patterns) {
+    if (!Array.isArray(patterns) || patterns.length === 0)
+        throw new Error("Region query requires one or more path patterns");
+    return patterns.map((pattern) => {
+        if (typeof pattern !== "string")
+            throw new Error("Region path patterns must be strings");
+        return assertRegionPattern(pattern);
+    });
+}
+function readRegionDeclarations(documents) {
+    return documents.map((document) => ({
+        contract: document.contract,
+        patterns: decodeContractDocument(document.documentBytes).region,
+    }));
+}
 function regionSelection(value) {
     const selection = record(value, "region selection");
     if (typeof selection.kind !== "string")

package/build/src/kanshi/select.js

@@ -1,4 +1,17 @@
-import { regionOverlaps } from "../library/region.js";
+import { regionsOverlap } from "../body/region.js";
+function regionOverlaps(mine, declarations) {
+    const overlaps = [];
+    for (const declaration of declarations) {
+        const pairs = regionsOverlap(mine, declaration.patterns);
+        if (pairs.length === 0)
+            continue;
+        overlaps.push({
+            contract: declaration.contract,
+            patterns: pairs.map(([minePattern, theirsPattern]) => ({ mine: minePattern, theirs: theirsPattern })),
+        });
+    }
+    return overlaps;
+}
 export function selectKanshi(input) {
     const { report, contract } = input;
     return {

package/build/src/library/contract-forwarding.d.ts

@@ -6,8 +6,8 @@ import type { AuditReport } from "../protocol/audit.js";
 import type { WorktreeHooks } from "./configuration.js";
 import type { DeliveryValue } from "./delivery.js";
 import { type MutationResult } from "./mutation.js";
-import type { Review } from "./contract-forwarding-result.js";
-export type { Review } from "./contract-forwarding-result.js";
+import type { Review } from "./mutation.js";
+export type { Review } from "./mutation.js";
 import { Repo } from "./repo.js";
 export type DeliveryExecutionInput = Readonly<{
     scope: RepositoryScope;

package/build/src/library/contract-operations.d.ts

@@ -2,7 +2,7 @@ import { type ErasedRequestCommand, type RequestProtocol, type ServiceRequestCom
 import type { AuditReport } from "../protocol/audit.js";
 import type { IntegrationConflictMaterialized } from "../protocol/deliver.js";
 import type { DeliveryValue } from "./delivery.js";
-import type { MutationResult } from "./mutation.js";
+import { type MutationResult } from "./mutation.js";
 import type { DeliveryExecutionInput, Review } from "./contract-forwarding.js";
 import { z } from "zod";
 type DeliveryResult = MutationResult<DeliveryValue> | IntegrationConflictMaterialized;

package/build/src/library/contract-operations.js

@@ -1,8 +1,8 @@
 import { contractId, snapshotId } from "../core/facts/types.js";
 import { requestBodyCommand } from "../akuma/request-rendezvous.js";
 import { eraseRequestCommand, } from "../akuma/request-wire.js";
-import { auditResultSchema, decodeContractLiveFailure, deliveryResultSchema, encodeContractLiveFailure, reviewResultSchema, } from "./contract-forwarding-result.js";
-import { auditReportSchema } from "./contract-forwarding-result.js";
+import { auditReportSchema, auditResultSchema, deliveryResultSchema, reviewResultSchema, } from "./mutation.js";
+import { decodeContractLiveFailure, encodeContractLiveFailure } from "./refusal.js";
 import { isAbsolute, resolve } from "node:path";
 import { z } from "zod";
 const absolutePathSchema = z.string().refine((value) => isAbsolute(value) && resolve(value) === value);