@foldrun/core 1.4.2 → 2.1.0

package/dist/index.d.ts

@@ -24,7 +24,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";
@@ -35,5 +34,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/dist/index.js

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

package/dist/src/catalog.d.ts

@@ -83,7 +83,14 @@ export declare function clampEffort(catalog: Catalog | null, modelId: string, ef
 export declare function catalogCost(catalog: Catalog | null, modelId: string, usage: {
     inputTokens: number;
     outputTokens: number;
+    cacheReadTokens?: number;
+    cacheWriteTokens?: number;
 }): number | null;
+/** 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 declare const CACHE_WRITE_MULTIPLIER = 1.25;
+export declare 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/dist/src/catalog.js

@@ -200,8 +200,23 @@ export function catalogCost(catalog, modelId, usage) {
     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/dist/src/deploy.d.ts

@@ -97,7 +97,9 @@ export declare function deployIssues(files: DeployFile[]): DeployIssue[];
  */
 export declare function runsInFlight(tenant: string, workspace: string): string[];
 /** What a deploy would do, without doing it. */
-export declare function planDeploy(tenant: string, workspace: string, files: DeployFile[]): DeployPlan;
+export declare function planDeploy(tenant: string, workspace: string, files: DeployFile[], opts?: {
+    keepUntracked?: boolean;
+}): DeployPlan;
 export interface DeployOptions {
     /** The commit these files came from, recorded so the dashboard can show it. */
     commit?: string | null;
@@ -115,6 +117,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;
 }
 /**
  * Deploy a file list to a workspace, if it checks out.
@@ -124,32 +129,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 declare const pushNotePath: (tenant: string, workspace: string) => string;
-export declare function readPushNote(tenant: string, workspace: string): PushNote | null;
-export declare function writePushNote(tenant: string, workspace: string, note: PushNote): void;
-/**
- * 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 declare function applyPendingPush(tenant: string, workspace: string, filesAt: (tenant: string, scope: string, ref: string) => DeployFile[]): {
-    commit: string;
-} | null;
 export declare function deployWorkspace(tenant: string, workspace: string, files: DeployFile[], opts?: DeployOptions): DeployResult;
 export declare function writeDeployedCommit(tenant: string, workspace: string, commit: string): void;
 export declare function deployedCommit(tenant: string, workspace: string): {

package/dist/src/deploy.js

@@ -20,7 +20,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { saveWorkspace, keptOnDeploy, workspaceDir, listRuns, parseFlow, parseToolDef, WORKSPACE_DIRS, assertSafeName, notifyWorkspaceChanged, } from "./store.js";
+import { saveWorkspace, keptOnDeploy, workspaceDir, listRunSummaries, listWorkspaceFiles, parseFlow, parseToolDef, WORKSPACE_DIRS, assertSafeName, } from "./store.js";
 import { lintFlow } from "./flow-lint.js";
 import { refNames } from "./refs.js";
 import matter from "gray-matter";
@@ -32,7 +32,6 @@ import { networkProblems } from "./network.js";
 import { actionProblems } from "./web-actions.js";
 import { languageProblem } from "./language.js";
 import { localeProblems } from "./locale.js";
-import { repoDir } from "./gitrepo.js";
 import { entriesNoFollow } from "./paths.js";
 import { filterIgnored, findingFingerprint, ruleForWhere, scanFiles } from "./scan.js";
 /** Directories a deploy never reads out of a source tree. */
@@ -434,12 +433,12 @@ export function deployIssues(files) {
 export function runsInFlight(tenant, workspace) {
     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, workspace, files) {
+export function planDeploy(tenant, workspace, files, opts = {}) {
     const dir = workspaceDir(tenant, workspace);
     const shipped = new Map(files.map((f) => [path.normalize(f.path), f.content]));
     const present = new Set();
@@ -481,7 +480,10 @@ export function planDeploy(tenant, workspace, files) {
     // 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,
         added: added.sort(),
@@ -492,62 +494,18 @@ export function planDeploy(tenant, workspace, files) {
         blockedBy: runsInFlight(tenant, workspace),
     };
 }
-export const pushNotePath = (tenant, workspace) => path.join(repoDir(tenant, workspace), "foldrun-last-push.json");
-export function readPushNote(tenant, workspace) {
-    try {
-        return JSON.parse(fs.readFileSync(pushNotePath(tenant, workspace), "utf8"));
-    }
-    catch {
-        return null;
-    }
-}
-export function writePushNote(tenant, workspace, note) {
-    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.
+ * Deploy a file list to a workspace, if it checks out.
  *
- * Only `blockedBy`: a push refused for `issues` is a broken workspace and
- * wants a person, not a retry.
+ * Returns the plan either way, with `applied` saying whether anything changed.
+ * A refused deploy is a normal outcome, not an exception: the caller is a
+ * webhook or a CLI that needs to report *why*, and every reason is already in
+ * the plan.
  */
-export function applyPendingPush(tenant, workspace, filesAt) {
-    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, workspace, files, opts = {}) {
     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 };
@@ -559,7 +517,7 @@ export function deployWorkspace(tenant, workspace, files, opts = {}) {
             return { ...plan, applied: false, commit: null, preserved: 0, unexpectedRemovals };
         }
     }
-    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);

package/dist/src/history.d.ts

@@ -9,11 +9,6 @@
  */
 type TreeReader = (tenant: string, scope: string) => RevisionFile[] | null;
 export declare function registerTreeReader(fn: TreeReader): void;
-/** Something to do after a commit lands on main — the mirror push. Registered
- *  by mirror.ts; this module cannot import it (secrets, settings). */
-type AfterCommit = (tenant: string, scope: string, sha: string) => void;
-export declare function registerAfterCommit(fn: AfterCommit): void;
-export declare function notifyCommit(tenant: string, scope: string, sha: string): void;
 export interface RevisionFile {
     path: string;
     /** Null when the file did not exist before. */
@@ -55,17 +50,42 @@ export declare function recordRevision(tenant: string, scope: string, files: Rev
     id?: string;
     commit?: string | null;
 }): Revision | null;
+/** Whether a revision can be restored to: it has a snapshot. */
+export declare function hasSnapshot(tenant: string, scope: string, id: string): boolean;
+/** The whole tree at revision `id`, or null when it has no snapshot. */
+export declare function snapshotAt(tenant: string, scope: string, id: string): {
+    path: string;
+    content: string;
+}[] | null;
+/** The newest revision that can be restored to — what "now" is in history. */
+export declare function headRevision(tenant: string, scope: string): RevisionSummary | null;
+/**
+ * A scope with no snapshot yet gets one: its tree as it stands, recorded as
+ * a revision of its own — where its history starts. Every workspace that
+ * existed when history moved off git starts here, and so does one created
+ * by a path that never recorded a change. Returns the head's id, or null
+ * when there is nothing to snapshot.
+ */
+export declare function ensureBaseline(tenant: string, scope: string, by?: string): string | null;
+/**
+ * The revision a restore means: an id (or the commit a deploy recorded), a
+ * date (`2026-10-17`, `2026-10-17T09:00Z`) or a span back from now (`90m`,
+ * `12h`, `3d`, `2w`) — the newest revision with a snapshot at or before that
+ * moment. Null when history holds nothing that old. Throws (status 400) on
+ * something that is none of those.
+ */
+export declare function resolveRevision(tenant: string, scope: string, to: string, now?: number): {
+    id: string;
+    at: string;
+    by: string;
+    message: string;
+} | null;
 /** Newest first. `forPath` narrows to revisions that touched one file. */
 export declare function listRevisions(tenant: string, scope: string, opts?: {
     forPath?: string;
     limit?: number;
 }): RevisionSummary[];
 export declare function readRevision(tenant: string, scope: string, id: string, forPath?: string): Revision | null;
-/**
- * Make sure a scope's repository has its initial import, so a clone made
- * right now is complete. A no-op once any commit exists.
- */
-export declare function ensureImported(tenant: string, scope: string): string | null;
 /** The most recent revision id for a scope — what a change is attributed
  *  to when nothing more specific (a deployed commit) is on record. */
 export declare function latestRevisionId(tenant: string, scope: string): string | null;