@geohar/unbien-durable 0.0.0-stage → 0.1.0

package/dist/pi_launch.js

@@ -0,0 +1,84 @@
+/**
+ * Durable binding's HeadlessLaunchPort implementation: the launch-wait-quit
+ * primitive behind the `launch_pi_task` tool — the ONE place the two
+ * bindings meet at runtime.
+ *
+ * Launch path: the pi SDK's headless `createAgentSession` (the programmatic
+ * equivalent of `pi` without a TUI — NOT `pi -p`, whose print-mode exit the
+ * un-bien extension deliberately never auto-starts the relay in). The session
+ * loads its extensions through pi's own resource discovery from the target
+ * cwd (installed pi-packages, `<cwd>/.pi/extensions`, `<agentDir>`), so the
+ * un-bien pi extension must be discoverable there — when it is, its
+ * session_start auto-init joins the UDS mesh under the session's display
+ * name, which is the SCOPED name minted per invocation.
+ *
+ * Readiness: the local UDS broker is probed (observer probe — never
+ * registers, never perturbs the roster) until the scoped name appears as a
+ * peer address; that address is the agent_send routing key for the task.
+ *
+ * Teardown: `session.dispose()` — the un-bien extension's session_shutdown
+ * handler leaves the mesh and closes the relay, exactly as it does for a
+ * quitting interactive pi.
+ */
+import { createAgentSession, } from "@earendil-works/pi-coding-agent";
+import { probeListPeers, } from "@geohar/un-bien";
+import { LOCAL_SESSION_NAME, sessionSockPath, } from "@geohar/un-bien/durable";
+/** Default readiness deadline: the launched session's auto-init does a cwd
+ *  lock + config read + UDS broker join before the name is visible. */
+const DEFAULT_READY_TIMEOUT_MS = 60_000;
+const READY_POLL_INTERVAL_MS = 250;
+export class HeadlessPiLaunch {
+    async launchHeadless(opts) {
+        const { session } = await createAgentSession({ cwd: opts.cwd });
+        return new HeadlessPiSession(session, opts.name);
+    }
+}
+export class HeadlessPiSession {
+    session;
+    name;
+    constructor(session, name) {
+        this.session = session;
+        this.name = name;
+    }
+    /** join-mesh-under-name: bind the scoped name, then bring the un-bien
+     *  extension up. `bindExtensions` fires session_start; the extension's
+     *  auto-init resolves the mesh name from the session display name (set
+     *  FIRST so the join sees it) and connects the broker. */
+    async joinMeshUnderName() {
+        this.session.setSessionName(this.name);
+        await this.session.bindExtensions({});
+    }
+    /** await-ready: poll the broker's observer probe until the scoped name is
+     *  a registered peer. Resolves with the broker-assigned address (the name
+     *  may carry a `#N` collision suffix the broker added). */
+    async awaitReady(opts) {
+        const timeoutMs = opts?.timeoutMs ?? DEFAULT_READY_TIMEOUT_MS;
+        const deadline = Date.now() + timeoutMs;
+        for (;;) {
+            const probe = await probeListPeers(sessionSockPath(LOCAL_SESSION_NAME), 2_000);
+            if (probe.status === "ok") {
+                const match = probe.detailed.find((entry) => entry.name === this.name ||
+                    entry.name.startsWith(`${this.name}#`));
+                if (match)
+                    return { address: match.address };
+            }
+            if (Date.now() >= deadline) {
+                throw new Error(`launched pi session "${this.name}" did not join the mesh within ` +
+                    `${timeoutMs}ms — the un-bien extension must be discoverable by ` +
+                    `pi from the target cwd (installed pi-package or .pi/extensions) ` +
+                    `and that cwd needs a un-bien local config (auto_start_relay)`);
+            }
+            await new Promise((resolve) => setTimeout(resolve, READY_POLL_INTERVAL_MS));
+        }
+    }
+    /** tear-down: quit gracefully (extension disposal leaves the mesh). */
+    async tearDown() {
+        try {
+            this.session.dispose();
+        }
+        catch {
+            /* best-effort — dispose must not throw even mid-run */
+        }
+    }
+}
+//# sourceMappingURL=pi_launch.js.map

