@kingcrab/pi-imessage 0.0.43 → 1.0.0

package/dist/agent/deliver.js

@@ -0,0 +1,139 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { AssistantEntry, } from "@earendil-works/pi-durable";
+import { finalReplyText } from "../extensions/final-text.js";
+import { Chats } from "./chats.js";
+import { DirectSends } from "./direct-send.js";
+import { Deliveries } from "./replies.js";
+import { RUN_RECORD, Runs, runRecord } from "./run.js";
+async function targets(harness) {
+    const chats = (await harness.snapshot(Chats, BACKGROUND_CONTEXT))?.items ?? [];
+    const runs = (await harness.snapshot(Runs, BACKGROUND_CONTEXT))?.items ?? [];
+    return [
+        ...chats,
+        ...runs.map((run) => ({
+            conversationId: run.conversationId,
+            chatGuid: run.chatGuid,
+            chat: run.chat,
+            label: "/run reply",
+        })),
+    ];
+}
+export async function recoverSending(harness) {
+    const directUnknown = await harness.commit(async (tx) => {
+        const sends = await tx.doc(DirectSends);
+        const changed = [];
+        for (const receipt of sends.requests) {
+            for (const part of ["textStatus", "fileStatus"]) {
+                if (receipt[part] !== "sending")
+                    continue;
+                receipt[part] = "unknown";
+                changed.push({ chatGuid: receipt.chatGuid, requestId: receipt.requestId, part });
+            }
+        }
+        return changed;
+    }, BACKGROUND_CONTEXT);
+    for (const { chatGuid, requestId, part } of directUnknown)
+        console.warn("Direct delivery unknown", chatGuid, requestId, part);
+    for (const { conversationId } of await targets(harness)) {
+        const unknown = await harness.commit(async (tx) => {
+            const deliveries = await tx.doc(Deliveries, conversationId);
+            const changed = [];
+            for (const [answerId, status] of Object.entries(deliveries.answers)) {
+                if (status === "sending") {
+                    deliveries.answers[answerId] = "unknown";
+                    changed.push(answerId);
+                }
+            }
+            return changed;
+        }, BACKGROUND_CONTEXT);
+        for (const answerId of unknown)
+            console.warn("Reply delivery unknown", conversationId, answerId);
+    }
+}
+/** Returns false when the answer must wait for an earlier in-flight send. */
+async function deliverAnswer(harness, storage, target, answerId, send) {
+    const { conversationId } = target;
+    const claim = await harness.commit(async (tx) => {
+        const entry = await tx.entry(AssistantEntry, answerId);
+        const text = finalReplyText(entry?.model?.[0]);
+        const deliveries = await tx.doc(Deliveries, conversationId);
+        const key = String(answerId);
+        const decided = () => {
+            if (deliveries.scanned === undefined || deliveries.scanned < answerId)
+                deliveries.scanned = answerId;
+            return true;
+        };
+        if (!text || deliveries.answers[key] || deliveries.drafts?.[key])
+            return { decided: decided() };
+        // The owning Session serializes admission with this claim. Read committed native submissions,
+        // not arbitrary user entries: passive logs and /run continuation text are not new human input.
+        let intervening = false;
+        let cursor;
+        do {
+            const page = await storage.scanSubmissions({ conversationId }, 100, cursor, BACKGROUND_CONTEXT);
+            intervening = page.items.some((input) => input.type === "input" &&
+                (input.status === "queued" || (input.entry !== undefined && input.entry > answerId)));
+            cursor = page.next;
+        } while (cursor && !intervening);
+        if (intervening) {
+            deliveries.drafts ??= {};
+            deliveries.drafts[key] = { status: "held", reason: "newer_input" };
+            return { decided: decided() };
+        }
+        // Do not overtake an earlier in-flight send in this chat.
+        if (Object.values(deliveries.answers).includes("sending"))
+            return { decided: false };
+        // Finals are claimed in order, so the only earlier unsent ones are held drafts; this answer replaces them.
+        const drafts = deliveries.drafts ?? {};
+        for (const [previous, draft] of Object.entries(drafts))
+            if (draft.status === "held" && Number(previous) < answerId)
+                drafts[previous] = { status: "superseded", replacement: answerId };
+        deliveries.answers[key] = "sending";
+        return { decided: decided(), text };
+    }, BACKGROUND_CONTEXT);
+    if (!claim.text)
+        return claim.decided;
+    let status = "sent";
+    try {
+        await send(target.chatGuid, claim.text);
+    }
+    catch {
+        // A throwing transport may already have sent. Never retry it automatically.
+        status = "unknown";
+    }
+    await harness.commit(async (tx) => {
+        (await tx.doc(Deliveries, conversationId)).answers[String(answerId)] = status;
+    }, BACKGROUND_CONTEXT);
+    if (status === "unknown")
+        console.warn("Reply delivery unknown", conversationId, String(answerId));
+    if (target.chat !== undefined) {
+        // A queued write never splits a turn that is running in the chat conversation.
+        const chat = await harness.conversation(target.chat, BACKGROUND_CONTEXT);
+        await chat?.submit({
+            type: "write",
+            requestId: `${RUN_RECORD}:${answerId}`,
+            entry: runRecord(`[${target.label}, ${status}]\n${claim.text}`, Date.now()),
+        }, BACKGROUND_CONTEXT);
+    }
+    return true;
+}
+/** Sends committed final answers in order, including those a /run writes between continuations. */
+export async function deliverReplies(harness, storage, send, enabled) {
+    for (const target of await targets(harness)) {
+        if (!enabled(target.chatGuid))
+            continue;
+        const scanned = (await harness.snapshot(Deliveries, target.conversationId, BACKGROUND_CONTEXT))?.scanned;
+        const answers = [];
+        let cursor;
+        do {
+            const page = await storage.scanEntries({ conversationId: target.conversationId, ...(scanned === undefined ? {} : { minEntryId: scanned }) }, 100, cursor, BACKGROUND_CONTEXT);
+            for (const entry of page.items)
+                if (AssistantEntry.is(entry) && finalReplyText(entry.model?.[0]))
+                    answers.push(entry.id);
+            cursor = page.next;
+        } while (cursor);
+        for (const answerId of answers.reverse())
+            if (!(await deliverAnswer(harness, storage, target, answerId, send)))
+                break;
+    }
+}

