@inflexa-ai/harness 0.40.0 → 0.41.1

package/dist/app/chat-turn.d.ts

@@ -1,14 +1,15 @@
 /**
- * The chat turn of a host: a turn is `runChatTurn`, and `prepareChatTurn` is its first step. The
- * host gives only its transport values, and the harness stores the opening, each round, and the outcome.
+ * The chat turn of a host: a turn is `runChatTurn`, which is `openChatTurn` and then the `run` of the
+ * open turn. `prepareChatTurn` is the first step of the open. The host gives only its transport
+ * values, and the harness stores the opening, each round, and the outcome.
  */
 import type { Pool } from "pg";
-import type { AgentSession } from "../auth/types.js";
+import type { RequestSession } from "../auth/types.js";
 import type { UsageRecorder } from "../billing/usage-recorder.js";
 import type { TokenUsageRollup } from "../contracts/usage.js";
 import type { DbError } from "../lib/db-result.js";
 import { type AgentFinish } from "../loop/run-agent.js";
-import type { EmitFn } from "../loop/types.js";
+import type { AgentDefinition, EmitFn } from "../loop/types.js";
 import { type ThreadType } from "../memory/thread-store.js";
 import type { AgentChat, PromptCachePolicy } from "../providers/types.js";
 import type { ThreadAgentResolver } from "../runtime/assemble.js";
@@ -54,12 +55,20 @@ export interface RunChatTurnDeps extends PrepareChatTurnDeps {
     /** The agent of a turn comes from the thread type, which only the preparation knows. */
     readonly agents: ThreadAgentResolver;
 }
