@visual-z/xeno 0.1.2 → 0.1.4

package/README.md

@@ -17,7 +17,7 @@ is ever summarized by a model, and nothing is ever rewritten in place.
 messages[]                             frozen system prefix + handoff + this node's events
 ```
 
-Version **0.1.2**. The on-disk session format will still change; `0.x` is that
+Version **0.1.4**. The on-disk session format will still change; `0.x` is that
 statement. Published as `@visual-z/xeno`; the license is `UNLICENSED` (readable and installable, no reuse granted).
 
 ## Install

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@visual-z/xeno",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "license": "UNLICENSED",
   "type": "module",
   "description": "Segmented append-only agent log with pure context and handoff projections",

package/src/core/progress.ts

@@ -27,6 +27,12 @@ function hasUnseenLines(requested: readonly LineRange[], observed: readonly Line
   });
 }
 
+/**
+ * A file version's fingerprint in the observation set. Keyed by digest alone:
+ * the same bytes under another path are not new work either.
+ */
+const versionKey = (_path: string, sha256: string): string => `version:${sha256}`;
+
 export function deriveProgress(
   previous: readonly ProgressEvidence[], events: readonly LogEvent[], node: number,
   eligibleChecks: ReadonlySet<string>,
@@ -45,6 +51,8 @@ export function deriveProgress(
       seen.push(item);
       reads.set(item.sha256, seen);
       if (item.observation_sha256 !== undefined) observations.add(item.observation_sha256);
+      // A version read before a cut is as known as one read in this segment.
+      observations.add(versionKey("", item.sha256));
     } else if (item.kind === "observation") observations.add(item.sha256);
     else checks.add(checkKey(item.command, item.gate, item.workspace_sha256));
   }
@@ -61,6 +69,7 @@ export function deriveProgress(
     const source = { node, event_id: event.id };
     const effect = event.effect;
     const observation = event.observation_sha256 ?? event.content_ref?.sha256 ?? event.content_sha256;
+    if (effect?.kind === "read" && effect.sha256 !== "") observations.add(versionKey(effect.path, effect.sha256));
     if (effect?.kind === "read" && effect.sha256 !== "") {
       const seen = reads.get(effect.sha256) ?? [];
       const novel = !seen.some((r) => r.ranges === undefined) &&
@@ -79,6 +88,15 @@ export function deriveProgress(
         if (observation !== undefined) observations.add(observation);
       }
     } else if (effect?.kind === "command" && effect.exit === 0) {
+      // D9 revision (2026-09-29, user-approved): output never seen before is a
+      // new observation, exactly as for read/grep. A model exploring with
+      // `sed -n` or `grep` in the shell is gathering evidence too; the digest
+      // excludes wall time, so an unchanged `git status` repeats and stalls.
+      if (observation !== undefined && !observations.has(observation)) {
+        observations.add(observation);
+        evidence.push({ kind: "observation", sha256: observation, source });
+        progressed = true;
+      }
       const key = checkKey(effect.cmd, effect.gate, effect.workspace_sha256);
       if (!checks.has(key)) {
         checks.add(key);
@@ -89,6 +107,22 @@ export function deriveProgress(
         // rerun of old evidence into a fresh completion by giving it a new name.
         if (eligibleChecks.has(event.id)) progressed = true;
       }
+    } else if (effect?.kind === "edit") {
+      // D9 revision (2026-09-29, user-approved): a file version no one has
+      // seen before is new evidence -- it is how implementation work shows up.
+      // Versions already seen anywhere (read, or either side of an edit) do
+      // not count, so an A->B->A rewrite loop still stalls.
+      // Both sides become durable evidence: the ledger is all a later
+      // derivation sees, and a version seen only as "before" must still be
+      // recognised when the file is edited back to it.
+      for (const [sha, isAfter] of [[effect.sha256_before, false], [effect.sha256_after, true]] as const) {
+        if (sha === null) continue;
+        const key = versionKey(effect.path, sha);
+        if (observations.has(key)) continue;
+        observations.add(key);
+        evidence.push({ kind: "observation", sha256: key, source });
+        if (isAfter) progressed = true;
+      }
     } else if ((name === "grep" || name === "find" || name === "ls" || name === "query") &&
         observation !== undefined && (event.content_ref?.bytes ?? event.content.length) > 0 &&
         !observations.has(observation)) {

package/src/runtime/oauth.ts

@@ -17,7 +17,7 @@ import { createServer, type Server } from "node:http";
 import { pollDeviceCode } from "./oauth-device.ts";
 
 /** Matches package.json. Sent as User-Agent so the server can see who we are (D18). */
-export const XENO_VERSION = "0.1.2";
+export const XENO_VERSION = "0.1.4";
 
 /**
  * Minutes subtracted from server expiry so a request issued at the edge

package/src/runtime/tools.ts

@@ -135,7 +135,7 @@ export type ApprovalChoice = "once" | "command" | "tool" | "deny";
 export const DEFAULT_TOOL_CONTEXT: Omit<ToolContext, "root"> = {
   // Runner prefixes are resolved in command position so `python3 -m pytest`
   // works without letting `echo pytest` forge a gate (D11 / M.2).
-  gates: { pytest: "pytest", tsc: "typecheck", cargo: "cargo", jest: "test", vitest: "test" },
+  gates: { pytest: "pytest", tsc: "typecheck", cargo: "cargo", jest: "test", vitest: "test", go: "go" },
   // Five minutes covers typical compiles and installs; longer work asks for
   // its own `timeout` up to the hour ceiling (omp uses the same 300 / 3600).
   // Approved change from 120s (2026-09-28): 120s hard-killed real builds.

package/src/store/workspace.ts

@@ -120,6 +120,12 @@ export async function scanWorkspace(
         if (err) return err;
         continue;
       }
+      // A symlink is not workspace content: it can point anywhere, and search
+      // and the file index already refuse to follow one. It is left out of the
+      // file set, so snapshots never read through it and a restore never
+      // deletes or replaces it (/back does not restore symlinks). Anything
+      // else that is not a regular file still fails the whole scan.
+      if (entry.isSymbolicLink()) continue;
       if (!entry.isFile()) return `cannot snapshot unsupported file type: ${rel}`;
 
       const info = await stat(abs);