@datename/fastcode-termux 0.1.6-beta → 0.1.6

package/dist/agent/protocol-mode.js

@@ -1,51 +0,0 @@
-import { getModelMeta } from "../lib/model-meta.js";
-const NATIVE_PROVIDERS = new Set([
-    "openai",
-    "openrouter",
-    "deepseek",
-    "groq",
-    "mistral",
-    "xai",
-    "moonshot",
-    "zhipu",
-    "qwen",
-    "ollama",
-]);
-export function toolCapabilityKey(providerId, model) {
-    return `${providerId}::${model}`;
-}
-export function resolveToolProtocol(config, providerId, model, env = process.env) {
-    const mode = String(env["FASTCODE_TOOL_PROTOCOL"] ?? "legacy").trim().toLowerCase();
-    if (mode === "legacy")
-        return "legacy";
-    if (mode === "native")
-        return "native";
-    if (mode !== "auto")
-        return "legacy";
-    const cached = config?.capabilities?.toolCalling?.[toolCapabilityKey(providerId, model)];
-    if (cached === "pseudo")
-        return "legacy";
-    if (cached === "native")
-        return "native";
-    if (!NATIVE_PROVIDERS.has(providerId))
-        return "legacy";
-    return getModelMeta(providerId, model).supportsTools ? "native" : "legacy";
-}
-export function withToolCapability(config, providerId, model, capability) {
-    const key = toolCapabilityKey(providerId, model);
-    return {
-        ...config,
-        capabilities: {
-            ...(config?.capabilities ?? {}),
-            toolCalling: {
-                ...(config?.capabilities?.toolCalling ?? {}),
-                [key]: capability,
-            },
-        },
-    };
-}
-export function isNativeUnsupportedError(message) {
-    return /\b400\b/.test(message)
-        && /tool|function/i.test(message)
-        && /not supported|unsupported|unrecognized|unknown|invalid|does not support/i.test(message);
-}

package/dist/agent/registry.d.ts

@@ -1,17 +0,0 @@
-import type { ApprovalDecision } from "./approval.js";
-import type { Tool, ToolCall, ToolCtx, ToolResult } from "./tools/types.js";
-export declare function assertToolContract(tools?: Tool[]): void;
-export declare function toolCatalogHash(tools?: Tool[]): string;
-export declare class ToolRegistry {
-    private readonly tools;
-    constructor(tools?: Tool[]);
-    get(name: string): Tool | undefined;
-    list(): Tool[];
-    approve(call: ToolCall, ctx: ToolCtx): ApprovalDecision;
-    execute(call: ToolCall, ctx: ToolCtx): Promise<ToolResult>;
-}
-export declare const registry: ToolRegistry;
-export declare function runAgentTool(call: ToolCall, cwd?: string, options?: {
-    signal?: AbortSignal;
-    turn?: number;
-}): Promise<ToolResult>;

package/dist/agent/registry.js

