atom-agent 1.1.0 → 1.3.0

package/dist/agent/normalize.js

@@ -1,3 +1,4 @@
+import { truncateHead } from "../tools/shared.js";
 // Safety net for custom executors (built-in tools already cap: read 64KB
 // head + truncation note + overflow pointer ≈ 66KB, bash 8KB, webfetch 64KB
 // + notes). The cap sits at 128KB so legitimate built-in outputs (overflow
@@ -27,8 +28,8 @@ export function normalizeToolResult(result) {
         }
     }
     if (text.length > TOOL_RESULT_CAP_CHARS) {
-        return (text.slice(0, TOOL_RESULT_CAP_CHARS) +
-            `\n[truncated: tool result exceeded ${TOOL_RESULT_CAP_CHARS} chars]`);
+        const t = truncateHead(text, TOOL_RESULT_CAP_CHARS, `\n[truncated: tool result exceeded ${TOOL_RESULT_CAP_CHARS} chars]`);
+        return t.head + t.note;
     }
     return text;
 }
@@ -92,6 +93,10 @@ export function normalizeChatResult(raw) {
             result["usage"] = m["usage"];
         if (m["reasoning"] !== undefined)
             result["reasoning"] = m["reasoning"];
+        // Length-truncation flag survives normalization (no calls or not — the
+        // loop decides; truncated-without-calls behaves as before).
+        if (m["truncated"] === true)
+            result.truncated = true;
         return { result: result, warnings };
     }
     if (!Array.isArray(callsRaw)) {
@@ -140,5 +145,7 @@ export function normalizeChatResult(raw) {
         out["usage"] = m["usage"];
     if (m["reasoning"] !== undefined)
         out["reasoning"] = m["reasoning"];
+    if (m["truncated"] === true)
+        out.truncated = true;
     return { result: out, warnings };
 }

package/dist/cli.js

@@ -4,8 +4,13 @@ import { render } from "ink";
 import { App } from "./App.js";
 import { DEFAULT_ENDPOINT, DEFAULT_MODEL, endpointConfig, } from "./zen.js";
 import { loadAuth, resolveApiKey } from "./auth.js";
+import { parseExtensionFlags } from "./extensions.js";
 import { writeTelemetryDashboard } from "./telemetry-dashboard.js";
 const args = process.argv.slice(2);
+// Extension trust lockdown (ticket 07): --no-extensions (--lockdown alias)
+// boots with zero third-party extensions; --enable/--disable-extension take
+// repeatable `*`/`?` patterns over extension names (CLI wins over atom.json).
+const extFlags = parseExtensionFlags(args);
 if (args.includes("--dashboard")) {
     // Local observability dashboard without starting the TUI: render every
     // stored session to ~/.atom/telemetry/dashboard.html and print the path.
@@ -54,15 +59,18 @@ else if (args.includes("--help") || args.includes("-h")) {
 Usage: npm start
 Flags: --dashboard (write ~/.atom/telemetry/dashboard.html and exit)
        --serve [--port <n>] (serve the live dashboard webUI on loopback and keep running)
+       --no-extensions (--lockdown alias: boot with zero third-party extensions; builtins unchanged)
+       --enable-extension <glob> (repeatable; only matching extensions load)
+       --disable-extension <glob> (repeatable; wins over --enable-extension)
 Env:
   KILO_API_KEY  optional (Kilo free models work anonymously; get a key at https://kilo.ai) — env wins over ~/.atom/auth.json
   OPENCODE_ZEN_API_KEY  optional when ~/.atom/auth.json has a zen key (get one at https://opencode.ai/auth)
   OPENAI_API_KEY / ANTHROPIC_API_KEY / DEEPSEEK_API_KEY / MISTRAL_API_KEY / GEMINI_API_KEY (GOOGLE_API_KEY alias)  optional per provider (env wins over stored)
   OPENCODE_ZEN_MODEL    optional (default: ${DEFAULT_MODEL}; when set, wins over the saved /model)
   OPENCODE_ZEN_ENDPOINT optional (default: ${DEFAULT_ENDPOINT})
-Commands: /model (model picker) | /models [refresh] (local discovery refresh; Kilo catalog refresh when Kilo is active) | /provider (provider + key picker) | /effort (reasoning-effort picker) | /tools | /skills (list installed skills) | /skill:name (invoke) | /context (context usage) | /queue + /steer (follow-ups while busy) | /autoscroll on|off (follow new output) | /thinking (toggle reasoning visibility) | /mode | /clear | /resume (restore last saved session) | /help | /exit | /quit — Tab cycles the permission mode normal → yolo → plan
+ Commands: /model (model picker) | /models [refresh] (local discovery refresh; Kilo catalog refresh when Kilo is active) | /provider (provider + key picker) | /effort (reasoning-effort picker) | /goal <objective> (pin one session objective; bare shows it, pause/resume/clear manage it) | /compact [focus] (summarize older turns) | /tools | /skills (list installed skills) | /skill:name (invoke) | /context (context usage) | /queue + /steer (follow-ups while busy) | /autoscroll (toggle follow new output) | /thinking (toggle reasoning visibility) | /mode | /trust | /allow | /deny | /rules | /clear | /new (fresh conversation, previous kept) | /rename <name> (rename current session) | /session (switch session picker) | /resume (restore last saved session) | /telemetry | /dashboard | /rewind | /help | /exit | /quit — Tab cycles the permission mode normal → yolo → plan → normal (extension slash commands appear in the / menu and palette, not in this static list)
 Providers: kilo (default; anonymous free models, key optional)/opencode-zen/openai/anthropic/deepseek/mistral/google-gemini/openai-compatible (keys in ~/.atom/auth.json, 0600 POSIX; use /provider to paste one) + local auto-discovery: ollama (:11434), lmstudio (:1234), llamacpp (:8080) — no keys needed, overrides via ATOM_OLLAMA_URL/ATOM_LMSTUDIO_URL/ATOM_LLAMACPP_URL.
-Note: reasoning_effort is sent only for opencode-zen supported models.`);
+Effort (Auto/Low/Medium/High/Max) applies on every provider: reasoning_effort for OpenAI-chat kinds, thinking budgets for Anthropic, thinking levels for Gemini. Auto omits the knob.`);
     process.exit(0);
 }
 const { endpoint, apiKey: envKey } = endpointConfig();
@@ -86,5 +94,19 @@ const envModel = process.env.OPENCODE_ZEN_MODEL?.trim() || undefined;
 // --serve parks above (the server holds the event loop), so the TUI must
 // never start alongside it: serve is a standalone mode like --dashboard.
 if (!args.includes("--serve")) {
-    render(_jsx(App, { apiKey: apiKey, endpoint: endpoint, initialModel: envModel, restorePrefs: true }));
+    // Production frame policy (Ink 7.1.1):
+    // - incrementalRendering: only changed terminal lines rewrite per frame.
+    //   Streaming paints touch the live tail + status bar, not the scrollback,
+    //   so this cuts flicker and stdout bytes on every token flush.
+    //   Escape hatch: ATOM_INCREMENTAL=0 restores full-frame rendering.
+    // - maxFps: 30 keeps keystroke-to-paint latency low; token paints already
+    //   coalesce to ~15fps via DRAFT_THROTTLE_MS, so Ink never does extra work.
+    // - concurrent: enables React concurrent features (useTransition /
+    //   useDeferredValue) for future deferral of expensive subtrees.
+    // Tests are unaffected: they render via ink-testing-library, not here.
+    render(_jsx(App, { apiKey: apiKey, endpoint: endpoint, initialModel: envModel, restorePrefs: true, extensionsLockdown: extFlags.lockdown, enableExtensions: extFlags.enable, disableExtensions: extFlags.disable }), {
+        incrementalRendering: process.env.ATOM_INCREMENTAL !== "0",
+        maxFps: 30,
+        concurrent: true,
+    });
 }

package/dist/compact.js

@@ -8,7 +8,7 @@
 //   by the summary; manual `/compact [focus]`; thrashing guard.
 // - opencode V2: preflight estimate = JSON-serialized request size at
 //   4 chars/token; summary via session model with TOOLS DISABLED, ≤4096
-//   output tokens, structured template; newest tail retained (~8000 tokens,
+//   output tokens, structured template; newest tail retained (~20000 tokens,
 //   tool outputs capped 2000 chars); overflow-recovery retry once.
 //
 // This module is pure + testable (mocked fetch only in tests, never live).
@@ -20,9 +20,10 @@ import { chatCompletionForProvider, } from "./zen.js";
 // ContextManager module; compact.ts imports what its splitter needs and
 // re-exports the stable surface so existing importers keep working untouched.
 import { estimateTokensForChars, messageChars } from "./context-manager.js";
+import { truncateHead } from "./tools/shared.js";
 export { COMPACT_PCT_DEFAULT, compactPct, computeContextLoad, estimateTokensForChars, historyChars, shouldAutoCompact, } from "./context-manager.js";
 // ---- Constants ----
-export const COMPACT_KEEP_TOKENS = 8000;
+export const COMPACT_KEEP_TOKENS = 20000;
 export const COMPACT_SUMMARY_MAX_TOKENS = 4096;
 export const COMPACT_TOOL_OUTPUT_CAP = 2000;
 // opencode's 4ch/token heuristic (V2 preflight estimate): chars/4 floors to
@@ -62,10 +63,12 @@ function turnChars(history, start, end) {
 export function capToolOutputsInTail(tail) {
     return tail.map((m) => {
         if (m.role === "tool" && typeof m.content === "string" && m.content.length > COMPACT_TOOL_OUTPUT_CAP) {
+            // Line-aware cap (issue 04): the retained head never ends mid-line;
+            // cap value and legacy note prefix are unchanged.
+            const t = truncateHead(m.content, COMPACT_TOOL_OUTPUT_CAP, "\n[truncated: tool output exceeded 2000 chars]");
             return {
                 ...m,
-                content: m.content.slice(0, COMPACT_TOOL_OUTPUT_CAP) +
-                    "\n[truncated: tool output exceeded 2000 chars]",
+                content: t.head + t.note,
             };
         }
         return { ...m };
@@ -100,7 +103,7 @@ export function splitHistoryForCompaction(history, keepTokens = COMPACT_KEEP_TOK
     // Everything fits but >1 turn: keep only the newest turn in the tail so
     // manual /compact still has an older turn to summarize (auto never
     // reaches here — its load would be far below threshold when everything
-    // fits in 8000 tokens).
+    // fits in 20000 tokens).
     if (tailStart === starts[0] && starts.length > 1) {
         tailStart = starts[starts.length - 1];
     }
@@ -114,28 +117,38 @@ export function splitHistoryForCompaction(history, keepTokens = COMPACT_KEEP_TOK
     return { head, tail, olderTurnCount };
 }
 // ---- Instruction template ----
-export function buildCompactionInstruction(focusText) {
+// goalObjective (ticket 08) is a prompt hint only: when a session goal is
+// live, the summarizer is told to preserve goal-relevant progress, evidence,
+// and next steps inside its prose (the canonical `Goal:` block is appended
+// separately after the POST). Absent/blank reads exactly as before, so
+// non-goal compaction output stays byte-identical.
+export function buildCompactionInstruction(focusText, goalObjective) {
     const focus = typeof focusText === "string" && focusText.trim().length > 0
         ? `\nFocus for this summary: ${focusText.trim()}\n`
         : "";
+    const goal = typeof goalObjective === "string" && goalObjective.trim().length > 0
+        ? `\nSession goal to preserve: "${goalObjective.trim()}" — keep goal-relevant progress, ` +
+            `evidence, and next steps for it in the summary so the next turn can continue it ` +
+            `without re-exploring.\n`
+        : "";
     return (`Summarize the conversation so far for context compaction. Be concise but preserve all information needed to continue the work without re-reading the full history.` +
-        `${focus}\n` +
+        `${focus}${goal}\n` +
         `Structure your summary with these headings (omit a section only when it has no content):\n` +
         `## Objective\n` +
-        `## Requirements\n` +
-        `## Decisions\n` +
-        `## Completed work\n` +
-        `## Active work\n` +
-        `## Blockers\n` +
-        `## Next moves\n` +
-        `## Relevant files\n` +
+        `## Important Details\n` +
+        `## Work State\n` +
+        `### Completed\n` +
+        `### Active\n` +
+        `### Blocked\n` +
+        `## Next Move\n` +
+        `## Relevant Files\n` +
         `Rules: no tools are available for this request — answer with the summary text only, no tool calls, no preamble beyond the headings.`);
 }
-export function buildSummaryMessages(systemContent, head, focusText) {
+export function buildSummaryMessages(systemContent, head, focusText, goalObjective) {
     return [
         { role: "system", content: systemContent },
         ...head.map((m) => ({ ...m })),
-        { role: "user", content: buildCompactionInstruction(focusText) },
+        { role: "user", content: buildCompactionInstruction(focusText, goalObjective) },
     ];
 }
 export function buildCompactedHistory(systemMessage, summaryText, tail, olderTurnCount, nowISO) {
@@ -190,7 +203,7 @@ export function truncateHeadForRetry(head) {
 // throw immediately with history untouched (caller must not swap).
 export async function requestCompactSummary(req) {
     const attempt = async (head) => {
-        const messages = buildSummaryMessages(req.systemContent, head, req.focusText);
+        const messages = buildSummaryMessages(req.systemContent, head, req.focusText, req.goalObjective);
         const res = await chatCompletionForProvider(req.provider, req.apiKey, req.model, messages, {
             baseURL: req.baseURL,
             endpointOverride: req.endpointOverride,
@@ -233,3 +246,142 @@ export async function requestCompactSummary(req) {
         }
     }
 }
+function pushUniquePath(list, p) {
+    if (p.length === 0 || list.includes(p))
+        return;
+    list.push(p);
+}
+// Collect read/modified paths from committed tool_calls in head (insertion
+// order, unique). Unparseable arguments are skipped — a bad payload must
+// never break compaction. A path both read and written lands in modified
+// only (the write implies the read).
+export function collectTouchedFiles(head) {
+    const read = [];
+    const modified = [];
+    for (const m of head) {
+        if (m?.role !== "assistant")
+            continue;
+        const calls = m.tool_calls;
+        if (!Array.isArray(calls))
+            continue;
+        for (const c of calls) {
+            const fn = c?.function;
+            if (typeof fn?.name !== "string")
+                continue;
+            let p = "";
+            try {
+                const args = typeof fn.arguments === "string" ? JSON.parse(fn.arguments) : null;
+                const raw = args?.path;
+                if (typeof raw === "string")
+                    p = raw.trim();
+            }
+            catch {
+                continue; // unparseable args pin nothing
+            }
+            if (p.length === 0)
+                continue;
+            if (fn.name === "write" || fn.name === "edit")
+                pushUniquePath(modified, p);
+            else if (fn.name === "read")
+                pushUniquePath(read, p);
+        }
+    }
+    // Modified implies read: keep modified entries out of the read list.
+    const modifiedSet = new Set(modified);
+    return { read: read.filter((p) => !modifiedSet.has(p)), modified };
+}
+// Canonical on-disk + on-resume format. Empty sections are omitted; both
+// empty renders "" (the caller then appends nothing).
+export function formatTouchedFiles(t) {
+    const lines = ["Touched files:"];
+    if (t.read.length > 0)
+        lines.push(`Read: ${t.read.join(", ")}`);
+    if (t.modified.length > 0)
+        lines.push(`Modified: ${t.modified.join(", ")}`);
+    return lines.length > 1 ? lines.join("\n") : "";
+}
+export function appendTouchedFiles(summaryText, touched) {
+    const block = formatTouchedFiles(touched);
+    if (!block)
+        return summaryText;
+    return `${summaryText}\n\n${block}`;
+}
+// ---- Size budget for the summary message ----
+// The summary text itself is never cut — only the file lists shrink to fit,
+// so an over-budget summary degrades gracefully instead of failing
+// compaction. Budget = the summary output cap via the 4ch/token estimator.
+export const COMPACT_SUMMARY_MAX_CHARS = COMPACT_SUMMARY_MAX_TOKENS * COMPACT_CHARS_PER_TOKEN;
+// Shrink the lists until the formatted block fits maxChars. Drops the oldest
+// entry from the longer list (ties: read first — modifications are the
+// higher-signal list). Never throws; an empty result formats to "".
+export function truncateTouchedFiles(touched, maxChars) {
+    const read = [...touched.read];
+    const modified = [...touched.modified];
+    while ((read.length > 0 || modified.length > 0) &&
+        formatTouchedFiles({ read, modified }).length > maxChars) {
+        if (read.length >= modified.length)
+            read.shift();
+        else
+            modified.shift();
+    }
+    return { read, modified };
+}
+// Append file lists to the summary within budget: shrink the lists (never
+// the model text) until summary + block fits; when nothing fits, the summary
+// stands alone and compaction still succeeds.
+export function fitSummaryWithFiles(summaryText, touched, maxChars = COMPACT_SUMMARY_MAX_CHARS) {
+    const before = touched.read.length + touched.modified.length;
+    const block = formatTouchedFiles(touched);
+    if (!block)
+        return { text: summaryText, truncated: false };
+    if (summaryText.length + 2 + block.length <= maxChars) {
+        return { text: `${summaryText}\n\n${block}`, truncated: false };
+    }
+    const room = Math.max(0, maxChars - summaryText.length - 2);
+    const shrunk = truncateTouchedFiles(touched, room);
+    const shrunkBlock = formatTouchedFiles(shrunk);
+    const truncated = shrunk.read.length + shrunk.modified.length < before;
+    if (!shrunkBlock)
+        return { text: summaryText, truncated };
+    return { text: `${summaryText}\n\n${shrunkBlock}`, truncated };
+}
+// ---- Goal block fitting (ticket 08) ----
+// Append the canonical `Goal:` block plus the touched-files lists within one
+// shared budget: the goal block rides with the model text (never shrunk — it
+// is one short line plus a capped checklist tail, see formatGoalForCompact),
+// so only the touched-files lists shrink via the same rule above. The goal
+// block lands BEFORE the files block, keeping `Touched files:` last so its
+// verbatim extractor (lastIndexOf below) still finds the appended block. An
+// empty goal block degrades exactly to fitSummaryWithFiles (non-goal output
+// byte-identical); an over-budget summary still stands alone and compaction
+// still succeeds.
+export function fitSummaryWithFilesAndGoal(summaryText, touched, goalBlock, maxChars = COMPACT_SUMMARY_MAX_CHARS) {
+    const base = typeof goalBlock === "string" && goalBlock.length > 0
+        ? `${summaryText}\n\n${goalBlock}`
+        : summaryText;
+    return fitSummaryWithFiles(base, touched, maxChars);
+}
+// ---- Resume surfacing ----
+// Pull the stored block(s) verbatim out of compacted summary messages — the
+// same format as stored, no reformatting. lastIndexOf prefers the appended
+// block (ours is always last; model prose comes first).
+export function extractTouchedFilesSection(text) {
+    const idx = text.lastIndexOf("Touched files:");
+    if (idx < 0)
+        return null;
+    const section = text.slice(idx).trimEnd();
+    return section.length > 0 ? section : null;
+}
+export function collectStoredTouchedFiles(history) {
+    const out = [];
+    for (const m of history) {
+        if (m?.role !== "user" || typeof m.content !== "string")
+            continue;
+        if (!m.content.includes("[Compacted context"))
+            continue;
+        const section = extractTouchedFilesSection(m.content);
+        if (section)
+            out.push(section);
+    }
+    return out;
+}

package/dist/config.js

@@ -19,13 +19,15 @@
 // Keys:
 // - provider: ProviderId for first-run default (needs its key, else zen)
 // - model: default model id (non-empty string)
-// - reasoningEffort: default/low/medium/high/max
-// - maxHistoryMessages: 10–1000 (message-count safety ceiling)
-// - maxHistoryChars: 10_000–2_000_000 (char safety ceiling — caps the
-//   window-derived budget, never the primary limit)
+// - reasoningEffort: auto/low/medium/high/max ("default" is accepted as a
+//   deprecated alias for "auto")
 // - maxToolSteps: 5–100 (tool rounds per turn)
 // - compactPct: 50–95 (auto-compact percent of verified window)
 // - telemetry: {enabled?: boolean} (local observability recording, default on)
+// - extensions: {enabled?: string[], disabled?: string[]} (per-extension
+//   enable/disable patterns over the extension name, `*`/`?` globs; disabled
+//   wins over enabled, non-empty enabled is an allowlist — see extensions.ts
+//   precedence. CLI --enable/--disable-extension wins over this when set.)
 import { existsSync, readFileSync } from "node:fs";
 import * as path from "node:path";
 import { homeDir } from "./auth.js";
@@ -35,7 +37,11 @@ export const ATOM_CONFIG_FILENAME = "atom.json";
 // Kept local (not imported from zen.js) so config.ts has no runtime import
 // of zen.js — zen.js imports loadAtomConfig for budget fallbacks, and a
 // runtime cycle would be fragile. Mirrors EFFORT_OPTIONS exactly.
-const EFFORT_VALUES = ["default", "low", "medium", "high", "max"];
+const EFFORT_VALUES = ["auto", "low", "medium", "high", "max"];
+// Pre-auto name for the same level (old atom.json files keep working).
+const LEGACY_EFFORT_VALUES = {
+    default: "auto",
+};
 export function projectConfigPath(projectDir) {
     return path.join(projectDir ?? process.cwd(), ATOM_CONFIG_FILENAME);
 }
@@ -106,13 +112,14 @@ function parseLevel(filePath, label) {
         if (typeof effort === "string" && EFFORT_VALUES.includes(effort)) {
             config.reasoningEffort = effort;
         }
+        else if (typeof effort === "string" && effort in LEGACY_EFFORT_VALUES) {
+            config.reasoningEffort = LEGACY_EFFORT_VALUES[effort];
+        }
         else {
             bad("reasoningEffort", `must be one of ${EFFORT_VALUES.join("/")}`);
         }
     }
     const ranged = [
-        { key: "maxHistoryMessages", min: 10, max: 1000 },
-        { key: "maxHistoryChars", min: 10_000, max: 2_000_000 },
         { key: "maxToolSteps", min: 5, max: 100 },
         { key: "compactPct", min: 50, max: 95 },
     ];
@@ -158,6 +165,35 @@ function parseLevel(filePath, label) {
             }
         }
     }
+    // Per-extension patterns (ticket 07): validated arrays of non-empty
+    // strings; a non-array key is ignored wholesale, bad entries are dropped
+    // with a warning (never throw, like every other key here).
+    const extensions = data["extensions"];
+    if (extensions !== undefined) {
+        if (!isRecord(extensions)) {
+            warnings.push(`${label} atom.json: ignoring invalid "extensions" (must be an object)`);
+        }
+        else {
+            const parsed = {};
+            for (const key of ["enabled", "disabled"]) {
+                const v = extensions[key];
+                if (v === undefined)
+                    continue;
+                if (!Array.isArray(v)) {
+                    warnings.push(`${label} atom.json: ignoring invalid "extensions.${key}" (must be an array of patterns)`);
+                    continue;
+                }
+                const kept = v.filter((e) => typeof e === "string" && e.length > 0);
+                if (kept.length !== v.length) {
+                    warnings.push(`${label} atom.json: "extensions.${key}" dropped ${v.length - kept.length} empty/non-string pattern(s)`);
+                }
+                parsed[key] = kept;
+            }
+            if (parsed.enabled !== undefined || parsed.disabled !== undefined) {
+                config.extensions = parsed;
+            }
+        }
+    }
     return { config, warnings, present: true };
 }
 export function loadAtomConfig(projectDir, homeDir) {