muonroi-cli 1.7.2 → 1.8.1

package/dist/src/orchestrator/auto-commit.js

@@ -0,0 +1,366 @@
+/**
+ * src/orchestrator/auto-commit.ts
+ *
+ * Deterministic "task done -> commit" enforcement (user directive 2026-06-21:
+ * the soft prompt rule "commit incrementally" was being ignored, so commits did
+ * not actually happen in real use). At the end of a successful agentic turn this
+ * auto-commits ONLY the files the agent changed during that turn, with the
+ * required attribution line.
+ *
+ * Scoping is by snapshot-diff, NOT a file-mutation tracker: we record the set of
+ * dirty/untracked paths BEFORE the turn and commit only paths that became dirty
+ * DURING it (dirtyAfter - dirtyBefore). This deliberately skips any file the user
+ * already had uncommitted before the turn — auto-commit must never fold a user's
+ * unrelated work-in-progress into an agent commit.
+ *
+ * Safety gates: git repo only · `MUONROI_AUTO_COMMIT=0` opt-out · never under
+ * unit tests (VITEST) · a sensitive-path denylist (.env / keys / secrets /
+ * .muonroi-cli) · fail-soft (a git error is logged, never breaks the turn).
+ *
+ * git is invoked via execFile with an argument array (no shell) so file paths
+ * cannot inject shell commands.
+ */
+import { execFile } from "node:child_process";
+import { logger } from "../utils/logger.js";
+import { resolve } from "node:path";
+import { promisify } from "node:util";
+const pexecFile = promisify(execFile);
+/** Attribution line every auto-commit message ends with (mirrors the prompt rule). */
+export const AUTO_COMMIT_ATTRIBUTION = "Coding by - Muonroi-CLI";
+/** Paths we must never auto-stage, regardless of who changed them (secrets). */
+const SENSITIVE_RE = /(^|\/)(\.env(\.[^/]*)?$|.*\.pem$|.*\.key$|.*\.p12$|.*\.pfx$|.*secret.*|.*credential.*|id_rsa|id_ed25519)/i;
+/**
+ * CLI-generated artifacts + build/dependency junk that must not be swept into an
+ * agent commit. The snapshot-diff catches everything that became dirty during the
+ * turn — including the CLI's OWN session/flow state (all `.muonroi-*`) which it
+ * writes into cwd. Real user repos usually gitignore node_modules/dist (so git
+ * status hides them), but exclude them too for repos that don't.
+ */
+const ARTIFACT_RE = /(^|\/)(\.muonroi-|node_modules\/|dist\/|build\/|coverage\/|\.next\/|\.turbo\/|\.git\/)|(^|\/)\.DS_Store$|\.log$/i;
+/**
+ * G1 commit quality gate. Default ON; disable with `MUONROI_COMMIT_GATE=0`
+ * (mirrors the `MUONROI_AUTO_COMMIT=0` convention). Off automatically under the
+ * unit-test suite so specs that commit fixtures aren't gated.
+ */
+export function isCommitGateEnabled() {
+    if (process.env.MUONROI_COMMIT_GATE === "0")
+        return false;
+    if (process.env.VITEST || process.env.NODE_ENV === "test")
+        return false;
+    return true;
+}
+/**
+ * G1: per-file LSP-errors gate. Runs the SAME LSP diagnostics produced at
+ * write-time on each staged path; blocks the commit if any staged file has an
+ * ERROR (severity 1). Scoped to each file's OWN diagnostics so unrelated repo
+ * breakage never blocks. Files with no registered LSP server return no
+ * diagnostics and pass (so docs/config/non-source commits are unaffected).
+ *
+ * Fails OPEN on timeout or any error — the gate must never hang a turn or block
+ * a commit on its own failure. Only a clean, in-budget run with a real
+ * severity-1 diagnostic blocks.
+ */
+/**
+ * G1 (pure): the gate's BLOCK decision for one staged file — its own
+ * severity-1 (error) diagnostics. Scoped by absolute path so a diagnostic LSP
+ * reports against a DIFFERENT file (cross-file type breakage) never blocks this
+ * commit, and warnings/infos (severity >= 2) are ignored. Exported for testing.
+ */
+export function blockingErrorsForFile(diagFiles, absPath) {
+    const out = [];
+    for (const f of diagFiles) {
+        if (resolve(f.filePath) !== absPath)
+            continue;
+        for (const d of f.diagnostics) {
+            if ((d.severity ?? 1) === 1)
+                out.push(d);
+        }
+    }
+    return out;
+}
+export async function gateStagedPaths(cwd, paths, budgetMs = 9_000) {
+    if (!isCommitGateEnabled())
+        return { ok: true };
+    try {
+        const { readFile } = await import("node:fs/promises");
+        const { syncFileWithLsp, summarizeDiagnostics } = await import("../lsp/runtime.js");
+        // Per-file diagnostics wait. The LSP default (1.5s) is fine for a WARM
+        // server (diagnostics cached) but a COLD tsserver loading the project on
+        // the first file pushes publishDiagnostics later — so a commit issued
+        // seconds after the first edit would slip past a 1.5s wait. Wait longer per
+        // file, bounded by the overall budgetMs (fail-open) so the gate can't hang.
+        const perFileWaitMs = 4_000;
+        const errorFiles = [];
+        const work = (async () => {
+            for (const p of paths) {
+                const abs = resolve(cwd, p);
+                let content;
+                try {
+                    content = await readFile(abs, "utf8");
+                }
+                catch {
+                    continue; // deleted / binary / unreadable → nothing to gate
+                }
+                const diags = await syncFileWithLsp(cwd, abs, content, false, true, perFileWaitMs).catch(() => []);
+                const errs = blockingErrorsForFile(diags, abs);
+                if (errs.length > 0) {
+                    const serverId = diags.find((f) => resolve(f.filePath) === abs)?.serverId ?? "lsp";
+                    errorFiles.push({ filePath: abs, serverId, diagnostics: errs });
+                }
+            }
+        })();
+        const TIMED_OUT = Symbol("timeout");
+        const outcome = await Promise.race([
+            work.then(() => "done"),
+            new Promise((r) => setTimeout(() => r(TIMED_OUT), budgetMs)),
+        ]);
+        if (outcome === TIMED_OUT) {
+            logger.error("orchestrator", `[commit-gate] LSP gate exceeded ${budgetMs}ms — allowing commit (fail-open)`);
+            return { ok: true };
+        }
+        if (errorFiles.length === 0)
+            return { ok: true };
+        const summary = summarizeDiagnostics(errorFiles) ?? `${errorFiles.length} file(s) have LSP errors`;
+        return { ok: false, summary };
+    }
+    catch (err) {
+        logger.error("orchestrator", "gate failed open", {
+            error: err,
+            stack: err?.stack?.split("\n").slice(0, 3),
+        });
+        return { ok: true };
+    }
+}
+/**
+ * G1 follow-up: the set of paths a bash-tool `git commit` would include, so the
+ * LSP commit gate can run on them. A raw `git commit` (unlike the `git_commit`
+ * tool) doesn't tell us its paths, so derive them from git state:
+ *   - always: the already-staged set (`git diff --cached --name-only`)
+ *   - `git commit -a`: + tracked modifications it auto-stages at commit time
+ *     (`git diff --name-only`)
+ *   - `git add -A`/`.`/`--all` chained in the SAME command: + the whole
+ *     working-tree change set (`git status --porcelain`), since the add hasn't
+ *     run yet at pre-exec time so it isn't reflected in `--cached`.
+ * Deleted/binary/unreadable paths are skipped later by gateStagedPaths when it
+ * reads them. KNOWN GAP: `git add <specific-path> && git commit` in one command
+ * where <specific-path> was not pre-staged is NOT covered (we don't parse
+ * pathspecs); the `git_commit` tool + auto-commit backstop remain the primary
+ * gates. Returns repo-relative paths (gateStagedPaths resolves them against cwd).
+ */
+export async function pathsForCommitGate(cwd, opts) {
+    const set = new Set();
+    const addLines = (out) => {
+        for (const line of out.split("\n")) {
+            const p = line.trim();
+            if (p)
+                set.add(p);
+        }
+    };
+    const staged = await git(cwd, ["diff", "--cached", "--name-only"]);
+    if (staged.ok)
+        addLines(staged.stdout);
+    if (opts.broadAdd) {
+        // `git add -A/.` stages every working-tree change; `--porcelain` enumerates
+        // exactly that superset (and omits gitignored dirs like node_modules/dist).
+        const status = await git(cwd, ["status", "--porcelain"]);
+        if (status.ok)
+            for (const p of parsePorcelainPaths(status.stdout))
+                set.add(p);
+    }
+    else if (opts.commitAll) {
+        // `git commit -a` auto-stages tracked modifications (not untracked files).
+        const mod = await git(cwd, ["diff", "--name-only"]);
+        if (mod.ok)
+            addLines(mod.stdout);
+    }
+    return [...set];
+}
+export function isAutoCommitEnabled() {
+    if (process.env.MUONROI_AUTO_COMMIT === "0")
+        return false;
+    // Never auto-commit while the unit-test suite runs — it executes in the repo
+    // working tree and would commit junk.
+    if (process.env.VITEST || process.env.NODE_ENV === "test")
+        return false;
+    return true;
+}
+async function git(cwd, args) {
+    try {
+        const { stdout } = await pexecFile("git", args, {
+            cwd,
+            timeout: 15_000,
+            maxBuffer: 16 * 1024 * 1024,
+            windowsHide: true,
+        });
+        return { stdout, ok: true };
+    }
+    catch {
+        // Expected for non-repos / hook rejections / nothing-to-commit — caller maps
+        // !ok to a skip reason; no throw escapes (fail-soft by contract).
+        return { stdout: "", ok: false };
+    }
+}
+/**
+ * Parse `git status --porcelain` output into the set of changed paths. Handles
+ * renames (`orig -> new`, keeps the new path) and quoted paths with spaces.
+ */
+export function parsePorcelainPaths(out) {
+    const set = new Set();
+    for (const line of out.split("\n")) {
+        if (line.length < 4)
+            continue;
+        let path = line.slice(3); // strip the 2-char XY status + the separating space
+        if (path.includes(" -> "))
+            path = path.slice(path.indexOf(" -> ") + 4);
+        path = path.trim().replace(/^"(.*)"$/, "$1");
+        if (path)
+            set.add(path);
+    }
+    return set;
+}
+export function isSensitivePath(path) {
+    return SENSITIVE_RE.test(path);
+}
+/** CLI artifact / build junk that must never be folded into an agent commit. */
+export function isCliArtifactPath(path) {
+    return ARTIFACT_RE.test(path);
+}
+/** Any path the auto-commit must skip: a secret or a CLI/build artifact. */
+export function isExcludedPath(path) {
+    return isSensitivePath(path) || isCliArtifactPath(path);
+}
+/**
+ * Backstop subject naming the changed FILES — used only by the deterministic
+ * end-of-turn safety net (when the agent did not commit its own work via the
+ * git_commit tool). Deliberately NOT derived from the raw user prompt (a
+ * truncated prompt is meaningless, especially for a multi-step plan); a file list
+ * at least says what changed. The meaningful, model-authored message is the
+ * git_commit tool's job (the agent writes it per chunk/plan-step).
+ */
+export function buildFileListSubject(paths) {
+    const names = paths.map((p) => p.split("/").pop() || p);
+    const shown = names.slice(0, 3).join(", ");
+    const more = names.length > 3 ? ` +${names.length - 3} more` : "";
+    return `chore: update ${paths.length} file(s) — ${shown}${more}`.slice(0, 72);
+}
+/**
+ * Split an AGENT-authored message into a bounded subject (first line, <=72 so it
+ * passes conventional-commit hooks) and a bounded body. Strips CRs and drops any
+ * attribution line the agent already added (we append exactly one ourselves).
+ * Callers pass subject/body/attribution as SEPARATE `-m` flags so git inserts the
+ * blank-line separators itself — embedding "\n\n" in a single `-m` arg gets
+ * mangled by Windows execFile (the attribution then glues onto the subject).
+ */
+export function splitCommitMessage(message) {
+    const lines = message
+        .replace(/\r/g, "")
+        .split("\n")
+        .filter((l) => l.trim() !== AUTO_COMMIT_ATTRIBUTION);
+    const subject = (lines[0] ?? "").trim().slice(0, 72);
+    const body = lines.slice(1).join("\n").trim().slice(0, 2000);
+    return { subject, body };
+}
+/** Snapshot the dirty/untracked path set before a turn (empty when not a repo). */
+export async function snapshotDirtyPaths(cwd) {
+    const r = await git(cwd, ["status", "--porcelain", "--untracked-files=all"]);
+    if (!r.ok)
+        return new Set();
+    return parsePorcelainPaths(r.stdout);
+}
+/**
+ * Commit the files the agent changed this turn. `dirtyBefore` is the snapshot
+ * from before the turn. Returns a result describing what happened; never throws.
+ */
+export async function maybeAutoCommitTurn(opts) {
+    if (!isAutoCommitEnabled())
+        return { committed: false, reason: "disabled" };
+    const { cwd, dirtyBefore, userMessage } = opts;
+    const inRepo = await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    if (!inRepo.ok || inRepo.stdout.trim() !== "true")
+        return { committed: false, reason: "not-a-repo" };
+    const dirtyAfter = await snapshotDirtyPaths(cwd);
+    const newPaths = [...dirtyAfter].filter((p) => !dirtyBefore.has(p) && !isExcludedPath(p));
+    if (newPaths.length === 0)
+        return { committed: false, reason: "no-agent-changes" };
+    const add = await git(cwd, ["add", "--", ...newPaths]);
+    if (!add.ok) {
+        logger.error("orchestrator", `[auto-commit] git add failed for ${newPaths.length} path(s) in ${cwd}`);
+        return { committed: false, reason: "add-failed" };
+    }
+    // G1 quality gate: do NOT auto-commit code that fails LSP error checks. The
+    // backstop simply skips (no spurious chore commit of broken code); the agent
+    // will see/fix it next turn. Staged paths stay staged (idempotent).
+    const gate = await gateStagedPaths(cwd, newPaths);
+    if (!gate.ok) {
+        logger.error("orchestrator", `[auto-commit] skipped — staged files have LSP errors:\n${gate.summary}`);
+        return { committed: false, reason: "lsp-errors", detail: gate.summary };
+    }
+    // Separate -m flags → git inserts the blank line between subject and
+    // attribution (Windows-safe; embedded "\n\n" in one -m arg gets mangled).
+    // Scope the commit to exactly the agent's paths (pathspec).
+    const commit = await git(cwd, [
+        "commit",
+        "-m",
+        buildFileListSubject(newPaths),
+        "-m",
+        AUTO_COMMIT_ATTRIBUTION,
+        "--",
+        ...newPaths,
+    ]);
+    if (!commit.ok) {
+        logger.error("orchestrator", `[auto-commit] git commit failed in ${cwd} (a pre-commit/commit-msg hook may have rejected it)`);
+        return { committed: false, reason: "commit-failed" };
+    }
+    const head = await git(cwd, ["rev-parse", "--short", "HEAD"]);
+    return { committed: true, sha: head.ok ? head.stdout.trim() : undefined, fileCount: newPaths.length };
+}
+/**
+ * Commit a SPECIFIC set of paths (absolute or repo-relative) with an
+ * AGENT-AUTHORED message — backs the git_commit tool. Stages only `paths` (minus
+ * secrets/artifacts), commits with the model's message + the attribution line,
+ * scoped by pathspec. No-op if nothing among `paths` is actually staged
+ * (e.g. already committed). Never throws.
+ */
+export async function commitSpecificPaths(cwd, paths, message) {
+    if (process.env.MUONROI_AUTO_COMMIT === "0")
+        return { committed: false, reason: "disabled" };
+    const safe = paths.filter((p) => !isExcludedPath(p));
+    if (safe.length === 0)
+        return { committed: false, reason: "no-eligible-paths" };
+    const inRepo = await git(cwd, ["rev-parse", "--is-inside-work-tree"]);
+    if (!inRepo.ok || inRepo.stdout.trim() !== "true")
+        return { committed: false, reason: "not-a-repo" };
+    const add = await git(cwd, ["add", "--", ...safe]);
+    if (!add.ok) {
+        logger.error("orchestrator", `[git_commit] git add failed for ${safe.length} path(s) in ${cwd}`);
+        return { committed: false, reason: "add-failed" };
+    }
+    // Only commit if these paths actually have staged changes (idempotent across
+    // repeat calls — already-committed files stage nothing).
+    const staged = await git(cwd, ["diff", "--cached", "--name-only", "--", ...safe]);
+    if (!staged.ok || !staged.stdout.trim())
+        return { committed: false, reason: "nothing-staged" };
+    // G1 quality gate: block the commit if any staged file has an LSP error. The
+    // git_commit tool surfaces reason+detail so the agent can fix and recommit.
+    const gate = await gateStagedPaths(cwd, safe);
+    if (!gate.ok) {
+        return { committed: false, reason: "lsp-errors", detail: gate.summary };
+    }
+    const { subject, body } = splitCommitMessage(message);
+    // Separate -m flags so git inserts the blank-line separators itself.
+    const mArgs = body
+        ? ["-m", subject, "-m", body, "-m", AUTO_COMMIT_ATTRIBUTION]
+        : ["-m", subject, "-m", AUTO_COMMIT_ATTRIBUTION];
+    const commit = await git(cwd, ["commit", ...mArgs, "--", ...safe]);
+    if (!commit.ok) {
+        logger.error("orchestrator", `[git_commit] git commit failed in ${cwd} (a pre-commit/commit-msg hook may have rejected it)`);
+        return { committed: false, reason: "commit-failed" };
+    }
+    const head = await git(cwd, ["rev-parse", "--short", "HEAD"]);
+    return {
+        committed: true,
+        sha: head.ok ? head.stdout.trim() : undefined,
+        fileCount: staged.stdout.trim().split("\n").length,
+    };
+}
+//# sourceMappingURL=auto-commit.js.map