@@ -1,90 +0,0 @@
-import { createHash } from "node:crypto";
-import { isTrusted } from "../config/trust.js";
-import { evaluateShellCommand } from "./guards.js";
-import { TOOLS } from "./tools/index.js";
-const STATE_SCOPES = new Set(["call", "turn", "session"]);
-const REVALIDATE_KEYS = new Set(["trust", "sandboxRoots", "schema", "modelCaps"]);
-export function assertToolContract(tools = TOOLS) {
-    const names = new Set();
-    for (const tool of tools) {
-        if (!tool.name || typeof tool.name !== "string")
-            throw new Error("tool contract: every tool needs a name");
-        if (names.has(tool.name))
-            throw new Error(`tool contract: duplicate tool name ${tool.name}`);
-        names.add(tool.name);
-        if (!STATE_SCOPES.has(tool.stateScope))
-            throw new Error(`tool contract: ${tool.name} has an invalid stateScope`);
-        for (const key of tool.revalidate ?? []) {
-            if (!REVALIDATE_KEYS.has(key))
-                throw new Error(`tool contract: ${tool.name} has an invalid revalidate key ${String(key)}`);
-        }
-        if (tool.requiresTrust && !(tool.revalidate ?? []).includes("trust")) {
-            throw new Error(`tool contract: ${tool.name} requiresTrust but does not revalidate "trust"`);
-        }
-    }
-}
-export function toolCatalogHash(tools = TOOLS) {
-    const catalog = tools
-        .map((tool) => ({
-        name: tool.name,
-        trust: Boolean(tool.requiresTrust),
-        scope: tool.stateScope,
-        revalidate: [...(tool.revalidate ?? [])].sort(),
-    }))
-        .sort((a, b) => a.name.localeCompare(b.name));
-    return createHash("sha1").update(JSON.stringify(catalog)).digest("hex").slice(0, 8);
-}
-export class ToolRegistry {
-    tools = new Map();
-    constructor(tools = TOOLS) {
-        assertToolContract(tools);
-        for (const tool of tools)
-            this.tools.set(tool.name, tool);
-    }
-    get(name) {
-        return this.tools.get(name);
-    }
-    list() {
-        return Array.from(this.tools.values());
-    }
-    approve(call, ctx) {
-        const tool = this.get(call.tool);
-        if (!tool)
-            return { kind: "deny", reason: `unknown tool: ${String(call.tool)}` };
-        if (tool.name === "shell") {
-            const verdict = evaluateShellCommand(call.command);
-            if (!verdict.allow)
-                return { kind: "deny", reason: verdict.output };
-        }
-        if ((tool.revalidate ?? []).includes("trust") && !isTrusted(ctx.cwd)) {
-            return {
-                kind: "deny",
-                reason: `project is not trusted: ${ctx.cwd}. Run \`fastcode trust ${ctx.cwd}\` or accept the trust prompt.`,
-            };
-        }
-        return { kind: "allow", scope: "once" };
-    }
-    async execute(call, ctx) {
-        const tool = this.get(call.tool);
-        if (!tool)
-            return { ok: false, output: `unknown tool: ${String(call.tool)}` };
-        const prepared = tool.prepare(call, ctx);
-        if (prepared.ok === false)
-            return { ok: false, output: prepared.output };
-        const decision = this.approve(call, ctx);
-        if (decision.kind === "deny")
-            return { ok: false, output: decision.reason ?? "denied by approval policy" };
-        if (decision.kind === "pending")
-            return { ok: false, output: "approval required, but no approval resolver is registered (fail closed)" };
-        try {
-            return await tool.execute(call, ctx);
-        }
-        catch (err) {
-            return { ok: false, output: err?.message ?? String(err) };
-        }
-    }
-}
-export const registry = new ToolRegistry();
-export async function runAgentTool(call, cwd = process.cwd(), options = {}) {
-    return registry.execute(call, { cwd, signal: options.signal, turn: options.turn });
-}

package/dist/agent/runner.d.ts