package/dist/agent/direct-send.js

@@ -0,0 +1,68 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { defineDoc } from "@earendil-works/pi-durable";
+/** Receipts only: no background worker or automatic retry of explicit sends. */
+export const DirectSends = defineDoc({
+    kind: "imessage.direct-sends",
+    version: 1,
+    scope: "session",
+    initial: () => ({ requests: [] }),
+});
+export async function deliverDirect(harness, input, sender) {
+    const { chatGuid, requestId } = input;
+    const text = input.text || null;
+    const filePath = input.filePath || null;
+    if (!chatGuid.trim() || !requestId.trim() || (!text && !filePath))
+        throw new Error("Chat GUID, request ID and text or file path are required");
+    const accepted = await harness.commit(async (tx) => {
+        const sends = await tx.doc(DirectSends);
+        const existing = sends.requests.find((send) => send.chatGuid === chatGuid && send.requestId === requestId);
+        if (existing) {
+            if (existing.text !== text || existing.filePath !== filePath)
+                throw new Error("Send request ID was already used with different content");
+            return { claimed: false, receipt: { ...existing } };
+        }
+        const receipt = {
+            chatGuid,
+            requestId,
+            text,
+            filePath,
+            textStatus: text ? "not_attempted" : null,
+            fileStatus: filePath ? "not_attempted" : null,
+        };
+        sends.requests.push(receipt);
+        return { claimed: true, receipt: { ...receipt } };
+    }, BACKGROUND_CONTEXT);
+    if (!accepted.claimed)
+        return accepted.receipt;
+    let receipt = accepted.receipt;
+    async function setStatus(part, status) {
+        receipt = await harness.commit(async (tx) => {
+            const sends = await tx.doc(DirectSends);
+            const record = sends.requests.find((send) => send.chatGuid === chatGuid && send.requestId === requestId);
+            if (!record)
+                throw new Error("Direct send receipt is missing");
+            record[part] = status;
+            return { ...record };
+        }, BACKGROUND_CONTEXT);
+    }
+    async function attempt(part, send) {
+        await setStatus(part, "sending");
+        let status = "sent";
+        try {
+            await send();
+        }
+        catch {
+            status = "unknown";
+        }
+        await setStatus(part, status);
+        if (status === "unknown")
+            console.warn("Direct delivery unknown", chatGuid, requestId, part);
+        return status;
+    }
+    // Explicit sends are plain text, independent of automatic reply settings.
+    if (text && (await attempt("textStatus", () => sender.sendMessage(chatGuid, text))) !== "sent")
+        return receipt;
+    if (filePath)
+        await attempt("fileStatus", () => sender.sendAttachment(chatGuid, filePath));
+    return receipt;
+}