package/dist/pi_launch.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi_launch.js","sourceRoot":"","sources":["../src/pi_launch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,EACL,kBAAkB,GAEnB,MAAM,iCAAiC,CAAA;AAKxC,OAAO,EACL,cAAc,GACf,MAAM,iBAAiB,CAAA;AACxB,OAAO,EACL,kBAAkB,EAClB,eAAe,GAChB,MAAM,yBAAyB,CAAA;AAEhC;uEACuE;AACvE,MAAM,wBAAwB,GAAG,MAAM,CAAA;AACvC,MAAM,sBAAsB,GAAG,GAAG,CAAA;AAElC,MAAM,OAAO,gBAAgB;IAC3B,KAAK,CAAC,cAAc,CAAC,IAGpB;QACC,MAAM,EAAE,OAAO,EAAE,GAAG,MAAM,kBAAkB,CAAC,EAAE,GAAG,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,CAAA;QAC/D,OAAO,IAAI,iBAAiB,CAAC,OAAO,EAAE,IAAI,CAAC,IAAI,CAAC,CAAA;IAClD,CAAC;CACF;AAED,MAAM,OAAO,iBAAiB;IAET,OAAO;IACf,IAAI;IAFf,YACmB,OAAqB,EAC7B,IAAY;uBADJ,OAAO;oBACf,IAAI;IACZ,CAAC;IAEJ;;;8DAG0D;IAC1D,KAAK,CAAC,iBAAiB;QACrB,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;QACtC,MAAM,IAAI,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC,CAAA;IACvC,CAAC;IAED;;+DAE2D;IAC3D,KAAK,CAAC,UAAU,CAAC,IAEhB;QACC,MAAM,SAAS,GAAG,IAAI,EAAE,SAAS,IAAI,wBAAwB,CAAA;QAC7D,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,SAAS,CAAA;QACvC,SAAS,CAAC;YACR,MAAM,KAAK,GAAG,MAAM,cAAc,CAChC,eAAe,CAAC,kBAAkB,CAAC,EACnC,KAAK,CACN,CAAA;YACD,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;gBAC1B,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,IAAI,CAC/B,CAAC,KAAK,EAAE,EAAE,CACR,KAAK,CAAC,IAAI,KAAK,IAAI,CAAC,IAAI;oBACxB,KAAK,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,IAAI,CAAC,IAAI,GAAG,CAAC,CACzC,CAAA;gBACD,IAAI,KAAK;oBAAE,OAAO,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,EAAE,CAAA;YAC9C,CAAC;YACD,IAAI,IAAI,CAAC,GAAG,EAAE,IAAI,QAAQ,EAAE,CAAC;gBAC3B,MAAM,IAAI,KAAK,CACb,wBAAwB,IAAI,CAAC,IAAI,iCAAiC;oBAChE,GAAG,SAAS,qDAAqD;oBACjE,kEAAkE;oBAClE,8DAA8D,CACjE,CAAA;YACH,CAAC;YACD,MAAM,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE,CAC5B,UAAU,CAAC,OAAO,EAAE,sBAAsB,CAAC,CAC5C,CAAA;QACH,CAAC;IACH,CAAC;IAED,uEAAuE;IACvE,KAAK,CAAC,QAAQ;QACZ,IAAI,CAAC;YACH,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAA;QACxB,CAAC;QAAC,MAAM,CAAC;YACP,uDAAuD;QACzD,CAAC;IACH,CAAC;CACF"}

