@inflexa-ai/harness 0.1.1

package/dist/execution/step-summary.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Per-step interpretive markdown summary — a focused `runAgent` tool-loop on
+ * the harness `ChatProvider` that consumes the step's in-memory transcript
+ * (the `runAgent` `messages` array the workflow body already holds) AND a
+ * scoped `read_file` so it grounds every quantitative claim in the persisted
+ * output files rather than confabulating from `execute_command` stdout.
+ *
+ * Contract:
+ *   - `runAgent` loop with a single `read_file` tool scoped to the step's
+ *     writable output tree (via `createReadFileTool(workspaceFs, workingDir)`).
+ *     The summarizer reads any output file it needs, then emits the markdown
+ *     summary as its final assistant text.
+ *   - Returns `{ stepId, agentId, markdown }` on non-empty final text;
+ *     `undefined` on empty/empty-after-trim, on a loop throw, or on no
+ *     text in the final assistant turn. Non-fatal — the workflow body decides
+ *     whether to write `output/summary.md`.
+ *   - `Session` is taken explicitly (see the harness-durable-runtime spec).
+ *
+ * Honest empty: with no output artifacts the prompt directs the model to
+ * state plainly that the step produced no output files — no synthesized
+ * results. Blocked steps skip this producer entirely (handled upstream).
+ *
+ * Transcript-from-memory: per the harness-thread-store spec, workflow loops have no `messages`
+ * table; reconstruction from `operation_outputs` is read-side only. At
+ * step time the workflow body already holds the array — pass it in.
+ */
+import type { AgentSession } from "../auth/types.js";
+import type { LoopMessage } from "../loop/types.js";
+import type { AgentChat } from "../providers/types.js";
+import type { WorkspaceFilesystem } from "../workspace/filesystem.js";
+import { type StepSummary } from "../schemas/step-summary.js";
+export interface GenerateStepSummaryOptions {
+    readonly provider: AgentChat;
+    readonly session: AgentSession;
+    readonly modelId: string;
+    /** In-memory transcript from `runAgent` — assistant + tool-result rounds. */
+    readonly messages: readonly LoopMessage[];
+    readonly artifactPaths: readonly string[];
+    /** Workspace read seam — backs the scoped `read_file` tool. */
+    readonly workspaceFs: WorkspaceFilesystem;
+    /** Absolute host path to the step's writable output tree — `read_file`'s working dir. */
+    readonly workingDir: string;
+    readonly stepId: string;
+    readonly agentId: string;
+    readonly runId: string;
+    readonly maxIterations?: number;
+    readonly signal?: AbortSignal;
+}
+/**
+ * Run the post-step summary loop on the harness provider against the supplied
+ * transcript, grounding claims in persisted files via `read_file`. Returns
+ * `undefined` on any non-fatal failure mode; the workflow body proceeds
+ * without `summary.md` in that case.
+ */
+export declare function generateStepSummary(opts: GenerateStepSummaryOptions): Promise<StepSummary | undefined>;

package/dist/execution/step-summary.js

