@foldrun/core 1.4.2 → 2.0.0

package/dist/src/library.js

@@ -344,53 +344,3 @@ registerTreeReader((tenant, scope) => {
     }
     return out;
 });
-/**
- * Make the shelf match a tree — what a push to the library repository does.
- * Written with plain fs and recorded as ONE revision at the end: going
- * through writeLibraryFile per file would commit each one on top of the
- * pushed commit, and the history would show a push as fifty edits.
- */
-export function syncLibraryFromTree(tenant, files, meta = {}) {
-    const wanted = new Map();
-    for (const f of files) {
-        const [kind, ...rest] = f.path.split("/");
-        if (!LIBRARY_KINDS.includes(kind) || rest.length === 0)
-            continue;
-        wanted.set(f.path, f.content);
-    }
-    const changes = [];
-    for (const kind of LIBRARY_KINDS) {
-        const dir = libraryDir(tenant, kind);
-        if (!fs.existsSync(dir))
-            continue;
-        for (const entry of fs.readdirSync(dir, { recursive: true })) {
-            const rel = `${kind}/${String(entry).split(path.sep).join("/")}`;
-            const full = path.join(dir, String(entry));
-            try {
-                if (!fs.statSync(full).isFile() || !TEXT_EXT.test(rel))
-                    continue;
-            }
-            catch {
-                continue;
-            }
-            if (!wanted.has(rel)) {
-                changes.push({ path: rel, before: fs.readFileSync(full, "utf8"), after: null });
-                fs.rmSync(full, { force: true });
-            }
-        }
-    }
-    for (const [rel, content] of wanted) {
-        const [kind, ...rest] = rel.split("/");
-        const full = path.join(libraryDir(tenant, kind), assertLibraryPath(kind, rest.join("/")));
-        const before = fs.existsSync(full) ? fs.readFileSync(full, "utf8") : null;
-        if (before === content)
-            continue;
-        fs.mkdirSync(path.dirname(full), { recursive: true });
-        fs.writeFileSync(full, content);
-        if (kind === "scripts" || /scripts\//.test(rel) || (kind === "tools" && !rel.endsWith(".md")))
-            fs.chmodSync(full, 0o755);
-        changes.push({ path: rel, before, after: content });
-    }
-    recordRevision(tenant, "@library", changes, { by: meta.by ?? "deploy", message: meta.commit ? `deployed ${meta.commit.slice(0, 7)}` : "synced from push", commit: meta.commit ?? null });
-    return changes.length;
-}

package/dist/src/platform.d.ts

@@ -90,8 +90,6 @@ export interface PlatformHooks {
     syncPublicShares(tenant: string, workspace: string): Promise<{
         added: string[];
     }>;
-    /** The workspace a preview was branched from, for inherited secrets. Default: none. */
-    previewSourceOf(tenant: string, workspace: string): string | null;
     /** This account's own data key, or null to use the install key. */
     tenantKey(tenant: string): Buffer | null;
     /** The egress proxy — a per-step lease that keeps credentials out of the
@@ -101,7 +99,7 @@ export interface PlatformHooks {
      *  workspace deleted. What a scheduler that keeps flows in memory rather
      *  than re-reading every workspace each tick needs to hear. Default:
      *  nothing — locally the scheduler reads the disk. Never throws. */
-    workspaceChanged(tenant: string, workspace: string, why: "write" | "deploy" | "push" | "delete"): void;
+    workspaceChanged(tenant: string, workspace: string, why: "write" | "deploy" | "delete"): void;
     /** Can a step in this isolation mode be re-attached to after the driver
      *  that started it is gone? True means an orphaned step with a `sandbox`
      *  on its record is resumed rather than destroyed and run again. Default:

package/dist/src/platform.js

@@ -25,7 +25,6 @@ const local = {
     isolation: {},
     killRunSandboxes() { },
     syncPublicShares: async () => ({ added: [] }),
-    previewSourceOf: () => null,
     tenantKey: () => null,
     egress: { lease: async () => null },
     workspaceChanged() { },

package/dist/src/run-container.d.ts

@@ -97,7 +97,36 @@ export interface StepTiming {
     sandboxMs: number;
     firstOutputMs: number | null;
     totalMs: number;
+    /** Where the start-up went, phase by phase — see STARTUP_PHASES. Absent
+     *  from an executor that marks none, and from a resumed driver (the
+     *  first driver's phases are on the record already). */
+    phases?: StartupPhases;
 }
+/**
+ * The start-up of one step, in the order it happens. Each is the moment the
+ * phase ENDED, in ms since the executor began the step, so the gap between
+ * two neighbours is what the later one cost (FOL-29: "pod ready" was the
+ * only number, and the six seconds after it had no names).
+ *
+ * The executor marks its own: `services` (the account's search/browser pods
+ * up), `room` (room on the cluster to start — platform pod-room.ts),
+ * `applied` (pod created), `ready`, `files` (the workspace copied in),
+ * `go` (the step released). The sandbox marks the rest as `{"e":"mark"}`
+ * lines: `shim` (the shim saw go), `system` (system packages restored),
+ * `driver` (node up), `imports` (core loaded), `tools` (runtime and tools
+ * built, the SDK about to start) and `model` (the model's first text or tool
+ * call). A worker that predates a mark ignores the line — parseDriverLine
+ * answers null for an `e` it does not know.
+ */
+export declare const STARTUP_PHASES: readonly ["services", "room", "applied", "ready", "files", "go", "shim", "system", "driver", "imports", "tools", "model"];
+export type StartupPhase = (typeof STARTUP_PHASES)[number];
+export type StartupPhases = Partial<Record<StartupPhase, number>>;
+/** A sandbox-side mark: which phase ended, and when (epoch ms, the
+ *  sandbox's clock — the same machine's as the worker's on one node). */
+export declare function parseDriverMark(line: string): {
+    name: StartupPhase;
+    at: number;
+} | null;
 export interface StepActuals {
     busyCpuSecs: number | null;
     peakMemBytes: number | null;

package/dist/src/run-container.js

@@ -30,6 +30,42 @@ import { safeTenantSegment, systemInstallSh, SYSTEM_FROM_INPUT_SH, INSTALL_SOCKE
 import { egressCaSh } from "./network.js";
 import { isOperatorEvent } from "./operator.js";
 import { parseBrowserPod } from "./browser-pod.js";
+/**
+ * The start-up of one step, in the order it happens. Each is the moment the
+ * phase ENDED, in ms since the executor began the step, so the gap between
+ * two neighbours is what the later one cost (FOL-29: "pod ready" was the
+ * only number, and the six seconds after it had no names).
+ *
+ * The executor marks its own: `services` (the account's search/browser pods
+ * up), `room` (room on the cluster to start — platform pod-room.ts),
+ * `applied` (pod created), `ready`, `files` (the workspace copied in),
+ * `go` (the step released). The sandbox marks the rest as `{"e":"mark"}`
+ * lines: `shim` (the shim saw go), `system` (system packages restored),
+ * `driver` (node up), `imports` (core loaded), `tools` (runtime and tools
+ * built, the SDK about to start) and `model` (the model's first text or tool
+ * call). A worker that predates a mark ignores the line — parseDriverLine
+ * answers null for an `e` it does not know.
+ */
+export const STARTUP_PHASES = [
+    "services", "room", "applied", "ready", "files", "go",
+    "shim", "system", "driver", "imports", "tools", "model",
+];
+/** A sandbox-side mark: which phase ended, and when (epoch ms, the
+ *  sandbox's clock — the same machine's as the worker's on one node). */
+export function parseDriverMark(line) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith('{"e":"mark"'))
+        return null;
+    try {
+        const parsed = JSON.parse(trimmed);
+        if (parsed.e !== "mark" || typeof parsed.at !== "number" || !Number.isFinite(parsed.at))
+            return null;
+        return STARTUP_PHASES.includes(parsed.name) ? { name: parsed.name, at: parsed.at } : null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * The one place the timing line is worded, so the docker and k8s traces
  * read the same and a cold-start regression is greppable across both.
@@ -37,7 +73,11 @@ import { parseBrowserPod } from "./browser-pod.js";
 export function timingLine(t) {
     const s = (ms) => `${(ms / 1000).toFixed(2)}s`;
     const first = t.firstOutputMs === null ? "no output" : `first output +${s(t.firstOutputMs)}`;
-    return `timing: sandbox ready in ${s(t.sandboxMs)}, ${first}, ${s(t.totalMs)} total`;
+    const phases = t.phases
+        ? STARTUP_PHASES.filter((p) => typeof t.phases[p] === "number").map((p) => `${p} ${s(t.phases[p])}`)
+        : [];
+    return `timing: sandbox ready in ${s(t.sandboxMs)}, ${first}, ${s(t.totalMs)} total` +
+        (phases.length ? ` · start-up: ${phases.join(" → ")}` : "");
 }
 const cli = () => process.env.FOLDRUN_CONTAINER_CLI ?? "docker";
 // Paths that must never come back from a container, whatever happened in
@@ -374,7 +414,17 @@ const DRIVER = `// The runner container's entrypoint. Reads one step, executes i
 // same core the server uses, speaks JSONL on stdout, exits.
 import fs from "node:fs";
 const input = JSON.parse(fs.readFileSync("/opt/runner/job/input.json", "utf8"));
-const emit = (type, text, extra) => process.stdout.write(JSON.stringify({ e: "event", type, text, ...extra }) + "\\n");
+// Start-up marks (run-container.ts#STARTUP_PHASES): which phase just ended,
+// on the sandbox's clock. A worker that does not know a mark skips the line.
+const mark = (name) => process.stdout.write(JSON.stringify({ e: "mark", name, at: Date.now() }) + "\\n");
+mark("driver");
+let modelSpoke = false;
+const emit = (type, text, extra) => {
+  // The model's first text or tool call is where start-up ends and the
+  // step's own work begins — runtime and tool lines before it are set-up.
+  if (!modelSpoke && (type === "text" || type === "tool")) { modelSpoke = true; mark("model"); }
+  process.stdout.write(JSON.stringify({ e: "event", type, text, ...extra }) + "\\n");
+};
 // What this sandbox actually touched, read at the last moment from the
 // kernel's own books: cgroup v2 for CPU busy-time and peak memory,
 // /proc/net/dev for bytes on the wire. Every read is best-effort — gVisor
@@ -430,6 +480,7 @@ try {
   const { prepareRuntime } = await import("@foldrun/core/runtime");
   const { materializeFileSecrets } = await import("@foldrun/core/secret-files");
   const { paidWebActions } = await import("@foldrun/core/browser-pod");
+  mark("imports");
 
   const agentDir = "/workspace/" + input.agentRel;
   // HOME is where a bare relative path lands when anything resolves one
@@ -512,6 +563,7 @@ try {
   const ask = input.ask ? buildAskTool({ channel, timeoutSec: input.ask.timeoutSec, emit }) : { server: null };
   const inbox = channel ? inboxReader(channel, emit) : undefined;
 
+  mark("tools");
   const outcome = await executeStep({
     agentDir,
     workspaceRoot: "/workspace",
@@ -1260,6 +1312,8 @@ export async function runStepInContainer(args) {
             throw new Error(`container create failed:\n${create.stderr}`);
         containerId = create.stdout.trim();
         const sandboxMs = Date.now() - t0;
+        // Docker's phases are measured from create, its rent clock.
+        const phases = { ready: sandboxMs };
         const cp = (from, to) => {
             const out = spawnSync(cli(), ["cp", from, to], { encoding: "utf8" });
             if (out.status !== 0)
@@ -1268,6 +1322,7 @@ export async function runStepInContainer(args) {
         cp(`${wsIn}/.`, `${containerId}:/workspace`);
         cp(`${libIn}/.`, `${containerId}:/library`);
         cp(`${jobIn}/input.json`, `${containerId}:/opt/runner/job/input.json`);
+        phases.files = Date.now() - t0;
         // Start attached and read the driver's JSONL. The step timeout gets a
         // backstop out here — a wedged container is killed, not waited on.
         let firstOutputAt = null;
@@ -1292,6 +1347,11 @@ export async function runStepInContainer(args) {
                         break;
                     const line = buffer.slice(0, nl);
                     buffer = buffer.slice(nl + 1);
+                    const marked = parseDriverMark(line);
+                    if (marked) {
+                        phases[marked.name] ??= Math.max(0, marked.at - t0);
+                        continue;
+                    }
                     const parsed = parseDriverLine(line);
                     if (!parsed)
                         continue;
@@ -1339,6 +1399,7 @@ export async function runStepInContainer(args) {
             sandboxMs,
             firstOutputMs: firstOutputAt === null ? null : firstOutputAt - t0 - sandboxMs,
             totalMs: Date.now() - t0,
+            phases,
         };
         args.emit("info", timingLine(timing));
         return { ...outcome, timing };

package/dist/src/runner.js

@@ -33,7 +33,7 @@ import { ASK_TOOL, applyOperatorEvent, askPromptLine, askTimeoutSec, buildAskToo
 import { sendPlainNotification } from "./notify.js";
 import { TOOL_MAP, BUILTIN_TOOLS, ownToolNames, toolRefs, legacyUseNames, legacyUseError, retiredToolNames, retiredToolError } from "./tool-names.js";
 import { refNames } from "./refs.js";
-import { accountDir, workspaceDir, buildMemoryIndex, workspaceMemoryIndex, knowledgeIndex, workspaceKnowledgeIndex, workspaceTools, brokenToolReport, listWorkspaces, listTenants, listRuns, syncBundleFor, parseToolDef, readFlow, markerPresent, whenRowsPath, parseApis, resolveModel, parseProvider, providerEnvFor, resolveEffort, isEffortWord, EFFORT_LEVELS, checkFormatVersion, readRun, writeRun, runSummary, verdictOf, sumAttempts, parseSchemaText, STORAGE_DIR, adoptLegacyVersionKey, listAgents, } from "./store.js";
+import { accountDir, workspaceDir, buildMemoryIndex, workspaceMemoryIndex, knowledgeIndex, workspaceKnowledgeIndex, workspaceTools, brokenToolReport, listWorkspaces, listTenants, listRuns, liveRuns, syncBundleFor, parseToolDef, readFlow, markerPresent, whenRowsPath, parseApis, resolveModel, parseProvider, providerEnvFor, resolveEffort, isEffortWord, EFFORT_LEVELS, checkFormatVersion, readRun, writeRun, runSummary, verdictOf, sumAttempts, parseSchemaText, STORAGE_DIR, adoptLegacyVersionKey, listAgents, } from "./store.js";
 import { loadCatalog, checkModel, clampEffort, catalogCost, findModel } from "./catalog.js";
 import { resolveSecrets, getSecret, materializeSecrets, secretSites } from "./secrets.js";
 import { resolveNetwork, networkLine, proxyEnv, EGRESS_CA_ENV } from "./network.js";
@@ -2687,6 +2687,12 @@ stepIndex) {
             const secs = (ms) => Math.round(ms) / 1000;
             step.computeSecs = outcome.timing ? secs(outcome.timing.totalMs) : null;
             step.startupSecs = outcome.timing ? secs(outcome.timing.sandboxMs) : null;
+            // Where the start-up went, phase by phase (run-container.ts#STARTUP_PHASES),
+            // in seconds — what the cold-start numbers are computed from.
+            const phases = outcome.timing?.phases;
+            step.startup = phases && Object.keys(phases).length
+                ? Object.fromEntries(Object.entries(phases).map(([k, v]) => [k, secs(v)]))
+                : null;
             // Which reservation those seconds held — as numbers, because the bill
             // is per core-second and per GiB-second, and what was held must come
             // from the record, never from what the config says at billing time.
@@ -4768,7 +4774,9 @@ function lastActivity(run) {
 export function reconcileRuns(tenant, now = Date.now(), live) {
     const closed = [];
     for (const workspace of listWorkspaces(tenant)) {
-        for (const summary of listRuns(tenant, workspace.name)) {
+        // Live runs only, read whole — every other status is passed over below,
+        // and parsing the workspace's whole history every sweep was the cost.
+        for (const summary of liveRuns(tenant, workspace.name)) {
             if (drivingRuns.has(summary.id))
                 continue;
             // Driven by another process — a second worker pod, on a platform with

package/dist/src/secrets.js

@@ -218,11 +218,9 @@ export function setSecretSites(tenant, name, sites, workspace) {
 export function secretSites(tenant, names, workspace) {
     const out = {};
     const own = workspace ? read(tenant, workspace) : {};
-    const source = workspace ? platform.previewSourceOf(tenant, workspace) : null;
-    const inherited = source ? read(tenant, source) : {};
     const account = read(tenant);
     for (const name of names) {
-        const rec = own[name] ?? inherited[name] ?? account[name];
+        const rec = own[name] ?? account[name];
         if (rec?.sites?.length)
             out[name] = [...rec.sites];
     }
@@ -298,15 +296,6 @@ export function getSecret(tenant, name, workspace) {
         const own = decrypt(tenant, read(tenant, workspace)[name]);
         if (own !== null)
             return { value: own, scope: "workspace" };
-        // A preview is a branch of its source workspace, and the branch's
-        // agents need the same credentials the source's do. Its own store is
-        // still consulted first, so a preview can override one on purpose.
-        const source = platform.previewSourceOf(tenant, workspace);
-        if (source) {
-            const inherited = decrypt(tenant, read(tenant, source)[name]);
-            if (inherited !== null)
-                return { value: inherited, scope: "workspace" };
-        }
     }
     const shared = decrypt(tenant, read(tenant)[name]);
     return shared === null ? null : { value: shared, scope: "account" };

package/dist/src/starter.js

@@ -373,8 +373,8 @@ Debugging a failed run is usually: \`runs\` to find it, \`runs/<id>\` to read wh
 step failed and what it cost, fix the markdown, \`deploy\`, then \`rerun\`.
 
 Every route, with request and response shapes, is in \`docs/api.md\` in the
-foldrun repository — including secrets, keys, billing, OAuth, webhooks and the
-git push endpoint.
+foldrun repository — including secrets, keys, billing, OAuth, webhooks and
+restore.
 
 ## Writing a flow
 

package/dist/src/store.d.ts

@@ -754,15 +754,6 @@ export interface WorkspaceSummary {
     flows: number;
     deployedAt: string;
     runCount: number;
-    /** Set when this workspace is a branch's preview of another (preview.ts):
-     *  which one, which branch, which commit. Read from the marker beside the
-     *  directory here rather than through preview.ts, which imports this file. */
-    preview?: {
-        source: string;
-        branch: string;
-        commit: string;
-        at: string;
-    };
     /** The workspace's picture, as a URL, when the page that lists it looked
      *  one up (avatars.ts) — the store itself does not. */
     avatar?: string | null;
@@ -824,7 +815,7 @@ export interface ChangeMeta {
 }
 export declare function writeWorkspaceFile(tenant: string, workspace: string, rel: string, content: string, meta?: ChangeMeta): void;
 /** Tell the platform, and never let its listener fail a write. */
-declare function workspaceChanged(tenant: string, workspace: string, why: "write" | "deploy" | "push" | "delete"): void;
+declare function workspaceChanged(tenant: string, workspace: string, why: "write" | "deploy" | "delete"): void;
 export { workspaceChanged as notifyWorkspaceChanged };
 export declare function syncBundleFor(file: string, change?: "Creation" | "Update"): void;
 /**
@@ -1144,6 +1135,12 @@ export interface StepRecord {
      */
     computeSecs?: number | null;
     startupSecs?: number | null;
+    /** When each start-up phase ended, in seconds since the executor began
+     *  the step — `services`, `applied`, `ready`, `files`, `go`, `shim`,
+     *  `system`, `driver`, `imports`, `tools`, `model` (run-container.ts
+     *  #STARTUP_PHASES). Only the phases this step went through; null from
+     *  an executor that marks none, absent on steps from before 17 Oct 2026. */
+    startup?: Record<string, number> | null;
     /** Which reservation class the sandbox held (small | large), and the
      *  actual limits it held, as numbers. Facts of the step: a price is per
      *  core-second, so what was reserved must come from the record, never
@@ -1288,6 +1285,14 @@ export declare function listRunOutputs(tenant: string, workspace: string, runId:
 export declare function runOutputPath(tenant: string, workspace: string, runId: string, agent: string, rel: string): string | null;
 export declare function readRun(tenant: string, workspace: string, runId: string): RunRecord | null;
 export declare function writeRun(tenant: string, workspace: string, run: RunRecord): void;
+/**
+ * The workspace's live runs — queued, running, or parked at a gate — read
+ * whole, newest first. Off the run index: only the live records are opened,
+ * where listRuns parses every record the workspace ever kept. What the
+ * periodic sweeps want (reconcile, the watchdog), and on a box that keeps
+ * ninety days of runs that is a handful of files instead of thousands.
+ */
+export declare function liveRuns(tenant: string, workspace: string): RunRecord[];
 export interface RunWithWorkspace extends RunRecord {
     workspace: string;
 }

package/dist/src/store.js

@@ -1681,7 +1681,7 @@ export function mayApprove(flow, who) {
 }
 /** A live run of this flow — the fact overlap: decisions are made on. */
 export function flowHasLiveRun(tenant, workspace, flowName) {
-    return listRuns(tenant, workspace).some((r) => r.flow === flowName && (r.status === "running" || r.status === "queued" || r.status === "awaiting-approval"));
+    return listRunSummaries(tenant, workspace).some((r) => r.flow === flowName && (r.status === "running" || r.status === "queued" || r.status === "awaiting-approval"));
 }
 // Split a flow file into its frontmatter, any prose before the first step,
 // and one block per step. Blocks come back in the same order as parseFlow's
@@ -2012,13 +2012,6 @@ export function listWorkspaces(tenant) {
             }
         }
         const runsDir = path.join(pDir, "runs");
-        let preview;
-        try {
-            preview = JSON.parse(fs.readFileSync(path.join(dir, `.${name}.preview.json`), "utf8"));
-        }
-        catch {
-            // not a preview
-        }
         return {
             name,
             description,
@@ -2026,7 +2019,6 @@ export function listWorkspaces(tenant) {
             flows: listFlows(tenant, name).length,
             deployedAt: fs.statSync(pDir).mtime.toISOString(),
             runCount: fs.existsSync(runsDir) ? fs.readdirSync(runsDir).filter((f) => f.endsWith(".json") && !f.startsWith(".")).length : 0,
-            ...(preview ? { preview } : {}),
         };
     })
         .sort((a, b) => b.deployedAt.localeCompare(a.deployedAt));
@@ -2697,6 +2689,24 @@ export function writeRun(tenant, workspace, run) {
     fs.renameSync(tmp, p);
     noteRunWritten(path.dirname(p), run, p);
 }
+/**
+ * The workspace's live runs — queued, running, or parked at a gate — read
+ * whole, newest first. Off the run index: only the live records are opened,
+ * where listRuns parses every record the workspace ever kept. What the
+ * periodic sweeps want (reconcile, the watchdog), and on a box that keeps
+ * ninety days of runs that is a handful of files instead of thousands.
+ */
+export function liveRuns(tenant, workspace) {
+    const out = [];
+    for (const s of listRunSummaries(tenant, workspace)) {
+        if (!LIVE_STATUSES.has(s.status))
+            continue;
+        const run = readRun(tenant, workspace, s.id);
+        if (run)
+            out.push(run);
+    }
+    return out;
+}
 /**
  * Every run in the account, newest first, off the per-workspace index.
  *
@@ -2721,6 +2731,13 @@ export function listAllRuns(tenant) {
     }))
         .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
 }
+/**
+ * Which version of a file this is. mtime alone missed a rewrite inside one
+ * mtime tick (coarse on some NFS servers), leaving a stale row that the
+ * sweeps act on; every write here is a rename to a new file, so the inode
+ * moves on each write whatever the clock says, and the size usually does.
+ */
+const fileStamp = (st) => `${st.mtimeMs}:${st.ino}:${st.size}`;
 const RUN_INDEX = ".index.json";
 const LIVE_STATUSES = new Set(["queued", "running", "awaiting-approval"]);
 /** One run's row. */
@@ -2780,22 +2797,22 @@ export function runFromSummary(s) {
 const runIndexCache = new Map();
 function readRunIndex(dir) {
     const file = path.join(dir, RUN_INDEX);
-    let mtimeMs;
+    let stamp;
     try {
-        mtimeMs = fs.statSync(file).mtimeMs;
+        stamp = fileStamp(fs.statSync(file));
     }
     catch {
         runIndexCache.delete(dir);
         return null;
     }
     const cached = runIndexCache.get(dir);
-    if (cached && cached.mtimeMs === mtimeMs)
+    if (cached && cached.stamp === stamp)
         return cached.index;
     try {
         const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
         if (parsed?.v !== 1 || typeof parsed.runs !== "object" || !parsed.runs)
             return null;
-        runIndexCache.set(dir, { index: parsed, mtimeMs });
+        runIndexCache.set(dir, { index: parsed, stamp });
         return parsed;
     }
     catch {
@@ -2808,13 +2825,18 @@ function writeRunIndex(dir, index) {
     fs.writeFileSync(tmp, JSON.stringify(index));
     fs.renameSync(tmp, file);
     try {
-        runIndexCache.set(dir, { index, mtimeMs: fs.statSync(file).mtimeMs });
+        runIndexCache.set(dir, { index, stamp: fileStamp(fs.statSync(file)) });
     }
     catch {
         runIndexCache.delete(dir);
     }
 }
-const sameRow = (a, b) => !!a && JSON.stringify({ ...a, mtimeMs: 0 }) === JSON.stringify({ ...b, mtimeMs: 0 });
+const sameRow = (a, b) => {
+    if (!a)
+        return false;
+    const { mtimeMs: _m, stamp: _s, ...row } = a;
+    return JSON.stringify(row) === JSON.stringify(b);
+};
 /** writeRun just saved `run` at `file`: bring its row up to date. The file
  *  is rewritten only when the row's content moved — a live step appends an
  *  event several times a second, and the row does not change for that;
@@ -2828,7 +2850,8 @@ function noteRunWritten(dir, run, file) {
         const row = summarizeRun(run);
         if (sameRow(index.runs[run.id], row))
             return;
-        index.runs[run.id] = { ...row, mtimeMs: fs.statSync(file).mtimeMs };
+        const st = fs.statSync(file);
+        index.runs[run.id] = { ...row, mtimeMs: st.mtimeMs, stamp: fileStamp(st) };
         writeRunIndex(dir, index);
     }
     catch {
@@ -2866,19 +2889,20 @@ export function listRunSummaries(tenant, workspace) {
             continue;
         const id = f.slice(0, -".json".length);
         present.add(id);
-        let mtimeMs;
+        let st;
         try {
-            mtimeMs = fs.statSync(path.join(dir, f)).mtimeMs;
+            st = fs.statSync(path.join(dir, f));
         }
         catch {
             continue; // pruned between the listing and the stat
         }
+        const stamp = fileStamp(st);
         const row = index.runs[id];
-        if (row && row.mtimeMs === mtimeMs)
+        if (row && row.stamp === stamp)
             continue;
         try {
             const run = JSON.parse(fs.readFileSync(path.join(dir, f), "utf8"));
-            index.runs[id] = { ...summarizeRun(run), mtimeMs };
+            index.runs[id] = { ...summarizeRun(run), mtimeMs: st.mtimeMs, stamp };
             changed = true;
         }
         catch {
@@ -2900,7 +2924,7 @@ export function listRunSummaries(tenant, workspace) {
         }
     }
     return Object.values(index.runs)
-        .map(({ mtimeMs: _m, ...row }) => row)
+        .map(({ mtimeMs: _m, stamp: _s, ...row }) => row)
         .sort((a, b) => b.startedAt.localeCompare(a.startedAt));
 }
 /** Every workspace's runs as summaries, tagged with the workspace. */

package/index.ts

@@ -36,7 +36,6 @@ export * from "./src/tool-names.ts";
 export * from "./src/history.ts";
 export * from "./src/zip.ts";
 export * from "./src/package.ts";
-export * from "./src/gitrepo.ts";
 export * from "./src/storage.ts";
 export * from "./src/secrets.ts";
 export * from "./src/oauth-presets.ts";
@@ -47,5 +46,3 @@ export * from "./src/approvals.ts";
 export * from "./src/deploy.ts";
 export * from "./src/agent-import.ts";
 export * from "./src/account.ts";
-export * from "./src/tar.ts";
-export * from "./src/git.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldrun/core",
-  "version": "1.4.2",
+  "version": "2.0.0",
   "description": "Agents are just folders. The format, the runner, the checks.",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",
@@ -9,7 +9,6 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./git-hook": "./dist/src/git-hook.js",
     "./*": {
       "types": "./dist/src/*.d.ts",
       "default": "./dist/src/*.js"
@@ -18,7 +17,6 @@
   "foldrun": {
     "publicApi": [
       ".",
-      "./git-hook",
       "./agents-md",
       "./browser-pod",
       "./flow-patterns",