@inflexa-ai/harness 0.46.2 → 0.48.0

package/dist/report-model/production-resolver.js

@@ -5,13 +5,13 @@
  * The realization holds three layers. Layer one is identity: membership through `snapshotEntry`, and a
  * streamed hash compare with `computeSha256File`. A hash mismatch fails before any parse. Layer two is
  * the host fast path: an in-process parse of a CSV, a TSV, a JSON, or a parquet file at or under the cap.
- * Layer three is the fall-through: an over-cap file or a host parse fault goes to the extraction arm. On any
- * doubt the read falls through, thus correctness never depends on the host parser. An extension that names
- * no tabular format refuses here, because the host decides the format for both arms.
+ * Layer three is the fall-through: an over-cap file or a host parse fault fails as `extraction-unavailable`.
+ * On any doubt the read falls through, thus the host parser never gives a partial or guessed answer. An
+ * extension that names no tabular format refuses the same way.
  *
  * A read of the bytes is the expensive part, thus an optional `ArtifactReadCache` outlives one resolver. It
- * holds the streamed hash and the extracted rows against a stat signature. Two tool calls of one analysis
- * share one cache, and each call still binds its own extraction arm with its own auth.
+ * holds the streamed hash and the parsed rows against a stat signature. Two tool calls of one analysis
+ * share one cache.
  *
  * The realization calls the shared assert functions in `assert-rules.ts`, and it mirrors the locator walk
  * and the reason choices of `fixture-resolver.ts`. Thus one semantics exists, and the fixture stays the
@@ -22,7 +22,6 @@ import { readFile, stat } from "node:fs/promises";
 import { extname } from "node:path";
 import { parquetReadObjects } from "hyparquet";
 import { z } from "zod";
-import { isWorkflowCancellation } from "../runtime/dbos.js";
 import { allWithConcurrency } from "../lib/async-utils.js";
 import { computeSha256File } from "../lib/fs-helpers.js";
 import { parseJsonAs } from "../lib/parse-json.js";
@@ -92,6 +91,10 @@ export function createArtifactReadStore() {
         },
     };
 }