@@ -0,0 +1,106 @@
+/**
+ * Per-step interpretive markdown summary — a focused `runAgent` tool-loop on
+ * the harness `ChatProvider` that consumes the step's in-memory transcript
+ * (the `runAgent` `messages` array the workflow body already holds) AND a
+ * scoped `read_file` so it grounds every quantitative claim in the persisted
+ * output files rather than confabulating from `execute_command` stdout.
+ *
+ * Contract:
+ *   - `runAgent` loop with a single `read_file` tool scoped to the step's
+ *     writable output tree (via `createReadFileTool(workspaceFs, workingDir)`).
+ *     The summarizer reads any output file it needs, then emits the markdown
+ *     summary as its final assistant text.
+ *   - Returns `{ stepId, agentId, markdown }` on non-empty final text;
+ *     `undefined` on empty/empty-after-trim, on a loop throw, or on no
+ *     text in the final assistant turn. Non-fatal — the workflow body decides
+ *     whether to write `output/summary.md`.
+ *   - `Session` is taken explicitly (see the harness-durable-runtime spec).
+ *
+ * Honest empty: with no output artifacts the prompt directs the model to
+ * state plainly that the step produced no output files — no synthesized
+ * results. Blocked steps skip this producer entirely (handled upstream).
+ *
+ * Transcript-from-memory: per the harness-thread-store spec, workflow loops have no `messages`
+ * table; reconstruction from `operation_outputs` is read-side only. At
+ * step time the workflow body already holds the array — pass it in.
+ */
+import { forSubAgent } from "../auth/types.js";
+import { finalText, runAgent } from "../loop/run-agent.js";
+import { passthroughStep } from "../loop/run-step.js";
+import { stepSummaryPrompt } from "../prompts/execute-analysis/step-summary.js";
+import { createReadFileTool } from "../tools/workspace/read-file.js";
+import { StepSummarySchema } from "../schemas/step-summary.js";
+import { incrementSummaryNullCount } from "./step-summary-metrics.js";
+const SYSTEM_PROMPT = `You are a sandbox agent writing a post-step interpretive summary of work you just completed.
+
+Your prior conversation — tool calls, code output, intermediate results — is in the message history above. Use it for narrative and intent.
+
+Ground every quantitative claim in a PERSISTED output file: open it with the read_file tool and report what the file actually contains. A number that appears only in command stdout is NOT a citable result — read the artifact that holds it. If there are no output files, say so plainly; do not invent numbers and do not synthesize results no artifact backs.
+
+When finished, output ONLY the markdown summary as your final message — no preamble, no apologies, no tool calls.`;
+/** Sub-agent identity for the summary loop — provenance only. */
+const SUMMARY_AGENT_ID = "step-summary-writer";
+/** Iteration budget: a handful of read_file reads plus the final write-up. */
+const DEFAULT_MAX_ITERATIONS = 12;
+/**
+ * Sanitize a transcript that came from the loop so it can prefix a fresh
+ * loop turn: any final assistant `tool_use` block needs a matching
+ * `tool_result` we are not going to produce. Drop the trailing partial round.
+ */
+function sanitizeTranscript(messages) {
+    const out = [...messages];
+    while (out.length > 0) {
+        const last = out[out.length - 1];
+        const blocks = Array.isArray(last.content) ? last.content : [];
+        const hasOpenToolUse = last.role === "assistant" && blocks.some((b) => b.type === "tool-call");
+        if (hasOpenToolUse) {
+            out.pop();
+            continue;
+        }
+        break;
+    }
+    return out;
+}
+/**
+ * Run the post-step summary loop on the harness provider against the supplied
+ * transcript, grounding claims in persisted files via `read_file`. Returns
+ * `undefined` on any non-fatal failure mode; the workflow body proceeds
+ * without `summary.md` in that case.
+ */
+export async function generateStepSummary(opts) {
+    const transcript = sanitizeTranscript(opts.messages);
+    const userPrompt = stepSummaryPrompt(opts.artifactPaths.join("\n"));
+    const writer = {
+        id: SUMMARY_AGENT_ID,
+        systemPrompt: SYSTEM_PROMPT,
+        model: opts.modelId,
+        tools: [createReadFileTool(opts.workspaceFs, opts.workingDir)],
+        maxIterations: opts.maxIterations ?? DEFAULT_MAX_ITERATIONS,
+    };
+    const signal = opts.signal ?? new AbortController().signal;
+    let result;
+    try {
+        result = await runAgent(writer, [...transcript, { role: "user", content: userPrompt }], forSubAgent(opts.session, SUMMARY_AGENT_ID), {
+            provider: opts.provider,
+            signal,
+            emit: () => { },
+            runStep: passthroughStep,
+        });
+    }
+    catch (err) {
+        console.warn(`[step-summary] Summary loop failed runId=${opts.runId} stepId=${opts.stepId} agentId=${opts.agentId}: ${err instanceof Error ? err.message : err}`);
+        incrementSummaryNullCount(opts.agentId, "throw");
+        return undefined;
+    }
+    const markdown = finalText(result.messages);
+    if (!markdown || markdown.trim().length === 0) {
+        console.warn(`[step-summary] Empty markdown runId=${opts.runId} stepId=${opts.stepId} agentId=${opts.agentId}`);
+        incrementSummaryNullCount(opts.agentId, "empty");
+        return undefined;
+    }
+    return StepSummarySchema.parse({
+        stepId: opts.stepId,
+        agentId: opts.agentId,
+        markdown,
+    });
+}