package/dist/src/orchestrator/batch-turn-runner.d.ts

@@ -3,7 +3,7 @@ import type { getModelInfo } from "../models/registry.js";
 import { type resolveModelRuntime } from "../providers/runtime.js";
 import type { BashTool } from "../tools/bash.js";
 import type { AgentMode, StreamChunk, TaskRequest, ToolCall, ToolResult } from "../types/index.js";
-import type { BatchClientOptions, LegacyProvider, ProcessMessageObserver } from "./agent-options.js";
+import type { BatchClientOptions, LegacyProvider } from "./agent-options.js";
 import type { TurnRunnerDepsBase } from "./turn-runner-deps.js";
 /**
  * Dependency surface BatchTurnRunner needs to reach back into Agent state
@@ -46,7 +46,8 @@ export declare class BatchTurnRunner {
     constructor(deps: BatchTurnRunnerDeps);
     run(args: {
         userModelMessage: ModelMessage;
-        observer?: ProcessMessageObserver;
+        userEnrichedMessage: ModelMessage;
+        observer?: any;
         provider: LegacyProvider;
         subagents: unknown[];
         system: string;

package/dist/src/orchestrator/batch-turn-runner.js

@@ -133,6 +133,7 @@ export class BatchTurnRunner {
                     const batchRequestId = `turn-${Date.now()}-${stepNumber}`;
                     // Phase O1 — capture providerOptions SHAPE for batch path too.
                     deps.setLastProviderOptionsShape(extractProviderOptionsShape(runtime.providerOptions));
+                    const _messagesForCall = deps.messages.map((m) => (m === args.userModelMessage ? args.userEnrichedMessage : m));
                     await addBatchRequests({
                         ...deps.getBatchClientOptions(signal),
                         batchId: batch.batch_id,
@@ -143,7 +144,7 @@ export class BatchTurnRunner {
                                     chat_get_completion: buildBatchChatCompletionRequest({
                                         modelId: runtime.modelId,
                                         system,
-                                        messages: [...deps.messages, ...turnMessages],
+                                        messages: [..._messagesForCall, ...turnMessages],
                                         temperature: 0.7,
                                         maxOutputTokens: !batchCaps.acceptsParam("maxOutputTokens", runtime.modelInfo)
                                             ? undefined

package/dist/src/orchestrator/compaction-proposer-prompt.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Compaction proposer prompt — model decides if compaction is needed and what to keep/drop.
+ * Replaces the heuristic shouldCompactContext + findCutPoint with LLM judgement.
+ *
+ * The principle: only compact when the model says yes, and keep exactly what the model says to keep.
+ * No hard-coded thresholds, no automatic FIFO cutting.
+ */
+export declare const COMPACT_PROPOSER_SYSTEM_PROMPT = "You are a conversation-compaction proposer. Your job is to decide:\n1. Whether compaction is NEEDED right now\n2. Which tool outputs / messages to KEEP verbatim\n3. Which tool outputs / messages to DROP entirely\n4. Which tool outputs / messages to SUMMARIZE\n\nRules:\n- DO NOT compact if the current task is IN PROGRESS and tool-output evidence is needed for the next steps.\n- DO NOT compact mid-turn \u2014 wait until a natural pause (user message boundary, task completed).\n- ALWAYS keep error messages, test-failure logs, and critical data (file paths, function names, API responses).\n- ALWAYS keep the most recent N tool-turn results that contain evidence for unfinished work.\n- Transient outputs (directory listings, git log --oneline, simple confirmations) can be DROPPED.\n- Raw file contents that were used as evidence for edits should be DROPPED once the edit is verified (the edit result is what matters).\n- Long search/grep outputs should be SUMMARIZED to preserve which files matched, not the full content.\n\nOutput format \u2014 strict JSON, no markdown fences, no extra text:\n{\n  \"shouldCompact\": boolean,\n  \"reason\": \"short explanation why compact or not\",\n  \"actions\": [\n    {\n      \"messageIndex\": number,\n      \"action\": \"keep\" | \"drop\" | \"summarize\",\n      \"reason\": \"why this action for this message\"\n    }\n  ]\n}\n\n- \"messageIndex\" refers to the index in the messages array I provide.\n- \"keep\" = keep verbatim in the active conversation.\n- \"drop\" = remove entirely from conversation (not even in summary).\n- \"summarize\" = include in the summary generation input.\n- The most recent turn (user + assistant + tool messages) should always be \"keep\".\n- Only mark messages as \"drop\" if they are truly transient and irrelevant to future work.\n- When in doubt, prefer \"keep\" or \"summarize\" over \"drop\".";