+/** The cells of a fall-through. No reader outside the host exists, thus the reference fails as `extraction-unavailable`. */
+function fallThroughCells(path, hostDetail) {
+    return { kind: "unavailable", detail: `the host read of the file at ${path} stopped because ${hostDetail}, and no other reader exists` };
+}
 /** Build an `Err` that carries the unresolved reference. The `detail` key is present only when there is a detail to carry. */
 function fail(reference, reason, detail) {
     const failure = detail !== undefined ? { reference, reason, detail } : { reference, reason };
@@ -104,10 +107,9 @@ function describeReference(reference) {
 /**
  * Map a file extension to the format that the host arm reads. An unknown extension gives back `undefined`.
  *
- * This is the one format decision of the report path. The extraction request carries the answer, thus the
- * sandbox arm never repeats the mapping and the two arms hold no second table between them.
+ * This is the one format decision of the report path.
  */
-function detectFormat(path) {
+export function detectFormat(path) {
     switch (extname(path).toLowerCase()) {
         case ".csv":
             return "csv";
@@ -130,8 +132,7 @@ function detectFormat(path) {
  * where the caller detects the loss.
  *
  * A non-finite number is not a cell either. A parquet float column holds a `NaN` or an `Infinity`, thus the
- * coercion drops it and the row omits the key. The extraction script (`tasks/extract-values-script.ts`)
- * drops the same value to `None`, thus the host arm and the sandbox arm read the same bytes the same way.
+ * coercion drops it and the row omits the key.
  */
 export function coerceCell(value) {
     if (value === null || value === undefined) {
@@ -339,10 +340,7 @@ async function parseParquet(bytes) {
 }
 /**
  * Read the cells of one artifact through the host fast path. An over-cap file and a parse fault each give
- * back a fall-through, thus the arm reads them out of process.
- *
- * An extension that names no tabular format stops here. The arm reads a file by a decided format, and no
- * format is decided, thus the arm has nothing to obey and the read is unavailable.
+ * back a fall-through. An extension that names no tabular format stops here.
  */
 async function hostReadCells(cap, path, identity) {
     const format = detectFormat(path);
@@ -350,26 +348,33 @@ async function hostReadCells(cap, path, identity) {
         return { kind: "unsupported-format", detail: `the file at ${path} has no supported tabular format, thus no reader is decided for it` };
     }
     if (identity.size > cap) {
-        return { kind: "fall-through", format, detail: `the file size of ${identity.size} bytes is over the ${cap}-byte cap` };
+        return { kind: "fall-through", detail: `the file size of ${identity.size} bytes is over the ${cap}-byte cap` };
     }
     let bytes;
     try {
         bytes = await readFile(identity.absolute);
     }
     catch {
-        return { kind: "fall-through", format, detail: "the file could not be read" };
-    }
-    if (format === "parquet") {
-        const rows = await parseParquet(bytes);
-        return rows === undefined ? { kind: "fall-through", format, detail: "the parquet read did not succeed" } : { kind: "rows", rows };
+        return { kind: "fall-through", detail: "the file could not be read" };
     }
+    const rows = await parseTable(format, bytes);
+    return rows === undefined ? { kind: "fall-through", detail: PARSE_FAULT_DETAIL[format] } : { kind: "rows", rows };
+}
+/** The detail of a parse fault, for each format. */
+const PARSE_FAULT_DETAIL = {
+    csv: "the delimited parse did not succeed",
+    tsv: "the delimited parse did not succeed",
+    json: "the JSON parse did not succeed",
+    parquet: "the parquet read did not succeed",
+};
+/** Parse the bytes of one table in a decided format. A parse fault gives back `undefined`. */
+export async function parseTable(format, bytes) {
+    if (format === "parquet")
+        return parseParquet(bytes);
     const text = bytes.toString("utf8");
-    if (format === "json") {
-        const rows = parseJsonTable(text);
-        return rows === undefined ? { kind: "fall-through", format, detail: "the JSON parse did not succeed" } : { kind: "rows", rows };
-    }
-    const rows = parseDelimited(text, format === "tsv" ? "\t" : ",");
-    return rows === undefined ? { kind: "fall-through", format, detail: "the delimited parse did not succeed" } : { kind: "rows", rows };
+    if (format === "json")
+        return parseJsonTable(text);
+    return parseDelimited(text, format === "tsv" ? "\t" : ",");
 }
 /**
  * Compute the identity of one artifact: membership, containment, and the on-disk hash.
@@ -417,58 +422,6 @@ async function computeIdentity(workspaceRoot, analysisId, path, snapshot, readCa
     readCache?.set(resolved.absolute, { signature, hash: onDiskHash });
     return { kind: "ready", onDiskHash, fileType: entry.fileType, absolute: resolved.absolute, size, signature };
 }
-/**
- * Resolve each fall-through artifact through the extraction arm. One call covers the whole batch. An
- * absent arm gives back `unavailable`, and the detail names the absent arm. An arm that gives no answer
- * for a path gives back `unreadable`.
- */
-async function extractFallThrough(arm, requests) {
-    const out = new Map();
-    if (requests.length === 0) {
-        return out;
-    }
-    if (arm === undefined) {
-        for (const request of requests) {
-            out.set(request.path, {
-                kind: "unavailable",
-                detail: `the extraction arm is not wired, and the file at ${request.path} needs it because ${request.hostDetail}`,
-            });
-        }
-        return out;
-    }
-    let answered;
-    try {
-        answered = await arm.extract(requests.map((request) => ({ path: request.path, hash: request.hash, format: request.format })));
-    }
-    catch (cause) {
-        // The arm speaks the throw protocol for a genuine infrastructure fault. This boundary turns the
-        // throw into a value, thus each reference on the batch reads a failure as data. A cancel of the
-        // workflow is not a fault of the read, thus it leaves to DBOS with no change.
-        if (isWorkflowCancellation(cause))
-            throw cause;
-        for (const request of requests) {
-            out.set(request.path, { kind: "unreadable", detail: `the extraction arm did not read the file at ${request.path}` });
-        }
-        return out;
-    }
-    if (answered.isErr()) {
-        for (const request of requests) {
-            out.set(request.path, {
-                kind: "unavailable",
-                detail: `the host refused the sandbox (${answered.error.reason}), thus the file at ${request.path} was not read`,
-            });
-        }
-        return out;
-    }
-    const answers = answered.value;
-    for (const request of requests) {
-        const answer = answers.get(request.path);
-        out.set(request.path, answer === undefined
-            ? { kind: "unreadable", detail: `the extraction arm did not read the file at ${request.path}` }
-            : { kind: "rows", rows: answer.rows });
-    }
-    return out;
-}
 /**
  * Give back the rows that an earlier pass read for these exact bytes, or `undefined` when nothing shared
  * them. The signature compare is the whole guard: a file that changed on disk holds a different signature,
@@ -479,8 +432,8 @@ function sharedRows(readCache, identity) {
     return held !== undefined && held.signature === identity.signature && held.rows !== undefined ? held.rows : undefined;
 }
 /**
- * Share the rows of one clean read, thus the next pass over the same bytes starts no second container and
- * parses nothing again. A failed read is transient, thus only rows enter the cache.
+ * Share the rows of one clean read, thus the next pass over the same bytes parses nothing again. A failed
+ * read is transient, thus only rows enter the cache.
  */
 function shareRows(readCache, identity, rows) {
     readCache?.set(identity.absolute, { signature: identity.signature, hash: identity.onDiskHash, rows });
@@ -500,7 +453,7 @@ function accessesOf(reference) {
     }
 }
 /**
- * Make the production resolver over the workspace root and the optional extraction arm.
+ * Make the production resolver over the workspace root.
  *
  * The resolver holds a per-pass cache. `prepare` groups the references by artifact, reads each file one
  * time, and fills the cache. `resolve` then answers from the cache. A `resolve` with no prior `prepare`
@@ -508,7 +461,7 @@ function accessesOf(reference) {
  * artifact on both paths, and never one read for each reference.
  */
 export function createProductionResolver(deps) {
-    const { workspaceRoot, analysisId, extractionArm, readCache } = deps;
+    const { workspaceRoot, analysisId, readCache } = deps;
     const cap = deps.cap ?? DEFAULT_CAP_BYTES;
     // The per-pass caches. `prepare` clears and refills them, thus a later pass reads the artifacts again.
     const idCache = new Map();
@@ -528,8 +481,8 @@ export function createProductionResolver(deps) {
     }
     /**
      * Give back the cells of one path, from the cache after a prepare, or by a fresh read. A fresh read
-     * runs the host fast path, and it resolves a fall-through through the arm as a batch of one. The
-     * outcome enters the cache, thus a second reference at one path opens no second batch.
+     * runs the host fast path. The outcome enters the cache, thus a second reference at one path reads
+     * nothing again.
      */
     async function getCells(path, identity) {
         const cached = cellsCache.get(path);
@@ -549,18 +502,9 @@ export function createProductionResolver(deps) {
             cellsCache.set(path, parsed);
             return parsed;
         }
-        if (read.kind === "unsupported-format") {
-            const unavailable = { kind: "unavailable", detail: read.detail };
-            cellsCache.set(path, unavailable);
-            return unavailable;
-        }
-        const resolved = await extractFallThrough(extractionArm, [{ path, hash: identity.onDiskHash, format: read.format, hostDetail: read.detail }]);
-        const cells = resolved.get(path) ?? { kind: "unreadable", detail: `the extraction arm did not read the file at ${path}` };
-        if (cells.kind === "rows") {
-            shareRows(readCache, identity, cells.rows);
-        }
-        cellsCache.set(path, cells);
-        return cells;
+        const unavailable = read.kind === "unsupported-format" ? { kind: "unavailable", detail: read.detail } : fallThroughCells(path, read.detail);
+        cellsCache.set(path, unavailable);
+        return unavailable;
     }
     /**
      * The identity gate that a cell-reading reference passes before a read of cells.
@@ -788,7 +732,7 @@ export function createProductionResolver(deps) {
             }
         }
         // An earlier pass over these exact bytes already paid for the rows. Take them, thus the second pass
-        // of one analysis parses nothing again and starts no second container.
+        // of one analysis parses nothing again.
         const pending = [];
         for (const target of cellTargets) {
             const shared = sharedRows(readCache, target.identity);
@@ -800,10 +744,6 @@ export function createProductionResolver(deps) {
             }
         }
         const reads = await allWithConcurrency(pending.map((target) => async () => ({ target, read: await hostReadCells(cap, target.path, target.identity) })), PREPARE_CONCURRENCY);
-        // Split the clean reads from the fall-throughs, then resolve every fall-through in one arm call. An
-        // unsupported format reaches no arm, because no reader is decided for it.
-        const fallThrough = [];
-        const identityByPath = new Map();
         for (const { target, read } of reads) {
             if (read.kind === "rows") {
                 cellsCache.set(target.path, { kind: "rows", rows: read.rows });
@@ -813,16 +753,7 @@ export function createProductionResolver(deps) {
                 cellsCache.set(target.path, { kind: "unavailable", detail: read.detail });
             }
             else {
-                identityByPath.set(target.path, target.identity);
-                fallThrough.push({ path: target.path, hash: target.identity.onDiskHash, format: read.format, hostDetail: read.detail });
-            }
-        }
-        const resolved = await extractFallThrough(extractionArm, fallThrough);
-        for (const [path, cells] of resolved) {
-            cellsCache.set(path, cells);
-            const identity = identityByPath.get(path);
-            if (cells.kind === "rows" && identity !== undefined) {
-                shareRows(readCache, identity, cells.rows);
+                cellsCache.set(target.path, fallThroughCells(target.path, read.detail));
             }
         }
     }

package/dist/report-render/chart-export.d.ts

@@ -46,6 +46,15 @@ export declare function rendererApi(api: Echarts.CustomSeriesRenderItemAPI): Ren
  * behind.
  */
 export declare function renderChartSvg(echarts: ChartRuntime, option: EchartOption, size: ChartExportSize): Result<string, string>;
+/**
+ * The count of coordinates that one option draws, summed over its series.
+ *
+ * The count bounds the export. A cloud of many thousands of points gives an SVG of many megabytes, two times,
+ * thus the page builds the SVG of such a chart on a click, with the points as one raster layer. An empty slot draws nothing, thus it counts nothing. A radar
+ * polygon draws one coordinate for each indicator, and a violin outline draws two vertices for each grid
+ * point, thus each counts every coordinate that it draws.
+ */
+export declare function plottedPoints(option: EchartOption): number;
 /**
  * The two SVG files of one chart, or `undefined` for a chart past the export bound.
  *

package/dist/report-render/chart-export.js

@@ -138,7 +138,7 @@ function finishedSvg(svg, size) {
  * polygon draws one coordinate for each indicator, and a violin outline draws two vertices for each grid
  * point, thus each counts every coordinate that it draws.
  */
-function plottedPoints(option) {
+export function plottedPoints(option) {
     const series = option.series;
     if (!Array.isArray(series))
         return 0;

package/dist/report-render/views/chart-view.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The chart card markup.
  *

package/dist/report-render/views/chart-view.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/** @jsxImportSource hono/jsx */
 /**
  * The chart card markup.
  *

package/dist/report-render/views/lineage.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The lineage keys of a grounded block, and the control that opens the chain of one key.
  *

package/dist/report-render/views/page-view.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The page assembly: the hero, the bands, the appendix band, and the footer.
  *

package/dist/report-render/views/page-view.js

@@ -1,4 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/** @jsxImportSource hono/jsx */
 /**
  * The page assembly: the hero, the bands, the appendix band, and the footer.
  *

package/dist/report-render/views/prose.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The prose markup: the text block, the claim block, the section wrapper, and the page navigation.
  *

package/dist/report-render/views/prose.js

@@ -1,4 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/** @jsxImportSource hono/jsx */
 /**
  * The prose markup: the text block, the claim block, the section wrapper, and the page navigation.
  *

package/dist/report-render/views/references-view.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The reference markup: the one evidence marker, and the one appendix list under it.
  *

package/dist/report-render/views/values.d.ts

@@ -1,3 +1,4 @@
+/** @jsxImportSource hono/jsx */
 /**
  * The value markup: the metric card, the data table, the figure, and the citation card.
  *

package/dist/report-render/views/values.js

@@ -1,4 +1,5 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "hono/jsx/jsx-runtime";
+/** @jsxImportSource hono/jsx */
 /**
  * The value markup: the metric card, the data table, the figure, and the citation card.
  *

package/dist/runtime/assemble.d.ts

@@ -19,6 +19,7 @@ import { type ConversationAgentDeps } from "../agents/conversation-agent.js";
 import { type ApprovePlanInput, type ApprovePlanRefusal, type PlanApproval } from "../app/approve-plan.js";
 import { type ChatTurns } from "../app/chat-turn-workflow.js";
 import { type WorkSurface } from "../app/work.js";
+import { type RunCanceler } from "../execution/run-canceler.js";
 import { type ReportSessionRuntime } from "../app/report-session-runtime.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { ResourcePolicy } from "../config/resource-limits.js";
@@ -27,6 +28,7 @@ import { type ChromeConfig } from "../lib/chrome.js";
 import { type AcquireEyes } from "../lib/eyes.js";
 import type { ThreadType } from "../memory/thread-store.js";
 import { type ExecuteAnalysisDeps, type ExecuteAnalysisInput, type ExecuteAnalysisResult } from "../workflows/execute-analysis.js";
+import type { SandboxClient } from "../sandbox/client.js";
 import { type SandboxStepDeps, type SandboxStepInput, type SandboxStepResult } from "../workflows/sandbox-step.js";
 import { type DataProfileDeps, type DataProfileWorkflowInput } from "../tasks/data-profile.js";
 import { type CitationResolverConfig } from "../citations/resolve.js";
@@ -34,6 +36,7 @@ import type { CitationResolver } from "../citations/types.js";
 import type { AuthContext, Identity } from "../auth/types.js";
 import type { ReferenceResolver } from "../report-model/reference-resolver.js";
 import type { ProvenanceSeam } from "../provenance/seam.js";
+import type { SyncSessionFile } from "../workspace/session-files.js";
 import { type AskGateway } from "../tools/approval/gateway.js";
 import type { MakeSessionPagePublisher, ResolvePageAsset, ResolvePageUrl } from "../tools/report-session/index.js";
 import type { BioToolKeys } from "../tools/bio/keys.js";
@@ -56,12 +59,19 @@ export type SandboxStepCallable = (input: SandboxStepInput) => Promise<SandboxSt
  * the same memory that the conversation agent writes.
  */
 export type CoreWorkflowDeps = {
-    readonly sandboxStep: Omit<SandboxStepDeps, "usageRecorder" | "citationResolver" | "toolOutputStore" | "runAuthorizer">;
-    readonly buildExecuteAnalysis: (sandboxStep: SandboxStepCallable) => Omit<ExecuteAnalysisDeps, "usageRecorder" | "literatureReviewer" | "toolOutputStore" | "workingMemory"> & {
-        /** API keys for the bio/chem tools of the literature reviewer of the synthesis. */
+    readonly sandboxStep: Omit<SandboxStepDeps, "usageRecorder" | "citationResolver" | "toolOutputStore" | "runAuthorizer" | "leases">;
+    readonly buildExecuteAnalysis: (sandboxStep: SandboxStepCallable) => Omit<ExecuteAnalysisDeps, "usageRecorder" | "synthesisLookups" | "toolOutputStore" | "workingMemory" | "workspaceFs"> & {
+        /** API keys for the bio/chem tools of the lookups of the synthesis. */
         readonly bioKeys: BioToolKeys;
     };
-    readonly dataProfile: Omit<DataProfileDeps, "usageRecorder" | "toolOutputStore">;
+    readonly dataProfile: Omit<DataProfileDeps, "usageRecorder" | "toolOutputStore" | "leases">;
+};
+/** The sandboxes of the runtime. The assembly builds the one sandbox module over the client. */
+export type CoreSandboxDeps = {
+    /** The backend client that the embedder made. Only the sandbox module calls it. */
+    readonly client: SandboxClient;
+    /** How long a lease can go unused before it loses its machine. Absent: 15 minutes. */
+    readonly idlePeriodMs?: number;
 };
 /** The registered, callable workflow handles. */
 export type RegisteredWorkflows = {
@@ -71,9 +81,9 @@ export type RegisteredWorkflows = {
 };
 /**
  * Conversation-agent deps minus the workflow callable, the resource policy, the
- * usage recorder, the report-session anchor, the eyes, and the tool output store.
- * `assembleCoreRuntime` supplies each of those itself. Thus a caller cannot wire
- * one of these six values:
+ * usage recorder, the report-session anchor, the eyes, the tool output store, and the
+ * file sync. `assembleCoreRuntime` supplies each of those itself. Thus a caller cannot wire
+ * one of these values:
  *
  * - a stale callable
  * - a policy that diverges from the one the workflows see
@@ -81,12 +91,13 @@ export type RegisteredWorkflows = {
  * - an anchor over a different session runtime
  * - a seam that only half the agent tree looks through
  * - a store that only half the agent tree keeps its texts in
+ * - a file sync that only half the agent tree writes through
  *
  * The assembly resolves the eyes one time, from `CoreRuntimeDeps.eyes` and the
  * chrome config. A caller that bound the eyes here would give the conversation
  * agent a seam that the report agent never sees.
  */
-export type ConversationAssemblyDeps = Omit<ConversationAgentDeps, "executeAnalysisWorkflow" | "resourcePolicy" | "usageRecorder" | "citationResolver" | "anchorReportSession" | "eyes" | "toolOutputStore" | "registerSubAgent">;
+export type ConversationAssemblyDeps = Omit<ConversationAgentDeps, "executeAnalysisWorkflow" | "usageRecorder" | "citationResolver" | "anchorReportSession" | "eyes" | "toolOutputStore" | "registerSubAgent" | "syncSessionFile">;
 /**
  * What binds one reference resolver: the analysis whose pinned artifacts it reads, and the identity and the
  * auth of the tool call that reads them. A resolver serves one analysis, thus the report tools build one for
@@ -105,9 +116,9 @@ export type MakeReportReferenceResolver = (scope: ReportResolverScope) => Promis
 export type CoreRuntimeDeps = {
     readonly conversation: ConversationAssemblyDeps;
     readonly workflows: CoreWorkflowDeps;
+    readonly sandbox: CoreSandboxDeps;
     /**
-     * Host resource policy — per-step ceilings and machine budget. One supply
-     * point for planner/routing guidance and workflow-input budget snapshots.
+     * Host resource policy — the per-step ceilings and the budget of the sandbox lease grant.
      */
     readonly resourcePolicy?: ResourcePolicy;
     /**
@@ -121,7 +132,7 @@ export type CoreRuntimeDeps = {
     readonly citationResolverConfig?: CitationResolverConfig;
     /**
      * The byte cap on the in-process host read of a report reference. A file over the
-     * cap falls through to the extraction arm. Absent, the resolver uses its 16 MiB
+     * cap falls through, and its reference fails as `extraction-unavailable`. Absent, the resolver uses its 16 MiB
      * default. The embedder tunes it here, thus a host changes it with no harness change.
      */
     readonly reportHostReadCapBytes?: number;
@@ -129,7 +140,7 @@ export type CoreRuntimeDeps = {
      * The report reference resolver of an embedder. A managed host reads its pinned
      * artifacts from its own store, thus it binds a realization of the seam here and the
      * report tools resolve through it. Absent, the harness wires the production resolver
-     * over the workspace tree and the extraction arm, which is the whole OSS path. A bound
+     * over the workspace tree, which is the whole OSS path. A bound
      * factory replaces that wiring, thus `reportHostReadCapBytes` then governs nothing.
      */
     readonly makeReportReferenceResolver?: MakeReportReferenceResolver;
@@ -188,6 +199,13 @@ export type CoreRuntimeDeps = {
      * which an embedder calls on its own. Thus that composition binds the seam there as well.
      */
     readonly provenance?: ProvenanceSeam;
+    /**
+     * The host copy of each file that a chat thread or a report session writes outside a run. A host that keeps the
+     * files of an analysis in its own store binds it, and each write reaches it with its bytes and its owner: the
+     * thread for the scratch files of a session, and the analysis for a `write_file` or `edit_file` write. Absent,
+     * the files stay in the workspace tree alone, which is the whole local path.
+     */
+    readonly syncSessionFile?: SyncSessionFile;
     /**
      * The credential of a chat turn that this process did not open, for example a turn that a recovery runs after a
      * restart. The workflow input of a turn holds no credential. Absent, or `undefined` for a turn: the turn pauses
@@ -263,6 +281,8 @@ export type CoreRuntime = {
      * ends one work in each state, and `resume` and `hold` reach the waits of one work. Only a client resumes paused work.
      */
     readonly work: WorkSurface;
+    /** The run canceler of `work`. It also ends the sandbox leases of the canceled workflows at once. */
+    readonly runCanceler: RunCanceler;
     /**
      * Approve a stored plan by its id and start its run with no model call. It runs over the deps that
      * reach the `execute_analysis` tool of the conversation agent, thus the approval and the tool launch