-/** The transport values of one turn. */
-export interface RunChatTurnParams {
+/**
+ * The session of a turn without its provenance. The harness sets the provenance from the agent that
+ * it resolves, because only the preparation knows the thread type.
+ */
+export type ChatTurnSession = Omit<RequestSession, "provenance">;
+/** What opens a turn: the thread and the user input. */
+export interface OpenChatTurnParams {
     readonly analysisId: string;
     readonly threadId: string;
     readonly userInput: string;
-    readonly session: AgentSession;
+}
+/** The transport values of a turn that is open. */
+export interface RunOpenChatTurnParams {
+    readonly session: ChatTurnSession;
     /** Makes the provider of the turn over the emit sink of the display recorder. */
     readonly chat: (emit: EmitFn) => AgentChat;
     readonly emit: EmitFn;
@@ -69,13 +78,15 @@ export interface RunChatTurnParams {
     readonly ask?: (request: AskRequest, emit: EmitFn) => Promise<AskApproval>;
     /** Who sent the user message. */
     readonly author?: string;
-    /** When the host opened the turn. Absent counts from the call. */
+    /** When the host opened the turn. Absent counts from the call to {@link openChatTurn}. */
     readonly startedAtMs?: number;
     /** The cache policy of the root loop. Absent gives {@link CONVERSATION_PROMPT_CACHE}. */
     readonly promptCache?: PromptCachePolicy;
     /** The budget of the view of the root loop. Absent gives {@link DEFAULT_CONVERSATION_BUDGET}. */
     readonly conversationBudget?: number;
 }
+/** The values of one whole turn. */
+export type RunChatTurnParams = OpenChatTurnParams & RunOpenChatTurnParams;
 export type ChatTurnOutcome = {
     readonly status: "done";
     readonly finish: AgentFinish;
@@ -87,7 +98,8 @@ export type ChatTurnOutcome = {
     readonly reason: string;
     readonly cause: unknown;
 };
-export type ChatTurnResult = {
+/** A turn that ended before its run. It wrote no row and no turn record. */
+export type ChatTurnRefusal = {
     readonly kind: "prepare_failed";
     readonly cause: unknown;
 } | {
@@ -95,7 +107,8 @@ export type ChatTurnResult = {
 } | {
     readonly kind: "agent_unresolved";
     readonly threadType: ThreadType;
-} | {
+};
+export interface ChatTurnRan {
     readonly kind: "ran";
     readonly outcome: ChatTurnOutcome;
     /** True when the opening of the turn landed. */
@@ -106,9 +119,25 @@ export type ChatTurnResult = {
     readonly turnUsage?: TokenUsageRollup;
     /** The final text of a run that returned. */
     readonly fallbackText?: string;
-};
+}
+export type ChatTurnResult = ChatTurnRefusal | ChatTurnRan;
+/**
+ * A turn that is prepared, with its agent resolved. Call `run` one time: each call stores a new
+ * opening of the same user message.
+ */
+export interface OpenChatTurn {
+    readonly kind: "ready";
+    /** The agent that runs the turn. The harness stamps its provenance on the session of the run. */
+    readonly agent: AgentDefinition;
+    readonly run: (params: RunOpenChatTurnParams) => Promise<ChatTurnRan>;
+}
+/**
+ * Open one chat turn: prepare it and resolve its agent. A refusal comes back before any row of the
+ * turn exists, thus a host can answer it before it starts a stream.
+ */
+export declare function openChatTurn(deps: RunChatTurnDeps, params: OpenChatTurnParams): Promise<OpenChatTurn | ChatTurnRefusal>;
 /**
- * Run one chat turn: prepare it, resolve its agent, store its opening, run the root loop with a
- * round sink that stores each round, and close the turn with its outcome.
+ * Run one chat turn: open it, store its opening, run the root loop with a round sink that stores
+ * each round, and close the turn with its outcome.
  */
 export declare function runChatTurn(deps: RunChatTurnDeps, params: RunChatTurnParams): Promise<ChatTurnResult>;

package/dist/app/chat-turn.js

@@ -1,6 +1,7 @@
 /**
- * The chat turn of a host: a turn is `runChatTurn`, and `prepareChatTurn` is its first step. The
- * host gives only its transport values, and the harness stores the opening, each round, and the outcome.
+ * The chat turn of a host: a turn is `runChatTurn`, which is `openChatTurn` and then the `run` of the
+ * open turn. `prepareChatTurn` is the first step of the open. The host gives only its transport
+ * values, and the harness stores the opening, each round, and the outcome.
  */
 import { unwrapOrThrow } from "../lib/result.js";
 import { finalText, runAgent } from "../loop/run-agent.js";
@@ -100,15 +101,14 @@ async function readTurnContext(pool, analysisId) {
 /** The root loop of a chat turn compacts its view past this estimate, in tokens. */
 export const DEFAULT_CONVERSATION_BUDGET = 150_000;
 /**
- * Run one chat turn: prepare it, resolve its agent, store its opening, run the root loop with a
- * round sink that stores each round, and close the turn with its outcome.
+ * Open one chat turn: prepare it and resolve its agent. A refusal comes back before any row of the
+ * turn exists, thus a host can answer it before it starts a stream.
  */
-export async function runChatTurn(deps, params) {
-    const logger = (deps.logger ?? createNoopLogger()).named("harness.chat");
-    const startedAtMs = params.startedAtMs ?? Date.now();
+export async function openChatTurn(deps, params) {
+    const openedAtMs = Date.now();
     let prepared;
     try {
-        prepared = await prepareChatTurn(deps, { analysisId: params.analysisId, threadId: params.threadId, userInput: params.userInput });
+        prepared = await prepareChatTurn(deps, params);
     }
     catch (cause) {
         return { kind: "prepare_failed", cause };
@@ -118,8 +118,33 @@ export async function runChatTurn(deps, params) {
     const agent = deps.agents.forThread(prepared.threadType);
     if (agent.isErr())
         return { kind: "agent_unresolved", threadType: prepared.threadType };
+    const ready = prepared;
+    return {
+        kind: "ready",
+        agent: agent.value,
+        run: (run) => runOpenTurn(deps, params, ready, agent.value, { ...run, startedAtMs: run.startedAtMs ?? openedAtMs }),
+    };
+}
+/**
+ * Run one chat turn: open it, store its opening, run the root loop with a round sink that stores
+ * each round, and close the turn with its outcome.
+ */
+export async function runChatTurn(deps, params) {
+    const { analysisId, threadId, userInput, ...run } = params;
+    const opened = await openChatTurn(deps, { analysisId, threadId, userInput });
+    if (opened.kind !== "ready")
+        return opened;
+    return opened.run(run);
+}
+async function runOpenTurn(deps, turn, prepared, agent, params) {
+    const logger = (deps.logger ?? createNoopLogger()).named("harness.chat");
+    const session = { ...params.session, provenance: { agentId: agent.id, callPath: [agent.id] } };
     const history = createThreadHistory(deps.pool, deps.logger);
-    const recorder = createConversationDisplayRecorder({ userText: params.userInput, topLevelCallPath: params.session.provenance.callPath, sink: params.emit });
+    const recorder = createConversationDisplayRecorder({
+        userText: userTextOf(prepared.userMessage),
+        topLevelCallPath: session.provenance.callPath,
+        sink: params.emit,
+    });
     // The groups that did not land yet, in the order of the turn. A failed write keeps them for the next write.
     let pending = [
         {
@@ -136,13 +161,13 @@ export async function runChatTurn(deps, params) {
             return;
         const closing = close === undefined ? {} : { close };
         const write = startSeq === undefined ? { opening: pending[0], rounds: pending.slice(1), ...closing } : { startSeq, rounds: pending, ...closing };
-        (await history.writeTurn(params.threadId, write)).match((written) => {
+        (await history.writeTurn(turn.threadId, write)).match((written) => {
             pending = [];
             startSeq = written.startSeq;
             storeError = undefined;
         }, (error) => {
             storeError = error;
-            logger.warn("chat turn write failed", { threadId: params.threadId, op: error.op, ...logger.errorFields(error.cause) });
+            logger.warn("chat turn write failed", { threadId: turn.threadId, op: error.op, ...logger.errorFields(error.cause) });
         });
     };
     await flush();
@@ -150,7 +175,7 @@ export async function runChatTurn(deps, params) {
     let outcome;
     let fallbackText;
     try {
-        const run = await runAgent(agent.value, prepared.messages, params.session, {
+        const run = await runAgent(agent, prepared.messages, session, {
             provider: params.chat(recorder.emit),
             signal: params.signal,
             emit: recorder.emit,
@@ -158,7 +183,7 @@ export async function runChatTurn(deps, params) {
             usageRecorder: params.usageRecorder,
             toolOutputStore: createToolOutputStore(deps.pool),
             promptCache: params.promptCache ?? CONVERSATION_PROMPT_CACHE,
-            compaction: compactionPolicy(deps, params, prepared.threadType, agent.value, recorder.emit),
+            compaction: compactionPolicy(deps, turn.analysisId, params, prepared.threadType, agent, recorder.emit),
             ...(deps.logger === undefined ? {} : { logger: deps.logger }),
             ...(ask === undefined ? {} : { ask: (request) => ask(request, recorder.emit) }),
             onRound: async (round) => {
@@ -175,7 +200,7 @@ export async function runChatTurn(deps, params) {
         const aborted = params.signal.aborted && cause instanceof Error && cause.name === "AbortError";
         outcome = aborted ? { status: "aborted" } : { status: "failed", reason: failureReasonOf(cause), cause };
     }
-    const durationMs = Date.now() - startedAtMs;
+    const durationMs = Date.now() - params.startedAtMs;
     const turnUsage = outcome.status === "failed" ? undefined : outcome.finish?.turnUsage;
     await flush({
         status: outcome.status,
@@ -193,8 +218,14 @@ export async function runChatTurn(deps, params) {
         ...(fallbackText === undefined ? {} : { fallbackText }),
     };
 }
+/** The sanitized text of the user message, thus the display never holds a secret that the model does not see. */
+function userTextOf(message) {
+    if (typeof message.content === "string")
+        return message.content;
+    return message.content.map((part) => (part.type === "text" ? part.text : "")).join("");
+}
 const WORKING_MEMORY_TOOL_ID = "update_working_memory";
-function compactionPolicy(deps, params, threadType, agent, emit) {
+function compactionPolicy(deps, analysisId, params, threadType, agent, emit) {
     // A report thread reads a frozen copy of the working memory, thus its agent declares no memory tool.
     const remembers = agent.tools.some((tool) => tool.id === WORKING_MEMORY_TOOL_ID);
     const workingMemory = createWorkingMemory(deps.pool);
@@ -205,7 +236,7 @@ function compactionPolicy(deps, params, threadType, agent, emit) {
         request: remembers ? MEMORY_COMPACTION_REQUEST : SUMMARY_COMPACTION_REQUEST,
         mask: remembers ? { allow: [WORKING_MEMORY_TOOL_ID] } : "none",
         keepFirstTurn: threadType === "report",
-        recordsAfter: async (view) => contextRecordsFor({ threadType, analysisId: params.analysisId, workingMemory, ...(await readTurnContext(deps.pool, params.analysisId)) }, view),
+        recordsAfter: async (view) => contextRecordsFor({ threadType, analysisId, workingMemory, ...(await readTurnContext(deps.pool, analysisId)) }, view),
     };
 }
 /** The reason of a failed turn. It never holds the error message, because each later turn sends the note to the vendor. */

package/dist/index.d.ts

@@ -82,8 +82,8 @@ export type { SuspendOn } from "./providers/errors.js";
 export { suspensionOfFailure } from "./workflows/suspension.js";
 export type { Suspension } from "./workflows/suspension.js";
 export { createStreamingChat } from "./providers/streaming-chat.js";
-export { DEFAULT_CONVERSATION_BUDGET, prepareChatTurn, runChatTurn } from "./app/chat-turn.js";
-export type { ChatTurnOutcome, ChatTurnResult, PrepareChatTurnDeps, PrepareChatTurnParams, PrepareChatTurnResult, RunChatTurnDeps, RunChatTurnParams, } from "./app/chat-turn.js";
+export { DEFAULT_CONVERSATION_BUDGET, openChatTurn, prepareChatTurn, runChatTurn } from "./app/chat-turn.js";
+export type { ChatTurnOutcome, ChatTurnRan, ChatTurnRefusal, ChatTurnResult, ChatTurnSession, OpenChatTurn, OpenChatTurnParams, PrepareChatTurnDeps, PrepareChatTurnParams, PrepareChatTurnResult, RunChatTurnDeps, RunChatTurnParams, RunOpenChatTurnParams, } from "./app/chat-turn.js";
 export { createThreadStore } from "./memory/thread-store.js";
 export type { ThreadStore, Thread, ThreadType, ThreadInputError, CreateThreadInput, ListThreadsInput, ThreadPage } from "./memory/thread-store.js";
 export { createThreadHistory, conversationRecordTurn } from "./memory/thread-history.js";

package/dist/index.js

@@ -130,7 +130,7 @@ export { createStreamingChat } from "./providers/streaming-chat.js";
 // and gives only its transport values: the harness stores the opening, each round,
 // and the outcome. `appendTurn` stays for a record of a host. `createThreadStore`
 // owns thread metadata (create/list/title).
-export { DEFAULT_CONVERSATION_BUDGET, prepareChatTurn, runChatTurn } from "./app/chat-turn.js";
+export { DEFAULT_CONVERSATION_BUDGET, openChatTurn, prepareChatTurn, runChatTurn } from "./app/chat-turn.js";
 export { createThreadStore } from "./memory/thread-store.js";
 export { createThreadHistory, conversationRecordTurn } from "./memory/thread-history.js";
 // The synthetic-message primitives. A host appends a record of out-of-band work (an analysis run's

package/dist/prompts/briefing.d.ts

@@ -21,6 +21,7 @@
  * field so the field-coverage guard test fails when a new field is added to the
  * schema without a deliberate decision about whether the agent needs to see it.
  */
+import { type WorkingMemory } from "../memory/working-memory.js";
 import type { DataProfileResult } from "../state/data-profile.js";
 import type { AnalysisStep } from "../schemas/workflow-state.js";
 /** Completed dependencies rendered as upstream blocks; the tail is counted, not rendered. */
@@ -50,6 +51,30 @@ export declare const STEP_NON_TASK_FIELDS: readonly ["id", "track", "step_type",
  * improvises the rest.
  */
 export declare function renderTask(step: AnalysisStep): string;
+/**
+ * The heading of the analysis-memory section. The orient core of the sandbox
+ * prompt names this same text, thus a test pins the two together.
+ */
+export declare const ANALYSIS_MEMORY_HEADING = "Analysis memory (read only)";
+/**
+ * The part of the working memory a step agent sees: the goal and the
+ * constraints. Hypotheses and findings stay out — they are the interpretive
+ * state of the conversation, not a rule for a step.
+ */
+export type StepMemory = Pick<WorkingMemory, "goal" | "constraints">;
+/** A memory with no goal and no constraints — the section renders nothing. */
+export declare function emptyStepMemory(): StepMemory;
+/**
+ * The goal and the constraints of the analysis, frozen at dispatch. The heading
+ * differs from the "Constraints" section of {@link renderTask}: those are the
+ * requirements of this plan step, these are the rules of the whole analysis.
+ *
+ * Bounded to `WORKING_MEMORY_LIMITS` the same way the chat render is: a row
+ * written before the caps existed degrades to its newest constraints, and each
+ * text is clamped. No id is rendered, because the step agent cannot address an
+ * entry — it has no memory tool.
+ */
+export declare function renderMemory(memory: StepMemory): string;
 /**
  * What anchors every path the agent writes or reads: the id the tree is mounted
  * at, and the step's writable directory.
@@ -109,10 +134,12 @@ export interface StepBriefing {
     readonly profile: DataProfileResult | null;
     /** The step's completed dependencies, in the plan's declared `depends_on` order. */
     readonly upstream: readonly UpstreamHandoff[];
+    /** The goal and the constraints of the analysis, read from the working memory at dispatch. */
+    readonly memory: StepMemory;
 }
 /**
  * Compose the seed. Absent sections collapse out entirely — an independent step
- * with no profile yields exactly the task and workspace sections, byte-identical
+ * with no profile and an empty memory yields exactly the task and workspace sections, byte-identical
  * to what a step got before any of this existed plus its paths.
  *
  * Pure: the same briefing composes to the same string, which is what makes the

package/dist/prompts/briefing.js

@@ -22,6 +22,7 @@
  * schema without a deliberate decision about whether the agent needs to see it.
  */
 import { DATA_PROFILE_ORIENTATION_MAX_CHARS, buildDataProfileOrientation } from "../app/data-profile-orientation.js";
+import { WORKING_MEMORY_LIMITS } from "../memory/working-memory.js";
 // ── Bounds ────────────────────────────────────────────────────────────
 /** Completed dependencies rendered as upstream blocks; the tail is counted, not rendered. */
 export const MAX_UPSTREAM_DEPS = 5;
@@ -113,6 +114,47 @@ export function renderTask(step) {
     }
     return parts.join("\n\n");
 }
+// ── (1b) Analysis memory ──────────────────────────────────────────────
+/**
+ * The heading of the analysis-memory section. The orient core of the sandbox
+ * prompt names this same text, thus a test pins the two together.
+ */
+export const ANALYSIS_MEMORY_HEADING = "Analysis memory (read only)";
+/** A memory with no goal and no constraints — the section renders nothing. */
+export function emptyStepMemory() {
+    return { goal: "", constraints: [] };
+}
+/**
+ * The goal and the constraints of the analysis, frozen at dispatch. The heading
+ * differs from the "Constraints" section of {@link renderTask}: those are the
+ * requirements of this plan step, these are the rules of the whole analysis.
+ *
+ * Bounded to `WORKING_MEMORY_LIMITS` the same way the chat render is: a row
+ * written before the caps existed degrades to its newest constraints, and each
+ * text is clamped. No id is rendered, because the step agent cannot address an
+ * entry — it has no memory tool.
+ */
+export function renderMemory(memory) {
+    const goal = clamp(memory.goal.trim(), WORKING_MEMORY_LIMITS.goalChars);
+    const all = memory.constraints.filter((c) => c.text.trim().length > 0);
+    const shown = all.slice(Math.max(0, all.length - WORKING_MEMORY_LIMITS.constraints));
+    if (goal.length === 0 && shown.length === 0)
+        return "";
+    const parts = [
+        "These entries come from the working memory of the analysis, read when this step was dispatched. " +
+            "A constraint from the user is binding. A constraint from the agent is context.",
+    ];
+    if (goal.length > 0)
+        parts.push(`Goal: ${goal}`);
+    if (shown.length > 0) {
+        const lines = shown.map((c) => `(${c.origin}) ${clamp(c.text.trim(), WORKING_MEMORY_LIMITS.entryChars)}`);
+        const omitted = all.length - shown.length;
+        if (omitted > 0)
+            lines.push(`(+${omitted} older ${omitted === 1 ? "constraint" : "constraints"} not shown)`);
+        parts.push(`Constraints:\n${bullets(lines)}`);
+    }
+    return section(ANALYSIS_MEMORY_HEADING, parts.join("\n\n"));
+}
 /** The in-sandbox analysis root of a frame — the read-only mount of the whole tree. */
 export function analysisRootOf(frame) {
     return `/${frame.analysisId}`;
@@ -190,7 +232,7 @@ function renderHandoff(handoff) {
 }
 /**
  * Compose the seed. Absent sections collapse out entirely — an independent step
- * with no profile yields exactly the task and workspace sections, byte-identical
+ * with no profile and an empty memory yields exactly the task and workspace sections, byte-identical
  * to what a step got before any of this existed plus its paths.
  *
  * Pure: the same briefing composes to the same string, which is what makes the
@@ -199,6 +241,7 @@ function renderHandoff(handoff) {
 export function composeStepBriefing(briefing) {
     return [
         renderTask(briefing.step),
+        renderMemory(briefing.memory),
         renderWorkspace(briefing.workspace),
         renderResources(briefing.step.resources),
         renderOrientation(briefing.profile, briefing.workspace.analysisId),

package/dist/prompts/compaction.d.ts

@@ -1,4 +1,4 @@
 /** The compaction request of a thread whose agent maintains the working memory. */
-export declare const MEMORY_COMPACTION_REQUEST = "The conversation is too long for the context window. The harness replaces the conversation above with your summary.\n\nFirst, move each lasting fact into the working memory with update_working_memory: the goal, each constraint, each hypothesis, and each finding with its run id. No other tool can run now.\n\nThen reply in plain text with the summary. Leave out what the working memory holds. Give:\n- the goals, and the current request of the user in its exact words\n- the decisions, with their reasons\n- the open questions\n- the file paths and the run ids that the work uses\n- the state of the work in progress\n\nThe conversation continues from your summary, the working memory, and the messages after them.";
+export declare const MEMORY_COMPACTION_REQUEST = "The conversation is too long for the context window. The harness replaces the conversation above with your summary.\n\nFirst, move each lasting fact into the working memory with update_working_memory: the goal, each constraint, each hypothesis, and each finding with its run id. Keep each constraint that the user gave as it is, because the user set it. No other tool can run now. Send all the memory edits in at most 3 replies, and put many calls in one reply. The reply after the edits must be the summary: if it calls a tool, the harness gets no summary.\n\nThen reply in plain text with the summary. Leave out each fact that a memory edit accepted. If the memory refused an edit, put that fact in the summary. Give:\n- the current request of the user in its exact words\n- the decisions, with their reasons\n- the approaches that failed or that the user ruled out, with the reasons\n- the open questions\n- the file paths, the run ids, and the other exact values that the work uses\n- the state of the work in progress\n\nThe conversation continues from your summary, the working memory, and the messages after them.";
 /** The compaction request of a thread that reads a frozen copy of the working memory, for example a report thread. */
-export declare const SUMMARY_COMPACTION_REQUEST = "The conversation is too long for the context window. The harness replaces the conversation above with your summary. No tool can run now.\n\nReply in plain text with the summary. Leave out what the working memory holds. Give:\n- the goals, and the current request of the user in its exact words\n- the decisions, with their reasons\n- the open questions\n- the file paths and the run ids that the work uses\n- the state of the work in progress\n\nThe conversation continues from your summary, the working memory, and the messages after them.";
+export declare const SUMMARY_COMPACTION_REQUEST = "The conversation is too long for the context window. The harness replaces the conversation above with your summary. No tool can run now.\n\nReply in plain text with the summary. Leave out what the working memory holds. Give:\n- the goals, and the current request of the user in its exact words\n- each change that the user made to the brief\n- the decisions, with their reasons\n- the approaches that failed or that the user ruled out, with the reasons\n- the open questions\n- the file paths, the run ids, and the other exact values that the work uses\n- the state of the work in progress\n\nThe conversation continues from your summary, the working memory, and the messages after them.";

package/dist/prompts/compaction.js

@@ -1,13 +1,15 @@
+import { COMPACTION_MAX_REQUESTS } from "../loop/compaction.js";
 /** The compaction request of a thread whose agent maintains the working memory. */
 export const MEMORY_COMPACTION_REQUEST = `The conversation is too long for the context window. The harness replaces the conversation above with your summary.
 
-First, move each lasting fact into the working memory with update_working_memory: the goal, each constraint, each hypothesis, and each finding with its run id. No other tool can run now.
+First, move each lasting fact into the working memory with update_working_memory: the goal, each constraint, each hypothesis, and each finding with its run id. Keep each constraint that the user gave as it is, because the user set it. No other tool can run now. Send all the memory edits in at most ${COMPACTION_MAX_REQUESTS - 1} replies, and put many calls in one reply. The reply after the edits must be the summary: if it calls a tool, the harness gets no summary.
 
-Then reply in plain text with the summary. Leave out what the working memory holds. Give:
-- the goals, and the current request of the user in its exact words
+Then reply in plain text with the summary. Leave out each fact that a memory edit accepted. If the memory refused an edit, put that fact in the summary. Give:
+- the current request of the user in its exact words
 - the decisions, with their reasons
+- the approaches that failed or that the user ruled out, with the reasons
 - the open questions
-- the file paths and the run ids that the work uses
+- the file paths, the run ids, and the other exact values that the work uses
 - the state of the work in progress
 
 The conversation continues from your summary, the working memory, and the messages after them.`;
@@ -16,9 +18,11 @@ export const SUMMARY_COMPACTION_REQUEST = `The conversation is too long for the
 
 Reply in plain text with the summary. Leave out what the working memory holds. Give:
 - the goals, and the current request of the user in its exact words
+- each change that the user made to the brief
 - the decisions, with their reasons
+- the approaches that failed or that the user ruled out, with the reasons
 - the open questions
-- the file paths and the run ids that the work uses
+- the file paths, the run ids, and the other exact values that the work uses
 - the state of the work in progress
 
 The conversation continues from your summary, the working memory, and the messages after them.`;

package/dist/prompts/sandbox-standards.d.ts

@@ -29,7 +29,7 @@
  * each composition stays byte-stable across its own steps.
  */
 import type { ToolchainSource } from "../sandbox/types.js";
-export declare const sandboxOrientCorePrompt = "# Sandbox Orient-Core\n\nThese apply to every agent that talks to a sandbox.\n\n## Your Briefing Is Authoritative\n\nYour first message is your briefing, composed for this step at the instant it was\ndispatched \u2014 after every step it depends on had finished. It names your task, your\nworking directory and the read-only analysis root, what the input dataset is\n(domain, organism, design, quality concerns, files), and what each upstream step\nproduced and where it put it. Work from it.\n\nDo NOT re-derive what it already gives you: no filesystem hunt for your inputs, no\nre-reading an upstream step whose summary you were handed, no re-deriving the\norganism or the dimensions from raw bytes. Reach further only where the briefing is\ngenuinely thin for what you must do:\n\n- `inspect_data_profile` \u2014 the full dataset profile: `scope:'overview'` for the\n  identity and the file census, `scope:'groups'` for the groups and the dimensions\n  that vary across them, `scope:'files'` for the members the profiler annotated\n  individually. It is the ONLY record of what the input data IS; no file on disk\n  carries it. Use it when the briefing's orientation is not enough, or when it\n  carried none.\n- `read_file` on an upstream step's summary \u2014 its path is in your briefing \u2014 when\n  the excerpt you were handed is not enough to build on.\n- `workspace_search({ query })` \u2014 natural-language search for a file the briefing\n  does not name. Optional `type` filter (`input-group` | `input-dimension` |\n  `input` | `output` | `summary` | `synthesis`) and `limit` (1-50, default 8).\n  Returns paths, descriptions, and metadata \u2014 not file contents. Most input files\n  carry no entry of their own; reach them through their group and `list_files`.\n\n## Your Workspace\n\nYour **working directory** \u2014 writable, and your cwd \u2014 and the read-only\n**analysis root** are named in your briefing. Use those paths exactly; do not\ninvent or guess one.\n\n- **Relative paths resolve against your working directory** \u2014 in `read_file`,\n  `list_files`, `file_stat`, `grep`, `write_file`, `edit_file`,\n  `execute_command`, and any script you run. `output/de.csv` means\n  `<working directory>/output/de.csv` everywhere \u2014 a file you write at a\n  relative path is read back at the same relative path.\n- **You may write only inside your working directory.** A write outside it\n  comes back as an `out_of_prefix` result (no I/O performed); fix the path.\n- The rest of the analysis is mounted **read-only** at the analysis root. Reach\n  input data (under `data/inputs/`) and other steps' outputs (under `runs/`)\n  with an **absolute** path beneath it.\n- **Absolute analysis-root paths are canonical** \u2014 use one whenever you\n  reference a file you didn't create in this step.\n\n`write_file` creates parent directories as needed \u2014 no separate mkdir.\n\n## Scope \u2014 Analysis Starts at Processed Data\n\nThis environment does **tertiary analysis**: turning processed data into\nbiological findings. Read processing \u2014 alignment, quantification, variant\ncalling, peak calling \u2014 belongs upstream, wherever the instrument output was\nhandled. No tool for it is installed, and none can be.\n\nYour inputs are count and expression matrices, called variants, peak sets,\nsignal tracks, and the metadata describing them. When a request arrives as raw\nreads or unprocessed instrument output, name the processed form you need and\nstop. Do not improvise a pipeline, do not substitute a Python reimplementation\nof an aligner or peak caller, and do not treat a missing upstream tool as an\nobstacle to route around \u2014 it is the boundary of the product, not a gap.\n\nData that has already been processed can still be **read**: `samtools`,\n`bcftools`, `tabix`, `bedtools` and `vcftools` are installed so you can\ninspect, subset, and convert existing BAM/CRAM, VCF and BED. Reading evidence at\nsites you already have is in scope; producing the calls is not.\n\n## Environment \u2014 No Network, No Installs\n\n**There is no egress from this sandbox.** Outbound connections are blocked at the\nfirewall, not merely discouraged: every download, API call, package install, and\n`ExperimentHub`/`AnnotationHub`/`models.download_*` style fetch fails outright.\nThere is no proxy, no mirror, and no retry that succeeds. Packages and reference\ndata were staged onto read-only mounts by the host **before** this container\nstarted, and that is the whole of what exists. Work that genuinely requires the\ninternet \u2014 fetching a dataset, querying an external API, literature lookup \u2014 is\ndone **outside** the sandbox through the host's tools, not from your scripts.\n\nSo: check what you need when you need it \u2014 a targeted lookup, never a catalog dump\nup front.\n\n- **Packages** \u2014 before importing a package you are not certain is present, look it\n  up with `list_available_packages`, narrowed to the packages you actually intend\n  to import. Importing one that isn't installed fails the script; the lookup costs\n  one call.\n- **Reference data** \u2014 `list_available_refs` resolves reference data into a real\n  path against the store mounted read-only at `/mnt/refs`. **Search by what the\n  data IS, not by where you expect it** (\"TF-target regulons\", \"hallmark gene\n  sets\", \"mouse\"): the store's directory layout is an installer detail, it differs\n  between hosts, and no path you have seen before is guaranteed to exist here.\n  Catalogued entries come back with the organism, the format, and the file's\n  internal shape, so read the entry and use the reader and species it names rather\n  than assuming \u2014 formats vary per dataset, and there is no guarantee any given\n  collection ships in the format your tool prefers.\n  The store is OPTIONAL and may be absent or hold none of what you want \u2014 a normal\n  state, not an error. Never assume a reference path exists and never hardcode one:\n  if a reference you need is not in the inventory, say so plainly and proceed with\n  what you do have (or state what must be provisioned) rather than inventing a path\n  or substituting something else unannounced. Pass reference paths EXPLICITLY to the\n  library \u2014 nothing in the image points a library at the store, so a library that\n  resolves data by name from an env var (CellTypist reads `$CELLTYPIST_FOLDER`)\n  will not find it unless you set that variable in `execute_command`'s `env`\n  for the command that needs it, using a path the inventory actually returned.\n- Do NOT call a library's built-in data fetcher \u2014 `dc.op.collectri()`,\n  `dc.op.progeny()`, `dc.op.msigdb()` and every other `dc.op.*()`, CellTypist's\n  `models.download_models()`, gseapy's Enrichr library names, `ExperimentHub`/\n  `AnnotationHub` \u2014 they all reach for the network and will fail. Load from an\n  inventory path instead. Do NOT download data or install packages at runtime.\n\n## CPU Budget and Parallelism\n\nYour briefing names this step's CPU quota and memory limit. The container's\ncore-count calls (`parallel::detectCores()`, `os.cpu_count()`) report the\nquota, so worker counts sized from them are safe.\n\nBLAS/OpenMP thread pools default to **1 thread** (`OMP_NUM_THREADS`,\n`OPENBLAS_NUM_THREADS`, `MKL_NUM_THREADS`, \u2026). A forked worker inherits its\nparent's pool size, so this default is what keeps `mclapply` /\n`multiprocessing` from running workers \u00D7 threads on a quota sized for one of\nthem. The rule: **workers \u00D7 threads-per-worker must not exceed the quota.** A\nmix is fine while the product stays inside it.\n\n- **Fork/worker parallelism** (`mclapply`, `BiocParallel`, `joblib`,\n  `multiprocessing`): size the workers from the reported core count and leave\n  the thread defaults alone \u2014 there is nothing to raise. `joblib` also\n  divides its own thread budget across its workers; do not manage it.\n- **Thread parallelism** (one process: xgboost, WGCNA, data.table, polars, a\n  single large BLAS fit): raise the thread variables for that command through\n  `execute_command`'s `env`, e.g.\n  `env: { \"OMP_NUM_THREADS\": \"4\", \"OPENBLAS_NUM_THREADS\": \"4\" }` on a 4-CPU\n  quota.\n\nExceeding the quota does not kill the step \u2014 the cgroup throttles it \u2014 but an\noversubscribed step runs slower and can starve the exec server that runs your\ncommands.\n\n## Context7 \u2014 Documentation Lookup\n\nWhen you are not certain of a function's signature or behavior, look it up\nwith context7 before you write the call: `resolve_library_id` with the\npackage name, then `query_docs` with the library ID and the function.\nRapidly-evolving packages (scvi-tools, spatialdata, cellrank, pertpy, muon)\nchange their APIs between releases, so check them against the docs or the\nskill references rather than memory.\n\n## Command Execution\n\n`execute_command` runs analysis work \u2014 scripts, bioinformatics CLI tools,\nshell pipes, and anything the workspace tools don't express. It starts in your\nworking directory; a relative `cwd` argument is resolved against it.\nIts `command` is an argv array. A one-element array runs through `sh -c`,\nso pipes, `&&`, redirection, quoting, and globbing work there. An array of\ntwo or more elements runs directly, with no shell.\n\nFor these tasks, prefer the dedicated workspace tools \u2014 they are faster than\nshelling out and don't waste a turn on path discovery:\n\n| Task                            | Use this tool   | Instead of                 |\n|-|-|-|\n| List files in a directory       | `list_files`    | `ls` / `ls -la`             |\n| Read a text/source/result file  | `read_file`     | `cat` / `less`             |\n| Search file contents by pattern | `grep`          | shell `grep` / `rg`        |\n| Size / type of a path           | `file_stat`     | `stat` / `wc -c`           |\n\n**Use `execute_command` for everything else**, including:\n\n- **Running scripts** \u2014 `python scripts/run.py`, `Rscript scripts/de.R`,\n  `ruff check scripts/foo.py`.\n- **Previewing huge / binary files** \u2014 `wc -l file.tsv`, `zcat file.gz | head`.\n  For text files, prefer `read_file` with `headLines` / `tailLines`.\n- **Shell pipes / chaining** \u2014 `sort | uniq -c | sort -rn | head`.\n- **`find`** \u2014 a recursive search by name, age, or size: `find . -name '*.h5ad'`,\n  `find . -size +10M`. `list_files` lists one directory only.\n- **Real CLI tools** \u2014 `samtools`, `bcftools`, `tabix`, `bedtools`,\n  `vcftools`, version probes like `python -c \"import x; print(x.__version__)\"`.\n\n**Shell behavior to know:**\n\n- `cd` does NOT persist across calls \u2014 each exec starts in your working\n  directory. For cross-call state, pass `cwd` or chain with `&&` in one exec.\n- Quote paths with spaces: `head \"data/inputs/My Folder/file.csv\"`. In Python,\n  use `pathlib.Path` or `os.path`.\n\n## Editing Files\n\n`edit_file` replaces `old_string` with `new_string`. Read the file first to\nget the exact text. When `replace_all` is false (default), `old_string` must\noccur exactly once \u2014 include surrounding context to make it unique.\n";
+export declare const sandboxOrientCorePrompt = "# Sandbox Orient-Core\n\nThese apply to every agent that talks to a sandbox.\n\n## Your Briefing Is Authoritative\n\nYour first message is your briefing, composed for this step at the instant it was\ndispatched \u2014 after every step it depends on had finished. It names your task, your\nworking directory and the read-only analysis root, what the input dataset is\n(domain, organism, design, quality concerns, files), and what each upstream step\nproduced and where it put it. Work from it.\n\nWhen the analysis has a recorded goal or constraints, the briefing carries them\nunder \"Analysis memory (read only)\": obey each constraint from the user, and treat\neach constraint from the agent as context. You cannot change that memory.\n\nDo NOT re-derive what it already gives you: no filesystem hunt for your inputs, no\nre-reading an upstream step whose summary you were handed, no re-deriving the\norganism or the dimensions from raw bytes. Reach further only where the briefing is\ngenuinely thin for what you must do:\n\n- `inspect_data_profile` \u2014 the full dataset profile: `scope:'overview'` for the\n  identity and the file census, `scope:'groups'` for the groups and the dimensions\n  that vary across them, `scope:'files'` for the members the profiler annotated\n  individually. It is the ONLY record of what the input data IS; no file on disk\n  carries it. Use it when the briefing's orientation is not enough, or when it\n  carried none.\n- `read_file` on an upstream step's summary \u2014 its path is in your briefing \u2014 when\n  the excerpt you were handed is not enough to build on.\n- `workspace_search({ query })` \u2014 natural-language search for a file the briefing\n  does not name. Optional `type` filter (`input-group` | `input-dimension` |\n  `input` | `output` | `summary` | `synthesis`) and `limit` (1-50, default 8).\n  Returns paths, descriptions, and metadata \u2014 not file contents. Most input files\n  carry no entry of their own; reach them through their group and `list_files`.\n\n## Your Workspace\n\nYour **working directory** \u2014 writable, and your cwd \u2014 and the read-only\n**analysis root** are named in your briefing. Use those paths exactly; do not\ninvent or guess one.\n\n- **Relative paths resolve against your working directory** \u2014 in `read_file`,\n  `list_files`, `file_stat`, `grep`, `write_file`, `edit_file`,\n  `execute_command`, and any script you run. `output/de.csv` means\n  `<working directory>/output/de.csv` everywhere \u2014 a file you write at a\n  relative path is read back at the same relative path.\n- **You may write only inside your working directory.** A write outside it\n  comes back as an `out_of_prefix` result (no I/O performed); fix the path.\n- The rest of the analysis is mounted **read-only** at the analysis root. Reach\n  input data (under `data/inputs/`) and other steps' outputs (under `runs/`)\n  with an **absolute** path beneath it.\n- **Absolute analysis-root paths are canonical** \u2014 use one whenever you\n  reference a file you didn't create in this step.\n\n`write_file` creates parent directories as needed \u2014 no separate mkdir.\n\n## Scope \u2014 Analysis Starts at Processed Data\n\nThis environment does **tertiary analysis**: turning processed data into\nbiological findings. Read processing \u2014 alignment, quantification, variant\ncalling, peak calling \u2014 belongs upstream, wherever the instrument output was\nhandled. No tool for it is installed, and none can be.\n\nYour inputs are count and expression matrices, called variants, peak sets,\nsignal tracks, and the metadata describing them. When a request arrives as raw\nreads or unprocessed instrument output, name the processed form you need and\nstop. Do not improvise a pipeline, do not substitute a Python reimplementation\nof an aligner or peak caller, and do not treat a missing upstream tool as an\nobstacle to route around \u2014 it is the boundary of the product, not a gap.\n\nData that has already been processed can still be **read**: `samtools`,\n`bcftools`, `tabix`, `bedtools` and `vcftools` are installed so you can\ninspect, subset, and convert existing BAM/CRAM, VCF and BED. Reading evidence at\nsites you already have is in scope; producing the calls is not.\n\n## Environment \u2014 No Network, No Installs\n\n**There is no egress from this sandbox.** Outbound connections are blocked at the\nfirewall, not merely discouraged: every download, API call, package install, and\n`ExperimentHub`/`AnnotationHub`/`models.download_*` style fetch fails outright.\nThere is no proxy, no mirror, and no retry that succeeds. Packages and reference\ndata were staged onto read-only mounts by the host **before** this container\nstarted, and that is the whole of what exists. Work that genuinely requires the\ninternet \u2014 fetching a dataset, querying an external API, literature lookup \u2014 is\ndone **outside** the sandbox through the host's tools, not from your scripts.\n\nSo: check what you need when you need it \u2014 a targeted lookup, never a catalog dump\nup front.\n\n- **Packages** \u2014 before importing a package you are not certain is present, look it\n  up with `list_available_packages`, narrowed to the packages you actually intend\n  to import. Importing one that isn't installed fails the script; the lookup costs\n  one call.\n- **Reference data** \u2014 `list_available_refs` resolves reference data into a real\n  path against the store mounted read-only at `/mnt/refs`. **Search by what the\n  data IS, not by where you expect it** (\"TF-target regulons\", \"hallmark gene\n  sets\", \"mouse\"): the store's directory layout is an installer detail, it differs\n  between hosts, and no path you have seen before is guaranteed to exist here.\n  Catalogued entries come back with the organism, the format, and the file's\n  internal shape, so read the entry and use the reader and species it names rather\n  than assuming \u2014 formats vary per dataset, and there is no guarantee any given\n  collection ships in the format your tool prefers.\n  The store is OPTIONAL and may be absent or hold none of what you want \u2014 a normal\n  state, not an error. Never assume a reference path exists and never hardcode one:\n  if a reference you need is not in the inventory, say so plainly and proceed with\n  what you do have (or state what must be provisioned) rather than inventing a path\n  or substituting something else unannounced. Pass reference paths EXPLICITLY to the\n  library \u2014 nothing in the image points a library at the store, so a library that\n  resolves data by name from an env var (CellTypist reads `$CELLTYPIST_FOLDER`)\n  will not find it unless you set that variable in `execute_command`'s `env`\n  for the command that needs it, using a path the inventory actually returned.\n- Do NOT call a library's built-in data fetcher \u2014 `dc.op.collectri()`,\n  `dc.op.progeny()`, `dc.op.msigdb()` and every other `dc.op.*()`, CellTypist's\n  `models.download_models()`, gseapy's Enrichr library names, `ExperimentHub`/\n  `AnnotationHub` \u2014 they all reach for the network and will fail. Load from an\n  inventory path instead. Do NOT download data or install packages at runtime.\n\n## CPU Budget and Parallelism\n\nYour briefing names this step's CPU quota and memory limit. The container's\ncore-count calls (`parallel::detectCores()`, `os.cpu_count()`) report the\nquota, so worker counts sized from them are safe.\n\nBLAS/OpenMP thread pools default to **1 thread** (`OMP_NUM_THREADS`,\n`OPENBLAS_NUM_THREADS`, `MKL_NUM_THREADS`, \u2026). A forked worker inherits its\nparent's pool size, so this default is what keeps `mclapply` /\n`multiprocessing` from running workers \u00D7 threads on a quota sized for one of\nthem. The rule: **workers \u00D7 threads-per-worker must not exceed the quota.** A\nmix is fine while the product stays inside it.\n\n- **Fork/worker parallelism** (`mclapply`, `BiocParallel`, `joblib`,\n  `multiprocessing`): size the workers from the reported core count and leave\n  the thread defaults alone \u2014 there is nothing to raise. `joblib` also\n  divides its own thread budget across its workers; do not manage it.\n- **Thread parallelism** (one process: xgboost, WGCNA, data.table, polars, a\n  single large BLAS fit): raise the thread variables for that command through\n  `execute_command`'s `env`, e.g.\n  `env: { \"OMP_NUM_THREADS\": \"4\", \"OPENBLAS_NUM_THREADS\": \"4\" }` on a 4-CPU\n  quota.\n\nExceeding the quota does not kill the step \u2014 the cgroup throttles it \u2014 but an\noversubscribed step runs slower and can starve the exec server that runs your\ncommands.\n\n## Context7 \u2014 Documentation Lookup\n\nWhen you are not certain of a function's signature or behavior, look it up\nwith context7 before you write the call: `resolve_library_id` with the\npackage name, then `query_docs` with the library ID and the function.\nRapidly-evolving packages (scvi-tools, spatialdata, cellrank, pertpy, muon)\nchange their APIs between releases, so check them against the docs or the\nskill references rather than memory.\n\n## Command Execution\n\n`execute_command` runs analysis work \u2014 scripts, bioinformatics CLI tools,\nshell pipes, and anything the workspace tools don't express. It starts in your\nworking directory; a relative `cwd` argument is resolved against it.\nIts `command` is an argv array. A one-element array runs through `sh -c`,\nso pipes, `&&`, redirection, quoting, and globbing work there. An array of\ntwo or more elements runs directly, with no shell.\n\nFor these tasks, prefer the dedicated workspace tools \u2014 they are faster than\nshelling out and don't waste a turn on path discovery:\n\n| Task                            | Use this tool   | Instead of                 |\n|-|-|-|\n| List files in a directory       | `list_files`    | `ls` / `ls -la`             |\n| Read a text/source/result file  | `read_file`     | `cat` / `less`             |\n| Search file contents by pattern | `grep`          | shell `grep` / `rg`        |\n| Size / type of a path           | `file_stat`     | `stat` / `wc -c`           |\n\n**Use `execute_command` for everything else**, including:\n\n- **Running scripts** \u2014 `python scripts/run.py`, `Rscript scripts/de.R`,\n  `ruff check scripts/foo.py`.\n- **Previewing huge / binary files** \u2014 `wc -l file.tsv`, `zcat file.gz | head`.\n  For text files, prefer `read_file` with `headLines` / `tailLines`.\n- **Shell pipes / chaining** \u2014 `sort | uniq -c | sort -rn | head`.\n- **`find`** \u2014 a recursive search by name, age, or size: `find . -name '*.h5ad'`,\n  `find . -size +10M`. `list_files` lists one directory only.\n- **Real CLI tools** \u2014 `samtools`, `bcftools`, `tabix`, `bedtools`,\n  `vcftools`, version probes like `python -c \"import x; print(x.__version__)\"`.\n\n**Shell behavior to know:**\n\n- `cd` does NOT persist across calls \u2014 each exec starts in your working\n  directory. For cross-call state, pass `cwd` or chain with `&&` in one exec.\n- Quote paths with spaces: `head \"data/inputs/My Folder/file.csv\"`. In Python,\n  use `pathlib.Path` or `os.path`.\n\n## Editing Files\n\n`edit_file` replaces `old_string` with `new_string`. Read the file first to\nget the exact text. When `replace_all` is false (default), `old_string` must\noccur exactly once \u2014 include surrounding context to make it unique.\n";
 /**
  * The orient-core layer for one declared toolchain. `"image"` states that an
  * acquisition is a host action and directs the agent to report a missing

package/dist/prompts/sandbox-standards.js

@@ -40,6 +40,10 @@ working directory and the read-only analysis root, what the input dataset is
 (domain, organism, design, quality concerns, files), and what each upstream step
 produced and where it put it. Work from it.
 
+When the analysis has a recorded goal or constraints, the briefing carries them
+under "Analysis memory (read only)": obey each constraint from the user, and treat
+each constraint from the agent as context. You cannot change that memory.
+
 Do NOT re-derive what it already gives you: no filesystem hunt for your inputs, no
 re-reading an upstream step whose summary you were handed, no re-deriving the
 organism or the dimensions from raw bytes. Reach further only where the briefing is

package/dist/runtime/assemble.d.ts

@@ -50,11 +50,13 @@ export type SandboxStepCallable = (input: SandboxStepInput) => Promise<SandboxSt
  * conversation agent does not — a half-wired ledger that reads as a complete
  * one. The protection has to hold on both sides of the assembly, not just the
  * conversation side. Each bag omits `toolOutputStore` for the same reason: each
- * loop must keep its texts in the one store that each read tool reads.
+ * loop must keep its texts in the one store that each read tool reads. The
+ * `executeAnalysis` bag omits `workingMemory`, because the step seeds must read
+ * the same memory that the conversation agent writes.
  */
 export interface CoreWorkflowDeps {
     readonly sandboxStep: Omit<SandboxStepDeps, "usageRecorder" | "citationResolver" | "toolOutputStore">;
-    readonly buildExecuteAnalysis: (sandboxStep: SandboxStepCallable) => Omit<ExecuteAnalysisDeps, "usageRecorder" | "citationResolver" | "toolOutputStore">;
+    readonly buildExecuteAnalysis: (sandboxStep: SandboxStepCallable) => Omit<ExecuteAnalysisDeps, "usageRecorder" | "citationResolver" | "toolOutputStore" | "workingMemory">;
     readonly dataProfile: Omit<DataProfileDeps, "usageRecorder" | "toolOutputStore">;
 }
 /** The registered, callable workflow handles. */

package/dist/runtime/assemble.js

@@ -28,6 +28,7 @@ import { bindExtractionTrigger, createExtractionArm, registerExtractValuesWorkfl
 import { registerDeriveTableExecWorkflow, triggerDeriveTableExec } from "../tasks/derive-table-exec.js";
 import { createCitationResolver } from "../citations/resolve.js";
 import { createThreadStore } from "../memory/thread-store.js";
+import { createWorkingMemory } from "../memory/working-memory.js";
 import { createArtifactReadStore, createProductionResolver } from "../report-model/production-resolver.js";
 import { createReportVersionStore } from "../state/report-versions.js";
 import { createToolOutputStore } from "../state/tool-outputs.js";
@@ -86,7 +87,13 @@ export function assembleCoreRuntime(deps) {
     });
     const toolOutputStore = createToolOutputStore(conversation.pool);
     const sandboxStep = registerSandboxStep({ ...wf.sandboxStep, citationResolver, usageRecorder, toolOutputStore });
-    const executeAnalysis = registerExecuteAnalysis({ ...wf.buildExecuteAnalysis(sandboxStep), citationResolver, usageRecorder, toolOutputStore });
+    const executeAnalysis = registerExecuteAnalysis({
+        ...wf.buildExecuteAnalysis(sandboxStep),
+        citationResolver,
+        usageRecorder,
+        toolOutputStore,
+        workingMemory: createWorkingMemory(conversation.pool),
+    });
     const dataProfile = registerDataProfileWorkflow({ ...wf.dataProfile, usageRecorder, toolOutputStore });
     // The extraction workflow shares the profile's sandbox and authorization rails, thus it draws the same
     // three seams from the profile deps. The report resolver factory binds the extraction arm over this

package/dist/schemas/file-metadata.js

@@ -24,16 +24,16 @@ export const FileMetadataSchema = z
  */
 export const SubmittedFileDescriptionSchema = z.object({
     /** Exact path of the file being described, copied from the prompt's list. */
-    path: z.string(),
-    description: z.string(),
-    dataType: z.string(),
-    format: z.string(),
-    rows: z.number().nullish(),
-    cols: z.number().nullish(),
-    tags: z.array(z.string()).optional(),
-    warnings: z.array(z.string()).optional(),
+    path: z.string().describe("The path of the file, copied exactly from the list of files that the harness gave."),
+    description: z.string().describe("One sentence that says what the file contains. A semantic search of the workspace later finds the file by this text."),
+    dataType: z.string().describe('The semantic type of the data, for example "count matrix" or "QC report".'),
+    format: z.string().describe('The file format, for example "csv", "tsv", "h5ad", or "png".'),
+    rows: z.number().nullish().describe("The count of rows, when you know it."),
+    cols: z.number().nullish().describe("The count of columns, when you know it."),
+    tags: z.array(z.string()).optional().describe("Short labels that help a search find the file."),
+    warnings: z.array(z.string()).optional().describe("Known problems of the file that a reader must know before use."),
 });
 /** Input contract for the `submit_file_metadata` tool. */
 export const SubmitFileMetadataInputSchema = z.object({
-    files: z.array(SubmittedFileDescriptionSchema),
+    files: z.array(SubmittedFileDescriptionSchema).describe("One entry per output file. You can cover the files in one call or in several."),
 });

package/dist/schemas/plan-schemas.d.ts

@@ -11,10 +11,10 @@ export declare const PlanStepSchema: z.ZodObject<{
     context: z.ZodOptional<z.ZodString>;
     description: z.ZodOptional<z.ZodString>;
     id: z.ZodString;
+    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     track: z.ZodString;
     step_type: z.ZodString;
     question: z.ZodString;
-    constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     acceptance_criteria: z.ZodArray<z.ZodString>;
     caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
     packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
@@ -44,10 +44,10 @@ export declare const PlannerPlanSchema: z.ZodObject<{
         context: z.ZodOptional<z.ZodString>;
         description: z.ZodOptional<z.ZodString>;
         id: z.ZodString;
+        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
         track: z.ZodString;
         step_type: z.ZodString;
         question: z.ZodString;
-        constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
         acceptance_criteria: z.ZodArray<z.ZodString>;
         caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
         packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;
@@ -86,10 +86,10 @@ export declare const PlanningAgentOutputSchema: z.ZodObject<{
             context: z.ZodOptional<z.ZodString>;
             description: z.ZodOptional<z.ZodString>;
             id: z.ZodString;
+            constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
             track: z.ZodString;
             step_type: z.ZodString;
             question: z.ZodString;
-            constraints: z.ZodOptional<z.ZodArray<z.ZodString>>;
             acceptance_criteria: z.ZodArray<z.ZodString>;
             caveats: z.ZodOptional<z.ZodArray<z.ZodString>>;
             packages: z.ZodNonOptional<z.ZodOptional<z.ZodArray<z.ZodString>>>;