@foldrun/core 1.4.2 → 2.1.0

package/dist/src/store.js

@@ -385,7 +385,6 @@ meta = {}) {
     // about it. Before this, every deploy silently erased everything the agents
     // had learned.
     const shipped = new Set(files.map((f) => path.normalize(f.path)));
-    const isAgentOwned = (rel) => keptOnDeploy(rel, shipped);
     // What is there now, for the revision: every editable file's content
     // before this save replaces the tree.
     const before = new Map();
@@ -399,6 +398,7 @@ meta = {}) {
             }
         }
     }
+    const isAgentOwned = (rel) => keptOnDeploy(rel, shipped) || (meta.keepUntracked === true && !before.has(rel) && !shipped.has(rel));
     const snapshot = fs.existsSync(dir) ? fs.mkdtempSync(path.join(dataRoot(), ".keep-")) : null;
     const preserved = [];
     if (snapshot) {
@@ -406,11 +406,15 @@ meta = {}) {
             const rel = String(entry).split(path.sep).join("/");
             const from = path.join(dir, rel);
             try {
-                if (!fs.statSync(from).isFile() || !isAgentOwned(rel))
+                // lstat, never stat: a link is never followed. An agent folder's link
+                // to a file outside the workspace was copied in as that file's
+                // contents — on a restore with keepUntracked, any such link
+                // (Codex, 18 Oct 2026).
+                if (!fs.lstatSync(from).isFile() || !isAgentOwned(rel))
                     continue;
             }
             catch {
-                continue; // a broken link or a file that vanished mid-deploy
+                continue; // a file that vanished mid-deploy
             }
             const to = path.join(snapshot, rel);
             fs.mkdirSync(path.dirname(to), { recursive: true });
@@ -1681,7 +1685,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 +2016,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 +2023,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));
@@ -2581,10 +2577,62 @@ export function sumAttempts(tries) {
     const secs = tries.map((t) => t.computeSecs).filter((c) => typeof c === "number");
     return {
         costUsd: costs.length ? costs.reduce((a, b) => a + b, 0) : null,
-        tokens: toks.length ? toks.reduce((a, b) => ({ input: a.input + b.input, output: a.output + b.output }), { input: 0, output: 0 }) : null,
+        tokens: toks.length ? sumTokens(toks) : null,
         computeSecs: secs.length ? secs.reduce((a, b) => a + b, 0) : null,
     };
 }
