atom-agent 1.3.0 → 1.5.0

package/dist/scheduler.js

@@ -218,6 +218,33 @@ export function canonicalFileKey(rawPath, cwd = process.cwd()) {
     }
     return abs;
 }
+/** Capture the mutable-registry inputs planBatches needs (see above). */
+export function captureSchedulerSnapshot() {
+    const names = toolNames();
+    const modes = {};
+    for (const name of names) {
+        try {
+            const mode = toolExecutionMode(name);
+            if (mode !== undefined)
+                modes[name] = mode;
+        }
+        catch {
+            // A failing mode read plans as "no hint" — fail safe, as before.
+        }
+    }
+    return {
+        toolNames: [...names],
+        customToolNames: names.filter((name) => {
+            try {
+                return isCustomTool(name);
+            }
+            catch {
+                return false;
+            }
+        }),
+        executionModes: modes,
+    };
+}
 // Partition one assistant message's tool_calls into commit batches,
 // preserving program order: consecutive batchable calls form one batch; any
 // serial-only call closes the batch and runs as a strict serial singleton.
@@ -228,7 +255,14 @@ export function canonicalFileKey(rawPath, cwd = process.cwd()) {
 // 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) {
+//
+// The optional snapshot (see captureSchedulerSnapshot) freezes the mutable
+// registry inputs for the whole block; absent, the snapshot is captured live
+// once up front — planning never re-reads the live registry mid-block.
+export function planBatches(calls, snapshot) {
+    const reg = snapshot ?? captureSchedulerSnapshot();
+    const knownTools = new Set(reg.toolNames);
+    const customTools = new Set(reg.customToolNames);
     const batches = [];
     let open = [];
     // Canonical file keys of the open batch ("read" and/or "write" per key).
@@ -255,12 +289,7 @@ export function planBatches(calls) {
     // 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 reg.executionModes[name] === "sequential";
     })) {
         return calls.map((call) => [{ call, parsed: lenientParse(call), parallelKey: null }]);
     }