package/dist/port.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Durable binding's AgentSessionPort + SessionControlPort implementations.
+ *
+ * A durable Conversation already has everything the port promises, with ONE
+ * structural difference from pi: its transcript and busy state are read
+ * asynchronously (Chord commits), while the port is synchronous (inbound rpc
+ * dispatch must not await the store). The bridge closes that gap with a
+ * TRANSCRIPT MIRROR (mirror.ts) kept in sync by the ConversationViewSource,
+ * which grows it with every entry the conversation view adds. Because
+ * durable conversation IDs are
+ * stable across restarts, there is NO session-replacement machinery here —
+ * no generations, no disposal re-arm, no stale-ctx juggling. A replacement
+ * is just a new conversation handle retargeted into a fresh port.
+ *
+ * ID mapping (documented v1 contract): durable ids are Seq-orderable
+ * branded numbers; the app's wire protocol (pi `SessionEntry` shape) keys
+ * entries by STRING ids and resumes paging with `since: <string leafId>`.
+ * The mirror stringifies every entry id (`String(id)`, `<id>.<n>` for an
+ * entry's later model messages) and the session-control verbs parse the
+ * app's string ids back with `entryIdOf`.
+ */
+import type { Context } from "@earendil-works/chord";
+import type { Conversation } from "@earendil-works/pi-durable";
+import type { AgentSessionPort, EntriesPage, EntryRange, NotifyLevel, SessionControlPort, SubmitContent, SubmitOptions, SubmitResult } from "@geohar/un-bien/core";
+import { type DurableTranscriptMirror } from "./mirror.js";
+export { DurableTranscriptMirror } from "./mirror.js";
+export interface DurableSessionPortOptions {
+    /** The conversation this port serves (stable id across restarts). */
+    conversation: Conversation;
+    /** Chord context for the async handoffs (BACKGROUND_CONTEXT in the host). */
+    context: Context;
+    /** Transcript mirror fed by the host's ConversationViewSource. */
+    mirror: DurableTranscriptMirror;
+    /** The conversation's working directory (host-configured). */
+    cwd: string;
+    /** Live busy flag, maintained by the host from run_start/run_end events. */
+    busy(): boolean;
+    /** Append a custom entry via a committed app entry (best-effort). */
+    appendAppEntry(entry: {
+        customType: string;
+        content: string;
+        display?: boolean;
+        details?: unknown;
+    }): void;
+    /** Log surface for notify + asynchronous submission failures. */
+    log(message: string, level?: NotifyLevel): void;
+    /** Event-plane fanout hook (the host's ConversationViewSource); the port's
+     *  subscribeEvents is additive on it. Absent = no events surface. */
+    subscribe?(handler: (event: string, payload: unknown) => void): () => void;
+}
+export declare class DurableSessionPort implements AgentSessionPort {
+    private readonly opts;
+    constructor(opts: DurableSessionPortOptions);
+    private get conversation();
+    get sessionId(): string | null;
+    get cwd(): string;
+    get streaming(): boolean;
+    submit(content: SubmitContent, submitOpts?: SubmitOptions): SubmitResult;
+    getEntries(range?: EntryRange): EntriesPage;
+    abort(): boolean;
+    compact(opts?: {
+        customInstructions?: string;
+    }): void;
+    notify(message: string, level?: NotifyLevel): void;
+    appendEntry(entry: {
+        customType: string;
+        content: string;
+        display?: boolean;
+        details?: unknown;
+    }): void;
+    subscribeEvents(handler: (event: string, payload: unknown) => void): () => void;
+}
+export interface DurableSessionControlOptions {
+    /** Create a conversation on the harness (the pi `new_session` analog). */
+    createConversation(context: Context): Promise<Conversation>;
+    /** Called with the NEW conversation so the host retargets bridge + port. */
+    retarget(conversation: Conversation): Promise<void>;
+    /** The CURRENT conversation (for fork). */
+    current(): Conversation;
+    context: Context;
+    /** Graceful host shutdown (close relay + harness; the process exits). */
+    shutdownHost(): Promise<void>;
+}
+export declare class DurableSessionControl implements SessionControlPort {
+    private readonly opts;
+    constructor(opts: DurableSessionControlOptions);
+    newSession(): Promise<void>;
+    fork(entryId: string, _opts?: {
+        position?: "at" | "before";
+        requestId?: string;
+    }): Promise<void>;
+    navigateTree(_entryId: string): Promise<void>;
+    shutdown(): Promise<void>;
+}

package/dist/port.js

@@ -0,0 +1,121 @@
+import { entryIdOf } from "./mirror.js";
+export { DurableTranscriptMirror } from "./mirror.js";
+export class DurableSessionPort {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    get conversation() {
+        return this.opts.conversation;
+    }
+    get sessionId() {
+        return String(this.opts.conversation.id);
+    }
+    get cwd() {
+        return this.opts.cwd;
+    }
+    get streaming() {
+        return this.opts.busy();
+    }
+    submit(content, submitOpts) {
+        // Fire-and-forget, matching the port contract: a refused handoff must be
+        // a synchronous answer, but durable's submit is a commit — the wait
+        // happens on the harness side and the reply rides the event plane.
+        // `steer` maps to durable's whenBusy:"steer" (join the running work);
+        // everything else queues as a follow-up, pi's deliverAs:"followUp".
+        // The port's content blocks are structurally pi-ai's TextContent |
+        // ImageContent — the same blocks durable's user input accepts.
+        const draft = {
+            type: "input",
+            content,
+            whenBusy: submitOpts?.deliverAs === "steer" ? "steer" : undefined,
+        };
+        void this.conversation
+            .submit(draft, this.opts.context)
+            .then((submission) => submission.wait(this.opts.context))
+            .then((settled) => {
+            const record = settled;
+            if (record?.status === "unanswered") {
+                this.opts.log(`submission unanswered: ${String(record.reason ?? "unknown reason")}`, "warning");
+            }
+        })
+            .catch((err) => {
+            const detail = err instanceof Error ? err.message : String(err);
+            this.opts.log(`submission failed: ${detail}`, "error");
+        });
+        return { ok: true };
+    }
+    getEntries(range) {
+        return this.opts.mirror.page(range);
+    }
+    abort() {
+        // The port reports whether an abort was REQUESTED (the port surface is
+        // synchronous; durable's abort resolves once the conversation is idle).
+        if (!this.opts.busy())
+            return false;
+        // Fire-and-forget per the port contract — but not unguarded: a store
+        // failure must log, not surface as an unhandled rejection.
+        void this.conversation.abort(this.opts.context).catch((err) => {
+            const detail = err instanceof Error ? err.message : String(err);
+            this.opts.log(`abort failed: ${detail}`, "warning");
+        });
+        return true;
+    }
+    compact(opts) {
+        // Manual compaction always works on durable; it runs as a task and the
+        // bridge forwards its completion via the compaction events.
+        void this.conversation
+            .compact(opts?.customInstructions, this.opts.context)
+            .catch((err) => {
+            const detail = err instanceof Error ? err.message : String(err);
+            this.opts.log(`compact failed: ${detail}`, "warning");
+        });
+    }
+    notify(message, level = "info") {
+        this.opts.log(message, level);
+    }
+    appendEntry(entry) {
+        // Custom entries are data-only sidecars on the durable side (there is
+        // no TUI renderer here); committed best-effort through the host hook.
+        this.opts.appendAppEntry(entry);
+    }
+    subscribeEvents(handler) {
+        // The event plane is owned by the host's ConversationViewSource (one watch
+        // per conversation); the bridge fans translations to every subscriber.
+        // Registering through the port is additive on that fanout.
+        return this.opts.subscribe?.(handler) ?? (() => undefined);
+    }
+}
+export class DurableSessionControl {
+    opts;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    async newSession() {
+        const created = await this.opts.createConversation(this.opts.context);
+        await this.opts.retarget(created);
+    }
+    async fork(entryId, _opts) {
+        // Durable forks always branch AT the entry (there is no "before"
+        // placement); the requestId correlation is app-plane state the bridge
+        // tracks, not a conversation concern. The app's string id parses back
+        // to the durable Seq id (see the module header's ID-mapping note).
+        const at = entryIdOf(entryId);
+        if (at === undefined)
+            throw new Error(`Entry not found: ${entryId}`);
+        const forked = await this.opts.current().fork(at, {
+            ownership: { kind: "ownerless" },
+        }, this.opts.context);
+        await this.opts.retarget(forked);
+    }
+    async navigateTree(_entryId) {
+        // Durable transcripts are linear: branching happens by forking a NEW
+        // conversation (which keeps a stable id of its own). In-place leaf
+        // moves have no durable equivalent.
+        throw new Error("navigateTree is not implemented on the durable binding — fork instead");
+    }
+    async shutdown() {
+        await this.opts.shutdownHost();
+    }
+}
+//# sourceMappingURL=port.js.map

package/dist/port.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.js","sourceRoot":"","sources":["../src/port.ts"],"names":[],"mappings":"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"}

package/dist/registrar.d.ts

@@ -0,0 +1,7 @@
+import { type ToolRegistration } from "@earendil-works/pi-durable";
+import type { MeshToolDef } from "@geohar/un-bien/core";
+export declare class DurableToolRegistrar {
+    /** Registered so far — the host extension installs these in one bundle. */
+    readonly registrations: ToolRegistration[];
+    registerTool(def: MeshToolDef): void;
+}

package/dist/registrar.js

@@ -0,0 +1,31 @@
+import { defineTool, } from "@earendil-works/pi-durable";
+export class DurableToolRegistrar {
+    /** Registered so far — the host extension installs these in one bundle. */
+    registrations = [];
+    registerTool(def) {
+        this.registrations.push(defineTool({
+            name: def.name,
+            description: def.promptSnippet
+                ? `${def.description}\n\nUsage: ${def.promptSnippet}`
+                : def.description,
+            parameters: def.parameters,
+            // SAFETY: the neutral defs build TypeBox schemas compatible with
+            // durable's validation; args arrive already validated, so the
+            // `never` parameter is only the generic inference's narrow view.
+            execute: async (args, _api, _context) => {
+                const outcome = await def.execute(args, undefined);
+                return {
+                    output: outcome.content,
+                    ...(outcome.details !== undefined
+                        ? // SAFETY: the mesh tools' details payloads are all JSON
+                            // trees (ACK results, MeshMessage records, rosters) — the
+                            // neutral def types them `unknown` only to stay
+                            // harness-neutral.
+                            { details: outcome.details }
+                        : {}),
+                };
+            },
+        }));
+    }
+}
+//# sourceMappingURL=registrar.js.map

package/dist/registrar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registrar.js","sourceRoot":"","sources":["../src/registrar.ts"],"names":[],"mappings":"AAcA,OAAO,EACL,UAAU,GAGX,MAAM,4BAA4B,CAAA;AAGnC,MAAM,OAAO,oBAAoB;IAC/B,2EAA2E;IAClE,aAAa,GAAuB,EAAE,CAAA;IAE/C,YAAY,CAAC,GAAgB;QAC3B,IAAI,CAAC,aAAa,CAAC,IAAI,CACrB,UAAU,CAAC;YACT,IAAI,EAAE,GAAG,CAAC,IAAI;YACd,WAAW,EAAE,GAAG,CAAC,aAAa;gBAC5B,CAAC,CAAC,GAAG,GAAG,CAAC,WAAW,cAAc,GAAG,CAAC,aAAa,EAAE;gBACrD,CAAC,CAAC,GAAG,CAAC,WAAW;YACnB,UAAU,EAAE,GAAG,CAAC,UAAU;YAC1B,iEAAiE;YACjE,8DAA8D;YAC9D,iEAAiE;YACjE,OAAO,EAAE,KAAK,EAAE,IAAW,EAAE,IAAI,EAAE,QAAQ,EAAgC,EAAE;gBAC3E,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,CAAA;gBAClD,OAAO;oBACL,MAAM,EAAE,OAAO,CAAC,OAAO;oBACvB,GAAG,CAAC,OAAO,CAAC,OAAO,KAAK,SAAS;wBAC/B,CAAC,CAAC,wDAAwD;4BACxD,0DAA0D;4BAC1D,gDAAgD;4BAChD,mBAAmB;4BACnB,EAAE,OAAO,EAAE,OAAO,CAAC,OAAoB,EAAE;wBAC3C,CAAC,CAAC,EAAE,CAAC;iBACR,CAAA;YACH,CAAC;SACF,CAAC,CACH,CAAA;IACH,CAAC;CACF"}

package/dist/thinking.d.ts

@@ -0,0 +1,24 @@
+/**
+ * The default thinking level for durable conversations.
+ *
+ * pi-durable starts every conversation's agent at thinking level "off", so a
+ * reasoning model answers without reasoning blocks and its working
+ * narration arrives as plain text. pi starts sessions at the user's
+ * `defaultThinkingLevel` ("medium" unless configured). The bridge applies
+ * the same default to each conversation it attaches whose level is still
+ * "off", clamped to what the conversation's model supports (glm-5.3 has no
+ * "medium", so it gets "high"). A level other than "off" is left alone.
+ */
+import type { Context } from "@earendil-works/chord";
+import type { ModelThinkingLevel } from "@earendil-works/pi-ai";
+import { type Models } from "@earendil-works/pi-ai/models";
+import type { Conversation } from "@earendil-works/pi-durable";
+/** pi's default when settings name none. */
+export declare const DEFAULT_THINKING_LEVEL: ModelThinkingLevel;
+/** Parse a thinking level from a flag or env value; undefined when invalid. */
+export declare function parseThinkingLevel(value: string | undefined): ModelThinkingLevel | undefined;
+/**
+ * Raise `conversation` from "off" to `level` (clamped to its model).
+ * Returns the level set, or undefined when nothing changed.
+ */
+export declare function ensureThinkingLevel(conversation: Conversation, models: Models, level: ModelThinkingLevel, context: Context): Promise<ModelThinkingLevel | undefined>;

package/dist/thinking.js

@@ -0,0 +1,36 @@
+import { clampThinkingLevel } from "@earendil-works/pi-ai/models";
+/** pi's default when settings name none. */
+export const DEFAULT_THINKING_LEVEL = "medium";
+const LEVELS = [
+    "off",
+    "minimal",
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+];
+/** Parse a thinking level from a flag or env value; undefined when invalid. */
+export function parseThinkingLevel(value) {
+    return LEVELS.find((level) => level === value);
+}
+/**
+ * Raise `conversation` from "off" to `level` (clamped to its model).
+ * Returns the level set, or undefined when nothing changed.
+ */
+export async function ensureThinkingLevel(conversation, models, level, context) {
+    if (level === "off")
+        return undefined;
+    const agent = await conversation.agent(context);
+    if (agent.thinkingLevel !== "off")
+        return undefined;
+    const model = agent.model !== undefined
+        ? models.getModel(agent.model.provider, agent.model.modelId)
+        : undefined;
+    const target = model !== undefined ? clampThinkingLevel(model, level) : level;
+    if (target === "off")
+        return undefined;
+    await conversation.configure({ thinkingLevel: target }, context);
+    return target;
+}
+//# sourceMappingURL=thinking.js.map

package/dist/thinking.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinking.js","sourceRoot":"","sources":["../src/thinking.ts"],"names":[],"mappings":"AAaA,OAAO,EAAE,kBAAkB,EAAe,MAAM,8BAA8B,CAAA;AAG9E,4CAA4C;AAC5C,MAAM,CAAC,MAAM,sBAAsB,GAAuB,QAAQ,CAAA;AAElE,MAAM,MAAM,GAAkC;IAC5C,KAAK;IACL,SAAS;IACT,KAAK;IACL,QAAQ;IACR,MAAM;IACN,OAAO;IACP,KAAK;CACN,CAAA;AAED,+EAA+E;AAC/E,MAAM,UAAU,kBAAkB,CAChC,KAAyB;IAEzB,OAAO,MAAM,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,KAAK,KAAK,CAAC,CAAA;AAChD,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,YAA0B,EAC1B,MAAc,EACd,KAAyB,EACzB,OAAgB;IAEhB,IAAI,KAAK,KAAK,KAAK;QAAE,OAAO,SAAS,CAAA;IACrC,MAAM,KAAK,GAAG,MAAM,YAAY,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IAC/C,IAAI,KAAK,CAAC,aAAa,KAAK,KAAK;QAAE,OAAO,SAAS,CAAA;IACnD,MAAM,KAAK,GACT,KAAK,CAAC,KAAK,KAAK,SAAS;QACvB,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,KAAK,CAAC,OAAO,CAAC;QAC5D,CAAC,CAAC,SAAS,CAAA;IACf,MAAM,MAAM,GAAG,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,kBAAkB,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAA;IAC7E,IAAI,MAAM,KAAK,KAAK;QAAE,OAAO,SAAS,CAAA;IACtC,MAAM,YAAY,CAAC,SAAS,CAAC,EAAE,aAAa,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,CAAA;IAChE,OAAO,MAAM,CAAA;AACf,CAAC"}

package/dist/view_translator.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Translate successive durable conversation-view states into pi's event
+ * plane: the event names and payloads `pi.on()` delivers, which the shared
+ * rpc-envelope producer turns into `pi --mode rpc` frames. The app therefore
+ * sees the same traffic from a durable conversation as from a pi session.
+ *
+ * pi-durable publishes state, not events: each view value holds the entries
+ * appended since the last one and the `pi.live` document (run control, the
+ * streaming answer, the tool round). `feed()` diffs that against what it has
+ * already emitted:
+ *
+ *   pi.live.run appears / disappears     → agent_start / agent_end + agent_settled
+ *   first message of a turn              → turn_start
+ *   pi.user entry                        → message_start + message_end
+ *   pi.live.generation.message           → message_start, then message_update per
+ *                                          block: text/thinking start, delta, end;
+ *                                          toolcall_start, toolcall_end
+ *   pi.assistant entry                   → remaining block deltas and ends, then
+ *                                          message_end; with no tool calls, turn_end
+ *   pi.live.tools slot running           → tool_execution_start
+ *   slot output/details change           → tool_execution_update {content, details}
+ *   pi.tool-result entry                 → tool_execution_end {content, details} with
+ *                                          the message's isError, then message_start +
+ *                                          message_end; the round's last → turn_end
+ *   slot done without an entry (faulted) → tool_execution_end, isError
+ *   pi.compaction entry                  → session_compact (the summary)
+ *   un-bien.app entry, display           → message_start + message_end, role custom
+ *   pi.live.runFailure (new)             → onRunFailure (the bridge records it as an
+ *                                          app entry, which then arrives as above)
+ *
+ * No toolcall_delta: the view holds a call's parsed arguments, not pi's raw
+ * argument text, and the app builds tool cards from tool_execution_start.
+ */
+import type { EntryRecord, LiveState, RunFailure } from "@earendil-works/pi-durable";
+type Emit = (name: string, payload: Record<string, unknown>) => void;
+export interface ViewTranslatorOptions {
+    emit: Emit;
+    onBusyChange?(busy: boolean): void;
+    onRunFailure?(failure: RunFailure): void;
+}
+export declare class ViewTranslator {
+    private readonly opts;
+    private busy;
+    private inTurn;
+    /** Blocks of the streaming answer already emitted, and which are closed. */
+    private stream;
+    private lastAssistant;
+    private pendingCalls;
+    private turnResults;
+    private readonly toolsStarted;
+    private readonly toolsEnded;
+    private readonly toolProgress;
+    private runFailureTask;
+    constructor(opts: ViewTranslatorOptions);
+    /**
+     * Take the state at attachment without emitting: a run in flight sets the
+     * busy flag, and a run failure already recorded is not reported again.
+     */
+    prime(live: LiveState | undefined): void;
+    /** Emit what changed: `added` are the entries new since the last call. */
+    feed(added: readonly EntryRecord[], live: LiveState | undefined): void;
+    private entry;
+    /** A message that arrives complete: start and end in one go. Only a run's
+     *  messages open a turn; a notice written while idle (a run failure, a
+     *  mesh notice) is just the message. */
+    private whole;
+    private assistant;
+    private toolResult;
+    private streaming;
+    /**
+     * Emit the block events that take the emitted blocks to `blocks`. A block
+     * ends when a later one starts, or, with `final`, at the message's end.
+     */
+    private diffBlocks;
+    private endBlock;
+    private slot;
+    private startTool;
+    private argsOf;
+    private beginTurn;
+    private endTurn;
+    private endRun;
+}
+export {};