package/dist/execution/topo-sort.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Topological sort of a plan DAG into execution waves.
+ *
+ * Uses Kahn's algorithm to group steps into waves where steps within
+ * a wave have no inter-dependencies and can run in parallel.
+ */
+import type { AnalysisStep } from "../schemas/workflow-state.js";
+/** A wave is a group of steps with no inter-dependencies that can run in parallel. */
+export type ExecutionWave = AnalysisStep[];
+/** Thrown when the plan DAG contains a dependency cycle. */
+export declare class CycleError extends Error {
+    readonly involvedSteps: string[];
+    constructor(involvedSteps: string[]);
+}
+/** Thrown when a step references a dependency that does not exist in the plan. */
+export declare class DependencyError extends Error {
+    readonly stepId: string;
+    readonly missingDependency: string;
+    constructor(stepId: string, missingDependency: string);
+}
+/**
+ * Convert a flat array of analysis steps into ordered execution waves.
+ *
+ * Steps within a wave share no inter-dependencies and can run concurrently.
+ * Wave ordering guarantees that all dependencies of wave N are satisfied
+ * by waves 0..N-1.
+ *
+ * @param steps - Flat array of analysis steps with `id` and `depends_on`
+ * @returns Ordered array of waves (each wave is an array of steps)
+ * @throws {DependencyError} If a step references a non-existent dependency
+ * @throws {CycleError} If the dependency graph contains a cycle
+ */
+export declare function topoSortIntoWaves(steps: AnalysisStep[]): ExecutionWave[];

package/dist/execution/topo-sort.js

@@ -0,0 +1,99 @@
+/**
+ * Topological sort of a plan DAG into execution waves.
+ *
+ * Uses Kahn's algorithm to group steps into waves where steps within
+ * a wave have no inter-dependencies and can run in parallel.
+ */
+// ── Errors ─────────────────────────────────────────────────────────
+/** Thrown when the plan DAG contains a dependency cycle. */
+export class CycleError extends Error {
+    involvedSteps;
+    constructor(involvedSteps) {
+        super(`Dependency cycle detected involving steps: ${involvedSteps.join(", ")}`);
+        this.name = "CycleError";
+        this.involvedSteps = involvedSteps;
+    }
+}
+/** Thrown when a step references a dependency that does not exist in the plan. */
+export class DependencyError extends Error {
+    stepId;
+    missingDependency;
+    constructor(stepId, missingDependency) {
+        super(`Step "${stepId}" depends on "${missingDependency}" which does not exist in the plan`);
+        this.name = "DependencyError";
+        this.stepId = stepId;
+        this.missingDependency = missingDependency;
+    }
+}
+// ── Core ───────────────────────────────────────────────────────────
+/**
+ * Convert a flat array of analysis steps into ordered execution waves.
+ *
+ * Steps within a wave share no inter-dependencies and can run concurrently.
+ * Wave ordering guarantees that all dependencies of wave N are satisfied
+ * by waves 0..N-1.
+ *
+ * @param steps - Flat array of analysis steps with `id` and `depends_on`
+ * @returns Ordered array of waves (each wave is an array of steps)
+ * @throws {DependencyError} If a step references a non-existent dependency
+ * @throws {CycleError} If the dependency graph contains a cycle
+ */
+export function topoSortIntoWaves(steps) {
+    if (steps.length === 0)
+        return [];
+    // Build lookup and validate dependencies exist
+    const stepById = new Map();
+    for (const step of steps) {
+        stepById.set(step.id, step);
+    }
+    for (const step of steps) {
+        for (const dep of step.depends_on) {
+            if (!stepById.has(dep)) {
+                throw new DependencyError(step.id, dep);
+            }
+        }
+    }
+    // Kahn's algorithm: compute in-degree for each step (only counting
+    // edges within this step set)
+    const inDegree = new Map();
+    const dependents = new Map();
+    for (const step of steps) {
+        inDegree.set(step.id, 0);
+        dependents.set(step.id, []);
+    }
+    for (const step of steps) {
+        for (const dep of step.depends_on) {
+            inDegree.set(step.id, (inDegree.get(step.id) ?? 0) + 1);
+            dependents.get(dep).push(step.id);
+        }
+    }
+    // Process wave by wave: each wave consists of all nodes with in-degree 0
+    const waves = [];
+    let remaining = steps.length;
+    // Seed the first frontier with all zero-indegree nodes
+    let frontier = steps.filter((s) => inDegree.get(s.id) === 0).map((s) => s.id);
+    while (frontier.length > 0) {
+        // Current frontier forms a wave
+        const wave = frontier.map((id) => stepById.get(id));
+        waves.push(wave);
+        remaining -= frontier.length;
+        // Compute next frontier
+        const nextFrontier = [];
+        for (const id of frontier) {
+            for (const dep of dependents.get(id)) {
+                const newDeg = (inDegree.get(dep) ?? 1) - 1;
+                inDegree.set(dep, newDeg);
+                if (newDeg === 0) {
+                    nextFrontier.push(dep);
+                }
+            }
+        }
+        frontier = nextFrontier;
+    }
+    // If nodes remain, the graph has a cycle
+    if (remaining > 0) {
+        const cycleSteps = steps.filter((s) => (inDegree.get(s.id) ?? 0) > 0).map((s) => s.id);
+        throw new CycleError(cycleSteps);
+    }
+    return waves;
+}