+/** The record's shape from what a step reports (ExecOutcome.usage). */
+export function tokensOf(usage) {
+    if (!usage)
+        return null;
+    return {
+        input: usage.inputTokens,
+        output: usage.outputTokens,
+        cacheRead: usage.cacheReadTokens ?? 0,
+        cacheWrite: usage.cacheWriteTokens ?? 0,
+    };
+}
+/** Field-by-field sum; the cache fields are present in the result whenever
+ *  any input had them, so a run of old and new steps still reads whole. */
+export function sumTokens(list) {
+    const out = { input: 0, output: 0 };
+    for (const t of list) {
+        out.input += t.input;
+        out.output += t.output;
+        if (t.cacheRead !== undefined || t.cacheWrite !== undefined) {
+            out.cacheRead = (out.cacheRead ?? 0) + (t.cacheRead ?? 0);
+            out.cacheWrite = (out.cacheWrite ?? 0) + (t.cacheWrite ?? 0);
+        }
+    }
+    return out;
+}
+/** The share of all input that the prompt cache served, 0–1; null when
+ *  there was no input, or the record predates the split and cannot say. */
+export function cacheHitRate(t) {
+    if (!t || t.cacheRead === undefined)
+        return null;
+    return t.input > 0 ? Math.min(1, t.cacheRead / t.input) : null;
+}
+/** The cache share over several counts, taking only those that report the
+ *  split: a step recorded before it holds its cache traffic inside `input`,
+ *  and counting that as uncached would understate the rate. The rule the
+ *  Usage page and the CLI's totals follow too. */
+export function measuredHitRate(list) {
+    let read = 0;
+    let all = 0;
+    for (const t of list) {
+        if (!t || t.cacheRead === undefined)
+            continue;
+        read += t.cacheRead;
+        all += t.input;
+    }
+    return all > 0 ? read / all : null;
+}
+/** A run's token counts, summed over its steps; null when no step reported any. */
+export function runTokens(run) {
+    const toks = run.steps.map((s) => s.tokens).filter((t) => !!t);
+    return toks.length ? sumTokens(toks) : null;
+}
 export function runFilePath(tenant, workspace, runId) {
     assertSafeName(runId, "run id");
     return path.join(workspaceDir(tenant, workspace), "runs", `${runId}.json`);
@@ -2697,6 +2745,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 +2787,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 +2853,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 +2881,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 +2906,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 +2945,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 +2980,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/dist/src/tool-loop.d.ts

@@ -13,9 +13,12 @@ export interface LoopTool {
     run: (args: Record<string, string | undefined>) => Promise<string> | string;
 }
 export interface LoopUsage {
-    /** Everything sent, cache reads and writes included. */
+    /** Everything sent, cache reads and writes included; the two cache
+     *  fields say how much of it the prompt cache served or stored. */
     inputTokens: number;
     outputTokens: number;
+    cacheReadTokens: number;
+    cacheWriteTokens: number;
     costUsd: number;
 }
 export interface LoopResult {

package/dist/src/tool-loop.js

@@ -170,6 +170,8 @@ export async function runToolLoop(o) {
                 usage = {
                     inputTokens: models.reduce((n, m) => n + (m.inputTokens ?? 0) + (m.cacheReadInputTokens ?? 0) + (m.cacheCreationInputTokens ?? 0), 0),
                     outputTokens: models.reduce((n, m) => n + (m.outputTokens ?? 0), 0),
+                    cacheReadTokens: models.reduce((n, m) => n + (m.cacheReadInputTokens ?? 0), 0),
+                    cacheWriteTokens: models.reduce((n, m) => n + (m.cacheCreationInputTokens ?? 0), 0),
                     costUsd,
                 };
                 if (message.subtype === "success") {

package/dist/src/translator.d.ts

@@ -1,4 +1,16 @@
 type Json = Record<string, unknown>;
+/**
+ * An OpenAI-shaped usage object as Anthropic's: fresh input, cached input,
+ * output. Both OpenAI shapes count the cached part INSIDE the prompt total
+ * (Chat's prompt_tokens_details.cached_tokens, Responses'
+ * input_tokens_details.cached_tokens; DeepSeek says prompt_cache_hit_tokens),
+ * so it is taken out of input here or the step would count it twice.
+ */
+export declare function anthropicUsage(u: Json | undefined, wire: TranslatorWire): {
+    input: number;
+    cached: number;
+    output: number;
+};
 export type TranslatorWire = "chat" | "responses";
 export interface TranslatorSpec {
     /** The provider's base, e.g. https://api.openai.com/v1 — `/chat/completions`

package/dist/src/translator.js

@@ -22,7 +22,9 @@
 // and their results, streaming — and drops what a Chat-Completions endpoint
 // has no word for (cache_control, top_k, server-side tools, thinking on
 // endpoints that lack reasoning_effort). Anything dropped is said once in
-// the run trace. The translation is pure functions over JSON so the tests
+// the run trace. Those endpoints cache prompt prefixes on their own side;
+// the cached share they report comes back as cache_read_input_tokens, so a
+// step's record says how much of its context was re-read. The translation is pure functions over JSON so the tests
 // can drive every mapping without a network; the server around them is a
 // few dozen lines.
 import http from "node:http";
@@ -31,6 +33,33 @@ import { PROTECTED_PARAMS } from "./providers.js";
 import { viaEgress } from "./egress.js";
 import { trimSlashes } from "./paths.js";
 import { captureRefusalHeaders, isRefusalStatus, refusalLine } from "./refusal.js";
+/**
+ * An OpenAI-shaped usage object as Anthropic's: fresh input, cached input,
+ * output. Both OpenAI shapes count the cached part INSIDE the prompt total
+ * (Chat's prompt_tokens_details.cached_tokens, Responses'
+ * input_tokens_details.cached_tokens; DeepSeek says prompt_cache_hit_tokens),
+ * so it is taken out of input here or the step would count it twice.
+ */
+export function anthropicUsage(u, wire) {
+    if (!u)
+        return { input: 0, cached: 0, output: 0 };
+    const total = Number((wire === "chat" ? u.prompt_tokens : u.input_tokens) ?? 0);
+    const details = (wire === "chat" ? u.prompt_tokens_details : u.input_tokens_details);
+    const raw = Number(details?.cached_tokens ?? u.prompt_cache_hit_tokens ?? 0);
+    const cached = Number.isFinite(raw) ? Math.max(0, Math.min(raw, total)) : 0;
+    return {
+        input: total - cached,
+        cached,
+        output: Number((wire === "chat" ? u.completion_tokens : u.output_tokens) ?? 0),
+    };
+}
+function usageBlock(u) {
+    return {
+        input_tokens: u?.input ?? 0,
+        output_tokens: u?.output ?? 0,
+        ...(u && u.cached > 0 ? { cache_read_input_tokens: u.cached } : {}),
+    };
+}
 function dropped() {
     const seen = new Set();
     return {
@@ -466,10 +495,7 @@ export function fromChatCompletion(res, requestedModel, stopSequences) {
         content,
         stop_reason: stop.reason,
         stop_sequence: stop.sequence,
-        usage: {
-            input_tokens: Number(usage.prompt_tokens ?? 0),
-            output_tokens: Number(usage.completion_tokens ?? 0),
-        },
+        usage: usageBlock(anthropicUsage(usage, "chat")),
     };
 }
 /**
@@ -532,7 +558,7 @@ export class StreamTranslator {
         const out = this.start(chunk);
         const u = chunk.usage;
         if (u && (u.prompt_tokens !== undefined || u.completion_tokens !== undefined)) {
-            this.usage = { input: Number(u.prompt_tokens ?? 0), output: Number(u.completion_tokens ?? 0) };
+            this.usage = anthropicUsage(u, "chat");
         }
         const choice = (chunk.choices ?? [])[0];
         if (!choice)
@@ -609,7 +635,7 @@ export class StreamTranslator {
         out.push(this.event("message_delta", {
             type: "message_delta",
             delta: { stop_reason: stop.reason, stop_sequence: stop.sequence },
-            usage: { input_tokens: this.usage?.input ?? 0, output_tokens: this.usage?.output ?? 0 },
+            usage: usageBlock(this.usage),
         }));
         out.push(this.event("message_stop", { type: "message_stop" }));
         return out;
@@ -648,10 +674,7 @@ export function fromResponses(res, requestedModel) {
         content,
         stop_reason: stop,
         stop_sequence: null,
-        usage: {
-            input_tokens: Number(usage.input_tokens ?? 0),
-            output_tokens: Number(usage.output_tokens ?? 0),
-        },
+        usage: usageBlock(anthropicUsage(usage, "responses")),
     };
 }
 /**
@@ -768,7 +791,7 @@ export class ResponsesStreamTranslator {
             const r = ev.response ?? {};
             const u = r.usage;
             if (u)
-                this.usage = { input: Number(u.input_tokens ?? 0), output: Number(u.output_tokens ?? 0) };
+                this.usage = anthropicUsage(u, "responses");
             const reason = r.incomplete_details?.reason;
             if (typeof reason === "string")
                 this.incomplete = reason;
@@ -790,7 +813,7 @@ export class ResponsesStreamTranslator {
         out.push(this.event("message_delta", {
             type: "message_delta",
             delta: { stop_reason: reason, stop_sequence: null },
-            usage: { input_tokens: this.usage?.input ?? 0, output_tokens: this.usage?.output ?? 0 },
+            usage: usageBlock(this.usage),
         }));
         out.push(this.event("message_stop", { type: "message_stop" }));
         return out;

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.1.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",

package/src/catalog.ts

@@ -245,13 +245,29 @@ export function clampEffort(
 export function catalogCost(
   catalog: Catalog | null,
   modelId: string,
-  usage: { inputTokens: number; outputTokens: number },
+  usage: { inputTokens: number; outputTokens: number; cacheReadTokens?: number; cacheWriteTokens?: number },
 ): number | null {
   const m = findModel(catalog, modelId);
   if (!m || m.promptPrice == null || m.completionPrice == null) return null;
-  return usage.inputTokens * m.promptPrice + usage.outputTokens * m.completionPrice;
+  // A catalogue quotes one input price; cache traffic is priced off it with
+  // the multipliers every gateway that bills for caching has copied from
+  // Anthropic. Before the counts were split (18 Oct 2026) every cached
+  // token was billed here at the full rate — a long cached step cost ten
+  // times its price on the ledger.
+  // inputTokens is all input; the cache fields are parts of it.
+  const read = usage.cacheReadTokens ?? 0;
+  const written = usage.cacheWriteTokens ?? 0;
+  const fresh = Math.max(0, usage.inputTokens - read - written);
+  const input = fresh + written * CACHE_WRITE_MULTIPLIER + read * CACHE_READ_MULTIPLIER;
+  return input * m.promptPrice + usage.outputTokens * m.completionPrice;
 }
 
+/** Anthropic's cache multipliers over the input price: a write costs a
+ *  quarter more than fresh input, a read a tenth of it. One source for the
+ *  mid-step ceiling (priceTurn) and the record's repricing (catalogCost). */
+export const CACHE_WRITE_MULTIPLIER = 1.25;
+export const CACHE_READ_MULTIPLIER = 0.1;
+
 /** Catalogue entries as completion items: price per MTok, context, and the
  *  one capability that decides agent-worthiness. Tool-capable models first —
  *  on an agent platform they are almost always what the author wants. */

package/src/deploy.ts

@@ -25,7 +25,8 @@ import {
   saveWorkspace,
   keptOnDeploy,
   workspaceDir,
-  listRuns,
+  listRunSummaries,
+  listWorkspaceFiles,
   parseFlow,
   parseToolDef,
   WORKSPACE_DIRS,
@@ -44,7 +45,6 @@ import { networkProblems } from "./network.ts";
 import { actionProblems } from "./web-actions.ts";
 import { languageProblem } from "./language.ts";
 import { localeProblems } from "./locale.ts";
-import { repoDir } from "./gitrepo.ts";
 import { entriesNoFollow } from "./paths.ts";
 import { filterIgnored, findingFingerprint, ruleForWhere, scanFiles, type ScanFinding, type ScanOptions } from "./scan.ts";
 
@@ -455,13 +455,13 @@ export function deployIssues(files: DeployFile[]): DeployIssue[] {
  */
 export function runsInFlight(tenant: string, workspace: string): string[] {
   if (!fs.existsSync(workspaceDir(tenant, workspace))) return [];
-  return listRuns(tenant, workspace)
+  return listRunSummaries(tenant, workspace)
     .filter((r) => r.status === "queued" || r.status === "running" || r.status === "awaiting-approval")
     .map((r) => r.id);
 }
 
 /** What a deploy would do, without doing it. */
-export function planDeploy(tenant: string, workspace: string, files: DeployFile[]): DeployPlan {
+export function planDeploy(tenant: string, workspace: string, files: DeployFile[], opts: { keepUntracked?: boolean } = {}): DeployPlan {
   const dir = workspaceDir(tenant, workspace);
   const shipped = new Map(files.map((f) => [path.normalize(f.path), f.content]));
 
@@ -499,7 +499,10 @@ export function planDeploy(tenant: string, workspace: string, files: DeployFile[
   // memory, the platform's own files. Reporting these as removals would be
   // a lie, and the alarming kind; one predicate serves both.
   const shippedPaths = new Set(shipped.keys());
-  const removed = [...present].filter((rel) => !shipped.has(rel) && !keptOnDeploy(rel, shippedPaths));
+  // keepUntracked (a restore): what is not editable source stays, as
+  // saveWorkspace keeps it — see its meta.keepUntracked.
+  const tracked = opts.keepUntracked ? new Set(listWorkspaceFiles(tenant, workspace)) : null;
+  const removed = [...present].filter((rel) => !shipped.has(rel) && !keptOnDeploy(rel, shippedPaths) && (!tracked || tracked.has(rel)));
 
   return {
     files,
@@ -529,6 +532,9 @@ export interface DeployOptions {
    * no window between the check and the swap. Absent: no check, as before.
    */
   expectRemoved?: string[];
+  /** Keep what is not editable source (planDeploy, saveWorkspace): a
+   *  restore takes history's tree, and history tracks source only. */
+  keepUntracked?: boolean;
 }
 
 /**
@@ -539,73 +545,6 @@ export interface DeployOptions {
  * webhook or a CLI that needs to report *why*, and every reason is already in
  * the plan.
  */
-/** What a push recorded about itself, where the Repository page reads it. */
-export interface PushNote {
-  commit: string;
-  at: string;
-  applied: boolean;
-  issues?: unknown[];
-  blockedBy?: string[];
-  /** Set when a blocked push was applied later, by the retry. */
-  appliedAt?: string;
-}
-
-export const pushNotePath = (tenant: string, workspace: string) =>
-  path.join(repoDir(tenant, workspace), "foldrun-last-push.json");
-
-export function readPushNote(tenant: string, workspace: string): PushNote | null {
-  try {
-    return JSON.parse(fs.readFileSync(pushNotePath(tenant, workspace), "utf8")) as PushNote;
-  } catch {
-    return null;
-  }
-}
-
-export function writePushNote(tenant: string, workspace: string, note: PushNote) {
-  try {
-    fs.writeFileSync(pushNotePath(tenant, workspace), JSON.stringify(note));
-  } catch {
-    // The note is a record, not the deploy. Losing it must not fail a push.
-  }
-  // A push waiting on a run is the scheduler's to apply; tell it there is one.
-  notifyWorkspaceChanged(tenant, workspace, "push");
-}
-
-/**
- * A push whose deploy was refused only because a run was in flight is not a
- * failure — it is a deploy that has not happened yet. Git already said the
- * push succeeded (the deploy happens after the client is gone), so nothing
- * would ever tell anyone the workspace on disk is behind `main`. This applies
- * it once the runs are done.
- *
- * Only `blockedBy`: a push refused for `issues` is a broken workspace and
- * wants a person, not a retry.
- */
-export function applyPendingPush(
-  tenant: string,
-  workspace: string,
-  filesAt: (tenant: string, scope: string, ref: string) => DeployFile[],
-): { commit: string } | null {
-  const note = readPushNote(tenant, workspace);
-  if (!note || note.applied) return null;
-  if (!note.blockedBy?.length || (note.issues?.length ?? 0) > 0) return null;
-  if (runsInFlight(tenant, workspace).length > 0) return null;
-  // Only the commit the note names, and only while it is still what main
-  // points at — a newer push supersedes it and wrote its own note.
-  const result = deployWorkspace(tenant, workspace, filesAt(tenant, workspace, note.commit), {
-    commit: note.commit,
-    force: false,
-  });
-  writePushNote(tenant, workspace, {
-    ...note,
-    applied: result.applied,
-    issues: result.issues ?? [],
-    blockedBy: result.blockedBy ?? [],
-    ...(result.applied ? { appliedAt: new Date().toISOString() } : {}),
-  });
-  return result.applied ? { commit: note.commit } : null;
-}
-
 export function deployWorkspace(
   tenant: string,
   workspace: string,
@@ -615,7 +554,7 @@ export function deployWorkspace(
   assertSafeName(tenant, "tenant");
   assertSafeName(workspace, "workspace");
 
-  const plan = planDeploy(tenant, workspace, files);
+  const plan = planDeploy(tenant, workspace, files, { keepUntracked: opts.keepUntracked });
   const blocked = plan.blockedBy.length > 0 && !opts.force;
   if (plan.issues.length > 0 || blocked) {
     return { ...plan, applied: false, commit: null, preserved: 0 };
@@ -628,7 +567,7 @@ export function deployWorkspace(
     }
   }
 
-  const { preserved } = saveWorkspace(tenant, workspace, files, { commit: opts.commit ?? null, by: opts.by ?? "deploy", message: opts.message });
+  const { preserved } = saveWorkspace(tenant, workspace, files, { commit: opts.commit ?? null, by: opts.by ?? "deploy", message: opts.message, keepUntracked: opts.keepUntracked });
   const commit = opts.commit ?? null;
   if (commit) writeDeployedCommit(tenant, workspace, commit);
   return { ...plan, applied: true, commit, preserved }; // saveWorkspace told the platform