package/dist/src/orchestrator/compaction-proposer-prompt.js

@@ -0,0 +1,43 @@
+/**
+ * Compaction proposer prompt — model decides if compaction is needed and what to keep/drop.
+ * Replaces the heuristic shouldCompactContext + findCutPoint with LLM judgement.
+ *
+ * The principle: only compact when the model says yes, and keep exactly what the model says to keep.
+ * No hard-coded thresholds, no automatic FIFO cutting.
+ */
+export const COMPACT_PROPOSER_SYSTEM_PROMPT = `You are a conversation-compaction proposer. Your job is to decide:
+1. Whether compaction is NEEDED right now
+2. Which tool outputs / messages to KEEP verbatim
+3. Which tool outputs / messages to DROP entirely
+4. Which tool outputs / messages to SUMMARIZE
+
+Rules:
+- DO NOT compact if the current task is IN PROGRESS and tool-output evidence is needed for the next steps.
+- DO NOT compact mid-turn — wait until a natural pause (user message boundary, task completed).
+- ALWAYS keep error messages, test-failure logs, and critical data (file paths, function names, API responses).
+- ALWAYS keep the most recent N tool-turn results that contain evidence for unfinished work.
+- Transient outputs (directory listings, git log --oneline, simple confirmations) can be DROPPED.
+- Raw file contents that were used as evidence for edits should be DROPPED once the edit is verified (the edit result is what matters).
+- Long search/grep outputs should be SUMMARIZED to preserve which files matched, not the full content.
+
+Output format — strict JSON, no markdown fences, no extra text:
+{
+  "shouldCompact": boolean,
+  "reason": "short explanation why compact or not",
+  "actions": [
+    {
+      "messageIndex": number,
+      "action": "keep" | "drop" | "summarize",
+      "reason": "why this action for this message"
+    }
+  ]
+}
+
+- "messageIndex" refers to the index in the messages array I provide.
+- "keep" = keep verbatim in the active conversation.
+- "drop" = remove entirely from conversation (not even in summary).
+- "summarize" = include in the summary generation input.
+- The most recent turn (user + assistant + tool messages) should always be "keep".
+- Only mark messages as "drop" if they are truly transient and irrelevant to future work.
+- When in doubt, prefer "keep" or "summarize" over "drop".`;
+//# sourceMappingURL=compaction-proposer-prompt.js.map