@@ -1,106 +0,0 @@
-import type { ChatChunk, ChatMessage, NativeToolCall, Provider, ReasoningEffort, ToolSchema } from "../types.js";
-import type { ActiveFile } from "../session/log.js";
-import type { SideEffects } from "./tools/types.js";
-import { type CompactionConfig } from "./compaction.js";
-import { type ToolProtocol } from "./protocol-mode.js";
-export interface ToolCall {
-    tool: string;
-    [key: string]: any;
-}
-export interface LoopDetectionOptions {
-    readOnlyThreshold?: number;
-    sideEffectThreshold?: number;
-    window?: number;
-    exemptReadOnly?: boolean;
-}
-export interface RunOptions {
-    provider: Provider;
-    apiKey?: string;
-    model: string;
-    messages?: ChatMessage[];
-    prompt: string;
-    system?: string;
-    maxTurns?: number;
-    allowTools?: boolean;
-    tokenBudget?: number;
-    costBudgetUsd?: number;
-    signal?: AbortSignal;
-    cwd?: string;
-    idleTimeoutMs?: number;
-    contextBudgetChars?: number;
-    compaction?: CompactionConfig;
-    contextWindow?: number;
-    serverOpaqueState?: string;
-    loopDetection?: LoopDetectionOptions;
-    reasoningEffort?: ReasoningEffort;
-    protocol?: ToolProtocol;
-    tools?: ToolSchema[];
-    onProtocolFallback?: (message: string) => void;
-    onNativeOk?: () => void;
-    takeSteering?: () => string[];
-    onDelta?: (delta: string, text: string) => void;
-}
-export type AgentStopReason = "complete" | "max_turns" | "token_budget" | "cost_budget" | "loop_detected" | "aborted" | "incomplete" | "stream_error";
-export type AgentErrorKind = "token_budget" | "cost_budget" | "loop_detected" | "aborted" | "stream_error";
-export type AgentEvent = {
-    type: "compaction";
-    beforeChars: number;
-    afterChars: number;
-    beforeTokens: number;
-    afterTokens: number;
-    droppedMessages: number;
-    keptMessages: number;
-    reason: "threshold" | "heap";
-    source: "local" | "server";
-    summaryFile?: string;
-} | {
-    type: "assistant_raw";
-    text: string;
-    toolCalls?: NativeToolCall[];
-} | {
-    type: "assistant_text";
-    text: string;
-} | {
-    type: "tool_call";
-    id: string;
-    call: ToolCall;
-    native?: boolean;
-} | {
-    type: "tool_result";
-    id: string;
-    call: ToolCall;
-    ok: boolean;
-    output: string;
-    sideEffects?: SideEffects;
-} | {
-    type: "usage";
-    usage: NonNullable<ChatChunk["usage"]>;
-} | {
-    type: "loop_detected";
-    fingerprint: string;
-    occurrences: number;
-    warned: boolean;
-} | {
-    type: "notice";
-    text: string;
-} | {
-    type: "error";
-    kind: AgentErrorKind;
-    message: string;
-    text?: string;
-    used?: number;
-} | {
-    type: "checkpoint";
-    turn: number;
-    cwd: string;
-    providerId: string;
-    model: string;
-    activeFiles: ActiveFile[];
-} | {
-    type: "done";
-    history: ChatMessage[];
-    finalText: string;
-    stopReason: AgentStopReason;
-};
-export declare const LOOP_WARNING: string;
-export declare function runAgent(options: RunOptions): AsyncGenerator<AgentEvent, void, void>;

package/dist/agent/runner.js

