afucontext 0.0.0-stage → 0.1.17

package/src/afu_host_integrations/pi/dist/index.js

@@ -0,0 +1,565 @@
+import { sessionEntryToContextMessages, convertToLlm, estimateTokens, getAgentDir, SettingsManager, DEFAULT_COMPACTION_SETTINGS } from "@earendil-works/pi-coding-agent";
+import { journal, sessionHash, afuTrigger, summaryPrefix, observationId, afuStatus, afuDashboard, STATUS_COMMAND, DASHBOARD_COMMAND, CompactWorkerClient, HostCompactPool, bindingKey, findAppliedArtifact, normalizeContent, } from "../../shared/runtime-client/dist/index.js";
+export function createCompactPiExtension(options = {}) {
+    return function compactPi(pi) {
+        const injected = options.worker instanceof CompactWorkerClient ? options.worker : undefined;
+        const host = new HostCompactPool(options.worker instanceof CompactWorkerClient ? undefined : options.worker);
+        const compact = async (request, ctx, signal) => {
+            if (injected)
+                return injected.compact(request, signal);
+            return host.compact(request, await piHostBinding(ctx, pi), signal);
+        };
+        let warned = false;
+        const log = journal("pi");
+        const pending = new Map();
+        let epoch = 0;
+        let timer;
+        let automatic;
+        const fingerprint = (ctx) => bindingKey([
+            ctx.sessionManager.getSessionId(), ctx.model,
+            ctx.sessionManager.buildContextEntries(),
+        ]);
+        const invalidate = () => {
+            epoch++;
+            if (timer)
+                clearTimeout(timer);
+            timer = undefined;
+        };
+        // /afuctx-status and /afuctx-dashboard, like the Claude Code and Codex commands.
+        pi.registerCommand?.(STATUS_COMMAND, {
+            description: "Show AFU context-compaction status for this session",
+            handler: async (_args, ctx) => {
+                ctx.ui.notify(await afuStatus("pi", ctx.sessionManager.getSessionId()), "info");
+            },
+        });
+        pi.registerCommand?.(DASHBOARD_COMMAND, {
+            description: "Open the AFU dashboard in the browser",
+            handler: async (_args, ctx) => {
+                ctx.ui.notify(await afuDashboard(), "info");
+            },
+        });
+        pi.on("agent_start", invalidate);
+        pi.on("session_before_switch", invalidate);
+        pi.on("session_before_fork", invalidate);
+        pi.on("session_before_tree", invalidate);
+        pi.on("model_select", invalidate);
+        // Ready summaries per Pi session. They replace the summarized prefix of the
+        // very next model request (as the Codex/Claude Code gateway and DSH do),
+        // whether or not Pi's own compaction later accepts them.
+        const ready = new Map();
+        // What the next model request carries, recorded when Pi builds it and
+        // settled by the assistant message that answers it (request_receipt).
+        const outgoing = new Map();
+        const cacheSeen = new Set();
+        // A summary Pi committed from AFU stays in every later request until the
+        // next compaction; those requests are the ones it made smaller.
+        const committed = new Map();
+        pi.on("context", async (event, ctx) => {
+            const sid = ctx.sessionManager.getSessionId();
+            const summary = ready.get(sid);
+            const messages = summary ? applyPreparedSummary(event.messages, summary) : undefined;
+            if (!summary || !messages) {
+                const carried = committed.get(sid);
+                const first = event.messages[0];
+                outgoing.set(sid, carried && first?.role === "compactionSummary"
+                    ? { applied: true, ...(carried.artifactId ? { artifactId: carried.artifactId } : {}), removed: carried.removed }
+                    : { applied: false });
+                return undefined;
+            }
+            outgoing.set(sid, { applied: true, ...(summary.artifactId ? { artifactId: summary.artifactId } : {}), removed: summary.removedTokens });
+            log("summary_applied", { session: sessionHash(sid), artifact_id: summary.artifactId, phase: "host_request", removed_tokens_estimate: summary.removedTokens });
+            return { messages: messages };
+        });
+        pi.on("message_end", async (event, ctx) => {
+            const message = event.message;
+            if (message.role !== "assistant")
+                return;
+            const sid = ctx.sessionManager.getSessionId();
+            const sent = outgoing.get(sid);
+            outgoing.delete(sid);
+            if (!sent)
+                return;
+            const usage = message.usage ? piSummaryUsage(message.usage) : {};
+            // Pi reports absent cache counters as zero. Once this session's provider
+            // has reported a cache read, a zero is a real miss.
+            if (usage.cache_usage_known)
+                cacheSeen.add(sid);
+            else if (cacheSeen.has(sid) && typeof usage.input_tokens === "number")
+                Object.assign(usage, { cache_usage_known: true, cache_read_input_tokens: 0 });
+            const ok = message.stopReason !== "error" && message.stopReason !== "aborted";
+            log("request_receipt", {
+                session: sessionHash(sid), applied: sent.applied, upstream_success: ok,
+                ...(sent.artifactId ? { artifact_id: sent.artifactId } : {}),
+                ...(sent.applied && sent.removed !== undefined ? { removed_tokens_estimate: sent.removed } : {}),
+                ...(ok ? usage : {}),
+            });
+        });
+        const report = (ctx, error) => {
+            if (ctx.signal?.aborted)
+                return;
+            // Pi's own compaction declining (its keep-recent window covers the whole
+            // session) is not a model problem; the summary is still used per request.
+            if (error instanceof Error && /Nothing to compact|Already compacted/.test(error.message))
+                return;
+            log("adapter_error", { session: sessionHash(ctx.sessionManager.getSessionId()), reason: "host_model_unavailable_or_changed" });
+            if (warned || options.notifyErrors === false)
+                return;
+            warned = true;
+            const message = "host model unavailable or changed";
+            ctx.ui.notify(`compact unavailable; Pi compaction remains active: ${message}`, "warning");
+        };
+        pi.on("agent_settled", async (_event, ctx) => {
+            invalidate();
+            const generation = epoch;
+            // Context size as Pi itself measures it, for the dashboard's progress to the AFU trigger.
+            let usage;
+            try {
+                usage = ctx.getContextUsage();
+            }
+            catch {
+                usage = undefined;
+            }
+            log("request_observed", {
+                session: sessionHash(ctx.sessionManager.getSessionId()), phase: "host_turn_settled",
+                ...(usage?.tokens == null ? {} : { estimated_input_tokens: usage.tokens }),
+                ...afuTrigger(usage?.contextWindow),
+            });
+            const entries = ctx.sessionManager.buildContextEntries();
+            const visible = modelVisibleEntries(entries);
+            const latest = visible.at(-1);
+            if (latest === undefined)
+                return;
+            const request = piEntriesToRequest(entries, ctx, new Set([latest.id]));
+            if (request === undefined)
+                return;
+            try {
+                const identity = fingerprint(ctx);
+                const binding = injected ? undefined : await piHostBinding(ctx, pi);
+                const prepare = () => injected ? injected.compact(request, ctx.signal) : host.compact(request, binding, ctx.signal);
+                const deadline = Date.now() + 630_000;
+                const valid = () => generation === epoch && identity === fingerprint(ctx) && !ctx.signal?.aborted;
+                const inspect = async (result) => {
+                    if (!valid())
+                        return;
+                    if (piCompactionFromResult(visible, result, usage?.tokens ?? 0)) {
+                        const prepared = preparedSummary(visible, result);
+                        if (prepared)
+                            ready.set(ctx.sessionManager.getSessionId(), prepared);
+                        // Pi refuses to compact ("Nothing to compact") while its keep-recent
+                        // window covers the whole branch, and shows that as an error. The
+                        // summary is already used per request, so only commit when Pi can.
+                        if (!piCanCompact(ctx, visible, options.keepRecentTokens))
+                            return;
+                        // The native compact API aborts an active turn. Invoke only while idle,
+                        // with no queued prompt, then revalidate again in the native hook.
+                        if (!ctx.isIdle?.() || ctx.hasPendingMessages?.() || automatic)
+                            return;
+                        if (binding && !await binding.current())
+                            return;
+                        if (!valid() || !ctx.isIdle() || ctx.hasPendingMessages())
+                            return;
+                        automatic = { result, fingerprint: identity, ...(binding ? { binding } : {}) };
+                        const clear = () => { automatic = undefined; };
+                        try {
+                            ctx.compact({ onComplete: clear, onError: error => { clear(); report(ctx, error); } });
+                        }
+                        catch (error) {
+                            clear();
+                            throw error;
+                        }
+                        return;
+                    }
+                    if (!["scheduled", "running"].includes(result.async_job.status) || Date.now() >= deadline)
+                        return;
+                    timer = setTimeout(() => {
+                        timer = undefined;
+                        if (!valid())
+                            return;
+                        void prepare().then(inspect).catch(error => { if (valid())
+                            report(ctx, error); });
+                    }, 500);
+                    timer.unref?.();
+                };
+                await inspect(await prepare());
+                warned = false;
+            }
+            catch (error) {
+                report(ctx, error);
+            }
+        });
+        pi.on("session_before_compact", async (event, ctx) => {
+            invalidate();
+            const started = performance.now();
+            const entries = modelVisibleEntries(ctx.sessionManager.buildContextEntries());
+            const latest = entries.at(-1);
+            if (latest === undefined)
+                return;
+            const requiredIds = new Set([latest.id]);
+            const request = piEntriesToRequest(entries, ctx, requiredIds);
+            if (request === undefined)
+                return;
+            try {
+                const prepared = automatic;
+                // COSEC: an automatically requested commit must never use a stale model,
+                // session or history, nor fall back to an unrelated native summary.
+                if (prepared && ((prepared.binding && !await prepared.binding.current()) ||
+                    prepared.fingerprint !== fingerprint(ctx) || event.signal.aborted))
+                    return { cancel: true };
+                const result = prepared?.result ?? await compact(request, ctx, event.signal);
+                warned = false;
+                const compaction = piCompactionFromResult(entries, result, event.preparation.tokensBefore);
+                if (compaction) {
+                    const sid = sessionHash(ctx.sessionManager.getSessionId());
+                    const artifactId = observationId(result);
+                    const previous = pending.get(sid);
+                    if (previous?.artifactId && previous.artifactId !== artifactId)
+                        log("summary_discarded", { session: sid, artifact_id: previous.artifactId, reason: "superseded" });
+                    pending.set(sid, { signature: bindingKey([compaction.summary, compaction.firstKeptEntryId]), artifactId, removed: removedBy(entries, compaction.firstKeptEntryId, compaction.summary) });
+                    log("summary_handoff", { session: sid, artifact_id: artifactId });
+                }
+                return compaction === undefined ? (prepared ? { cancel: true } : undefined) : { compaction };
+            }
+            catch (error) {
+                if (!event.signal.aborted)
+                    report(ctx, error);
+                return automatic ? { cancel: true } : undefined;
+            }
+            finally {
+                log("host_compaction_receipt", { session: sessionHash(ctx.sessionManager.getSessionId()), host_compaction_ms: performance.now() - started });
+            }
+        });
+        pi.on("session_compact", async (event, ctx) => {
+            // Pi's history now starts from its own compaction entry; the prepared
+            // prefix can no longer match, so stop offering it.
+            ready.delete(ctx.sessionManager.getSessionId());
+            committed.delete(ctx.sessionManager.getSessionId());
+            const sid = sessionHash(ctx.sessionManager.getSessionId());
+            const handoff = pending.get(sid);
+            if (event.fromExtension && handoff?.signature === bindingKey([event.compactionEntry.summary, event.compactionEntry.firstKeptEntryId])) {
+                committed.set(ctx.sessionManager.getSessionId(), { ...(handoff.artifactId ? { artifactId: handoff.artifactId } : {}), removed: handoff.removed });
+                log("summary_applied", { session: sid, artifact_id: handoff.artifactId, phase: "host_commit", removed_tokens_estimate: handoff.removed });
+            }
+            else if (handoff)
+                log("summary_discarded", { session: sid, artifact_id: handoff.artifactId, reason: "host_used_other_summary" });
+            pending.delete(sid);
+        });
+        pi.on("session_compact_failed", async (_event, ctx) => {
+            const sid = sessionHash(ctx.sessionManager.getSessionId());
+            const handoff = pending.get(sid);
+            if (pending.delete(sid)) {
+                log("summary_discarded", { session: sid, artifact_id: handoff?.artifactId, reason: "host_commit_failed" });
+                log("adapter_error", { session: sid, reason: "host_commit_failed" });
+            }
+        });
+        pi.on("session_shutdown", async () => {
+            invalidate();
+            automatic = undefined;
+            ready.clear();
+            committed.clear();
+            outgoing.clear();
+            log("runtime_stopped");
+            await host.close();
+            await injected?.close();
+        });
+    };
+}
+/** Use the same provider runtime (including OAuth/custom headers) as Pi chat. */
+export async function piHostBinding(ctx, pi) {
+    const model = ctx.model;
+    if (!model)
+        throw new Error("No selected Pi model");
+    if (!Number.isSafeInteger(model.contextWindow) || model.contextWindow <= 0)
+        throw new Error("Pi model window unavailable");
+    const identity = async () => {
+        const selected = ctx.model;
+        if (!selected)
+            return "";
+        const auth = await ctx.modelRegistry.getApiKeyAndHeaders(selected);
+        if (!auth.ok)
+            throw new Error("Pi authentication unavailable");
+        return bindingKey([ctx.sessionManager.getSessionId(), selected, auth]);
+    };
+    const key = await identity();
+    let usage = {};
+    return {
+        key,
+        diagnostics: { host: "pi", session: sessionHash(ctx.sessionManager.getSessionId()), usage: () => usage },
+        contextWindow: model.contextWindow,
+        current: async () => key === await identity(),
+        complete: async (prompt, signal, ids) => {
+            const entries = ids?.length ? modelVisibleEntries(ctx.sessionManager.buildContextEntries()) : [];
+            const selected = summaryPrefix(entries.map(entry => ({ id: entry.id, messages: convertToLlm(sessionEntryToContextMessages(entry)) })), ids, prompt);
+            const definitions = pi?.getAllTools();
+            const tools = pi?.getActiveTools().map(name => {
+                const tool = definitions?.find(t => t.name === name);
+                if (!tool)
+                    throw new Error("Active Pi tool unavailable");
+                return { name: tool.name, description: tool.description, parameters: tool.parameters };
+            });
+            const response = await ctx.modelRegistry.complete(model, {
+                ...(ids?.length ? { systemPrompt: ctx.getSystemPrompt(), ...(tools ? { tools } : {}) } : {}),
+                messages: [...selected.messages, { role: "user", content: selected.prompt, timestamp: Date.now() }],
+            }, { signal, maxTokens: piSummaryMaxTokens(ctx, model), sessionId: ctx.sessionManager.getSessionId() });
+            usage = piSummaryUsage(response.usage);
+            const failure = (reason) => Object.assign(new Error("Pi summary incomplete"), { afuReason: reason });
+            if (response.stopReason === "length")
+                throw failure("summary_output_limit");
+            if (response.stopReason === "error")
+                throw failure("summary_provider_error");
+            if (response.stopReason !== "stop")
+                throw failure("summary_incomplete");
+            if (response.content.some(b => b.type === "toolCall"))
+                throw failure("summary_called_tool");
+            return response.content.filter(b => b.type === "text").map(b => b.text).join("\n");
+        },
+    };
+}
+export function piEntriesToRequest(entries, ctx, requiredIds) {
+    const usage = ctx.getContextUsage();
+    if (usage === undefined || usage.contextWindow <= 0)
+        return undefined;
+    const visible = modelVisibleEntries(entries);
+    if (visible.length < 2)
+        return undefined;
+    const callGroups = toolCallGroups(visible);
+    const items = visible.map((entry) => {
+        const message = sessionEntryToContextMessages(entry)[0];
+        if (message === undefined)
+            throw new Error(`Pi entry ${entry.id} has no model-visible message`);
+        const record = message;
+        const role = typeof record.role === "string" ? record.role : "user";
+        const callId = typeof record.toolCallId === "string" ? record.toolCallId : undefined;
+        const atomicGroup = callId === undefined ? callGroups.entryGroups.get(entry.id) : callGroups.calls.get(callId);
+        return {
+            schema_version: "1",
+            id: entry.id,
+            kind: entry.type === "compaction" ? "artifact" : piKind(role),
+            content: normalizeContent(record.content ?? ("summary" in entry ? entry.summary : "")),
+            source: { schema_version: "1", provider: "pi.session", source_id: entry.id },
+            required: requiredIds.has(entry.id),
+            ...(atomicGroup === undefined ? {} : { atomic_group: atomicGroup }),
+            metadata: {
+                adapter: "pi",
+                native_role: role,
+                native_entry_type: entry.type,
+            },
+        };
+    });
+    return {
+        schema_version: "1",
+        session_id: ctx.sessionManager.getSessionId(),
+        token_budget: usage.contextWindow,
+        items,
+        query: "",
+        mode: "active",
+        metadata: {
+            adapter: "pi",
+            // Pi's own measurement of the whole request; the worker follows it for the trigger.
+            ...(Number.isSafeInteger(usage.tokens) && usage.tokens > 0 ? { host_context_tokens: usage.tokens } : {}),
+            source_profile: {
+                representation: "text",
+                sequence_semantics: "append_only",
+                atomic_unit: "turn",
+                preserve_atomic_units: true,
+                loss_tolerance: "low",
+            },
+            runtime_version: "0.84.4",
+            query_aware: false,
+        },
+    };
+}
+export function piCompactionFromResult(entries, result, tokensBefore) {
+    const artifact = findAppliedArtifact(result);
+    if (artifact === undefined || typeof artifact.item.content !== "string")
+        return undefined;
+    const visible = modelVisibleEntries(entries);
+    const visibleIds = visible.map((entry) => entry.id);
+    const start = coveredStart(visibleIds, artifact.replacedItemIds, visible);
+    if (start < 0 || start + artifact.replacedItemIds.length >= visibleIds.length)
+        return undefined;
+    const firstKeptEntryId = visibleIds[start + artifact.replacedItemIds.length];
+    if (firstKeptEntryId === undefined)
+        return undefined;
+    return {
+        summary: artifact.item.content,
+        firstKeptEntryId,
+        tokensBefore,
+        estimatedTokensAfter: result.usage.output_tokens,
+        details: {
+            ...(artifact.artifactId === undefined ? {} : { artifactId: artifact.artifactId }),
+            diagnostics: result.diagnostics,
+        },
+    };
+}
+/**
+ * Output budget for one summary, the way Pi sizes its own: 80% of
+ * compaction.reserveTokens (16,384 by default, so 13,107), capped by the
+ * model's maxTokens. Reasoning models spend part of it thinking; a fixed
+ * 4,096 made long summaries stop at the limit and every retry fail.
+ */
+export function piSummaryMaxTokens(ctx, model) {
+    let reserve = DEFAULT_COMPACTION_SETTINGS.reserveTokens;
+    try {
+        const value = SettingsManager.create(ctx.cwd, getAgentDir()).getCompactionReserveTokens();
+        if (Number.isFinite(value) && value > 0)
+            reserve = value;
+    }
+    catch { /* Pi's default */ }
+    const budget = Math.max(4096, Math.floor(0.8 * reserve));
+    return typeof model.maxTokens === "number" && model.maxTokens > 0 ? Math.min(budget, model.maxTokens) : budget;
+}
+/** Pi's compaction.keepRecentTokens for this project (Pi's own default when unset). */
+function piKeepRecentTokens(ctx) {
+    try {
+        const value = SettingsManager.create(ctx.cwd, getAgentDir()).getCompactionKeepRecentTokens();
+        if (Number.isFinite(value) && value >= 0)
+            return value;
+    }
+    catch { /* fall back to Pi's default */ }
+    return DEFAULT_COMPACTION_SETTINGS.keepRecentTokens;
+}
+/**
+ * Whether Pi's own compaction would accept a commit now: the messages after
+ * the latest compaction must exceed keepRecentTokens (Pi's estimate), or Pi
+ * reports "Nothing to compact (session too small)".
+ */
+export function piCanCompact(ctx, visible, keepRecent = piKeepRecentTokens(ctx)) {
+    let total = 0;
+    for (const entry of visible) {
+        if (entry.type === "compaction") {
+            total = 0;
+            continue;
+        }
+        for (const message of sessionEntryToContextMessages(entry))
+            total += estimateTokens(message);
+    }
+    return total > keepRecent;
+}
+/** A ready result that replaces a leading run of the given entries. */
+export function preparedSummary(visible, result) {
+    const artifact = findAppliedArtifact(result);
+    if (artifact === undefined || typeof artifact.item.content !== "string")
+        return undefined;
+    const ids = visible.map((entry) => entry.id);
+    const start = coveredStart(ids, artifact.replacedItemIds, visible);
+    if (start < 0 || start + artifact.replacedItemIds.length >= ids.length)
+        return undefined;
+    const head = visible.slice(0, start).flatMap((entry) => sessionEntryToContextMessages(entry));
+    const replaced = visible.slice(start, start + artifact.replacedItemIds.length).flatMap((entry) => sessionEntryToContextMessages(entry));
+    const replacedChars = JSON.stringify(replaced).length;
+    // Same id the summary_started/summary_ready events carry, so the dashboard links them.
+    const artifactId = observationId(result) ?? artifact.artifactId;
+    return {
+        head,
+        replaced,
+        summary: artifact.item.content,
+        ...(artifactId === undefined ? {} : { artifactId }),
+        removedTokens: Math.max(0, Math.round((replacedChars - artifact.item.content.length) / 4)),
+    };
+}
+/**
+ * Replace the summarized prefix of a model request with Pi's own compaction
+ * summary message. Only an exact prefix match is rewritten; anything else
+ * (a later Pi compaction, a branch switch, edited history) is sent unchanged.
+ */
+export function applyPreparedSummary(messages, ready) {
+    const head = ready.head ?? [];
+    const count = ready.replaced.length;
+    if (messages.length <= head.length + count)
+        return undefined;
+    for (let index = 0; index < head.length; index++) {
+        if (JSON.stringify(messages[index]) !== JSON.stringify(head[index]))
+            return undefined;
+    }
+    for (let index = 0; index < count; index++) {
+        if (JSON.stringify(messages[head.length + index]) !== JSON.stringify(ready.replaced[index]))
+            return undefined;
+    }
+    const first = messages[head.length];
+    return [
+        ...messages.slice(0, head.length),
+        { role: "compactionSummary", summary: ready.summary, tokensBefore: ready.removedTokens, timestamp: first?.timestamp ?? Date.now() },
+        ...messages.slice(head.length + count),
+    ];
+}
+/** Tokens (Pi's estimate) the entries before firstKeptEntryId cost, minus the summary replacing them. */
+function removedBy(entries, firstKeptEntryId, summary) {
+    let total = 0;
+    for (const entry of entries) {
+        if (entry.id === firstKeptEntryId)
+            break;
+        for (const message of sessionEntryToContextMessages(entry))
+            total += estimateTokens(message);
+    }
+    return Math.max(0, total - Math.ceil(summary.length / 4));
+}
+/**
+ * Where the summarized range starts among the visible entries. Pi 1.x keeps
+ * the system prompt as session entries (role "system") ahead of the
+ * conversation; AFU never summarizes those, so a summary may start after them.
+ * Returns -1 when the covered ids are not a contiguous run after that head.
+ */
+export function coveredStart(visibleIds, replaced, visible) {
+    if (replaced.length === 0)
+        return -1;
+    let start = 0;
+    while (start < visible.length && visibleIds[start] !== replaced[0] && isSystemEntry(visible[start]))
+        start++;
+    if (visibleIds[start] !== replaced[0])
+        return -1;
+    for (let index = 0; index < replaced.length; index++)
+        if (visibleIds[start + index] !== replaced[index])
+            return -1;
+    return start;
+}
+function isSystemEntry(entry) {
+    return sessionEntryToContextMessages(entry).every((message) => message.role === "system");
+}
+function modelVisibleEntries(entries) {
+    return entries.filter((entry) => sessionEntryToContextMessages(entry).length > 0);
+}
+function piKind(role) {
+    if (role === "assistant")
+        return "assistant";
+    if (role === "toolResult" || role === "tool")
+        return "tool";
+    if (role === "system")
+        return "system";
+    return "user";
+}
+function toolCallGroups(entries) {
+    const calls = new Map();
+    const entryGroups = new Map();
+    for (const entry of entries) {
+        const message = sessionEntryToContextMessages(entry)[0];
+        if (!isRecord(message) || !Array.isArray(message.content))
+            continue;
+        const callIds = message.content.flatMap((block) => {
+            if (!isRecord(block) || block.type !== "toolCall" || typeof block.id !== "string")
+                return [];
+            return [block.id];
+        });
+        if (callIds.length === 0)
+            continue;
+        const group = `pi-tool-batch:${entry.id}`;
+        entryGroups.set(entry.id, group);
+        for (const callId of callIds)
+            calls.set(callId, group);
+    }
+    return { calls, entryGroups };
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export default createCompactPiExtension();
+export function piSummaryUsage(u) {
+    if (!u)
+        return { cache_usage_known: false };
+    return {
+        input_tokens: u.input + (u.cacheRead ?? 0) + (u.cacheWrite ?? 0), output_tokens: u.output,
+        cache_usage_known: u.cacheRead > 0,
+        ...(u.cacheRead > 0 ? { cache_read_input_tokens: u.cacheRead } : {}),
+        ...(u.cacheWrite > 0 ? { cache_creation_input_tokens: u.cacheWrite } : {}),
+    };
+}
+//# sourceMappingURL=index.js.map

package/src/afu_host_integrations/shared/runtime-client/dist/commands.js

@@ -0,0 +1,40 @@
+import { execFile } from "node:child_process";
+/**
+ * In-host commands (/afuctx-status, /afuctx-dashboard) for hosts without a
+ * gateway: they run AFU's own CLI from the installed runtime. The command
+ * line is recorded at install time (AFU_STATE_CLI); nothing is taken from
+ * user input except the host's own session id, passed as one argument.
+ */
+export const STATUS_COMMAND = "afuctx-status";
+export const DASHBOARD_COMMAND = "afuctx-dashboard";
+function cli(env) {
+    try {
+        const value = JSON.parse(env.AFU_STATE_CLI ?? "");
+        return Array.isArray(value) && value.length > 0 && value.every(v => typeof v === "string") ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function run(args, env, timeoutMs) {
+    const base = cli(env);
+    if (!base)
+        return Promise.resolve("AFU runtime command is unavailable; reinstall AFU for this host.");
+    const state = env.AFU_STATE_DIR ? ["--state", env.AFU_STATE_DIR] : [];
+    return new Promise(resolve => {
+        // COSEC: fixed executable and argv array; no shell.
+        execFile(base[0], [...base.slice(1), ...args, ...state], { timeout: timeoutMs, env: { ...process.env, ...env }, maxBuffer: 1 << 20 }, (error, stdout, stderr) => {
+            const text = (stdout || "").trim() || (stderr || "").trim();
+            resolve(text || (error ? "AFU command failed: " + error.code : ""));
+        });
+    });
+}
+/** Short status of this host and of the given host session. */
+export function afuStatus(host, sessionId, env = process.env) {
+    return run(["status", host, "--brief", "--session", sessionId], env, 15_000);
+}
+/** Start (or reuse) the dashboard and return its link line. */
+export function afuDashboard(env = process.env) {
+    return run(["ui"], env, 30_000);
+}
+//# sourceMappingURL=commands.js.map