package/dist/src/orchestrator/compaction.d.ts

@@ -1,5 +1,27 @@
 import { type ModelMessage } from "ai";
 import type { ProviderFactory as LegacyProvider } from "../providers/runtime.js";
+/**
+ * A single action the compaction proposer model wants to take on one message.
+ */
+export interface CompactionProposeAction {
+    messageIndex: number;
+    action: "keep" | "drop" | "summarize";
+    reason: string;
+}
+/**
+ * The full decision returned by the compaction proposer model.
+ */
+export interface CompactionProposal {
+    shouldCompact: boolean;
+    reason: string;
+    actions: CompactionProposeAction[];
+}
+/**
+ * Call the model to propose what to compact/keep/drop.
+ * The model sees the current messages and decides whether compaction is needed at all.
+ * Returns null if the proposer call fails (caller should fall back gracefully).
+ */
+export declare function proposeCompaction(provider: LegacyProvider, modelId: string, messages: ModelMessage[], signal?: AbortSignal): Promise<CompactionProposal | null>;
 export interface CompactionSettings {
     reserveTokens: number;
     keepRecentTokens: number;

package/dist/src/orchestrator/compaction.js

@@ -2,8 +2,50 @@ import { generateText } from "ai";
 import { isMetaAnalysisPrompt } from "../pil/layer6-output.js";
 import { getProviderCapabilities } from "../providers/capabilities.js";
 import { requireRuntimeProvider, resolveModelRuntime } from "../providers/runtime.js";
+import { COMPACT_PROPOSER_SYSTEM_PROMPT } from "./compaction-proposer-prompt.js";
 import { containsEncryptedReasoning } from "./reasoning.js";
 import { countTokens } from "./token-counter.js";
+/**
+ * Call the model to propose what to compact/keep/drop.
+ * The model sees the current messages and decides whether compaction is needed at all.
+ * Returns null if the proposer call fails (caller should fall back gracefully).
+ */
+export async function proposeCompaction(provider, modelId, messages, signal) {
+    try {
+        const runtime = resolveModelRuntime(provider, modelId);
+        const compactCaps = getProviderCapabilities(requireRuntimeProvider(runtime));
+        const serialized = serializeConversation(messages);
+        const result = await generateText({
+            model: runtime.model,
+            system: COMPACT_PROPOSER_SYSTEM_PROMPT,
+            prompt: `Current conversation messages:\n\n${serialized}\n\nDecide if compaction is needed and what to keep/drop/summarize. Return strict JSON.`,
+            abortSignal: signal,
+            maxRetries: 1,
+            temperature: 0.1,
+            ...(!compactCaps.acceptsParam("maxOutputTokens", runtime.modelInfo) ? {} : { maxOutputTokens: 2048 }),
+            ...(runtime.providerOptions ? { providerOptions: runtime.providerOptions } : {}),
+        });
+        const text = result.text.trim();
+        // Attempt to parse top-level JSON object. The model might wrap in markdown fences — strip those.
+        const jsonStr = text.replace(/^```(?:json)?\s*|\s*```$/gi, "").trim();
+        const parsed = JSON.parse(jsonStr);
+        // Validate shape
+        if (typeof parsed.shouldCompact !== "boolean" || !Array.isArray(parsed.actions)) {
+            return null;
+        }
+        // Validate each action
+        for (const action of parsed.actions) {
+            if (typeof action.messageIndex !== "number" || !["keep", "drop", "summarize"].includes(action.action)) {
+                return null;
+            }
+        }
+        return parsed;
+    }
+    catch {
+        // Proposer failure is non-fatal — caller falls back to heuristic or no-compact
+        return null;
+    }
+}
 const TOOL_RESULT_MAX_CHARS = 8000;
 const MIN_KEPT_TOKENS_ON_RETRY = 4000;
 export const DEFAULT_RESERVE_TOKENS = 16_384;

package/dist/src/orchestrator/delegations.d.ts

@@ -40,6 +40,7 @@ export declare class DelegationManager {
     start(request: TaskRequest, options: StartDelegationOptions): Promise<ToolResult>;
     list(): Promise<DelegationRun[]>;
     read(id: string): Promise<string>;
+    kill(id: string): Promise<ToolResult>;
     consumeNotifications(): Promise<DelegationNotification[]>;
     private getById;
 }

package/dist/src/orchestrator/delegations.js

@@ -107,6 +107,47 @@ export class DelegationManager {
             return `Delegation "${id}" completed, but its saved output could not be read.`;
         }
     }
