@astrosheep/keiyaku 4.0.0 → 4.0.1

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

@@ -0,0 +1,79 @@
+export const tellStateSql = `CASE
+  WHEN EXISTS (
+    SELECT 1 FROM tell_deliveries d
+    WHERE d.tell_id = tells.id AND (d.route = 'launch' OR d.receipt = 'unavailable')
+  ) THEN 'told'
+  WHEN EXISTS (SELECT 1 FROM tell_receipts r WHERE r.evidence = 'exact' AND r.tell_id = tells.id) THEN 'told'
+  WHEN EXISTS (
+    SELECT 1 FROM tell_receipts r
+    JOIN tell_deliveries d ON d.turn_sequence = r.turn_sequence AND d.fence = r.fence
+    WHERE r.evidence = 'fence' AND d.tell_id = tells.id
+  ) THEN 'told'
+  ELSE 'pending'
+END`;
+export const pendingTellSequencesSql = `SELECT tells.sequence FROM tells WHERE ${tellStateSql} = 'pending'`;
+export const pendingTellProtectionSql = `SELECT d.turn_sequence FROM tell_deliveries d
+  JOIN tells ON tells.id = d.tell_id WHERE ${tellStateSql} = 'pending'`;
+function tellDeliveries(database, id) {
+    const rows = database.prepare(`SELECT turn_sequence, route, receipt, delivered_at FROM tell_deliveries
+    WHERE tell_id = ? ORDER BY sequence`).all(id);
+    return rows.map((row) => row.receipt == null
+        ? { 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 decodeTellRow(database, row) {
+    return {
+        kind: "tell",
+        sequence: row.sequence,
+        id: row.id,
+        body: row.body,
+        state: row.state,
+        recordedAt: row.recorded_at,
+        deliveries: tellDeliveries(database, row.id),
+    };
+}
+export function decodeTellAtSequence(database, sequence) {
+    const row = database.prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+    FROM tells WHERE sequence = ?`).get(sequence);
+    if (row === undefined)
+        throw new Error(`Akuma timeline references missing tell ${sequence}`);
+    return decodeTellRow(database, row);
+}
+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);
+    return sequence;
+}
+export function tellFact(database, id) {
+    const row = database.prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state
+    FROM tells WHERE id = ?`).get(id);
+    return row === undefined ? null : decodeTellRow(database, row);
+}
+export function insertTellDeliveryFact(database, input) {
+    const result = database.prepare(`INSERT OR IGNORE INTO tell_deliveries(
+    tell_id, route, turn_sequence, fence, receipt, delivered_at
+  ) VALUES (?, ?, ?, ?, ?, ?)`).run(input.tellId, input.route, input.turnSequence, input.fence, input.route === "live" ? input.receipt : null, input.deliveredAt);
+    const row = database.prepare(`SELECT route, receipt FROM tell_deliveries
+    WHERE tell_id = ? AND turn_sequence = ? AND fence = ?`)
+        .get(input.tellId, input.turnSequence, input.fence);
+    if (row === undefined || (result.changes === 0
+        && (row.route !== input.route || row.receipt !== (input.route === "live" ? input.receipt : null)))) {
+        throw new Error(`tell delivery ${input.tellId} has conflicting evidence`);
+    }
+}
+export function insertTellReceiptFact(database, input) {
+    database.prepare(`INSERT OR IGNORE INTO tell_receipts(
+    evidence, tell_id, turn_sequence, fence, kind, received_at
+  ) VALUES (?, ?, ?, ?, ?, ?)`).run(input.evidence, input.evidence === "exact" ? input.tellId : null, input.evidence === "fence" ? input.turnSequence : null, input.evidence === "fence" ? input.fence : null, input.kind, input.receivedAt);
+}
+export function tellIdsForFence(database, turnSequence, fence) {
+    return database.prepare(`SELECT tell_id FROM tell_deliveries
+    WHERE turn_sequence = ? AND fence = ? ORDER BY sequence`)
+        .all(turnSequence, fence).map((row) => row.tell_id);
+}
+export function pendingTellFacts(database) {
+    const rows = database.prepare(`SELECT sequence, id, body, recorded_at, ${tellStateSql} AS state FROM tells
+    WHERE ${tellStateSql} = 'pending' ORDER BY sequence`).all();
+    return rows.map((row) => decodeTellRow(database, row));
+}

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

@@ -0,0 +1,15 @@
+import type { DatabaseSync } from "node:sqlite";
+import type { CallFact, TellFact, TurnEndFact, TurnStartFact } from "./facts.js";
+import { type ActivityFact } from "./rows.js";
+export type TimelineFact = TurnStartFact | CallFact | ActivityFact | TellFact | TurnEndFact;
+export type ActivityFactSlice = Readonly<{
+    rows: readonly TimelineFact[];
+    lowestRetained: number | null;
+    highest: number | null;
+}>;
+export declare function pruneActivityFacts(database: DatabaseSync, limit: number): void;
+export declare function activityFactSlice(database: DatabaseSync, input: Readonly<{
+    before?: number;
+    since?: number;
+    limit: number;
+}>): ActivityFactSlice;

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

@@ -0,0 +1,86 @@
+import { decodeActivityRow, decodeCallRow, decodeTurnRow, } from "./rows.js";
+import { decodeTellAtSequence, pendingTellProtectionSql, pendingTellSequencesSql } from "./tells.js";
+export function pruneActivityFacts(database, limit) {
+    const count = database.prepare("SELECT COUNT(*) AS count FROM timeline").get();
+    if (count.count <= limit + 500)
+        return;
+    const cutoff = database.prepare(`SELECT sequence FROM timeline ORDER BY sequence DESC LIMIT 1 OFFSET ?`)
+        .get(limit - 1);
+    if (cutoff === undefined)
+        return;
+    database.prepare(`WITH protected_turns(sequence) AS (
+      SELECT sequence FROM turns WHERE end_sequence IS NULL
+      UNION SELECT turn_sequence FROM calls WHERE sequence >= ?
+      UNION SELECT turn_sequence FROM activity WHERE sequence >= ?
+      UNION SELECT sequence FROM turns WHERE end_sequence >= ?
+      UNION ${pendingTellProtectionSql}
+    ), protected(sequence) AS (
+      SELECT sequence FROM protected_turns
+      UNION SELECT sequence FROM calls WHERE turn_sequence IN (SELECT sequence FROM protected_turns)
+      UNION SELECT end_sequence FROM turns WHERE sequence IN (SELECT sequence FROM protected_turns) AND end_sequence IS NOT NULL
+      UNION ${pendingTellSequencesSql}
+    )
+    DELETE FROM timeline WHERE sequence < ? AND sequence NOT IN protected`)
+        .run(cutoff.sequence, cutoff.sequence, cutoff.sequence, cutoff.sequence);
+}
+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 = ?`)
+        .get(sequence);
+    if (row === undefined)
+        throw new Error(`Akuma timeline references missing Turn ${sequence}`);
+    return decodeTurnRow(row);
+}
+function turnStart(database, sequence) {
+    const row = database.prepare("SELECT sequence, body_sequence, started_at 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 };
+}
+function decodeTimelineRow(database, row) {
+    if (row.kind === "turn-start")
+        return turnStart(database, row.sequence);
+    if (row.kind === "turn-end") {
+        const source = database.prepare("SELECT sequence FROM turns WHERE end_sequence = ?").get(row.sequence);
+        const fact = source === undefined ? undefined : turn(database, source.sequence).end;
+        if (fact === undefined)
+            throw new Error(`Akuma timeline references missing Turn end ${row.sequence}`);
+        return fact;
+    }
+    if (row.kind === "call") {
+        const value = database.prepare("SELECT sequence, turn_sequence, body, at FROM calls WHERE sequence = ?")
+            .get(row.sequence);
+        if (value === undefined)
+            throw new Error(`Akuma timeline references missing call ${row.sequence}`);
+        return decodeCallRow(value);
+    }
+    if (row.kind === "activity") {
+        const value = database.prepare("SELECT sequence, turn_sequence, event_json, at FROM activity WHERE sequence = ?")
+            .get(row.sequence);
+        if (value === undefined)
+            throw new Error(`Akuma timeline references missing activity ${row.sequence}`);
+        return decodeActivityRow(value);
+    }
+    return decodeTellAtSequence(database, row.sequence);
+}
+export function activityFactSlice(database, input) {
+    const bounds = database.prepare("SELECT MIN(sequence) AS lowest, MAX(sequence) AS highest FROM timeline")
+        .get();
+    let rows;
+    if (input.before !== undefined) {
+        rows = database.prepare(`SELECT * FROM (
+      SELECT sequence, kind FROM timeline WHERE sequence < ? ORDER BY sequence DESC LIMIT ?
+    ) ORDER BY sequence`).all(input.before, input.limit);
+    }
+    else if (input.since !== undefined) {
+        rows = database.prepare(`SELECT sequence, kind FROM timeline WHERE sequence > ? ORDER BY sequence LIMIT ?`)
+            .all(input.since, input.limit);
+    }
+    else {
+        rows = database.prepare(`SELECT * FROM (
+      SELECT sequence, kind FROM timeline ORDER BY sequence DESC LIMIT ?
+    ) ORDER BY sequence`).all(input.limit);
+    }
+    return { rows: rows.map((row) => decodeTimelineRow(database, row)), lowestRetained: bounds.lowest, highest: bounds.highest };
+}

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

@@ -1,7 +1,9 @@
 export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
-export { AkumaArchetypeError } from "./archetype.js";
+export type { WorldRoot } from "../world.js";
+export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
+export type { ArchetypeCatalogRow } from "./archetype.js";
 export { AkumaBodyRequestError } from "./requests.js";
-export type { AkumaList, AkumaListRow, AkumaStatus, ActivityHistory, ActivityRow, ActivitySnapshot, ForkReceipt, InterruptReceipt, TellReceipt, UnbornAkumaListRow, } from "./akuma.js";
+export type { AkumaList, AkumaListInput, AkumaListRow, AkumaStatus, ActivityHistory, ActivityRow, ActivitySnapshot, ActivitySnapshotEntry, ForkReceipt, InterruptReceipt, TellResult, UnbornAkumaListRow, } from "./akuma.js";
 export type { AgentEvent, ToolCall, ToolEvent, ToolResult } from "./provider.js";
 export type { AkuId } from "./identity.js";
 export type { Confinement, KillEvidence, ProviderOptions, ResumeCoordinate, TurnFact, } from "./heart/index.js";

package/build/src/akuma/index.js

@@ -1,3 +1,3 @@
 export { Akuma, AkumaHandle, AkumaNotBornError } from "./akuma.js";
-export { AkumaArchetypeError } from "./archetype.js";
+export { AkumaArchetypeError, listArchetypeDefinitions, listArchetypes } from "./archetype.js";
 export { AkumaBodyRequestError } from "./requests.js";

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

@@ -0,0 +1,97 @@
+import { type ToolCall, type ToolResult } from "./provider.js";
+import type { ActivitySlice, TellDelivery, TellFact, TimelineFact, TurnEndFact } from "./heart/index.js";
+export type ActivityRow = Readonly<{
+    kind: "turn";
+    sequence: number;
+    turnSequence: number;
+    bodySequence: number;
+    at: string;
+}> | Readonly<{
+    kind: "call";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    text: string;
+}> | Readonly<{
+    kind: "said";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    text: string;
+    truncated?: true;
+}> | Readonly<{
+    kind: "thought";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    text: string;
+    truncated?: true;
+}> | Readonly<{
+    kind: "tool";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    completedAt?: string;
+    durationMs?: number;
+    name: string;
+    call: ToolCall;
+    state: "running" | ToolResult;
+    truncated?: true;
+}> | Readonly<{
+    kind: "note";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    text: string;
+    truncated?: true;
+}> | Readonly<{
+    kind: "tell";
+    sequence: number;
+    at: string;
+    tellId: string;
+    text: string;
+    state: TellFact["state"];
+    deliveries: readonly TellDelivery[];
+}> | Readonly<{
+    kind: "outcome";
+    sequence: number;
+    turnSequence: number;
+    at: string;
+    outcome: TurnEndFact["outcome"];
+}>;
+export type ActivitySnapshot = Readonly<{
+    entries: readonly ActivitySnapshotEntry[];
+    lowestRetained: number | null;
+    highest: number | null;
+}>;
+export type ActivitySnapshotEntry = Readonly<{
+    kind: "row";
+    row: ActivityRow;
+}> | Readonly<{
+    kind: "gap";
+    count: number;
+}>;
+export type ActivitySnapshotProfile = "status" | "feedback";
+export type ActivityHistory = Readonly<{
+    rows: readonly ActivityRow[];
+    omitted: number;
+    hasEarlier: boolean;
+    hasLater: boolean;
+    historyLost: boolean;
+    lowestRetained: number | null;
+    highest: number | null;
+}>;
+/** Project the complete retained fact window in persisted timeline order. */
+export declare function projectTimeline(facts: readonly TimelineFact[]): readonly ActivityRow[];
+/** Apply the bounded snapshot policy after semantic projection. */
+export declare function selectActivitySnapshot(facts: readonly TimelineFact[], input?: Readonly<{
+    lowestRetained?: number | null;
+    highest?: number | null;
+    profile?: ActivitySnapshotProfile;
+}>): ActivitySnapshot;
+/** Apply cursor and limit to the one semantic timeline projection. */
+export declare function projectActivityHistory(slice: ActivitySlice, input: Readonly<{
+    before?: number;
+    since?: number;
+    limit: number;
+}>): ActivityHistory;

package/build/src/akuma/projection.js

@@ -0,0 +1,145 @@
+import { decodeAgentEvent } from "./provider.js";
+const TAIL_LIMIT = 3;
+const VOICE_LIMIT = 5;
+function duration(startedAt, completedAt) {
+    const start = Date.parse(startedAt);
+    const end = Date.parse(completedAt);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start)
+        return undefined;
+    return end - start;
+}
+function toolKey(turnSequence, id) {
+    return `${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 } : {}) };
+    }
+    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 null;
+}
+/** Project the complete retained fact window in persisted timeline order. */
+export function projectTimeline(facts) {
+    const state = { rows: [], running: new Map() };
+    for (const fact of facts) {
+        if (fact.kind === "turn-start")
+            state.rows.push({ settled: false, row: { kind: "turn", sequence: fact.sequence, turnSequence: fact.sequence, bodySequence: fact.bodySequence, at: fact.startedAt } });
+        else if (fact.kind === "turn-end")
+            state.rows.push({ settled: true, row: { kind: "outcome", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.completedAt, outcome: fact.outcome } });
+        else if (fact.kind === "call")
+            state.rows.push({ settled: true, row: { kind: "call", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, text: fact.body } });
+        else if (fact.kind === "tell")
+            state.rows.push({ settled: fact.state !== "pending", row: { kind: "tell", sequence: fact.sequence, at: fact.recordedAt, tellId: fact.id, text: fact.body, state: fact.state, deliveries: fact.deliveries } });
+        else
+            projectActivityEvent(state, fact);
+    }
+    return state.rows.map((entry) => entry.row);
+}
+function projectActivityEvent(state, fact) {
+    const event = decodeAgentEvent(fact.event);
+    const narration = narrationRow(fact, event);
+    if (narration !== null) {
+        state.rows.push({ settled: true, row: narration });
+        return;
+    }
+    if (event.type !== "tool")
+        return;
+    const key = toolKey(fact.turnSequence, event.id);
+    if (event.phase === "started") {
+        state.running.set(key, state.rows.length);
+        state.rows.push({ settled: false, row: { kind: "tool", sequence: fact.sequence, turnSequence: fact.turnSequence, at: fact.at, name: event.name, call: event.call, state: "running", ...(event.truncated === true ? { truncated: true } : {}) } });
+        return;
+    }
+    const index = state.running.get(key);
+    const started = index === undefined ? undefined : state.rows[index]?.row;
+    if (started?.kind !== "tool") {
+        state.rows.push({ settled: true, row: {
+                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 startedAt = started.at;
+    const durationMs = duration(startedAt, fact.at);
+    const completed = {
+        kind: "tool", sequence: started.sequence, turnSequence: fact.turnSequence, at: startedAt,
+        completedAt: fact.at, ...(durationMs === undefined ? {} : { durationMs }),
+        name: event.name, call: event.call, state: event.result,
+        ...(started?.kind === "tool" && started.truncated === true || event.truncated === true ? { truncated: true } : {}),
+    };
+    state.rows[index] = { settled: true, row: completed };
+    state.running.delete(key);
+}
+function pinned(row, latestOutcome, openTurn) {
+    return row === latestOutcome
+        || (row.kind === "turn" && row.turnSequence === openTurn)
+        || (row.kind === "call" && row.turnSequence === openTurn)
+        || (row.kind === "tool" && row.state === "running")
+        || (row.kind === "tell" && row.state === "pending");
+}
+/** Apply the bounded snapshot policy after semantic projection. */
+export function selectActivitySnapshot(facts, input = {}) {
+    const projected = projectTimeline(facts);
+    const ended = new Set(projected.filter((row) => row.kind === "outcome").map((row) => row.turnSequence));
+    const openTurn = projected.findLast((row) => row.kind === "turn" && !ended.has(row.turnSequence));
+    const latestOutcome = projected.findLast((row) => row.kind === "outcome");
+    const ordinary = projected.filter((row) => !pinned(row, latestOutcome, openTurn?.turnSequence));
+    const selected = new Set(ordinary.slice(-TAIL_LIMIT));
+    if ((input.profile ?? "status") === "status") {
+        for (const row of ordinary.filter((value) => value.kind === "said" || value.kind === "thought").slice(-VOICE_LIMIT)) {
+            selected.add(row);
+        }
+    }
+    for (const row of projected)
+        if (pinned(row, latestOutcome, openTurn?.turnSequence))
+            selected.add(row);
+    const entries = [];
+    let hidden = [];
+    const flush = () => {
+        if (hidden.length === 1)
+            entries.push({ kind: "row", row: hidden[0] });
+        else if (hidden.length > 1)
+            entries.push({ kind: "gap", count: hidden.length });
+        hidden = [];
+    };
+    for (const row of projected) {
+        if (!selected.has(row))
+            hidden.push(row);
+        else {
+            flush();
+            entries.push({ kind: "row", row });
+        }
+    }
+    flush();
+    return {
+        entries,
+        lowestRetained: input.lowestRetained ?? (facts[0]?.sequence ?? null),
+        highest: input.highest ?? (facts.at(-1)?.sequence ?? null),
+    };
+}
+/** Apply cursor and limit to the one semantic timeline projection. */
+export function projectActivityHistory(slice, input) {
+    const projected = projectTimeline(slice.rows);
+    const eligible = projected.filter((row) => input.before !== undefined
+        ? row.sequence < input.before
+        : input.since !== undefined ? row.sequence > input.since : true);
+    const rows = input.since !== undefined ? eligible.slice(0, input.limit) : eligible.slice(-input.limit);
+    const forwardHistoryLost = input.since !== undefined
+        && slice.rows[0] !== undefined
+        && slice.rows[0].sequence > input.since + 1;
+    return {
+        rows,
+        omitted: Math.max(0, eligible.length - rows.length),
+        hasEarlier: input.since === undefined && eligible.length > rows.length,
+        hasLater: input.since !== undefined && eligible.length > rows.length,
+        historyLost: forwardHistoryLost || (input.since === undefined && eligible.length === rows.length
+            && slice.lowestRetained !== null && slice.lowestRetained > 1),
+        lowestRetained: slice.lowestRetained,
+        highest: slice.highest,
+    };
+}

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

@@ -1,5 +1,7 @@
-import type { Confinement, ProviderOptions, ResumeCoordinate } from "./heart/index.js";
-export type { ProviderOptions, ResumeCoordinate } from "./heart/index.js";
+import type { Confinement, ProviderOptions } from "./heart/index.js";
+import { decodeResumeCoordinate, encodeResumeCoordinate, type ResumeCoordinate } from "./coordinate.js";
+export type { ResumeCoordinate } from "./coordinate.js";
+export type { ProviderOptions } from "./heart/index.js";
 export declare const AKUMA_REQUESTS_ENV = "AKUMA_REQUESTS";
 export declare const AGENT_EVENT_TEXT_LIMIT = 16384;
 export declare const AGENT_THOUGHT_TEXT_LIMIT = 4000;
@@ -36,6 +38,7 @@ export type ToolEvent = Readonly<{
     id: string;
     name: string;
     call: ToolCall;
+    truncated?: true;
 }> & (Readonly<{
     phase: "started";
     result?: never;
@@ -49,16 +52,21 @@ export type AgentEvent = Readonly<{
 }> | Readonly<{
     type: "assistant";
     text: string;
+    truncated?: true;
 }> | Readonly<{
     type: "thought";
     text: string;
+    truncated?: true;
 }> | ToolEvent | Readonly<{
     type: "note";
     text: string;
+    truncated?: true;
 }> | Readonly<{
     type: "unknown";
     kind: string;
+    truncated?: true;
 }>;
+export { decodeResumeCoordinate, encodeResumeCoordinate };
 export declare function decodeProviderOptions(value: unknown): ProviderOptions;
 export declare function decodeAgentEvent(value: unknown): AgentEvent;
 export declare function encodeAgentEvent(event: AgentEvent): unknown;
@@ -86,10 +94,46 @@ export type TurnResult = Readonly<{
     kind: "failed";
     diagnostic: string;
 }>;
-export type Drive = Readonly<{
+export type ProviderFence = string;
+export type TellReceipt = Readonly<{
+    evidence: "exact";
+    tellId: string;
+    kind: string;
+}> | Readonly<{
+    evidence: "fence";
+    fence: ProviderFence;
+    kind: string;
+}>;
+export type TellSubmission = Readonly<{
+    kind: "accepted";
+    fence: ProviderFence;
+}> | Readonly<{
+    kind: "turn-ended";
+}>;
+export type Session = Readonly<{
+    admission: Readonly<{
+        fence: ProviderFence;
+    }>;
     events: AsyncIterable<AgentEvent>;
+    receipts?: AsyncIterable<TellReceipt>;
     completion: Promise<TurnResult>;
     abort(): Promise<void>;
+    tell?(tell: Readonly<{
+        id: string;
+        text: string;
+    }>): Promise<TellSubmission>;
+}>;
+export type DriveInput = Readonly<{
+    body: string;
+    launchTells: readonly Readonly<{
+        id: string;
+        text: string;
+    }>[];
+    cwd: string;
+    options: ProviderOptions;
+    requests?: Readonly<{
+        dir: string;
+    }>;
 }>;
 export type ProviderOptionAdmission = Readonly<{
     kind: "admitted";
@@ -111,13 +155,15 @@ export type ProviderAdapter = Readonly<{
     }>): Promise<Readonly<{
         session: ResumeCoordinate;
     }>>;
-    start(input: Readonly<{
-        prompt: string;
-        cwd: string;
-        options: ProviderOptions;
-        session?: ResumeCoordinate;
-        requests?: Readonly<{
-            dir: string;
+    start(input: DriveInput & Readonly<{
+        session: Readonly<{
+            kind: "fresh";
+        }>;
+    }>): Promise<Session>;
+    resume?(input: DriveInput & Readonly<{
+        session: Readonly<{
+            kind: "resume";
+            coordinate: ResumeCoordinate;
         }>;
-    }>): Promise<Drive>;
+    }>): Promise<Session>;
 }>;