package/dist/index.d.ts

@@ -0,0 +1,112 @@
+/**
+ * Curated public interface for `@inflexa-ai/harness` — the embedder-facing
+ * front door. Every deep subpath (`@inflexa-ai/harness/...`) remains
+ * importable; this barrel exposes only the surface an embedder needs to wire
+ * the agent with its own seam realizations.
+ */
+export { assembleCoreRuntime } from "./runtime/assemble.js";
+export type { CoreRuntime, CoreRuntimeDeps, CoreWorkflowDeps, RegisteredWorkflows, ConversationAssemblyDeps, SandboxStepCallable } from "./runtime/assemble.js";
+export { bootHarness } from "./runtime/boot.js";
+export type { BootHarnessDeps, BootedHarness } from "./runtime/boot.js";
+export { createConversationAgent } from "./agents/conversation-agent.js";
+export type { ConversationAgentDeps } from "./agents/conversation-agent.js";
+export { createLocalRunAuthorizer } from "./auth/local-run-authorizer.js";
+export type { RunAuthorizer, AuthorizeRunInput, RunAuthorization } from "./execution/run-authorizer.js";
+export { createNoopBillingResolver } from "./billing/noop-resolver.js";
+export type { ResolveBilling, ResolvableSession, BillingMap, BillingHeaders, BillingFetchResult } from "./billing/resolver.js";
+export { createNoopRunCharge } from "./billing/noop-run-charge.js";
+export type { RunCharge } from "./billing/run-charge.js";
+export { createNoopArtifactRegistry } from "./execution/noop-artifact-registry.js";
+export type { ArtifactRegistry, ArtifactRegistrationInput, ArtifactSyncInput, ExternalRegistrationResult } from "./execution/artifact-registry.js";
+export type { ArtifactManifestEntry } from "./schemas/artifact-manifest.js";
+export type { ProvenanceCollector } from "./provenance/collector.js";
+export { UnavailablePreviewPublisher } from "./tools/report/preview-publisher.js";
+export type { PreviewPublisher, PreviewMintResult } from "./tools/report/preview-publisher.js";
+export { createDbosRunLauncher } from "./execution/dbos-run-launcher.js";
+export type { RunLauncher, LaunchOptions, LaunchRunOptions, LaunchOutcome } from "./execution/run-launcher.js";
+export { defineTool, isToolError } from "./tools/define-tool.js";
+export type { Tool, ToolDefinition, ToolContext, ToolError } from "./tools/define-tool.js";
+export { runAgent, finalText } from "./loop/run-agent.js";
+export type { RunAgentOptions, RunAgentResult, AgentFinish } from "./loop/run-agent.js";
+export type { AgentDefinition, RunStep, EmitFn, EmitEvent, EventSource } from "./loop/types.js";
+export { passthroughStep } from "./loop/run-step.js";
+export { forStep, forSubAgent, scopeResource, scopeWorkloadId } from "./auth/types.js";
+export type { AgentSession, RequestSession, RunSession, Identity, Scope, Credential, Provenance, RunFrame, AuthContext, ResourceCoordinates, } from "./auth/types.js";
+export { makeLocalAuth } from "./auth/local-auth-context.js";
+export { createAnthropicProvider } from "./providers/anthropic.js";
+export type { AnthropicProviderDeps } from "./providers/anthropic.js";
+export { createConfiguredAiSdkProvider } from "./providers/ai-sdk.js";
+export type { AiSdkProviderConfig, ConfiguredAiSdkProviderDeps } from "./providers/ai-sdk.js";
+export { createEmbeddingProvider } from "./providers/embedding.js";
+export type { EmbeddingProviderDeps } from "./providers/embedding.js";
+export type { AgentChat, ChatProvider, EmbeddingProvider, ChatRequest, ChatResponse, ChatStreamEvent, ModelMessage } from "./providers/types.js";
+export { toProviderError, isProviderError } from "./providers/errors.js";
+export type { ProviderError } from "./providers/errors.js";
+export { createStreamingChat } from "./providers/streaming-chat.js";
+export { prepareChatTurn } from "./app/chat-turn.js";
+export type { PrepareChatTurnDeps, PrepareChatTurnParams, PrepareChatTurnResult } from "./app/chat-turn.js";
+export { createThreadStore } from "./memory/thread-store.js";
+export type { ThreadStore, Thread, CreateThreadInput, ListThreadsInput, ThreadPage } from "./memory/thread-store.js";
+export { createThreadHistory } from "./memory/thread-history.js";
+export type { ThreadHistory, StoredMessage, MessagePage } from "./memory/thread-history.js";
+export { contentToCortexMessages } from "./memory/content-to-cortex.js";
+export { createCardResolver } from "./memory/reconstruct-cards.js";
+export type { ToolCardResolver, StoredToolCallForCard } from "./memory/reconstruct-cards.js";
+export type { CortexChatEvent, TextDeltaEvent, ToolStartedEvent, ToolFinishedEvent, FinishEvent, ChatErrorEvent } from "./contracts/chat-events.js";
+export type { CortexChatPart, PresentationPart, PresentationContent, PlanPart, RunCardPart, FileReferencePart, FileReferenceEntry, RunStartedPart, DagStatePart, DagStepState, StepStatus, StepActivityPart, StepPhase, StepFileTreePart, FileTreeEntry, StepOutputPart, StepOutputFile, StepSummaryPart, StepBlockedPart, RunSynthesisPart, SynthesizedFinding, BiologicalTheme, SynthesisProgressPart, SynthesisPhase, RunCompletedPart, RunCompletedFinding, RunFailedPart, PreviewPart, DataPreviewFailedPart, } from "./contracts/chat-parts.js";
+export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./contracts/part-registry.js";
+export type { CortexChatPartType, PartDescriptor, PartEmitter, PartConsumer } from "./contracts/part-registry.js";
+export { launchDbos, shutdownDbos, sweepEphemeralWorkflows } from "./runtime/dbos.js";
+export type { DbosConfig } from "./runtime/dbos.js";
+export { StatusString } from "@dbos-inc/dbos-sdk";
+export type { WorkflowStatusString } from "@dbos-inc/dbos-sdk";
+export { createPool } from "./lib/storage.js";
+export type { PoolConfig } from "./lib/storage.js";
+export type { Pool } from "pg";
+export { registerDataProfileWorkflow, triggerDataProfile, runDataProfile } from "./tasks/data-profile.js";
+export type { DataProfileDeps, DataProfileWorkflowInput, DataProfileTriggerDeps, DataProfileTriggerParams, DataProfileTriggerResult, } from "./tasks/data-profile.js";
+export { initCortexState } from "./state/init.js";
+export { upsertAnalysis } from "./state/analyses.js";
+export { clearDataProfile, loadDataProfileStatus, tryRetryDataProfile, reconcileOrphanedDataProfile } from "./state/data-profile.js";
+export type { DataProfileInputFile, DataProfileResult, DataProfileStatus } from "./state/data-profile.js";
+export type { StagedInput } from "./execution/staged-input.js";
+export type { ResolveWorkspaceRoot } from "./workspace/paths.js";
+export { createSandboxClient } from "./sandbox/create-sandbox.js";
+export type { CreateSandboxClientConfig, SandboxBackendConfig } from "./sandbox/create-sandbox.js";
+export type { SandboxClient } from "./sandbox/client.js";
+export { MachineBudgetSchema, ResourceLimitsSchema, ResourcePolicySchema, ResourceSpecSchema, parseResourcePolicy } from "./config/resource-limits.js";
+export type { MachineBudget, ResourceLimits, ResourcePolicy, ResourceSpec } from "./config/resource-limits.js";
+export { createWorkspaceFilesystem } from "./workspace/filesystem.js";
+export type { WorkspaceFilesystem, WorkspaceFilesystemDeps } from "./workspace/filesystem.js";
+export { workflowIdFromExec } from "./sandbox/exec-id.js";
+export { deliverExecEvent, execEventTopic } from "./sandbox/deliver-exec-event.js";
+export { ExecEventMessageSchema } from "./sandbox/types.js";
+export type { ExecEventMessage, DoneMarker } from "./sandbox/types.js";
+export { registerExecuteAnalysis } from "./workflows/execute-analysis.js";
+export type { ExecuteAnalysisDeps, ExecuteAnalysisInput, ExecuteAnalysisResult, RunProvenanceEvent } from "./workflows/execute-analysis.js";
+export { registerSandboxStep } from "./workflows/sandbox-step.js";
+export type { SandboxStepDeps, SandboxStepInput, SandboxStepResult, SandboxAgentBuildContext } from "./workflows/sandbox-step.js";
+export { createSandboxAgents, SANDBOX_AGENT_META } from "./agents/sandbox/index.js";
+export type { SandboxAgentDeps, SandboxStepCoords, AgentMeta } from "./agents/sandbox/index.js";
+export { AnalysisPlanSchema } from "./schemas/workflow-state.js";
+export type { AnalysisPlan, AnalysisStep } from "./schemas/workflow-state.js";
+export type { PlanStep } from "./workflows/execute-analysis-scheduler.js";
+export { validatePlan } from "./schemas/validate-plan.js";
+export type { ValidatePlanOptions } from "./schemas/validate-plan.js";
+export type { ValidationResult } from "./schemas/validate-plan.js";
+export { renderStepPrompt } from "./schemas/render-step-prompt.js";
+export { upsertPlan, loadPlan } from "./state/plans.js";
+export type { UpsertPlanInput } from "./state/plans.js";
+export { insertRun, queryActiveRun, updateRunStatus, queryRun, queryRunsByAnalysis, RunDedupCollisionError } from "./state/runs.js";
+export type { InsertRunInput } from "./state/runs.js";
+export { queryStepsByRun } from "./state/step-executions.js";
+export type { CortexRunRow, StepExecutionRow, RunStatus } from "./state/schema.js";
+export type { DbError } from "./lib/db-result.js";
+export { queryActiveSandboxes } from "./state/active-sandboxes.js";
+export { runStepDir } from "./workspace/paths.js";
+export { registerSandboxReaper } from "./sandbox/reaper.js";
+export type { RegisterReaperDeps } from "./sandbox/reaper.js";
+export { registerWatchdog } from "./sandbox/watchdog.js";
+export type { WatchdogDeps } from "./sandbox/watchdog.js";
+export { registerNotificationSweep } from "./sandbox/notification-sweep.js";
+export type { RegisterNotificationSweepDeps } from "./sandbox/notification-sweep.js";