+    async kill(id) {
+        const record = await this.getById(id);
+        if (!record) {
+            return {
+                success: false,
+                output: `Delegation "${id}" not found.`,
+            };
+        }
+        if (record.status !== "running") {
+            return {
+                success: false,
+                output: `Delegation "${id}" is not running (status: ${record.status}).`,
+            };
+        }
+        const pid = record.pid;
+        if (!pid) {
+            const jobPath = path.join(await ensureDelegationsDir(this.getCwd()), `${id}.json`);
+            await failDelegation(jobPath, "Cancelled: Process PID was not recorded.");
+            return {
+                success: true,
+                output: `Delegation "${id}" marked as cancelled (no active process ID was found).`,
+            };
+        }
+        try {
+            if (process.platform === "win32") {
+                spawn("taskkill", ["/F", "/T", "/PID", pid.toString()]).unref();
+            }
+            else {
+                process.kill(pid, "SIGTERM");
+            }
+        }
+        catch (err) {
+            // ignore
+        }
+        const jobPath = path.join(await ensureDelegationsDir(this.getCwd()), `${id}.json`);
+        await failDelegation(jobPath, "Cancelled by user.");
+        return {
+            success: true,
+            output: `Delegation "${id}" (PID: ${pid}) has been terminated.`,
+        };
+    }
     async consumeNotifications() {
         const dir = await ensureDelegationsDir(this.getCwd());
         const files = await readDelegationFiles(dir);

package/dist/src/orchestrator/error-utils.js

@@ -67,10 +67,24 @@ function humanizeApiErrorBase(error) {
     }
     if (APICallError.isInstance(error)) {
         const detail = extractResponseDetail(error.responseBody);
+        const status = error.statusCode;
+        // 5xx response bodies are usually generic server-side noise that MASKS the
+        // actionable status. Verified live: SiliconFlow returns a 500 with body
+        // {code:60000,message:"Request failed: Unknown error."} — surfacing that
+        // string told the user nothing and hid the fact it was a retryable 500.
+        // For 5xx prefer the canned "retry later" message + the status code; keep a
+        // body detail only when it actually adds information.
+        if (status && status >= 500) {
+            const canned = STATUS_MESSAGES[status] ?? "The API server returned an error. Please try again later.";
+            if (!detail || isOpaqueDetail(detail))
+                return `${canned} (HTTP ${status})`;
+            return `${detail} (HTTP ${status})`;
+        }
+        // 4xx: the body almost always says WHAT was wrong — keep it verbatim.
         if (detail)
             return detail;
-        if (error.statusCode && STATUS_MESSAGES[error.statusCode]) {
-            return STATUS_MESSAGES[error.statusCode];
+        if (status && STATUS_MESSAGES[status]) {
+            return STATUS_MESSAGES[status];
         }
     }
     const raw = error instanceof Error ? error.message : String(error);
@@ -99,6 +113,17 @@ function extractResponseDetail(body) {
     }
     return null;
 }
+/**
+ * A provider "detail" string that carries no diagnostic value — generic
+ * server-error phrasing that masks the more useful HTTP status. Verified live:
+ * SiliconFlow 500s carry message "Request failed: Unknown error.". Used only on
+ * the 5xx path so an informative server message is still preferred when present.
+ */
+function isOpaqueDetail(detail) {
+    const s = detail.trim().toLowerCase();
+    return (s.length < 4 ||
+        /unknown error|request failed|internal server error|service (unavailable|temporarily)|bad gateway|gateway time-?out|^error\.?$|^failed\.?$/.test(s));
+}
 const RESPONSE_BODY_CAP = 1000;
 export function summarizeApiErrorForLog(error) {
     if (!APICallError.isInstance(error))