package/dist/agent/harness.js

@@ -0,0 +1,79 @@
+import { mkdir, open, unlink } from "node:fs/promises";
+import { join } from "node:path";
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { createRegistry, Harness } from "@earendil-works/pi-durable";
+import { NodeExecutionEnv } from "@earendil-works/pi-durable/env/node";
+import { openNodeJsonlStorage } from "@earendil-works/pi-durable/storage/jsonl/node";
+import { chatBehavior } from "./behavior.js";
+import { RunExtension } from "./run.js";
+export async function openHarness(workingDir, models, extensions, policy) {
+    const directory = join(workingDir, "durable");
+    await mkdir(directory, { recursive: true });
+    const lockPath = join(directory, "owner.lock");
+    // Never steal a lock: after an unclean exit the operator must confirm its owner is dead.
+    const lock = await open(lockPath, "wx");
+    try {
+        await lock.writeFile(`${process.pid}\n`);
+        const storage = await openNodeJsonlStorage(directory, BACKGROUND_CONTEXT, { fsync: true });
+        try {
+            const registry = createRegistry();
+            registry.install(chatBehavior(storage));
+            registry.install(RunExtension);
+            for (const extension of extensions) {
+                if (registry.snapshot().extension(extension.name))
+                    throw new Error(`Duplicate extension name: ${extension.name}`);
+                registry.install(extension);
+            }
+            const env = new NodeExecutionEnv({ cwd: workingDir });
+            const harness = await Harness.open(storage, 
+            // Large Codex contexts exceed WebSocket frame limits; force SSE.
+            {
+                models,
+                registry,
+                env: () => env,
+                // Consume all admitted corrections at the next native boundary, not one per turn.
+                settings: {
+                    get stream() {
+                        return { ...policy.stream, transport: "sse" };
+                    },
+                    get retry() {
+                        return policy.retry;
+                    },
+                    steeringMode: "all",
+                    // Only run conversations select the run extension; reread so reinstalls apply.
+                    get extensions() {
+                        return registry
+                            .snapshot()
+                            .installed()
+                            .filter((extension) => extension.name !== RunExtension.name);
+                    },
+                },
+            }, BACKGROUND_CONTEXT);
+            let closing;
+            return {
+                harness,
+                storage,
+                registry,
+                close(beforeUnlock) {
+                    closing ??= (async () => {
+                        await harness.close(BACKGROUND_CONTEXT);
+                        // External browser resources must be closed before another owner can resume this workspace.
+                        await beforeUnlock?.();
+                        await lock.close();
+                        await unlink(lockPath);
+                    })();
+                    return closing;
+                },
+            };
+        }
+        catch (error) {
+            await storage.close(BACKGROUND_CONTEXT);
+            throw error;
+        }
+    }
+    catch (error) {
+        await lock.close();
+        await unlink(lockPath);
+        throw error;
+    }
+}

package/dist/agent/health.js