package/dist/index.js

@@ -0,0 +1,157 @@
+/**
+ * Curated public interface for `@inflexa-ai/harness` — the embedder-facing
+ * front door. Every deep subpath (`@inflexa-ai/harness/...`) remains
+ * importable; this barrel exposes only the surface an embedder needs to wire
+ * the agent with its own seam realizations.
+ */
+// Runtime assembly + composition root.
+export { assembleCoreRuntime } from "./runtime/assemble.js";
+// The harness-owned boot sequence: ordered boot steps around `assembleCoreRuntime`
+// (skill validation → state init → connection budget → assemble → launch) + a
+// `shutdown` handle the embedder wires to its process signals.
+export { bootHarness } from "./runtime/boot.js";
+export { createConversationAgent } from "./agents/conversation-agent.js";
+// Seam: run authorization.
+export { createLocalRunAuthorizer } from "./auth/local-run-authorizer.js";
+// Seam: billing resolution.
+export { createNoopBillingResolver } from "./billing/noop-resolver.js";
+// Seam: run-level billing bracket.
+export { createNoopRunCharge } from "./billing/noop-run-charge.js";
+// Seam: artifact registration.
+export { createNoopArtifactRegistry } from "./execution/noop-artifact-registry.js";
+// Seam: report preview publishing.
+export { UnavailablePreviewPublisher } from "./tools/report/preview-publisher.js";
+// Run launching.
+export { createDbosRunLauncher } from "./execution/dbos-run-launcher.js";
+// Tool primitive.
+export { defineTool, isToolError } from "./tools/define-tool.js";
+// Agent loop.
+export { runAgent, finalText } from "./loop/run-agent.js";
+// `passthroughStep` is the in-process `RunStep`: the host request/chat path runs
+// the loop with no durability wrapper (workflow contexts use the durable step).
+// An embedder driving `runAgent` outside a workflow passes it as `runStep`.
+export { passthroughStep } from "./loop/run-step.js";
+// Session value objects + helpers.
+export { forStep, forSubAgent, scopeResource, scopeWorkloadId } from "./auth/types.js";
+export { makeLocalAuth } from "./auth/local-auth-context.js";
+// Providers.
+export { createAnthropicProvider } from "./providers/anthropic.js";
+// The general provider-configuration path: `createConfiguredAiSdkProvider`
+// builds a `ChatProvider` from an `AiSdkProviderConfig` — the connection+model
+// union discriminated over the `anthropic` and `openai-compatible` kinds — with
+// `ConfiguredAiSdkProviderDeps` as its argument shape. `createAnthropicProvider`
+// above is a convenience over this union's `anthropic` arm.
+export { createConfiguredAiSdkProvider } from "./providers/ai-sdk.js";
+export { createEmbeddingProvider } from "./providers/embedding.js";
+// Provider error channel. `ProviderError` is the value `chat`/`embed` fail
+// with; `toProviderError` is its sole constructor. Exposed so an embedder
+// realizing its own `ChatProvider`/`EmbeddingProvider` fails with the exact
+// same shape the harness's own realizations do, rather than re-deriving it.
+// `isProviderError` is the structural guard an embedder driving `chatStream`
+// directly needs: `chatStream` throws a `ProviderError` value (a plain object,
+// not an `Error`), so a `catch` recognizes it by shape, not `instanceof`.
+export { toProviderError, isProviderError } from "./providers/errors.js";
+// `createStreamingChat` wraps a `ChatProvider` as a streaming `AgentChat` (the
+// type `runAgent`'s `provider` option takes): its `chat` drives the provider's
+// `chatStream` and forwards each text delta to `onText`, so a same-process host
+// gets live token streaming out of the otherwise non-streaming loop.
+export { createStreamingChat } from "./providers/streaming-chat.js";
+// Conversation turn + thread memory — the transport-free halves of one chat
+// turn a same-process host drives itself. `prepareChatTurn` assembles the
+// message array (thread-ownership resolution, title seed, analysis-context
+// injection); the caller runs `runAgent` with its own `emit`; `appendTurn`
+// (`createThreadHistory`) persists the turn. `createThreadStore` owns thread
+// metadata (create/list/title). `contentToCortexMessages` + `createCardResolver`
+// reconstruct display cards from a persisted thread on reload.
+export { prepareChatTurn } from "./app/chat-turn.js";
+export { createThreadStore } from "./memory/thread-store.js";
+export { createThreadHistory } from "./memory/thread-history.js";
+export { contentToCortexMessages } from "./memory/content-to-cortex.js";
+export { createCardResolver } from "./memory/reconstruct-cards.js";
+export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./contracts/part-registry.js";
+// Embedder runtime surface — what a same-process host needs to run durable
+// workflows itself: the DBOS lifecycle, per-workflow registration + triggers,
+// the staged-input manifest contract, the sandbox/workspace factories over its
+// workspace tree, and the exec-callback envelope pieces (the HTTP→DBOS-topic
+// ingress is the embedder's to host; see the sandbox-server callback protocol).
+// DBOS lifecycle. `sweepEphemeralWorkflows` is a pre-launch boot duty: once the
+// `ephemeral` workflow is registered, a host crash mid-run leaves a PENDING
+// `ephemeral:*` row that the next launch's recovery would re-dispatch (a sandbox
+// for a chat turn that no longer exists). The embedder sweeps it with a direct
+// system-DB UPDATE between state-init and `launchDbos` — the only race-free point.
+export { launchDbos, shutdownDbos, sweepEphemeralWorkflows } from "./runtime/dbos.js";
+// DBOS workflow-status vocabulary. An embedder that reads its own
+// `dbos.workflow_status` rows must classify them against the SDK's status set,
+// but must never depend on `@dbos-inc/dbos-sdk` directly — the SDK is
+// module-singleton state, so a host's own copy is a different, un-launched
+// instance (same rationale as `deliverExecEvent` below). The barrel forwards the
+// status const + its union so the classification vocabulary comes from the one
+// launched SDK, not a drifting hand-kept string literal on the embedder side.
+export { StatusString } from "@dbos-inc/dbos-sdk";
+// Application pool. Exported so an embedder never declares its own `pg`
+// dependency: the pool it hands to workflow deps is built by the same pg
+// copy the harness queries with.
+export { createPool } from "./lib/storage.js";
+// Data-profile workflow: registration + trigger. `triggerDataProfile` claims a
+// startable row (`pending` or NULL status) or a `completed` one, in both cases only
+// when the analysis names a non-empty seeded input set; a failed profile is re-claimed
+// via `tryRetryDataProfile` and then started with `runDataProfile` (the managed retry
+// route's shape — embedders mirror it).
+export { registerDataProfileWorkflow, triggerDataProfile, runDataProfile } from "./tasks/data-profile.js";
+// Ledger surface the embedder needs around a trigger: schema init at boot,
+// the analysis-state seed (the trigger's CAS transitions the row this creates
+// — without it every trigger reports "failed"), and run-state observation.
+export { initCortexState } from "./state/init.js";
+export { upsertAnalysis } from "./state/analyses.js";
+// `reconcileOrphanedDataProfile` heals a ledger row stuck at `running` with no
+// backing workflow (a host that died between the ledger CAS and the DBOS
+// insert) — the embedder calls it once after launch, when recovery has run.
+// `clearDataProfile` nulls the whole profile ledger back to "no profile" when an
+// analysis's input set empties (deferring on a running workflow), so the UI
+// stops advertising a profile that describes files the analysis no longer has.
+export { clearDataProfile, loadDataProfileStatus, tryRetryDataProfile, reconcileOrphanedDataProfile } from "./state/data-profile.js";
+export { createSandboxClient } from "./sandbox/create-sandbox.js";
+export { MachineBudgetSchema, ResourceLimitsSchema, ResourcePolicySchema, ResourceSpecSchema, parseResourcePolicy } from "./config/resource-limits.js";
+export { createWorkspaceFilesystem } from "./workspace/filesystem.js";
+// Exec-callback ingress building blocks. Delivery goes through
+// `deliverExecEvent` — never a host-side `DBOS.send`: the SDK is
+// module-singleton state, and a host's own copy would be un-launched.
+export { workflowIdFromExec } from "./sandbox/exec-id.js";
+export { deliverExecEvent, execEventTopic } from "./sandbox/deliver-exec-event.js";
+export { ExecEventMessageSchema } from "./sandbox/types.js";
+// Run engine — the analysis + sandbox-step durable workflows an embedder
+// registers itself (in child-before-parent assemble-order: the parent's deps
+// close over the registered child callable). `assembleCoreRuntime` also wires
+// these, but an embedder running only the run engine registers them directly.
+export { registerExecuteAnalysis } from "./workflows/execute-analysis.js";
+export { registerSandboxStep } from "./workflows/sandbox-step.js";
+// Sandbox-agent catalog. `buildAgent` maps a `SandboxAgentBuildContext` onto
+// `SandboxAgentDeps`, then selects the per-step agent by id from this record;
+// `SANDBOX_AGENT_META` is the planner-facing meta the same ids key.
+export { createSandboxAgents, SANDBOX_AGENT_META } from "./agents/sandbox/index.js";
+// Plan schema, structural validation, and per-step prompt rendering — the gates
+// a plan passes before it can trigger a run, plus the prompt each step's agent
+// receives. `PlanStep` is the minimal `{ id, depends_on }` element type that
+// `ExecuteAnalysisInput.steps` is typed against; a parsed `AnalysisPlan`'s
+// richer `AnalysisStep[]` is assignable to it.
+export { AnalysisPlanSchema } from "./schemas/workflow-state.js";
+export { validatePlan } from "./schemas/validate-plan.js";
+export { renderStepPrompt } from "./schemas/render-step-prompt.js";
+// Plan + run + step ledgers around a trigger. `upsertPlan` takes a
+// caller-derived id and inserts-if-absent (the deterministic-id intake path);
+// the run-state calls mirror the chat trigger's reserve → dedup → status flow.
+export { upsertPlan, loadPlan } from "./state/plans.js";
+export { insertRun, queryActiveRun, updateRunStatus, queryRun, queryRunsByAnalysis, RunDedupCollisionError } from "./state/runs.js";
+export { queryStepsByRun } from "./state/step-executions.js";
+// Backs `WatchdogDeps.queryActiveSandboxes` when the embedder wires the watchdog.
+export { queryActiveSandboxes } from "./state/active-sandboxes.js";
+// Workspace-tree path convention — the root-relative step directory each
+// sandbox step confines its artifact writes to (join onto the resolved root).
+export { runStepDir } from "./workspace/paths.js";
+// Sandbox-hygiene scheduled workflows. Reaper reclaims a dead host's orphaned
+// containers; watchdog converts a dead sandbox into a prompt step failure
+// instead of a deadline-long `DBOS.recv` hang; the sweep prunes stale
+// notifications. Each is a `@DBOS.scheduled` no-op on an idle system.
+export { registerSandboxReaper } from "./sandbox/reaper.js";
+export { registerWatchdog } from "./sandbox/watchdog.js";
+export { registerNotificationSweep } from "./sandbox/notification-sweep.js";

package/dist/input-sanitization.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Input sanitization — two pure, always-on functions applied once to the
+ * incoming user message by the chat route (change 6). Never applied to
+ * assistant messages or tool results.
+ *
+ * Two pure functions, not a plug-in pipeline. What runs is exactly these two.
+ */
+/**
+ * NFC-normalize and strip control characters.
+ *
+ * Unicode normalization collapses visually-identical decomposed sequences
+ * to a canonical form; control-char stripping removes invisible C0/C1 bytes
+ * that could smuggle formatting or terminal escapes.
+ */
+export declare function normalizeUnicode(text: string): string;
+/**
+ * Replace structured secret formats with `[REDACTED: <name>]`.
+ *
+ * Only prefixed formats are matched — a 40-nucleotide `ACGT…` string or a
+ * 40-residue protein sequence passes through unchanged.
+ */
+export declare function redactSecrets(text: string): string;