@@ -1,352 +0,0 @@
-import { createHash } from "node:crypto";
-import { readFileSync, statSync } from "node:fs";
-import { estMessagesTokens, estTokens, getModelMeta } from "../lib/model-meta.js";
-import { compactMessages, DEFAULT_COMPACTION_CONFIG } from "./compaction.js";
-import { isLoopExempt, isReadOnlyToolCall, toolCallFingerprint } from "./guards.js";
-import { isNativeUnsupportedError } from "./protocol-mode.js";
-import { formatToolResults, parseToolCalls, stripToolCalls } from "./protocol.js";
-import { runStream } from "./stream.js";
-import { runAgentTool } from "./tools.js";
-export const LOOP_WARNING = "[loop detection] You appear to be repeating the same tool call. " +
-    "Do not repeat it again: inspect the result you already have, or change approach.";
-/**
- * Sliding-window loop detector.
- *
- * Semantics (fixed by FC-004, do not re-interpret):
- * - hits count the last `window` tool calls, not turns;
- * - read-only tools use a higher threshold than side-effecting tools (D-02);
- * - the first threshold hit yields a warning and resets that fingerprint's count;
- * - only a second full accumulation yields a terminal error;
- * - the table lives for one run (turn), so a new user task starts clean;
- * - fingerprints are normalized per tool call (absolute paths, timeoutMs removed).
- */
-class LoopState {
-    entries = new Map();
-    calls = 0;
-    readOnlyThreshold;
-    sideEffectThreshold;
-    window;
-    exemptReadOnly;
-    constructor(options = {}) {
-        this.readOnlyThreshold = positive(options.readOnlyThreshold, 6);
-        this.sideEffectThreshold = positive(options.sideEffectThreshold, 3);
-        this.window = positive(options.window, 5);
-        this.exemptReadOnly = options.exemptReadOnly === true;
-    }
-    check(fingerprint, readOnly) {
-        if (readOnly && this.exemptReadOnly)
-            return { action: "ok", occurrences: 0 };
-        this.calls += 1;
-        const index = this.calls;
-        let entry = this.entries.get(fingerprint);
-        if (!entry) {
-            entry = { warned: false, hits: [] };
-            this.entries.set(fingerprint, entry);
-        }
-        entry.hits = entry.hits.filter((hit) => index - hit < this.window);
-        entry.hits.push(index);
-        const threshold = readOnly ? this.readOnlyThreshold : this.sideEffectThreshold;
-        if (entry.hits.length < threshold)
-            return { action: "ok", occurrences: entry.hits.length };
-        const occurrences = entry.hits.length;
-        if (!entry.warned) {
-            entry.warned = true;
-            entry.hits = [];
-            return { action: "warn", occurrences };
-        }
-        return { action: "stop", occurrences };
-    }
-}
-export async function* runAgent(options) {
-    const provider = options.provider;
-    const model = options.model;
-    const cwd = options.cwd ?? process.cwd();
-    const signal = options.signal;
-    const maxTurns = Math.max(1, Math.floor(positive(options.maxTurns, 8)));
-    const tokenBudget = optionalPositive(options.tokenBudget);
-    const costBudget = optionalPositive(options.costBudgetUsd);
-    const loop = new LoopState(options.loopDetection);
-    let history = [...(options.messages ?? []), { role: "user", content: options.prompt }];
-    let currentText = "";
-    let lastVisible = "";
-    let consumedInput = 0;
-    let spentCost = 0;
-    let stopReason = "complete";
-    let errorMessage = "";
-    let naturalFinish = false;
-    let toolCallSeq = 0;
-    let protocol = options.protocol ?? "legacy";
-    let fellBack = false;
-    const activeFiles = new Map();
-    for (let turn = 0; turn < maxTurns; turn += 1) {
-        if (signal?.aborted) {
-            stopReason = "aborted";
-            break;
-        }
-        for (const steering of options.takeSteering?.() ?? []) {
-            history = [...history, { role: "system", content: "[user steering] " + steering }];
-            yield { type: "notice", text: "Steering applied to the next request." };
-        }
-        const contextWindow = options.contextWindow ?? getModelMeta(provider.id, model).contextWindow;
-        const compacted = compactMessages(history, options.compaction ?? DEFAULT_COMPACTION_CONFIG, {
-            contextWindow,
-            providerId: provider.id,
-            model,
-            serverOpaqueState: options.serverOpaqueState,
-        });
-        if (compacted.compacted) {
-            history = compacted.messages;
-            yield {
-                type: "compaction",
-                beforeChars: compacted.beforeChars,
-                afterChars: compacted.afterChars,
-                beforeTokens: compacted.beforeTokens,
-                afterTokens: compacted.afterTokens,
-                droppedMessages: compacted.droppedMessages,
-                keptMessages: compacted.keptMessages,
-                reason: compacted.reason ?? "threshold",
-                source: compacted.source === "server" ? "server" : "local",
-                summaryFile: compacted.summaryFile,
-            };
-        }
-        const promptTokens = estMessagesTokens(history, { providerId: provider.id, model }) +
-            estTokens(options.system ?? "", { providerId: provider.id, model });
-        if (tokenBudget !== undefined && consumedInput + promptTokens > tokenBudget) {
-            stopReason = "token_budget";
-            errorMessage = `Token budget exhausted (${consumedInput + promptTokens} > ${tokenBudget} estimated input tokens). Partial output is kept.`;
-            yield { type: "error", kind: "token_budget", message: errorMessage, text: lastVisible, used: consumedInput + promptTokens };
-            break;
-        }
-        if (costBudget !== undefined && spentCost >= costBudget) {
-            stopReason = "cost_budget";
-            errorMessage = `Cost budget exhausted ($${spentCost.toFixed(4)} of $${costBudget}). Partial output is kept.`;
-            yield { type: "error", kind: "cost_budget", message: errorMessage, text: lastVisible };
-            break;
-        }
-        currentText = "";
-        let resetNotice = "";
-        let streamed;
-        try {
-            streamed = await runStream(provider, {
-                model,
-                messages: history,
-                system: options.system,
-                reasoningEffort: options.reasoningEffort,
-                ...(protocol === "native" && options.tools && options.tools.length > 0 ? { tools: options.tools } : {}),
-            }, options.apiKey, {
-                signal,
-                idleTimeoutMs: options.idleTimeoutMs,
-                onDelta: (delta, text) => {
-                    currentText = text;
-                    options.onDelta?.(delta, text);
-                },
-                onReset: () => {
-                    resetNotice = "Retried stream returned different content; the earlier partial output was discarded and replaced by the new stream.";
-                },
-            });
-        }
-        catch (err) {
-            if (err?.name === "AbortError" || signal?.aborted) {
-                stopReason = "aborted";
-                break;
-            }
-            errorMessage = String(err?.message ?? err);
-            if (protocol === "native" && !fellBack && isNativeUnsupportedError(errorMessage)) {
-                fellBack = true;
-                protocol = "legacy";
-                options.onProtocolFallback?.(`Native tools were rejected (${errorMessage.slice(0, 160)}); retrying with the pseudo protocol.`);
-                turn -= 1;
-                continue;
-            }
-            stopReason = "stream_error";
-            const partial = stripToolCalls(String(err?.partialText ?? "")).trim();
-            if (partial)
-                lastVisible = partial;
-            yield { type: "error", kind: "stream_error", message: errorMessage, text: partial || undefined };
-            break;
-        }
-        if (signal?.aborted) {
-            stopReason = "aborted";
-            break;
-        }
-        if (resetNotice)
-            yield { type: "notice", text: resetNotice };
-        if (streamed.usage) {
-            consumedInput += streamed.usage.inputTokens ?? promptTokens;
-            spentCost += streamed.usage.costUsd ?? 0;
-            yield { type: "usage", usage: streamed.usage };
-        }
-        else {
-            consumedInput += promptTokens;
-        }
-        if (streamed.incomplete) {
-            const partial = stripToolCalls(streamed.text).trim();
-            if (partial)
-                lastVisible = partial;
-            stopReason = "incomplete";
-            errorMessage = `Connection ended before the response finished${streamed.retried > 0 ? ` (retried ${streamed.retried}×)` : ""}. ` +
-                "Partial output is kept — type 继续 to continue.";
-            yield { type: "notice", text: errorMessage };
-            yield { type: "checkpoint", turn: turn + 1, cwd, providerId: provider.id, model, activeFiles: Array.from(activeFiles.values()) };
-            break;
-        }
-        const visibleText = stripToolCalls(streamed.text);
-        if (visibleText)
-            lastVisible = visibleText;
-        const nativeCalls = protocol === "native" && options.allowTools !== false ? (streamed.toolCalls ?? []) : [];
-        if (nativeCalls.length > 0) {
-            yield { type: "assistant_raw", text: streamed.text, toolCalls: nativeCalls };
-            if (visibleText)
-                yield { type: "assistant_text", text: visibleText };
-            history = [...history, { role: "assistant", content: streamed.text, toolCalls: nativeCalls }];
-            for (const native of nativeCalls) {
-                if (signal?.aborted) {
-                    stopReason = "aborted";
-                    break;
-                }
-                const id = native.id || `tc_${++toolCallSeq}`;
-                let call;
-                let parseError = "";
-                try {
-                    const args = native.arguments ? JSON.parse(native.arguments) : {};
-                    if (!args || typeof args !== "object" || Array.isArray(args))
-                        throw new Error("arguments must be a JSON object");
-                    call = { ...args, tool: native.name };
-                }
-                catch (err) {
-                    parseError = `invalid arguments for ${native.name}: ${err?.message ?? String(err)}`;
-                    call = { tool: native.name };
-                }
-                const fingerprint = toolCallFingerprint(call, cwd);
-                if (!isLoopExempt(call.tool)) {
-                    const verdict = loop.check(fingerprint, isReadOnlyToolCall(call));
-                    if (verdict.action === "warn") {
-                        yield { type: "loop_detected", fingerprint, occurrences: verdict.occurrences, warned: false };
-                        history = [...history, { role: "system", content: LOOP_WARNING }];
-                    }
-                    else if (verdict.action === "stop") {
-                        stopReason = "loop_detected";
-                        errorMessage = `Loop detected: the same tool call repeated ${verdict.occurrences} times. Stopped before executing it again.`;
-                        yield { type: "error", kind: "loop_detected", message: errorMessage, text: lastVisible };
-                        break;
-                    }
-                }
-                yield { type: "tool_call", id, call, native: true };
-                const result = parseError
-                    ? { ok: false, output: parseError }
-                    : await runAgentTool(call, cwd, { signal, turn: turn + 1 });
-                trackSideEffects(activeFiles, result.sideEffects);
-                yield { type: "tool_result", id, call, ok: Boolean(result.ok), output: String(result.output ?? ""), sideEffects: result.sideEffects };
-                history = [...history, { role: "tool", toolCallId: id, content: String(result.output ?? "") }];
-            }
-            yield { type: "checkpoint", turn: turn + 1, cwd, providerId: provider.id, model, activeFiles: Array.from(activeFiles.values()) };
-            if (stopReason === "complete")
-                options.onNativeOk?.();
-            if (stopReason !== "complete")
-                break;
-            continue;
-        }
-        const calls = options.allowTools === false ? [] : parseToolCalls(streamed.text);
-        yield { type: "assistant_raw", text: streamed.text };
-        if (calls.length === 0) {
-            lastVisible = visibleText || streamed.text;
-            naturalFinish = true;
-            stopReason = "complete";
-            yield { type: "checkpoint", turn: turn + 1, cwd, providerId: provider.id, model, activeFiles: Array.from(activeFiles.values()) };
-            break;
-        }
-        history = [...history, { role: "assistant", content: streamed.text }];
-        if (visibleText)
-            yield { type: "assistant_text", text: visibleText };
-        const results = [];
-        for (const call of calls) {
-            if (signal?.aborted) {
-                stopReason = "aborted";
-                break;
-            }
-            const fingerprint = toolCallFingerprint(call, cwd);
-            if (!isLoopExempt(call.tool)) {
-                const verdict = loop.check(fingerprint, isReadOnlyToolCall(call));
-                if (verdict.action === "warn") {
-                    yield { type: "loop_detected", fingerprint, occurrences: verdict.occurrences, warned: false };
-                    history = [...history, { role: "system", content: LOOP_WARNING }];
-                }
-                else if (verdict.action === "stop") {
-                    stopReason = "loop_detected";
-                    errorMessage = `Loop detected: the same tool call repeated ${verdict.occurrences} times. Stopped before executing it again.`;
-                    yield { type: "error", kind: "loop_detected", message: errorMessage, text: lastVisible };
-                    break;
-                }
-            }
-            const id = `tc_${++toolCallSeq}`;
-            yield { type: "tool_call", id, call };
-            const result = await runAgentTool(call, cwd, { signal, turn: turn + 1 });
-            results.push({ call, ok: Boolean(result.ok), output: String(result.output ?? ""), sideEffects: result.sideEffects });
-            trackSideEffects(activeFiles, result.sideEffects);
-            yield { type: "tool_result", id, call, ok: Boolean(result.ok), output: String(result.output ?? ""), sideEffects: result.sideEffects };
-        }
-        if (results.length > 0)
-            history = [...history, { role: "user", content: formatToolResults(results) }];
-        yield { type: "checkpoint", turn: turn + 1, cwd, providerId: provider.id, model, activeFiles: Array.from(activeFiles.values()) };
-        if (stopReason !== "complete")
-            break;
-    }
-    if (stopReason === "stream_error") {
-        const partial = lastVisible;
-        if (partial)
-            history = [...history, { role: "assistant", content: partial }];
-        yield { type: "done", history, finalText: partial, stopReason };
-        return;
-    }
-    if (stopReason === "complete" && !naturalFinish)
-        stopReason = "max_turns";
-    let finalText = "";
-    if (stopReason === "aborted") {
-        const partial = stripToolCalls(currentText).trim() || lastVisible;
-        finalText = (partial ? partial + "\n\n" : "") + "[用户中断]";
-        yield { type: "error", kind: "aborted", message: "Cancelled.", text: partial };
-    }
-    else if (stopReason === "token_budget" || stopReason === "cost_budget" || stopReason === "loop_detected" || stopReason === "incomplete") {
-        finalText = lastVisible || errorMessage;
-    }
-    else if (stopReason === "max_turns") {
-        finalText = `Reached the maximum of ${maxTurns} agent tool turns. The work so far is kept in this session — type 继续 to keep going.`;
-    }
-    else {
-        finalText = lastVisible;
-    }
-    if (finalText)
-        history = [...history, { role: "assistant", content: finalText }];
-    yield { type: "done", history, finalText, stopReason };
-}
-function positive(value, fallback) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
-}
-function optionalPositive(value) {
-    return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
-}
-function trackSideEffects(activeFiles, sideEffects) {
-    if (!sideEffects)
-        return;
-    for (const file of [...(sideEffects.touched ?? []), ...(sideEffects.created ?? [])]) {
-        const meta = describeActiveFile(file);
-        if (meta)
-            activeFiles.set(file, meta);
-    }
-    for (const file of sideEffects.removed ?? [])
-        activeFiles.delete(file);
-}
-function describeActiveFile(file) {
-    try {
-        const info = statSync(file);
-        if (!info.isFile())
-            return undefined;
-        const sha1_8 = info.size > 8 * 1024 * 1024
-            ? "large"
-            : createHash("sha1").update(readFileSync(file)).digest("hex").slice(0, 8);
-        return { path: file, sha1_8, mtime: info.mtime.toISOString() };
-    }
-    catch {
-        return undefined;
-    }
-}