@@ -0,0 +1,32 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { configure, defineDoc } from "@earendil-works/pi-durable";
+/** Retained metadata for read-only inspection of historical isolated conversations. */
+export const Sessions = defineDoc({
+    kind: "imessage.sessions",
+    version: 1,
+    scope: "session",
+    initial: () => ({ items: [] }),
+});
+/** Explicit health checks reuse one tool-less conversation and never deliver to a chat. */
+export async function submitHealth(harness, defaults) {
+    const key = JSON.stringify(["health", "model-health"]);
+    const id = await harness.commit(async (tx) => {
+        const sessions = await tx.doc(Sessions);
+        const found = sessions.items.find((item) => item.key === key);
+        const id = found?.conversationId ?? (await tx.createConversation({ ownership: { kind: "ownerless" } })).id;
+        await configure(tx, id, { ...defaults, tools: [], instructions: "Reply OK. Do not use tools." });
+        if (!found)
+            sessions.items.push({
+                key,
+                label: "model-health",
+                conversationId: id,
+                chatGuid: "health",
+                deliver: false,
+            });
+        return id;
+    }, BACKGROUND_CONTEXT);
+    const conversation = await harness.conversation(id, BACKGROUND_CONTEXT);
+    if (!conversation)
+        throw new Error("Model health conversation missing");
+    return conversation.submit({ type: "input", content: "Reply OK.", requestId: crypto.randomUUID(), whenBusy: "followUp" }, BACKGROUND_CONTEXT);
+}

package/dist/agent/models.js

@@ -0,0 +1,69 @@
+import { join } from "node:path";
+import { ModelRuntime, SettingsManager } from "@earendil-works/pi-coding-agent";
+export function openModels(agentDir) {
+    return ModelRuntime.create({
+        authPath: join(agentDir, "auth.json"),
+        modelsPath: join(agentDir, "models.json"),
+    });
+}
+/** Read defaults and use only an explicitly configured, available fallback. */
+export async function readDefaults(runtime, workingDir, agentDir, policy = {}) {
+    const settings = SettingsManager.create(workingDir, agentDir);
+    const provider = settings.getDefaultProvider();
+    const modelId = settings.getDefaultModel();
+    const thinkingLevel = settings.getDefaultThinkingLevel();
+    await runtime.refresh();
+    if (provider && modelId && runtime.getModel(provider, modelId) && runtime.hasConfiguredAuth(provider))
+        return { model: { provider, modelId }, thinkingLevel };
+    const fallback = policy.fallback;
+    if (!fallback ||
+        !runtime.getModel(fallback.provider, fallback.modelId) ||
+        !runtime.hasConfiguredAuth(fallback.provider))
+        throw new Error(`Default model ${provider}/${modelId} is unavailable; no available configured fallback`);
+    console.warn(`Default model ${provider}/${modelId} unavailable; using ${fallback.provider}/${fallback.modelId}`);
+    return { model: { ...fallback }, thinkingLevel };
+}
+/** Match Pi's experimental Durable request policy; execution and retries remain native. */
+export function requestSettings(settings) {
+    return {
+        get stream() {
+            const provider = settings.getProviderRetrySettings();
+            const idle = settings.getHttpIdleTimeoutMs();
+            return {
+                timeoutMs: provider.timeoutMs ?? (idle === 0 ? 2_147_483_647 : idle),
+                maxRetryDelayMs: provider.maxRetryDelayMs,
+                ...(provider.maxRetries === undefined ? {} : { maxRetries: provider.maxRetries }),
+            };
+        },
+        get retry() {
+            return settings.getRetrySettings();
+        },
+    };
+}
+/** A live configuration getter applies tier changes to subsequent requests only. */
+export function withModelPolicy(models, policy) {
+    return new Proxy(models, {
+        get(target, key) {
+            if (key === "streamSimple") {
+                const streamSimple = (model, context, options) => {
+                    const tier = policy().codexServiceTier;
+                    if (!tier || model.provider !== "openai-codex" || !/^gpt-/.test(model.id))
+                        return target.streamSimple(model, context, options);
+                    const configured = {
+                        ...options,
+                        async onPayload(payload, payloadModel) {
+                            const current = (await options?.onPayload?.(payload, payloadModel)) ?? payload;
+                            if (typeof current !== "object" || current === null || Array.isArray(current))
+                                return current;
+                            return { ...current, service_tier: tier };
+                        },
+                    };
+                    return target.streamSimple(model, context, configured);
+                };
+                return streamSimple;
+            }
+            const value = Reflect.get(target, key, target);
+            return typeof value === "function" ? value.bind(target) : value;
+        },
+    });
+}

