atom-agent 0.3.0 → 1.1.0

package/dist/snapshots.js

@@ -8,11 +8,15 @@
 //
 // Session-scoped and in-memory (small files stay as Buffers; files over
 // SNAPSHOT_OVERFLOW_BYTES spill a copy under the OS temp dir — never the
-// repo itself). Restores are byte-exact and hash-verified (sha256 of the
+// repo itself). Checkpoints are bound to the history lineage they were
+// captured in: any history replacement (/clear, /new, /resume, compaction)
+// drops them via clearSnapshots (see src/rollback.ts) — disk files are
+// unaffected, only the undo evidence goes. Restores are byte-exact and hash-verified (sha256 of the
 // bytes on disk must equal the pre-mutation hash, not a model rewrite).
 // Shell side effects (bash) are explicitly out of scope: commands are never
 // snapshotted and cannot be undone — the /rewind UI says so outright.
 import { createHash, randomBytes } from "node:crypto";
+import * as fs from "node:fs";
 import { promises as fsp } from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
@@ -47,8 +51,12 @@ function currentMarks() {
     }
     return { history: 0, turns: 0 };
 }
-/** Test isolation (plus any future session reset): drops every checkpoint. */
+/** Test isolation (plus history-lineage resets): drops every checkpoint.
+ * Returns the number dropped so callers can report discarded undo evidence.
+ * Disk files are untouched — only the in-memory evidence (and its temp
+ * overflow copies) goes. */
 export function clearSnapshots() {
+    const dropped = checkpoints.length;
     for (const cp of checkpoints) {
         for (const f of cp.files) {
             if (f.overflowPath) {
@@ -58,6 +66,7 @@ export function clearSnapshots() {
     }
     checkpoints = [];
     seq = 0;
+    return dropped;
 }
 /** Newest-last copy for the picker and tests (the stored entries stay private). */
 export function listCheckpoints() {
@@ -69,6 +78,43 @@ export function getCheckpoint(id) {
 function snapshotDir() {
     return path.join(os.tmpdir(), SNAPSHOT_DIR);
 }
+// Crash-leftover overflow copies (a killed process never runs its eviction)
+// would leak in the temp dir forever: prune files older than maxAgeMs on
+// every new spill, mirroring the tool overflow-file precedent. Synchronous
+// and best-effort, never throws. Returns the number removed (for tests).
+export const SNAPSHOT_OVERFLOW_MAX_AGE_MS = 24 * 60 * 60 * 1000;
+export function pruneStaleSnapshotOverflow(maxAgeMs = SNAPSHOT_OVERFLOW_MAX_AGE_MS) {
+    try {
+        const dir = snapshotDir();
+        let entries;
+        try {
+            entries = fs.readdirSync(dir);
+        }
+        catch {
+            return 0; // nothing spilled yet — nothing to prune
+        }
+        const now = Date.now();
+        let removed = 0;
+        for (const name of entries) {
+            if (!name.startsWith("snapshot-"))
+                continue;
+            try {
+                const p = path.join(dir, name);
+                if (now - fs.statSync(p).mtimeMs > maxAgeMs) {
+                    fs.rmSync(p, { force: true });
+                    removed += 1;
+                }
+            }
+            catch {
+                // ignore per-file failures (a stale spill is harmless)
+            }
+        }
+        return removed;
+    }
+    catch {
+        return 0;
+    }
+}
 function newCheckpointId(nextSeq) {
     return `${Date.now().toString(36)}-${nextSeq.toString(36)}${randomBytes(3).toString("hex")}`;
 }
@@ -83,6 +129,7 @@ async function readPrior(abs) {
     const hash = createHash("sha256").update(bytes).digest("hex");
     if (bytes.byteLength > 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`;
@@ -179,6 +226,12 @@ export async function restoreCheckpointFiles(id, onRestored) {
             const prior = await priorBytesOf(f);
             if (prior === null)
                 return `Error: rewind failed: snapshot for ${f.abs} is unreadable`;
+            // Pre-write verification: the snapshot bytes in hand must hash to the
+            // pre-mutation hash BEFORE anything touches disk, so a corrupt snapshot
+            // fails loudly while leaving the live file exactly as it was.
+            if (createHash("sha256").update(prior).digest("hex") !== f.hash) {
+                return `Error: rewind failed: hash mismatch restoring ${f.abs}`;
+            }
             try {
                 await fsp.mkdir(path.dirname(f.abs), { recursive: true });
                 await fsp.writeFile(f.abs, prior);
@@ -186,6 +239,8 @@ export async function restoreCheckpointFiles(id, onRestored) {
             catch {
                 return `Error: rewind failed: cannot restore ${f.abs}`;
             }
+            // Post-write re-read: guards a concurrent modification racing the
+            // restore itself (the bytes just written must still hash correctly).
             let check;
             try {
                 check = await fsp.readFile(f.abs);

package/dist/system.js

@@ -7,7 +7,11 @@
 // add project/repo instructions, edit AGENTS.md.
 //
 // NOTE: the first line is pinned — tests/app.test.tsx asserts the prompt
-// starts with it. Keep it stable.
+// starts with it. Keep it stable. The last line orients the model to the
+// harness contract (single copy — tool descriptions must NOT repeat it):
+// every executor returns a string and never throws, so failures always
+// 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, a long-horizon coding agent that works through tools.",
     "",
@@ -17,6 +21,9 @@ export const SYSTEM_PROMPT = [
     "Prefer the smallest correct change. Fix root causes. Handle errors and edge cases. Remove dead code.",
     "Ground every claim in tool output, never in memory. Run commands to check facts.",
     "After each tool result, reflect briefly, then take the best next action toward the goal.",
+    "Batch independent work in one block: parallel-safe reads and searches in the same response run concurrently and finish in a single round-trip — one call per response is the slow path.",
     "Keep calling tools until verified done. Never end on an unverified summary or a guess.",
     "Done means tests and typecheck pass, or the blocker is named with its evidence.",
+    "",
+    "Harness contract: tools never throw — results are strings, failures arrive as `Error: ...` text. Read the error and adapt: invalid args say how to fix, a denial means replan around it, never retry it.",
 ].join("\n");