package/dist/agent/shell-session.d.ts

@@ -1,37 +0,0 @@
-export type ShellJobStatus = "running" | "done" | "failed" | "killed" | "timeout";
-export interface ShellExecResult {
-    ok: boolean;
-    status: ShellJobStatus;
-    output: string;
-    exitCode?: number | null;
-    sessionId?: string;
-    nextPollMs?: number;
-}
-export interface ShellJobView {
-    id: string;
-    command: string;
-    cwd: string;
-    status: ShellJobStatus;
-    exitCode?: number | null;
-    bytes: number;
-    startedAt: number;
-    pid?: number;
-}
-interface ExecOptions {
-    signal?: AbortSignal;
-    turn?: number;
-    timeoutMs?: number;
-    backgroundAfterMs?: number;
-}
-export declare function executeShellCommand(command: string, cwd: string, options?: ExecOptions): Promise<ShellExecResult>;
-export declare function pollShellSession(id: string, waitMs?: number): Promise<ShellExecResult | undefined>;
-export declare function killShellSession(id: string): boolean;
-export declare function listShellSessions(): ShellJobView[];
-export declare function shutdownShells(): void;
-export declare function shellPoolStats(): {
-    spawns: number;
-    active: number;
-    pool: number;
-    maxSpawnPerTurn: number;
-};
-export {};