package/dist/agent/progress-format.js

@@ -0,0 +1,87 @@
+/** The plain-text adapter; apps can render the same fields without parsing this text. */
+export function formatProgress(event) {
+    const prefix = event.parents.length ? `${event.parents.join("/")}/` : "";
+    const header = `[${prefix}${event.type}]`;
+    if (event.phase === "response") {
+        return `${event.success ? "✓" : "×"} ${header} ${event.name} (${(event.elapsedMs / 1000).toFixed(1)}s)`;
+    }
+    const summary = event.type === "tool" ? (event.name === "bash" ? event.commandPreview : event.summary) : undefined;
+    return `→ ${header} ${event.name}${summary ? `: ${summary}` : ""}`;
+}
+/** Screen the whole command before showing a bounded, non-clickable preview. */
+export function commandPreview(command) {
+    if (typeof command !== "string")
+        return "[command hidden]";
+    // Match a complete shell word, including concatenated quotes and escaped spaces.
+    const word = String.raw `(?:"(?:\\[\s\S]|[^"\\])*(?:"|$)|'[^']*(?:'|$)|\$\([\s\S]*\)|\x60(?:\\[\s\S]|[^\x60\\])*\x60|\\[\s\S]|[^\s;|&<>"'\\\x60])+`;
+    const key = String.raw `[\w.-]*(?:secret|token|password|passwd|credential|authorization|api[._-]?key|private[._-]?key|bearer)[\w.-]*`;
+    let maskNext = false;
+    const screened = command
+        .replace(/\\\r?\n/g, "")
+        .replace(/-----BEGIN[^\r\n]*PRIVATE KEY-----[\s\S]*?(?:-----END[^\r\n]*PRIVATE KEY-----|$)/g, "***")
+        .replace(/\b(?:sk-[a-z0-9_-]+|gh[pousr]_[a-z0-9_]+|github_pat_[a-z0-9_]+)\b/gi, "***")
+        .replace(/(https?:\/\/)[^\s/<>]+@/gi, "$1***@")
+        .replace(new RegExp(word, "g"), (argument) => {
+        if (maskNext) {
+            maskNext = false;
+            return "***";
+        }
+        const option = argument.replace(/["']/g, "");
+        if (new RegExp(`^(?:--${key}|--user|-u|bearer)$`, "i").test(option)) {
+            maskNext = true;
+            return argument;
+        }
+        // Headers can concatenate quoted/unquoted fragments in one shell word.
+        if (/\b(?:proxy-)?authorization\s*:/i.test(argument)) {
+            const quote = /^["']/.test(argument) && argument.at(-1) === argument[0] ? argument[0] : "";
+            return argument.replace(/(\b(?:proxy-)?authorization\s*:\s*)[\s\S]*/i, "$1***") + quote;
+        }
+        // Escaped JSON is an opaque shell argument; don't expose partial values.
+        if (new RegExp(String.raw `\\["']${key}\\["']\s*:`, "i").test(argument))
+            return "***";
+        return argument
+            .replace(new RegExp(String.raw `(["']${key}["']\s*:\s*)("(?:\\[\s\S]|[^"\\])*"|'[^']*'|[^\s,}\]]+)`, "gi"), (_match, prefix, value) => `${prefix}${/^["']/.test(value) ? `${value[0]}***${value[0]}` : "***"}`)
+            .replace(new RegExp(String.raw `((?:\b${key}|--user)\s*[=:]\s*)[\s\S]*`, "gi"), "$1***")
+            .replace(/(\bbearer\s+)[\s\S]*/gi, "$1***");
+    })
+        .replace(/\s+/g, " ")
+        .trim()
+        .replace(/https?:\/\/[^\s"'`<>]+/gi, (url) => url.replaceAll(":", "：").replaceAll("/", "／").replaceAll(".", "．"))
+        .replace(/\b(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+(?:com|org|net|cn|io|dev|app|co|edu|gov|uk|us)\b/gi, (host) => host.replaceAll(".", "．"));
+    const characters = Array.from(screened);
+    return characters.length > 120 ? `${characters.slice(0, 119).join("")}…` : screened;
+}
+/** Argument previews for non-bash tools; bash requests show only `commandPreview`. */
+export function argumentSummary(arguments_) {
+    return Object.entries(arguments_)
+        .filter(([key]) => key !== "timeout")
+        .map(([key, value]) => {
+        if (/secret|token|password|credential|authorization|api.?key/i.test(key))
+            return `${key}=[redacted]`;
+        if (typeof value === "number" || typeof value === "boolean")
+            return `${key}=${value}`;
+        if (typeof value === "string") {
+            if (["path", "filePath", "cwd", "query"].includes(key)) {
+                if (/secret|token|password|credential|authorization|api.?key|sk-[a-z0-9]|gh[pousr]_|github_pat_|bearer\s|https?:\/\/\S+@/i.test(value))
+                    return `${key}=[redacted]`;
+                return `${key}=${value
+                    .replace(/https?:\/\/\S+/gi, "[link omitted]")
+                    .replace(/[\r\n\t]/g, " ")
+                    .slice(0, 160)}`;
+            }
+            if (key === "url") {
+                try {
+                    const url = new URL(value);
+                    return `${key}=${url.hostname.replaceAll(".", "．")}`;
+                }
+                catch {
+                    return `${key}=[${value.length} chars]`;
+                }
+            }
+            return `${key}=[${value.length} chars]`;
+        }
+        return `${key}=[${Array.isArray(value) ? `${value.length} items` : "object"}]`;
+    })
+        .join(", ")
+        .slice(0, 400);
+}

package/dist/agent/progress.js

@@ -0,0 +1,135 @@
+import { BACKGROUND_CONTEXT } from "@earendil-works/chord/context";
+import { isReplyEnabled, readSettings } from "../config/settings.js";
+import { Chats } from "./chats.js";
+import { takeScheduledCompaction } from "./compaction.js";
+import { deliverDirect } from "./direct-send.js";
+import { argumentSummary, commandPreview, formatProgress } from "./progress-format.js";
+import { Runs } from "./run.js";
+async function calledTool(harness, task) {
+    if (task.kind !== "pi.tool")
+        return;
+    // The registered native task owns this input shape and its branded assistant ID.
+    const input = task.input;
+    const entry = await harness.commit((tx) => tx.entry(input.assistant), BACKGROUND_CONTEXT);
+    const message = entry?.model?.[0];
+    if (message?.role !== "assistant")
+        return;
+    const call = message.content.find((part) => part.type === "toolCall" && part.id === input.callId);
+    return call?.type === "toolCall" ? call : undefined;
+}
+/** Observe native admission and settlement; Durable owns execution and recovery. */
+export async function startProgress(harness, workingDir, sender) {
+    // Existing live work belongs to the previous startup; do not replay historical progress.
+    const seen = new Set((await harness.inspect(BACKGROUND_CONTEXT)).tasks.map(({ record }) => record.id));
+    const active = new Map();
+    let pending = Promise.resolve();
+    async function notify(task, notice) {
+        if (task.kind === "pi.compaction" && (await takeScheduledCompaction(harness, task.id)))
+            return;
+        const settings = await readSettings(workingDir);
+        if (!settings.progressMessages)
+            return;
+        const chats = (await harness.snapshot(Chats, BACKGROUND_CONTEXT))?.items ?? [];
+        const runs = (await harness.snapshot(Runs, BACKGROUND_CONTEXT))?.items ?? [];
+        let conversationId = task.conversationId;
+        let chatGuid;
+        const parents = [];
+        while (!chatGuid) {
+            chatGuid = [...chats, ...runs].find((item) => item.conversationId === conversationId)?.chatGuid;
+            if (chatGuid)
+                break;
+            const conversation = await harness.commit((tx) => tx.conversation(conversationId), BACKGROUND_CONTEXT);
+            if (!conversation?.owner)
+                return; // Health and unrelated ownerless conversations stay local.
+            const owner = await harness.getTask(conversation.owner.taskId, BACKGROUND_CONTEXT);
+            const call = owner && (await calledTool(harness, owner));
+            parents.unshift(call?.name ?? owner?.kind ?? "child");
+            conversationId = conversation.owner.conversationId;
+        }
+        if (!isReplyEnabled(settings, chatGuid))
+            return;
+        const tool = await calledTool(harness, task);
+        const request = tool
+            ? {
+                phase: "request",
+                type: "tool",
+                parents,
+                name: tool.name,
+                ...(tool.name === "bash"
+                    ? { commandPreview: commandPreview(tool.arguments.command) }
+                    : { summary: argumentSummary(tool.arguments) }),
+            }
+            : { phase: "request", type: "task", parents, name: task.kind };
+        notice.chatGuid = chatGuid;
+        notice.request = request;
+        const text = formatProgress(request);
+        const receipt = await deliverDirect(harness, { chatGuid, requestId: `progress:${task.id}`, text }, sender);
+        if (receipt.textStatus === "unknown")
+            console.warn("Progress delivery unknown", task.id, chatGuid);
+    }
+    async function settled(task, notice, elapsed) {
+        if (!notice.chatGuid || !notice.request || task.state.status !== "terminal")
+            return;
+        const settings = await readSettings(workingDir);
+        if (!settings.progressMessages || !isReplyEnabled(settings, notice.chatGuid))
+            return;
+        const outcome = task.state.outcome;
+        let success = outcome.status === "completed";
+        if (success && task.kind === "pi.tool" && outcome.status === "completed") {
+            const result = outcome.result;
+            const entryId = result && typeof result === "object" && "entryId" in result ? result.entryId : undefined;
+            const entry = typeof entryId === "number"
+                ? await harness.commit((tx) => tx.entry(entryId), BACKGROUND_CONTEXT)
+                : undefined;
+            const message = entry?.model?.[0];
+            success = message?.role === "toolResult" && !message.isError;
+        }
+        const text = formatProgress({ ...notice.request, phase: "response", success, elapsedMs: elapsed });
+        const receipt = await deliverDirect(harness, {
+            chatGuid: notice.chatGuid,
+            requestId: `progress:${task.id}:done`,
+            text,
+        }, sender);
+        if (receipt.textStatus === "unknown")
+            console.warn("Progress completion delivery unknown", task.id, notice.chatGuid);
+    }
+    const unsubscribe = harness.subscribeCommits(({ changes }) => {
+        for (const change of changes) {
+            if (change.type !== "task" || change.value.kind === "pi.generation")
+                continue;
+            const task = change.value;
+            if (task.state.status === "terminal") {
+                seen.delete(task.id);
+                const notice = active.get(task.id);
+                active.delete(task.id);
+                if (notice) {
+                    const elapsed = performance.now() - notice.admittedAt;
+                    pending = pending
+                        .then(() => settled(task, notice, elapsed))
+                        .catch((error) => {
+                        console.warn("Progress completion notification failed", task.id, error);
+                    });
+                }
+                continue;
+            }
+            if (task.state.status !== "pending" || seen.has(task.id))
+                continue;
+            seen.add(task.id);
+            const notice = { admittedAt: performance.now() };
+            active.set(task.id, notice);
+            // The synchronous observer must not call Session APIs or block adoption.
+            pending = pending
+                .then(() => notify(task, notice))
+                .catch((error) => {
+                console.warn("Progress notification failed", task.id, error);
+            });
+        }
+    });
+    return {
+        flush: () => pending,
+        async close() {
+            unsubscribe();
+            await pending;
+        },
+    };
+}