@@ -293,13 +322,13 @@ export function planBatches(calls) {
         // 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)) {
+        if (customTools.has(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)) {
+        if (malformed || !meta || !knownTools.has(name)) {
             singleton(call, parsed);
             continue;
         }

package/dist/session-revert.js

@@ -0,0 +1,125 @@
+// Session-scoped revert (ticket 08): "undo that bad turn".
+//
+// Composition only — no new snapshot system. Every piece already exists:
+//
+// - src/snapshots.ts: getCheckpoint (lookup), restoreCheckpointFiles
+//   (byte-exact, hash-verified file restore), conversationCutIndex (the
+//   turn-boundary cut shared by /rewind and forkSession), listCheckpoints
+//   (no-snapshot detection).
+// - src/sessions.ts: getSession (read), updateSession (atomic persist of the
+//   truncated record).
+//
+// Ordering is the atomicity story: file restore runs BEFORE the session
+// record is touched, so a failed restore (hash mismatch, unreadable
+// snapshot, unknown checkpoint) leaves the session file byte-identical —
+// nothing was written yet. If the record persist then fails (disk error,
+// record vanished mid-flight), the just-restored files are rolled back to
+// their pre-revert bytes best-effort and a clear error is returned; the
+// session file itself is untouched either way (updateSession only writes on
+// success, atomically).
+//
+// Forked branches are separate records (ticket 07): this writes exactly one
+// session file and never touches any other session or fork.
+//
+// Import budget: node:fs (promises only) + ./sessions.js + ./snapshots.js.
+// Never touches compact/overflow/config/context-manager, loop, todos,
+// file-diffs, legacy save, tool execution/registry, permissions/policy,
+// skills, or provider adapters.
+import { promises as fsp } from "node:fs";
+import { getSession, updateSession } from "./sessions.js";
+import { conversationCutIndex, getCheckpoint, listCheckpoints, restoreCheckpointFiles, } from "./snapshots.js";
+async function backupDisk(files) {
+    const out = [];
+    for (const f of files) {
+        try {
+            out.push({ abs: f.abs, existed: true, bytes: await fsp.readFile(f.abs) });
+        }
+        catch {
+            out.push({ abs: f.abs, existed: false, bytes: null });
+        }
+    }
+    return out;
+}
+async function rollbackDisk(backups) {
+    for (const b of backups) {
+        try {
+            if (!b.existed || b.bytes === null) {
+                await fsp.rm(b.abs, { force: true });
+            }
+            else {
+                await fsp.writeFile(b.abs, b.bytes);
+            }
+        }
+        catch {
+            // Best-effort: the session record is already byte-identical; a
+            // failed file rollback is reported, never thrown.
+        }
+    }
+}
+function assistantHasToolCalls(m) {
+    return m.role === "assistant" && m.tool_calls !== undefined;
+}
+// Revert one session's conversation AND files to a checkpoint captured
+// earlier in its lineage. Returns a success with the persisted session and
+// a confirmation line, or a failure with a clear error — failures never
+// write the session file.
+export async function revertSessionToCheckpoint(sessionId, checkpointId, home) {
+    if (typeof sessionId !== "string" || sessionId.length === 0) {
+        return { ok: false, error: "revert failed: missing session id — nothing was changed" };
+    }
+    if (typeof checkpointId !== "string" || checkpointId.length === 0) {
+        return {
+            ok: false,
+            error: "revert failed: missing checkpoint — nothing was changed. " +
+                "Pick a checkpoint from /rewind (every write/edit auto-snapshots).",
+        };
+    }
+    const session = getSession(sessionId, home);
+    if (!session) {
+        return { ok: false, error: "revert failed: unknown session — nothing was changed" };
+    }
+    const cp = getCheckpoint(checkpointId);
+    if (!cp) {
+        if (listCheckpoints().length === 0) {
+            return {
+                ok: false,
+                error: "no snapshots recorded — nothing to revert and nothing was changed. " +
+                    "Every write/edit auto-snapshots; make a file edit, then pick a checkpoint via /rewind.",
+            };
+        }
+        return { ok: false, error: "revert failed: checkpoint no longer available — nothing was changed" };
+    }
+    const backups = await backupDisk(cp.files);
+    // Files first: a failed restore returns before the record is touched,
+    // so the session file stays byte-identical.
+    const filesMsg = await restoreCheckpointFiles(cp.id);
+    if (filesMsg.startsWith("Error:")) {
+        return { ok: false, error: `${filesMsg} — session left exactly as it was` };
+    }
+    // Turn-boundary cut (the /rewind + forkSession rule, reused — never
+    // reimplemented): drops the whole turn containing the mark so
+    // assistant/tool_call pairing can never split. Marks clamp to the live
+    // lengths, so a checkpoint from a longer lineage can only shrink.
+    const historyCut = conversationCutIndex(session.history.map((m) => ({ role: m.role, hasToolCalls: assistantHasToolCalls(m) })), cp.historyLength, 1);
+    const turnsCut = conversationCutIndex(session.turns.map((t) => ({ role: t.role })), cp.turnsLength, 0);
+    const droppedMessages = session.history.length - historyCut;
+    const next = updateSession(sessionId, {
+        history: session.history.slice(0, historyCut),
+        turns: session.turns.slice(0, turnsCut),
+    }, home);
+    if (!next) {
+        await rollbackDisk(backups);
+        return {
+            ok: false,
+            error: "revert failed: could not save the rewound session (record rejected or vanished) — " +
+                "files were restored to their pre-revert state and the session is unchanged",
+        };
+    }
+    return {
+        ok: true,
+        session: next,
+        message: `(reverted "${session.title}" to checkpoint #${cp.seq} "${cp.label}" — ` +
+            `dropped ${droppedMessages} message(s), restored ${cp.files.length} file(s); ` +
+            `shell side effects were never snapshotted and are unchanged)`,
+    };
+}

package/dist/sessions.js

@@ -355,6 +355,107 @@ export function getSession(id, home) {
 export function loadSession(id, home) {
     return getSession(id, home);
 }
+// Turn-boundary cut for forks (ticket 07): the /rewind precedent's rule
+// (conversationCutIndex in snapshots.ts) — drop the whole turn containing
+// the mark so assistant/tool_call pairing can never split. Duplicated
+// locally (not imported) to honor this module's import budget (node:fs,
+// node:path, node:crypto, ./auth.js, ./goal.js only).
+function forkCutIndex(messages, mark, keepFirst) {
+    const len = messages.length;
+    const floor = Math.max(0, Math.floor(keepFirst));
+    if (len <= floor)
+        return len;
+    const m = Math.max(floor, Math.min(Number.isFinite(mark) ? Math.floor(mark) : len, len));
+    let turnStart = -1;
+    for (let i = m - 1; i >= floor; i--) {
+        if (messages[i]?.role === "user") {
+            turnStart = i;
+            break;
+        }
+    }
+    if (turnStart === -1)
+        return floor;
+    for (let i = turnStart; i < m; i++) {
+        const msg = messages[i];
+        if (msg !== undefined &&
+            msg.role === "assistant" &&
+            msg.hasToolCalls !== true) {
+            return m;
+        }
+    }
+    return turnStart;
+}
+// JSON deep copy for forked payloads (history/turns/metadata): the fork's
+// file is independent on disk either way, but a deep copy also keeps the
+// two in-memory records from aliasing nested objects. Falls back to the
+// original reference when the value is not JSON-serializable (records are
+// JSON-file shaped, so this path is defensive only).
+function deepCopyJson(value) {
+    try {
+        const text = JSON.stringify(value);
+        if (text === undefined)
+            return value;
+        return JSON.parse(text);
+    }
+    catch {
+        return value;
+    }
+}
+// Fork a session at a message (ticket 07): "try another approach from here".
+// Reads the source record and persists a brand-new session (fresh stable id
+// from the same scheme as createSession, createdAt/updatedAt = now) holding
+// the source's history up to atMessageIndex and nothing after, cut at a turn
+// boundary via forkCutIndex. atMessageIndex counts history messages to keep
+// (checkpoint-length semantics, like cp.historyLength in the rewind path);
+// omitted/NaN/Infinity forks at the tip, out-of-range values clamp.
+// The display transcript (turns) is sliced at the analogous boundary (the
+// system prompt at history[0] has no turns counterpart, hence the offset).
+// goal + metadata (todos/filediffs/extension keys) ride over opaquely so the
+// branch continues with full context; usageTotals resets to null so the new
+// branch accrues its own spend. provider/model/effort/mode/cwd are carried.
+// The source file is only read, never written; the active pointer is never
+// touched. Returns null when the source id is missing/unknown. Disk errors
+// from the fork write propagate to the caller.
+export function forkSession(sourceId, atMessageIndex, home) {
+    if (typeof sourceId !== "string" || sourceId.length === 0)
+        return null;
+    const source = getSession(sourceId, home);
+    if (!source)
+        return null;
+    const mark = atMessageIndex === undefined ? source.history.length : atMessageIndex;
+    const historyCut = forkCutIndex(source.history.map((m) => ({
+        role: m.role,
+        hasToolCalls: m.role === "assistant" &&
+            m.tool_calls !== undefined,
+    })), mark, 1);
+    const systemOffset = source.history[0]?.role === "system" ? 1 : 0;
+    const turnsMark = Math.max(0, Math.min(historyCut - systemOffset, source.turns.length));
+    const turnsCut = forkCutIndex(source.turns.map((t) => ({
+        role: t.role,
+        hasToolCalls: t.tool_calls !== undefined,
+    })), turnsMark, 0);
+    const at = new Date().toISOString();
+    const forked = {
+        id: newSessionId(),
+        title: `${source.title} (fork)`,
+        createdAt: at,
+        updatedAt: at,
+        cwd: source.cwd,
+        provider: source.provider,
+        model: source.model,
+        effort: source.effort,
+        mode: source.mode,
+        usageTotals: null,
+        // Opaque carry-over (tolerantly validated — a trashed goal reads as
+        // no-goal, never throws), same posture as createSession.
+        goal: serializeGoalForPersist(restoreGoalFromPersist(source.goal)),
+        history: deepCopyJson(source.history.slice(0, historyCut)),
+        turns: deepCopyJson(source.turns.slice(0, turnsCut)),
+        metadata: deepCopyJson({ ...source.metadata }),
+    };
+    persistSession(forked, home);
+    return forked;
+}
 export function listSessions(home) {
     let entries;
     try {

package/dist/snapshots.js

@@ -119,6 +119,34 @@ function newCheckpointId(nextSeq) {
     return `${Date.now().toString(36)}-${nextSeq.toString(36)}${randomBytes(3).toString("hex")}`;
 }
 async function readPrior(abs) {
+    let st;
+    try {
+        const s = await fsp.stat(abs);
+        st = s;
+    }
+    catch {
+        return { abs, existed: false, hash: null, bytes: null, overflowPath: null };
+    }
+    if (!st.isFile())
+        return { abs, existed: false, hash: null, bytes: null, overflowPath: null };
+    // Large files spill via STREAMING copy (constant memory): a full readFile
+    // just to decide the file is too big would itself OOM on GB inputs.
+    if (st.size > SNAPSHOT_OVERFLOW_BYTES) {
+        try {
+            pruneStaleSnapshotOverflow();
+            const dir = snapshotDir();
+            await fsp.mkdir(dir, { recursive: true });
+            const name = `snapshot-${process.pid}-${Date.now().toString(36)}-${randomBytes(4).toString("hex")}.bin`;
+            const file = path.join(dir, name);
+            const hash = await streamCopyWithHash(abs, file);
+            return { abs, existed: true, hash, bytes: null, overflowPath: file };
+        }
+        catch {
+            // Streaming failed (disk/perm) — fall through to the bounded read
+            // below, which keeps small files restorable; a huge file here can
+            // still press memory, but only when the disk path already failed.
+        }
+    }
     let bytes = null;
     try {
         bytes = await fsp.readFile(abs);
@@ -143,6 +171,47 @@ async function readPrior(abs) {
     }
     return { abs, existed: true, hash, bytes, overflowPath: null };
 }
+// Constant-memory file copy that hashes while streaming: the hash covers
+// exactly the bytes landed on disk (restore re-verifies against it).
+function streamCopyWithHash(src, dest) {
+    return new Promise((resolve, reject) => {
+        const hash = createHash("sha256");
+        let settled = false;
+        const fail = (e) => {
+            if (settled)
+                return;
+            settled = true;
+            reject(e instanceof Error ? e : new Error(String(e)));
+        };
+        let rs;
+        let ws;
+        try {
+            rs = fs.createReadStream(src);
+            ws = fs.createWriteStream(dest);
+        }
+        catch (e) {
+            fail(e);
+            return;
+        }
+        rs.on("error", fail);
+        ws.on("error", fail);
+        rs.on("data", (chunk) => {
+            hash.update(chunk);
+        });
+        ws.on("finish", () => {
+            if (settled)
+                return;
+            settled = true;
+            try {
+                resolve(hash.digest("hex"));
+            }
+            catch (e) {
+                reject(e instanceof Error ? e : new Error(String(e)));
+            }
+        });
+        rs.pipe(ws);
+    });
+}
 function pushCheckpoint(label, files, marks) {
     seq += 1;
     const cp = {

package/dist/system.js

@@ -13,93 +13,6 @@
 // arrive as `Error: ...` text inside the result (invalid args say how to
 // fix; a denial means replan, never retry).
 export const SYSTEM_PROMPT = [
-    "You are ATOM, an autonomous AI coding agent created by beast-ofcourse (Bhavin).",
-    "Your job is to solve software-engineering tasks accurately, efficiently, and with minimal unnecessary changes.",
-    "",
-    "## Core Loop",
-    "For every task, continuously follow:",
-    "UNDERSTAND → EXPLORE → PLAN → EXECUTE → VERIFY → COMPLETE",
-    "",
-    "Do not stop merely because the code was changed. A task is complete only when the result has been verified or a concrete blocker has been established with evidence.",
-    "",
-    "## Understand",
-    "- Identify the user's actual goal, constraints, and acceptance criteria.",
-    "- Resolve ambiguity from the repository before asking questions when the answer can be discovered with tools.",
-    "- Do not assume repository structure, APIs, behavior, or configuration. Inspect them.",
-    "",
-    "## Explore",
-    "- Read relevant files before modifying them.",
-    "- Search the repository before creating new code.",
-    "- Trace existing implementations, call sites, types, configuration, and tests.",
-    "- Prefer understanding existing architecture over introducing parallel implementations.",
-    "- For unfamiliar code, inspect enough surrounding context to understand how it actually works.",
-    "",
-    "## Plan",
-    "- For non-trivial tasks, create a concise ordered todo list before implementation.",
-    "- Keep exactly one todo in progress at a time.",
-    "- Mark todos complete immediately after their work is actually finished.",
-    "- Adapt the plan when exploration or verification reveals new information.",
-    "- Do not create unnecessary work just to satisfy the plan.",
-    "",
-    "## Execute",
-    "- Make the smallest correct change that solves the underlying problem.",
-    "- Preserve existing architecture, conventions, APIs, and behavior unless the task requires changing them.",
-    "- Reuse existing utilities, abstractions, and patterns before introducing new ones.",
-    "- Fix root causes rather than symptoms.",
-    "- Handle relevant errors, edge cases, race conditions, and failure paths.",
-    "- Avoid speculative features, unnecessary refactors, and unrelated formatting changes.",
-    "- Remove dead code or obsolete logic when your change makes it unnecessary.",
-    "",
-    "## Tool Strategy",
-    "- Tools are your source of truth for the repository and environment.",
-    "- Never claim something is true when it has not been established by tool output.",
-    "- Batch independent reads, searches, inspections, and other safe operations whenever possible.",
-    "- Prefer parallel tool execution over sequential calls when operations have no dependencies.",
-    "- Do not parallelize operations that depend on each other's results or could conflict.",
-    "- After each tool result, determine what information it provides, what remains unknown, and what action has the highest value next.",
-    "- Avoid repeatedly reading the same information unless the repository changed or verification requires it.",
-    "",
-    "## Verification",
-    "- Verify behavior after implementation.",
-    "- Run the most relevant tests, typechecks, linters, builds, or targeted checks available.",
-    "- Prefer targeted verification first, then broader verification when appropriate.",
-    "- Inspect failures instead of blindly retrying.",
-    "- If a test, command, or check fails because of your change, fix it before declaring completion.",
-    "- Do not declare success based solely on compilation if runtime behavior remains unverified.",
-    "- Do not end with an unverified summary.",
-    "",
-    "## Failure Recovery",
-    "- Tool failures are information, not reasons to stop.",
-    "- Tools return failures as text such as `Error: ...`; read the error carefully and adapt.",
-    "- Invalid arguments: correct the arguments using the tool's feedback.",
-    "- Permission or capability denial: replan using an available approach.",
-    "- Environment failure: determine whether the failure is caused by ATOM, the repository, or the environment.",
-    "- Never repeat the same failed action without changing the underlying cause.",
-    "- If progress is impossible, report the exact blocker and the evidence that proves it.",
-    "",
-    "## Efficiency",
-    "- Minimize unnecessary tool calls, context usage, latency, and duplicated work.",
-    "- Prefer high-information actions that answer multiple questions at once.",
-    "- Use repository search and targeted inspection instead of reading large unrelated files.",
-    "- Keep tool chains moving: when one result enables several independent next actions, perform them together.",
-    "- Do not waste time narrating internal reasoning to the user.",
-    "",
-    "## Code Quality",
-    "- Favor simple, readable, maintainable code.",
-    "- Follow the repository's existing style rather than imposing a personal style.",
-    "- Keep abstractions proportional to the problem.",
-    "- Avoid duplicated logic.",
-    "- Keep types accurate and explicit where they improve correctness.",
-    "- Preserve backwards compatibility unless breaking behavior is explicitly required.",
-    "- Consider security, performance, concurrency, resource cleanup, and error handling when relevant.",
-    "",
-    "## Completion Contract",
-    "Before finishing, confirm:",
-    "1. The requested behavior was implemented.",
-    "2. Relevant existing behavior was preserved.",
-    "3. The implementation is internally consistent with the repository.",
-    "4. Appropriate verification was performed.",
-    "5. Remaining failures or limitations are explicitly identified.",
-    "",
-    "Your final response should be concise and factual: summarize what changed, what was verified, and any remaining blocker."
+    "You are ATOM, An AI coding agent created by beast-ofcourse (Bhavin bogam).",
+    "Tools: read, write, edit, grep, glob, bash, bash_output, webfetch, websearch, ask_question, todowrite, todo_get, todo_update, update_goal (goal turns only).",
 ].join("\n");

package/dist/telemetry.js

@@ -52,6 +52,7 @@
 import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
 import * as path from "node:path";
 import { randomUUID } from "node:crypto";
+import { fileURLToPath } from "node:url";
 import { scrubSecrets } from "./policy.js";
 import { atomDir } from "./auth.js";
 export const TELEMETRY_VERSION = 1;
@@ -578,6 +579,30 @@ export function summarizeTelemetry(sessions) {
         .sort((a, b) => b.calls - a.calls || (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
     return agg;
 }
+// App version stamped onto session records (Temp-session gap: every record
+// carried atomVersion:null, so traces from different builds were
+// indistinguishable). Resolved once from the package manifest beside the
+// source tree — dist/ mirrors src/, so ../package.json holds in both
+// layouts. Cached, never throws: null when unreadable keeps today's shape.
+let cachedAtomVersion;
+export function resolveAtomVersion() {
+    if (cachedAtomVersion !== undefined)
+        return cachedAtomVersion;
+    try {
+        const here = fileURLToPath(import.meta.url);
+        const raw = readFileSync(path.join(path.dirname(here), "..", "package.json"), "utf8");
+        const v = JSON.parse(raw).version;
+        cachedAtomVersion = typeof v === "string" && v.length > 0 ? v : null;
+    }
+    catch {
+        cachedAtomVersion = null;
+    }
+    return cachedAtomVersion;
+}
+// Test seam: drop the cached manifest read (production never calls this).
+export function resetAtomVersion() {
+    cachedAtomVersion = undefined;
+}
 // In-memory trace for one session plus atomic turn-boundary persistence.
 // Every public method is safe to call with null/undefined turn ids and never
 // throws; when disabled, all record methods are no-ops.
@@ -607,7 +632,7 @@ export class TelemetryRecorder {
             sessionId: this.sessionId,
             startedAt: toIso(startedMs),
             endedAt: null,
-            atomVersion: opts.atomVersion ?? null,
+            atomVersion: opts.atomVersion !== undefined ? opts.atomVersion : resolveAtomVersion(),
             project: opts.project !== undefined ? opts.project : projectBasename(),
             provider: opts.provider ?? "unknown",
             model: opts.model ?? "unknown",