@hheei/pi-subagents 0.3.0 → 0.4.0

package/dist/state-db.d.ts

@@ -0,0 +1,52 @@
+import { DatabaseSync } from "node:sqlite";
+/** The one durable file for child records, commands, and tokens. */
+export declare function defaultStatePath(): string;
+export declare function openStateDb(filePath: string): DatabaseSync;
+export declare function withWrite<T>(db: DatabaseSync, run: () => T): T;
+export interface StoredCommand {
+    readonly id: string;
+    readonly parentSessionId: string;
+    readonly subagentId: string;
+    readonly direction: "to_child" | "to_parent";
+    readonly operation: string;
+    readonly payload: string;
+    readonly status: string;
+    readonly result: string | null;
+    readonly errorCode: string | null;
+    readonly error: string | null;
+}
+export declare function insertChild(db: DatabaseSync, parentSessionId: string, subagentId: string, revision: number, record: string): boolean;
+export declare function readChild(db: DatabaseSync, parentSessionId: string, subagentId: string): {
+    readonly revision: number;
+    readonly record: string;
+} | undefined;
+export declare function listChildRecords(db: DatabaseSync, parentSessionId: string): readonly string[];
+export declare function replaceChild(db: DatabaseSync, parentSessionId: string, subagentId: string, expectedRevision: number | undefined, revision: number, record: string): boolean;
+export declare function readMeta(db: DatabaseSync, parentSessionId: string, key: string): string | undefined;
+export declare function writeMeta(db: DatabaseSync, parentSessionId: string, key: string, value: string): void;
+export declare function enqueueCommand(db: DatabaseSync, command: {
+    readonly id: string;
+    readonly parentSessionId: string;
+    readonly subagentId: string;
+    readonly direction: "to_child" | "to_parent";
+    readonly operation: string;
+    readonly payload: string;
+    readonly createdAt: number;
+}): void;
+export declare function hasPendingCommand(db: DatabaseSync, parentSessionId: string, direction: "to_child" | "to_parent", subagentId?: string): boolean;
+export declare function claimCommand(db: DatabaseSync, parentSessionId: string, subagentId: string, direction: "to_child" | "to_parent"): StoredCommand | undefined;
+export declare function claimParentCommands(db: DatabaseSync, parentSessionId: string): readonly StoredCommand[];
+export declare function requeueAbandonedParentCommands(db: DatabaseSync, parentSessionId: string): void;
+export declare function deleteCommand(db: DatabaseSync, id: string): void;
+export declare function readCommand(db: DatabaseSync, id: string): StoredCommand | undefined;
+export declare function finishCommand(db: DatabaseSync, id: string, outcome: {
+    readonly status: "done";
+    readonly result: string;
+} | {
+    readonly status: "failed";
+    readonly errorCode: string;
+    readonly error: string;
+}): void;
+export declare function readToken(db: DatabaseSync, parentSessionId: string, runtimeIdentity: string): string | undefined;
+export declare function writeToken(db: DatabaseSync, parentSessionId: string, runtimeIdentity: string, token: string): void;
+export declare function deleteToken(db: DatabaseSync, parentSessionId: string, runtimeIdentity: string): void;

package/dist/state-db.js

