atom-agent 1.1.0 → 1.3.0

package/dist/providers.js

@@ -68,7 +68,7 @@ export const PROVIDERS = [
             "minimax-m2.7",
             "big-pickle",
         ],
-        notes: "OpenAI-compatible chat/completions. reasoning_effort only here.",
+        notes: "OpenAI-compatible chat/completions. /effort sends reasoning_effort (Auto omits it).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: true,
@@ -90,7 +90,7 @@ export const PROVIDERS = [
             "gpt-5.6-terra",
             "gpt-5.6-luna",
         ],
-        notes: "OpenAI-compatible chat/completions. reasoning_effort never sent.",
+        notes: "OpenAI-compatible chat/completions. /effort sends reasoning_effort (Auto omits it).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: true,
@@ -112,7 +112,7 @@ export const PROVIDERS = [
             "claude-3-5-sonnet-20241022",
             "claude-3-5-haiku-20241022",
         ],
-        notes: "Messages API with tool_use blocks. max_tokens 4096.",
+        notes: "Messages API with tool_use blocks. max_tokens 4096. /effort maps to the thinking budget (Auto omits it).",
         cache: {
             explicitBreakpoints: true,
             implicitPrefix: true,
@@ -134,7 +134,7 @@ export const PROVIDERS = [
             "deepseek-v4-flash",
             "deepseek-v4-pro",
         ],
-        notes: "OpenAI-compatible (no /v1 prefix). reasoning_effort never sent.",
+        notes: "OpenAI-compatible (no /v1 prefix). /effort sends reasoning_effort (Auto omits it).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: true,
@@ -156,7 +156,7 @@ export const PROVIDERS = [
             "mistral-small-latest",
             "open-mistral-nemo",
         ],
-        notes: "OpenAI-compatible chat/completions. reasoning_effort never sent.",
+        notes: "OpenAI-compatible chat/completions. /effort sends reasoning_effort (Auto omits it).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: false,
@@ -179,7 +179,7 @@ export const PROVIDERS = [
             "gemini-2.0-flash",
             "gemini-1.5-flash",
         ],
-        notes: "streamGenerateContent SSE; :generateContent fallback.",
+        notes: "streamGenerateContent SSE; :generateContent fallback. /effort maps to thinkingLevel (Auto omits it; Max rides high).",
         cache: {
             explicitBreakpoints: false,
             implicitPrefix: true,

package/dist/scheduler.js

@@ -1,10 +1,15 @@
-// Effect-aware tool scheduler: data-driven parallelism without Promise.all-
-// ing every tool.
+// Effect-aware tool scheduler: data-driven parallelism, parallel by default.
 //
-// The conservative contract (unchanged): batchable reads run concurrently,
-// mutations stay serialized, results commit in original call order, cancel
-// stops between batches, approval happens per call inside runOneTool. This
-// module only PLANS batches; execution (zen.ts runLoopWithChat) is untouched.
+// The contract: batchable calls run concurrently, conflicting calls stay
+// serialized, results commit in original call order, cancel stops between
+// batches, approval happens per call in order before execution. This module
+// only PLANS batches; execution (agent/loop.ts runLoopWithChat) is untouched.
+//
+// Parallel-by-default posture: side-effect-free reads batch unconditionally
+// (same target included — two reads can never race each other); only real
+// conflicts serialize: same-file write order, read/write on the same file,
+// invisible footprints (bash), shared ambient state (todos), interactive
+// prompts, and calls the planner cannot see (unknown/malformed/invalid).
 //
 // How it reasons (per tool, from the TOOL_EFFECTS table — the single
 // coupling point; the algorithm below has no per-tool branches):
@@ -16,24 +21,35 @@
 //   become inline-error singletons downstream, exactly as before).
 // - interactive (ask_question) or exclusive (shared ambient state the effect
 //   model cannot see: todowrite/todo_update/todo_get) → serial singleton.
-// - any filesystem/network WRITE, or any process SPAWN → serial singleton.
-//   Writes conflict GLOBALLY (not just same-target): a write splits the
-//   block and read-after-write stays ordered. Target-scoped write batching
-//   is a deliberate non-goal — correctness over theoretical parallelism.
-// - reads (filesystem or network) batch with pairwise-disjoint keys, where
-//   the key is tool + target. Same tool + same target serializes (the old
-//   overlap rule, kept verbatim: e.g. two reads of one path). Reads never
-//   conflict across keys — an all-read batch cannot race a writer, because
-//   writers never join batches.
-// - deterministic is declared per tool; its current enforcement is the
-//   same-key rule (a re-poll of the same background task, whose output can
-//   grow, never runs concurrently with itself).
+// - process SPAWN or network WRITE (bash: unbounded footprint) → serial
+//   singleton, splitting the block globally.
+// - filesystem writes (write/edit) batch on disjoint canonical file keys
+//   (see canonicalFileKey): same-file mutations never share a batch, so they
+//   stay strictly ordered in program order; different files run concurrently.
+//   An unresolvable target stays serial (never batch what you cannot see).
+// - reads (filesystem or network) always batch: a pure read has no observable
+//   footprint, so even the same tool + same target runs concurrently. A path
+//   read against an open write to the same canonical file still stays ordered
+//   (read-after-write): it splits the batch — and a write conflicts with any
+//   open read on its key (write-after-read stays ordered). Directory-scoped
+//   scans (grep/glob) vs concurrent writes to unscanned-listed files are out
+//   of scope — same exposure as an editor saving mid-scan; only
+//   same-canonical-path pairs are ordered.
+// - deterministic is informational only (same output for same args); it no
+//   longer drives batching — not even same-task bash_output polls serialize,
+//   since concurrent polls are side-effect-free reads whose results commit in
+//   call order anyway.
 //
 // Pure module except the shared arg validators (same imports zen.ts already
-// carries — no new coupling class). Covered by tests/scheduler.test.ts; the
-// end-to-end ordering/cancel behavior stays pinned by
-// tests/parallel-calls.test.ts.
-import { toolNames, validateToolArgs } from "./tools.js";
+// carries — no new coupling class) plus best-effort path canonicalization
+// (node:fs/node:path only, so the architecture boundary is unchanged:
+// scheduler still reasons from metadata, never from tool branches).
+// Covered by tests/scheduler.test.ts; the end-to-end ordering/cancel
+// behavior stays pinned by tests/parallel-calls.test.ts and
+// tests/parallel-writes.test.ts.
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { isCustomTool, toolExecutionMode, toolNames, validateToolArgs } from "./tools.js";
 const str = (v) => (typeof v === "string" ? v : "");
 const targetOf = (key) => (args) => {
     const t = str(args[key]);
@@ -83,8 +99,8 @@ export const TOOL_EFFECTS = {
         process: "none",
         interactive: false,
         exclusive: false,
-        // Live search results vary call to call; same-query conflict is still
-        // serialized by the same-key rule.
+        // Live search results vary call to call; concurrent same-query searches
+        // are merely redundant, never incorrect — reads always batch.
         deterministic: false,
         target: targetOf("query"),
     },
@@ -95,8 +111,8 @@ export const TOOL_EFFECTS = {
         process: "none",
         interactive: false,
         exclusive: false,
-        // A running task's output grows between polls — same-task polls
-        // serialize via the same-key rule.
+        // A running task's output grows between polls — concurrent same-task
+        // polls are side-effect-free reads whose results commit in call order.
         deterministic: false,
         target: targetOf("taskId"),
     },
@@ -166,22 +182,93 @@ export const TOOL_EFFECTS = {
         target: () => null,
     },
 };
+// Canonical per-file mutation key: the identity two mutation calls compare
+// before sharing a batch. Lexical resolve against the process cwd (the same
+// base the executors default to), then best-effort symlink resolution, then
+// case-folding on case-insensitive filesystems. Null when the target is
+// missing, empty, or unresolvable — unknown footprints stay serial. Sync and
+// best-effort by design: a handful of calls per tool block, and a miss only
+// costs parallelism, never correctness.
+export function canonicalFileKey(rawPath, cwd = process.cwd()) {
+    if (typeof rawPath !== "string" || rawPath.length === 0)
+        return null;
+    if (rawPath.includes("\0"))
+        return null;
+    let abs;
+    try {
+        abs = path.resolve(cwd, rawPath);
+    }
+    catch {
+        return null;
+    }
+    try {
+        abs = fs.realpathSync(abs);
+    }
+    catch {
+        // Fresh write target or unreadable link: the lexical path stands.
+    }
+    try {
+        abs = path.normalize(abs);
+    }
+    catch {
+        return null;
+    }
+    if (process.platform === "win32" || process.platform === "darwin") {
+        abs = abs.toLowerCase();
+    }
+    return abs;
+}
 // Partition one assistant message's tool_calls into commit batches,
-// preserving program order: consecutive batchable calls with pairwise
-// disjoint keys form one batch; any serial-only call — and any call whose
-// key already appears in the open batch — closes the batch and runs as a
-// strict serial singleton. A later batch never moves ahead of an earlier
-// serial call (read-after-write stays ordered), and batches never span the
-// block boundary.
+// preserving program order: consecutive batchable calls form one batch; any
+// serial-only call closes the batch and runs as a strict serial singleton.
+// Filesystem writes join a batch only on a disjoint canonical file key
+// (same-file mutations split into sequential batches, never concurrent); a
+// path read conflicting with an open write — or a write conflicting with any
+// open member — on the same canonical key also splits, so per-file program
+// order always holds. Reads never split on each other. A later batch never
+// moves ahead of an earlier serial call, and batches never span the block
+// boundary.
 export function planBatches(calls) {
     const batches = [];
     let open = [];
-    const keys = new Set();
+    // Canonical file keys of the open batch ("read" and/or "write" per key).
+    // This is the ONLY cross-call ordering state: same-file read/write pairs
+    // stay in program order; everything else batches freely.
+    const openFiles = new Map();
+    // Lenient parse for classification/fallback only (mirrors the loop: {}
+    // when the JSON is malformed — the error result commits downstream).
+    const lenientParse = (call) => {
+        try {
+            const raw = call?.function?.arguments ?? "{}";
+            const v = JSON.parse(typeof raw === "string" ? raw : "{}");
+            return typeof v === "object" && v !== null ? v : {};
+        }
+        catch {
+            return {};
+        }
+    };
+    // Extension sequential hint (ticket 06): a tool declaring sequential
+    // execution forces its whole sibling batch one-at-a-time (Pi-style). This
+    // only ever ADDS serialization — same-file order, bash/todo/prompt
+    // isolation, ordered commits, and the approval pre-pass are untouched
+    // (singletons satisfy every one of them; the loop below handles them
+    // exactly as before, one call per batch).
+    if (calls.some((call) => {
+        const name = typeof call?.function?.name === "string" ? call.function.name : "";
+        try {
+            return toolExecutionMode(name) === "sequential";
+        }
+        catch {
+            return false;
+        }
+    })) {
+        return calls.map((call) => [{ call, parsed: lenientParse(call), parallelKey: null }]);
+    }
     const flush = () => {
         if (open.length > 0) {
             batches.push(open);
             open = [];
-            keys.clear();
+            openFiles.clear();
         }
     };
     const singleton = (call, parsed) => {
@@ -201,6 +288,15 @@ export function planBatches(calls) {
             malformed = true;
         }
         const name = typeof call?.function?.name === "string" ? call.function.name : "(unknown)";
+        // Extension tools carry no scheduler effect metadata: their footprint is
+        // invisible, so they always run as serial singletons (fail safe, exactly
+        // like the old allowlist-miss). Batch planning is never corrupted by
+        // what it cannot see; validation still runs in the loop, where failures
+        // become inline-error results.
+        if (isCustomTool(name)) {
+            singleton(call, parsed);
+            continue;
+        }
         // Missing metadata fails safe to serial (never batch the unknown).
         const meta = TOOL_EFFECTS[name];
         if (malformed || !meta || !toolNames().includes(name)) {
@@ -212,17 +308,31 @@ export function planBatches(calls) {
             singleton(call, parsed);
             continue;
         }
-        // Interactive, ambient-state, mutating, or spawning calls serialize.
+        // Interactive, ambient-state, spawning, or network-writing calls
+        // serialize (bash has no statically visible footprint: global conflict).
         if (meta.interactive ||
             meta.exclusive ||
-            meta.filesystem === "write" ||
             meta.network === "write" ||
             meta.process !== "none") {
             singleton(call, parsed);
             continue;
         }
-        // Reads batch on disjoint tool+target keys; empty target = unknown
-        // footprint = serial.
+        // Filesystem writes batch on disjoint canonical file keys: the
+        // per-file mutation queue. Same-file mutations split into sequential
+        // batches (never interleave); disjoint files run concurrently.
+        if (meta.filesystem === "write") {
+            const fileKey = canonicalFileKey(parsed["path"]);
+            if (!fileKey || openFiles.has(fileKey)) {
+                singleton(call, parsed);
+                continue;
+            }
+            openFiles.set(fileKey, "write");
+            open.push({ call, parsed, parallelKey: `${name} ${fileKey}` });
+            continue;
+        }
+        // Reads always batch (parallel by default): a pure read has no
+        // observable footprint, so even the same tool + same target runs
+        // concurrently. Empty target = unknown footprint = serial.
         let target = null;
         try {
             target = meta.target(parsed);
@@ -235,11 +345,19 @@ export function planBatches(calls) {
             continue;
         }
         const key = `${name} ${target}`;
-        if (keys.has(key)) {
-            singleton(call, parsed);
+        // A path read against an open write to the same canonical file stays
+        // ordered (read-after-write): split the batch.
+        if (name === "read") {
+            const fileKey = canonicalFileKey(target);
+            if (fileKey && openFiles.get(fileKey) === "write") {
+                singleton(call, parsed);
+                continue;
+            }
+            if (fileKey && !openFiles.has(fileKey))
+                openFiles.set(fileKey, "read");
+            open.push({ call, parsed, parallelKey: key });
             continue;
         }
-        keys.add(key);
         open.push({ call, parsed, parallelKey: key });
     }
     flush();

package/dist/session.js

@@ -6,10 +6,13 @@
 // cannot corrupt or clobber the last good save.
 //
 // Shape: {version:1, savedAt, provider, model, effort, mode, usageTotals,
+// goal (ticket 07: the live session goal plus cumulative stats, or null),
 // history (full API history incl. system + tool pairs), turns (display
 // transcript)}. Writes are atomic (temp file + rename) to survive kills
 // mid-write. Loads never throw: missing -> "missing", anything malformed ->
-// "corrupt" (caller shows a one-line notice and starts fresh).
+// "corrupt" (caller shows a one-line notice and starts fresh). A missing or
+// corrupt goal degrades to no-goal (null) WITHOUT failing the load — the
+// conversation still restores.
 //
 // Privacy: the file can contain pasted secrets if the user typed them as
 // chat. Never print its contents; never commit it (it lives under ~/.atom,
@@ -19,6 +22,7 @@ import * as path from "node:path";
 import { atomDir, getStoredBaseURL, loadAuth, resolveApiKey } from "./auth.js";
 import { chatEndpointFor, isProviderId, openaiCompatibleChatEndpoint, } from "./providers.js";
 import { EFFORT_OPTIONS, } from "./zen.js";
+import { restoreGoalFromPersist, serializeGoalForPersist, } from "./goal.js";
 export const SESSION_VERSION = 1;
 export const SESSION_FILENAME = "session.json";
 export function sessionFilePath(home) {
@@ -74,6 +78,9 @@ export function saveSession(snapshot, home) {
         effort: snapshot.effort,
         mode: snapshot.mode,
         usageTotals: snapshot.usageTotals,
+        // Piggyback: the live goal rides every completed-turn save (no new save
+        // cadence — compaction and clean exit flow through here too).
+        goal: serializeGoalForPersist(snapshot.goal ?? null),
         history: snapshot.history.map((m) => ({ ...m })),
         turns: snapshot.turns.map((t) => ({ ...t })),
     };
@@ -210,9 +217,16 @@ function validateSession(data) {
     const model = data["model"];
     if (!isNonEmptyString(model))
         return null;
-    const effort = data["effort"];
-    if (typeof effort !== "string" ||
-        !EFFORT_OPTIONS.includes(effort)) {
+    // "default" is the pre-auto name for the same level: old saves map to
+    // "auto" instead of failing the load.
+    const rawEffort = data["effort"];
+    const effort = rawEffort === "default"
+        ? "auto"
+        : typeof rawEffort === "string" &&
+            EFFORT_OPTIONS.includes(rawEffort)
+            ? rawEffort
+            : null;
+    if (effort === null) {
         return null;
     }
     const mode = data["mode"];
@@ -241,9 +255,13 @@ function validateSession(data) {
         savedAt,
         provider,
         model,
-        effort: effort,
+        effort,
         mode,
         usageTotals: validateUsageTotals(data["usageTotals"]),
+        // Tolerant: a trashed goal degrades to no-goal (null) without failing
+        // the load — the conversation still restores. Re-serialized so the
+        // loaded record always carries concrete stats.
+        goal: serializeGoalForPersist(restoreGoalFromPersist(data["goal"])),
         history: history,
         turns: turns,
     };