@@ -0,0 +1,209 @@
+import { chmodSync, mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+/** The one durable file for child records, commands, and tokens. */
+export function defaultStatePath() {
+    return join(getAgentDir(), "pi-subagents", "state.sqlite");
+}
+const SCHEMA = `
+CREATE TABLE IF NOT EXISTS children (
+  parent_session_id TEXT NOT NULL,
+  subagent_id TEXT NOT NULL,
+  revision INTEGER NOT NULL,
+  record TEXT NOT NULL,
+  PRIMARY KEY (parent_session_id, subagent_id)
+);
+CREATE TABLE IF NOT EXISTS session_meta (
+  parent_session_id TEXT NOT NULL,
+  key TEXT NOT NULL,
+  value TEXT NOT NULL,
+  PRIMARY KEY (parent_session_id, key)
+);
+CREATE TABLE IF NOT EXISTS commands (
+  id TEXT PRIMARY KEY,
+  parent_session_id TEXT NOT NULL,
+  subagent_id TEXT NOT NULL,
+  direction TEXT NOT NULL,
+  operation TEXT NOT NULL,
+  payload TEXT NOT NULL,
+  status TEXT NOT NULL,
+  result TEXT,
+  error_code TEXT,
+  error TEXT,
+  created_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS commands_pending
+  ON commands (parent_session_id, subagent_id, direction, status, created_at);
+CREATE TABLE IF NOT EXISTS tokens (
+  parent_session_id TEXT NOT NULL,
+  runtime_identity TEXT NOT NULL,
+  token TEXT NOT NULL,
+  PRIMARY KEY (parent_session_id, runtime_identity)
+);
+`;
+const connections = new Map();
+export function openStateDb(filePath) {
+    const cached = connections.get(filePath);
+    if (cached !== undefined)
+        return cached;
+    mkdirSync(dirname(filePath), { recursive: true, mode: 0o700 });
+    const db = new DatabaseSync(filePath);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec(SCHEMA);
+    db.exec("DROP TABLE IF EXISTS presence");
+    chmodSync(filePath, 0o600);
+    connections.set(filePath, db);
+    return db;
+}
+export function withWrite(db, run) {
+    db.exec("BEGIN IMMEDIATE");
+    try {
+        const value = run();
+        db.exec("COMMIT");
+        return value;
+    }
+    catch (error) {
+        try {
+            db.exec("ROLLBACK");
+        }
+        catch {
+            // The original error is the one the caller handles.
+        }
+        throw error;
+    }
+}
+function commandFromRow(row) {
+    return {
+        id: row.id,
+        parentSessionId: row.parent_session_id,
+        subagentId: row.subagent_id,
+        direction: row.direction === "to_parent" ? "to_parent" : "to_child",
+        operation: row.operation,
+        payload: row.payload,
+        status: row.status,
+        result: row.result,
+        errorCode: row.error_code,
+        error: row.error,
+    };
+}
+const COMMAND_COLUMNS = "id, parent_session_id, subagent_id, direction, operation, payload, status, result, error_code, error";
+export function insertChild(db, parentSessionId, subagentId, revision, record) {
+    const result = db
+        .prepare(`INSERT INTO children (parent_session_id, subagent_id, revision, record)
+			 VALUES (?, ?, ?, ?)
+			 ON CONFLICT DO NOTHING`)
+        .run(parentSessionId, subagentId, revision, record);
+    return Number(result.changes) === 1;
+}
+export function readChild(db, parentSessionId, subagentId) {
+    const row = db
+        .prepare("SELECT revision, record FROM children WHERE parent_session_id = ? AND subagent_id = ?")
+        .get(parentSessionId, subagentId);
+    return row;
+}
+export function listChildRecords(db, parentSessionId) {
+    const rows = db
+        .prepare("SELECT record FROM children WHERE parent_session_id = ? ORDER BY record")
+        .all(parentSessionId);
+    return rows.map((row) => row.record);
+}
+export function replaceChild(db, parentSessionId, subagentId, expectedRevision, revision, record) {
+    const result = expectedRevision === undefined
+        ? db
+            .prepare(`UPDATE children SET revision = ?, record = ?
+						 WHERE parent_session_id = ? AND subagent_id = ?`)
+            .run(revision, record, parentSessionId, subagentId)
+        : db
+            .prepare(`UPDATE children SET revision = ?, record = ?
+						 WHERE parent_session_id = ? AND subagent_id = ? AND revision = ?`)
+            .run(revision, record, parentSessionId, subagentId, expectedRevision);
+    return Number(result.changes) === 1;
+}
+export function readMeta(db, parentSessionId, key) {
+    const row = db
+        .prepare("SELECT value FROM session_meta WHERE parent_session_id = ? AND key = ?")
+        .get(parentSessionId, key);
+    return row?.value;
+}
+export function writeMeta(db, parentSessionId, key, value) {
+    db.prepare(`INSERT INTO session_meta (parent_session_id, key, value) VALUES (?, ?, ?)
+		 ON CONFLICT (parent_session_id, key) DO UPDATE SET value = excluded.value`).run(parentSessionId, key, value);
+}
+export function enqueueCommand(db, command) {
+    db.prepare(`INSERT INTO commands (
+		   id, parent_session_id, subagent_id, direction, operation, payload, status, created_at
+		 ) VALUES (?, ?, ?, ?, ?, ?, 'pending', ?)`).run(command.id, command.parentSessionId, command.subagentId, command.direction, command.operation, command.payload, command.createdAt);
+}
+export function hasPendingCommand(db, parentSessionId, direction, subagentId) {
+    const row = subagentId === undefined
+        ? db
+            .prepare(`SELECT 1 AS hit FROM commands
+						 WHERE parent_session_id = ? AND direction = ? AND status = 'pending'
+						 LIMIT 1`)
+            .get(parentSessionId, direction)
+        : db
+            .prepare(`SELECT 1 AS hit FROM commands
+						 WHERE parent_session_id = ? AND subagent_id = ? AND direction = ? AND status = 'pending'
+						 LIMIT 1`)
+            .get(parentSessionId, subagentId, direction);
+    return row !== undefined;
+}
+export function claimCommand(db, parentSessionId, subagentId, direction) {
+    const row = db
+        .prepare(`UPDATE commands SET status = 'working'
+			 WHERE id = (
+			   SELECT id FROM commands
+			   WHERE parent_session_id = ? AND subagent_id = ? AND direction = ? AND status = 'pending'
+			   ORDER BY created_at
+			   LIMIT 1
+			 )
+			 RETURNING ${COMMAND_COLUMNS}`)
+        .get(parentSessionId, subagentId, direction);
+    return row === undefined ? undefined : commandFromRow(row);
+}
+export function claimParentCommands(db, parentSessionId) {
+    const rows = db
+        .prepare(`UPDATE commands SET status = 'working'
+			 WHERE id IN (
+			   SELECT id FROM commands
+			   WHERE parent_session_id = ? AND direction = 'to_parent' AND status = 'pending'
+			   ORDER BY created_at
+			   LIMIT 20
+			 )
+			 RETURNING ${COMMAND_COLUMNS}`)
+        .all(parentSessionId);
+    return rows.map(commandFromRow);
+}
+export function requeueAbandonedParentCommands(db, parentSessionId) {
+    db.prepare(`UPDATE commands SET status = 'pending'
+		 WHERE parent_session_id = ? AND direction = 'to_parent' AND status = 'working'`).run(parentSessionId);
+}
+export function deleteCommand(db, id) {
+    db.prepare("DELETE FROM commands WHERE id = ?").run(id);
+}
+export function readCommand(db, id) {
+    const row = db.prepare(`SELECT ${COMMAND_COLUMNS} FROM commands WHERE id = ?`).get(id);
+    return row === undefined ? undefined : commandFromRow(row);
+}
+export function finishCommand(db, id, outcome) {
+    if (outcome.status === "done") {
+        db.prepare("UPDATE commands SET status = 'done', result = ? WHERE id = ?").run(outcome.result, id);
+        return;
+    }
+    db.prepare("UPDATE commands SET status = 'failed', error_code = ?, error = ? WHERE id = ?").run(outcome.errorCode, outcome.error, id);
+}
+export function readToken(db, parentSessionId, runtimeIdentity) {
+    const row = db
+        .prepare("SELECT token FROM tokens WHERE parent_session_id = ? AND runtime_identity = ?")
+        .get(parentSessionId, runtimeIdentity);
+    return row?.token;
+}
+export function writeToken(db, parentSessionId, runtimeIdentity, token) {
+    db.prepare(`INSERT INTO tokens (parent_session_id, runtime_identity, token) VALUES (?, ?, ?)
+		 ON CONFLICT (parent_session_id, runtime_identity) DO UPDATE SET token = excluded.token`).run(parentSessionId, runtimeIdentity, token);
+}
+export function deleteToken(db, parentSessionId, runtimeIdentity) {
+    db.prepare("DELETE FROM tokens WHERE parent_session_id = ? AND runtime_identity = ?").run(parentSessionId, runtimeIdentity);
+}

package/dist/state.d.ts

@@ -6,9 +6,17 @@ export interface StateSnapshot {
     readonly activeTool?: string;
     readonly usage: UsageSummary;
 }
+export interface TranscriptFacts {
+    readonly usage: UsageSummary;
+    readonly summary?: string;
+    readonly stopReason?: string;
+    readonly interrupted?: string;
+    readonly containsInput: boolean;
+}
 export interface StateProjector {
     applyEvent(event: unknown): StateSnapshot;
     rebuild(entries: readonly unknown[]): StateSnapshot;
+    applyTranscriptFacts(facts: TranscriptFacts): StateSnapshot;
     /**
      * Puts the projected state back in step with a state the child itself reported. Without it a
      * transcript that still ends in a tool result keeps projecting "running" over a child that has
@@ -19,6 +27,10 @@ export interface StateProjector {
 }
 export declare function summarizeCurrentBranch(entries: readonly unknown[]): string | undefined;
 export declare function aggregateUsage(entries: readonly unknown[]): UsageSummary;
+/** What the parent projects from a session. The transcript itself never crosses the bridge. */
+export declare function transcriptFacts(entries: readonly unknown[], expectedInput?: string): TranscriptFacts;
+/** A mailbox answer is untrusted. Anything that is not these fields is not facts. */
+export declare function parseTranscriptFacts(value: unknown): TranscriptFacts | undefined;
 /** The phase a streaming assistant update is in: what the parent shows as the child's activity. */
 export type AssistantPhaseKind = "thinking" | "generating" | "toolcall";
 export interface AssistantPhase {

package/dist/state.js

@@ -101,6 +101,89 @@ export function aggregateUsage(entries) {
     }
     return total;
 }
+function userText(message) {
+    if (typeof message.content === "string")
+        return message.content;
+    if (!Array.isArray(message.content))
+        return undefined;
+    return message.content
+        .map((part) => {
+        const content = record(part);
+        return content?.type === "text" && typeof content.text === "string" ? content.text : "";
+    })
+        .join("");
+}
+function lastCompletedAssistant(entries) {
+    let last;
+    for (const entry of entries) {
+        const item = assistant(entry);
+        if (item === undefined || !completed(item.message))
+            continue;
+        last = item.message;
+    }
+    return last;
+}
+/** What the parent projects from a session. The transcript itself never crosses the bridge. */
+export function transcriptFacts(entries, expectedInput) {
+    const last = lastCompletedAssistant(entries);
+    const summary = summarizeCurrentBranch(entries);
+    const stopReason = typeof last?.stopReason === "string" ? last.stopReason : undefined;
+    const interrupted = last === undefined ? undefined : diagnostic(last);
+    const containsInput = expectedInput !== undefined &&
+        entries.some((entry) => {
+            const value = record(entry);
+            const message = record(value?.message);
+            return message?.role === "user" && userText(message) === expectedInput;
+        });
+    return {
+        usage: aggregateUsage(entries),
+        ...(summary === undefined ? {} : { summary }),
+        ...(stopReason === undefined ? {} : { stopReason }),
+        ...(interrupted === undefined ? {} : { interrupted }),
+        containsInput,
+    };
+}
+function usageNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+/** A mailbox answer is untrusted. Anything that is not these fields is not facts. */
+export function parseTranscriptFacts(value) {
+    if (!isRecord(value) || typeof value.containsInput !== "boolean" || !isRecord(value.usage)) {
+        return undefined;
+    }
+    const usage = value.usage;
+    const inputTokens = usageNumber(usage.inputTokens);
+    const outputTokens = usageNumber(usage.outputTokens);
+    const cacheReadTokens = usageNumber(usage.cacheReadTokens);
+    const cacheWriteTokens = usageNumber(usage.cacheWriteTokens);
+    const turns = usageNumber(usage.turns);
+    const costUsd = usage.costUsd === null ? null : usageNumber(usage.costUsd);
+    if (inputTokens === undefined ||
+        outputTokens === undefined ||
+        cacheReadTokens === undefined ||
+        cacheWriteTokens === undefined ||
+        turns === undefined ||
+        costUsd === undefined) {
+        return undefined;
+    }
+    const summary = typeof value.summary === "string" ? value.summary : undefined;
+    const stopReason = typeof value.stopReason === "string" ? value.stopReason : undefined;
+    const interrupted = typeof value.interrupted === "string" ? value.interrupted : undefined;
+    return {
+        usage: {
+            inputTokens,
+            outputTokens,
+            cacheReadTokens,
+            cacheWriteTokens,
+            costUsd,
+            turns,
+        },
+        ...(summary === undefined ? {} : { summary }),
+        ...(stopReason === undefined ? {} : { stopReason }),
+        ...(interrupted === undefined ? {} : { interrupted }),
+        containsInput: value.containsInput,
+    };
+}
 /**
  * Categorizes a streaming assistant update into the phase the parent projects. The child throttles
  * duplicate deltas with the same answer, so both ends of the bridge agree on what "still thinking"
@@ -143,6 +226,17 @@ export function createStateProjector(initialState = "running") {
         ...(activeTool === undefined ? {} : { activeTool }),
         usage,
     });
+    const applyFacts = (facts) => {
+        activeTool = undefined;
+        summary = facts.summary;
+        usage = facts.usage;
+        interrupted = facts.interrupted;
+        if (facts.stopReason === "error")
+            state = "error";
+        else if (facts.stopReason !== undefined && state === "error")
+            state = "done";
+        return snapshot();
+    };
     return {
         applyEvent(event) {
             const value = record(event);
@@ -207,6 +301,15 @@ export function createStateProjector(initialState = "running") {
                     }
                 }
             }
+            else if (value.type === "compaction_start") {
+                summary = "compacting...";
+                activeTool = undefined;
+            }
+            else if (value.type === "compaction_end") {
+                if (summary === "compacting...") {
+                    summary = undefined;
+                }
+            }
             else if (value.type === "error") {
                 state = "error";
                 interrupted =
@@ -215,27 +318,10 @@ export function createStateProjector(initialState = "running") {
             return snapshot();
         },
         rebuild(entries) {
-            activeTool = undefined;
-            summary = summarizeCurrentBranch(entries);
-            usage = aggregateUsage(entries);
-            let lastAssistant;
-            for (const entry of entries) {
-                const item = assistant(entry);
-                if (item === undefined || !completed(item.message))
-                    continue;
-                lastAssistant = item.message;
-            }
-            if (lastAssistant !== undefined) {
-                interrupted = diagnostic(lastAssistant);
-                if (lastAssistant.stopReason === "error")
-                    state = "error";
-                else if (state === "error")
-                    state = "done";
-            }
-            else {
-                interrupted = undefined;
-            }
-            return snapshot();
+            return applyFacts(transcriptFacts(entries));
+        },
+        applyTranscriptFacts(facts) {
+            return applyFacts(facts);
         },
         syncState(next) {
             state = next;

package/dist/tool-presentation.d.ts

@@ -1,9 +1,4 @@
 import type { ExtensionAPI, ToolRenderers } from "@earendil-works/pi-coding-agent";
-/**
- * Owned presentations for the four parent-facing subagent tools. The native renderers keep the
- * model-visible text and raw errors when pi-ext-ui is absent; a loaded pi-ext-ui wraps the same
- * presentation through the ext-core provider registry, so both paths share one semantic source.
- */
 export interface AgentSpawnDetails {
     readonly id: string;
     readonly path: string;
@@ -15,3 +10,5 @@ export declare function parentToolRenderers(pi: ExtensionAPI): {
     readonly get: ToolRenderers;
     readonly stop: ToolRenderers;
 };
+/** The child's blocker report names the reason in the header and keeps the full message readable. */
+export declare function contactParentRenderers(pi: ExtensionAPI): ToolRenderers;

package/dist/tool-presentation.js

@@ -1,4 +1,15 @@
-import { agentResultText, createToolPresentationRenderers, isRecord, } from "@hheei/pi-ext-core";
+import { agentResultText, createOptionalToolRenderers, createToolPresentationRenderers, isRecord, } from "@hheei/pi-ext-core";
+/**
+ * Owned presentations for every subagent tool. Each definition ships its own native renderers, so a
+ * session without pi-ext-ui still shows the tool title, full request, model-visible text and raw
+ * errors; when the UI is loaded it decorates those same native renderers through ext-core's
+ * optional-renderer point and reads the same ToolPresentation, so both paths share one semantic
+ * source. This package never depends on pi-ext-ui.
+ */
+/** Native presentation renderers, then the optional UI frame over them. */
+function ownedRenderers(pi, name, present) {
+    return createOptionalToolRenderers(pi, name, createToolPresentationRenderers(pi, name, present));
+}
 function stringField(source, key) {
     const value = source?.[key];
     return typeof value === "string" && value.trim() !== "" ? value : undefined;
@@ -149,12 +160,34 @@ function stopPresentation(args, result) {
         ...(confirmation === undefined ? {} : { copy: { primary: confirmation } }),
     };
 }
+function contactPresentation(args, result) {
+    const record = isRecord(args) ? args : undefined;
+    const reason = stringField(record, "reason") ?? "blocked";
+    const message = stringField(record, "message");
+    const confirmation = result === undefined ? undefined : agentResultText(result);
+    const copy = message === undefined
+        ? undefined
+        : {
+            primary: message,
+            ...(confirmation === undefined ? {} : { full: `${message}\n${confirmation}` }),
+        };
+    return {
+        summary: reason,
+        ...(message === undefined ? {} : { request: message }),
+        ...(confirmation === undefined ? {} : { output: confirmation }),
+        ...(copy === undefined ? {} : { copy }),
+    };
+}
 /** One renderer set per tool, named exactly after its tool so nested calls resolve too. */
 export function parentToolRenderers(pi) {
     return {
-        spawn: createToolPresentationRenderers(pi, "agent_spawn", spawnPresentation),
-        send: createToolPresentationRenderers(pi, "agent_send", sendPresentation),
-        get: createToolPresentationRenderers(pi, "agent_get", getPresentation),
-        stop: createToolPresentationRenderers(pi, "agent_stop", stopPresentation),
+        spawn: ownedRenderers(pi, "agent_spawn", spawnPresentation),
+        send: ownedRenderers(pi, "agent_send", sendPresentation),
+        get: ownedRenderers(pi, "agent_get", getPresentation),
+        stop: ownedRenderers(pi, "agent_stop", stopPresentation),
     };
 }
+/** The child's blocker report names the reason in the header and keeps the full message readable. */
+export function contactParentRenderers(pi) {
+    return ownedRenderers(pi, "contact_parent", contactPresentation);
+}

package/dist/tools.js

@@ -2,7 +2,7 @@ import { textToolResult } from "@hheei/pi-ext-core";
 import { Type } from "typebox";
 import { Value } from "typebox/value";
 import { isOperationError } from "./domain.js";
-import { parentToolRenderers } from "./tool-presentation.js";
+import { contactParentRenderers, parentToolRenderers, } from "./tool-presentation.js";
 const spawnSchema = Type.Object({
     task: Type.String({ minLength: 1 }),
     agent: Type.String({
@@ -66,7 +66,7 @@ function getSpawnDescription(agents) {
         formatAvailableAgents(agents),
     ].join("\n");
 }
-const SEND_DESCRIPTION = "Send input, steer, or follow-up instructions to an existing subagent (e.g. 'agent-1'), resuming its session when it is idle, blocked, done, or errored. Results are returned automatically when the task finishes; do not poll agent_get. Related subagent tools: agent_spawn, agent_get, agent_stop.";
+const SEND_DESCRIPTION = "Send input, steer, or follow-up instructions to an existing subagent (e.g. 'agent-1'), resuming its session when it is idle, blocked, done, or errored. A child whose runtime has ended is resumed the same way: send to that id, do not spawn a replacement. Stop it first only when send reports the previous process is still running. Results are returned automatically when the task finishes; do not poll agent_get. Related subagent tools: agent_spawn, agent_get, agent_stop.";
 const GET_DESCRIPTION = "Inspect one subagent's status, progress, or diagnostic details by id (e.g. 'agent-1'). Use keys to choose fields; defaults to 'status,progress'. Results are returned automatically; use this for inspection, not completion polling. Related subagent tools: agent_spawn, agent_send, agent_stop.";
 const STOP_DESCRIPTION = "Stop a subagent's runtime by id (e.g. 'agent-1'). The child keeps its session, so a later agent_send can resume it. Related subagent tools: agent_spawn, agent_send, agent_get.";
 const CONTACT_DESCRIPTION = "Notify the parent session when you are BLOCKED and cannot continue without parent decision or intervention. Do NOT call this on success or task completion: simply output your final answer directly as normal text in your response, and the harness will automatically capture and report your result to the parent.";
@@ -247,6 +247,7 @@ export function registerChildTools(pi, identity, options) {
                 ? "Error report delivered to the parent."
                 : "Blocker report queued for the parent.", undefined);
         },
+        ...contactParentRenderers(pi),
     };
     pi.registerTool(tool);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hheei/pi-subagents",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Independent background Pi subagent sessions with durable identity and RPC control.",
   "type": "module",
   "main": "dist/index.js",
@@ -35,16 +35,16 @@
     "access": "public"
   },
   "dependencies": {
-    "@hheei/pi-ext-core": "^0.3.0"
+    "@hheei/pi-ext-core": "^0.5.0"
   },
   "peerDependencies": {
-    "@earendil-works/pi-coding-agent": ">=1.2.0",
-    "@earendil-works/pi-tui": ">=1.2.0",
+    "@earendil-works/pi-coding-agent": ">=1.3.0",
+    "@earendil-works/pi-tui": ">=1.3.0",
     "typebox": "*"
   },
   "devDependencies": {
-    "@earendil-works/pi-coding-agent": "1.2.0",
-    "@earendil-works/pi-tui": "1.2.0"
+    "@earendil-works/pi-coding-agent": "1.3.0",
+    "@earendil-works/pi-tui": "1.3.0"
   },
   "scripts": {
     "build": "node -e \"import { rmSync } from 'node:fs'; rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json"

package/dist/bridge-client.d.ts

@@ -1,60 +0,0 @@
-import { type ChildIdentity } from "./domain.js";
-import { type ChildInputSource } from "./protocol.js";
-export interface ChildBridgeRequest {
-    readonly operation: string;
-    readonly payload: unknown;
-}
-export interface ChildBridgeClientOptions {
-    /** The parent's bridge socket. */
-    readonly endpoint: string;
-    readonly identity: ChildIdentity;
-    /** Executes a parent request; a thrown error becomes a failure response. */
-    readonly handleRequest: (request: ChildBridgeRequest) => Promise<unknown>;
-    /**
-     * Called after every successful handshake, including the first. A reconnecting child uses it to
-     * resend whatever state the parent needs to stay synchronized.
-     */
-    readonly onConnect?: () => void;
-    readonly reconnectDelayMs?: number;
-    readonly maxBufferedReports?: number;
-    readonly maxFrameBytes?: number;
-    readonly connectTimeoutMs?: number;
-    readonly reportTimeoutMs?: number;
-    readonly diagnose?: (message: string) => void;
-}
-/**
- * The child side of the bridge: one long-lived connection to the parent, carrying both directions
- * of control.
- *
- * The child therefore never owns its own lifecycle endpoint: it dials the parent, keeps dialing
- * while the parent is away, and reconnects with the same identity when the parent comes back (a
- * parent restart re-listens the same socket path). Reports the parent has not accepted yet are
- * buffered here, bounded, and flushed in order after a reconnect, so a report is never silently
- * lost just because the parent was momentarily gone. Pi events are advisory snapshots and are
- * dropped instead of buffered.
- */
-export declare class ChildBridgeClient {
-    #private;
-    constructor(options: ChildBridgeClientOptions);
-    get connected(): boolean;
-    /**
-     * Starts the connect loop. It keeps retrying on its own: a panel child outlives the parent
-     * process that started it, so being unable to reach the parent is a state to wait out, not a
-     * failure to give up on. Call `close()` to stop it.
-     */
-    start(): void;
-    /** Sends an advisory frame: Pi events and child lifecycle signals. */
-    sendEvent(event: unknown): void;
-    /**
-     * Tells the parent that input arrived, with its source and nothing else. The parent uses this
-     * to cancel an idle countdown, so the text of a human message stays inside the child.
-     */
-    sendChildInput(source: ChildInputSource): void;
-    /**
-     * Reports to the parent, waiting for its answer. While the parent is unreachable the report is
-     * buffered instead of failed, and delivered after the reconnect.
-     */
-    sendReport(operation: string, payload: unknown, signal?: AbortSignal): Promise<unknown>;
-    /** Stops reconnecting and fails everything still waiting for the parent. */
-    close(): void;
-}