@inflexa-ai/harness 0.22.1 → 0.23.0

package/dist/app/chat-turn.js

@@ -75,6 +75,7 @@ export async function prepareChatTurn(deps, params) {
         runActivityContext,
         history,
         workingMemory: createWorkingMemory(pool),
+        ...(deps.logger ? { logger: deps.logger } : {}),
     });
     return { kind: "ok", threadType, messages, userMessage };
 }

package/dist/app/message-assembly.d.ts

@@ -35,6 +35,7 @@
  * thread store.
  */
 import type { ModelMessage } from "ai";
+import type { Logger } from "../lib/logger.js";
 import type { LoopMessage } from "../loop/types.js";
 import type { ThreadHistory } from "../memory/thread-history.js";
 import type { ThreadType } from "../memory/thread-store.js";
@@ -64,6 +65,8 @@ export interface AssembleMessagesArgs {
     readonly workingMemory: WorkingMemoryStore;
     /** History-window token budget. Defaults to {@link DEFAULT_HISTORY_TOKEN_BUDGET}. */
     readonly tokenBudget?: number;
+    /** Diagnostic seam for the history repair record; omitted falls back to no-op. */
+    readonly logger?: Logger;
 }
 export interface AssembledMessages {
     /** The full message array for `runAgent`. */

package/dist/app/message-assembly.js

@@ -34,7 +34,9 @@
  * tail injections (ephemeral, re-derived each turn) are never written to the
  * thread store.
  */
+import { createNoopLogger } from "../lib/console-logger.js";
 import { unwrapOrThrow } from "../lib/result.js";
+import { stripUnansweredToolCalls } from "../memory/tool-call-integrity.js";
 import { normalizeUnicode, redactSecrets } from "../input-sanitization.js";
 /**
  * Token budget for the `loadRecent` history window. Sized to leave headroom
@@ -49,6 +51,21 @@ export const DEFAULT_HISTORY_TOKEN_BUDGET = 120_000;
 export async function assembleMessages(args) {
     const budget = args.tokenBudget ?? DEFAULT_HISTORY_TOKEN_BUDGET;
     const history = unwrapOrThrow(await args.history.loadRecent(args.threadId, budget, { keepFirstTurn: args.threadType === "report" }));
+    // Read-side safety net for the wire contract: every tool call carries a
+    // result. The loop upholds it at every exit, but the store outlives any one
+    // writer — a row an older build wrote, or a hand-edited database, can carry
+    // an unanswered call, and the provider boundary then refuses the WHOLE
+    // transcript on every turn: the thread is wedged forever. Stripping the
+    // orphan here degrades one message instead. The warning is the only account
+    // a reader gets that the stored thread and the assembled one differ.
+    const repaired = stripUnansweredToolCalls(history);
+    if (repaired.length > 0) {
+        (args.logger ?? createNoopLogger()).named("assembly").warn("unanswered tool calls stripped from thread history", {
+            threadId: args.threadId,
+            toolCallIds: repaired.map((d) => d.toolCallId),
+            tools: repaired.map((d) => d.toolName),
+        });
+    }
     // Sanitization — applied once, here, to the new user input only.
     const userMessage = {
         role: "user",

package/dist/contracts/chat-parts.d.ts

@@ -359,4 +359,20 @@ export interface DataPreviewFailedPart {
     /** Optional taxonomy of failure kinds. */
     errorKind?: "render" | "submit" | "build" | "timeout" | "internal";
 }
-export type CortexChatPart = PresentationPart | PlanPart | RunCardPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | PreviewPart | DataPreviewFailedPart;
+/**
+ * The record that a turn started a report session. It rides the chat stream
+ * live, and it persists into the turn at the position of the spawn.
+ *
+ * The part is a placement record and a freshness signal only. The thread
+ * store is the authority for the session: its existence, its title, and its
+ * archived state. When the thread of the part is archived or absent, a
+ * consumer renders nothing for it.
+ */
+export interface ReportSessionStartedPart {
+    type: "data-report-session-started";
+    /** The id of the report thread that the spawn made. */
+    threadId: string;
+    /** The id of the conversation thread that spawned it. */
+    parentThreadId: string;
+}
+export type CortexChatPart = PresentationPart | PlanPart | RunCardPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | PreviewPart | DataPreviewFailedPart | ReportSessionStartedPart;

package/dist/contracts/index.d.ts

@@ -2,7 +2,7 @@ export { ORGAN_SYSTEMS, OrganSystemSchema, ORGAN_SYSTEM_LABELS, organSystemLabel
 export type { OrganSystem } from "./organ-system.js";
 export { SEVERITIES, SeveritySchema } from "./severity.js";
 export type { Severity } from "./severity.js";
-export type { PlanStep, PresentationContent, PresentationPart, PlanPart, RunCardPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, DagStatePart, StepPhase, StepActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, PreviewPart, DataPreviewFailedPart, CortexChatPart, } from "./chat-parts.js";
+export type { PlanStep, PresentationContent, PresentationPart, PlanPart, RunCardPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, DagStatePart, StepPhase, StepActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, PreviewPart, DataPreviewFailedPart, ReportSessionStartedPart, CortexChatPart, } from "./chat-parts.js";
 export type { EventSource, TextDeltaEvent, ToolStartedEvent, ToolFinishedEvent, FinishEvent, ChatErrorEvent, CortexChatEvent } from "./chat-events.js";
 export type { TokenUsageRollup } from "./usage.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";

package/dist/contracts/part-registry.js

@@ -18,6 +18,7 @@ export const PART_REGISTRY = {
     "data-run-failed": { emitter: "workflow", consumer: "sidebar", transient: false, reconciling: false },
     "data-report-preview": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
     "data-report-preview-failed": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
+    "data-report-session-started": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
 };
 export function isTransient(type) {
     return PART_REGISTRY[type].transient;

package/dist/contracts/schemas/chat-parts.d.ts

@@ -467,6 +467,11 @@ export declare const DataPreviewFailedPartSchema: z.ZodObject<{
         internal: "internal";
     }>>;
 }, z.core.$strip>;
+export declare const ReportSessionStartedPartSchema: z.ZodObject<{
+    type: z.ZodLiteral<"data-report-session-started">;
+    threadId: z.ZodString;
+    parentThreadId: z.ZodString;
+}, z.core.$strip>;
 export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"data-presentation">;
     id: z.ZodString;
@@ -763,4 +768,8 @@ export declare const CortexChatPartSchema: z.ZodDiscriminatedUnion<[z.ZodObject<
         build: "build";
         internal: "internal";
     }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"data-report-session-started">;
+    threadId: z.ZodString;
+    parentThreadId: z.ZodString;
 }, z.core.$strip>], "type">;

package/dist/contracts/schemas/chat-parts.js

@@ -294,6 +294,12 @@ export const DataPreviewFailedPartSchema = z.object({
     reason: z.string(),
     errorKind: z.enum(["render", "submit", "build", "timeout", "internal"]).optional(),
 });
+// ── Report Session Started ─────────────────────────────────────────
+export const ReportSessionStartedPartSchema = z.object({
+    type: z.literal("data-report-session-started"),
+    threadId: z.string(),
+    parentThreadId: z.string(),
+});
 // ── Union ───────────────────────────────────────────────────────────
 export const CortexChatPartSchema = z.discriminatedUnion("type", [
     PresentationPartSchema,
@@ -315,4 +321,5 @@ export const CortexChatPartSchema = z.discriminatedUnion("type", [
     RunFailedPartSchema,
     PreviewPartSchema,
     DataPreviewFailedPartSchema,
+    ReportSessionStartedPartSchema,
 ]);

package/dist/loop/run-agent.js

@@ -5,6 +5,7 @@ import { stripNulCharacters } from "../input-sanitization.js";
 import { createNoopLogger } from "../lib/console-logger.js";
 import { hintForZodIssue, repairToolInput } from "../lib/zod-issues.js";
 import { markInterruptedMessage, syntheticUserMessage } from "../memory/ai-sdk-message-storage.js";
+import { stripUnansweredToolCalls } from "../memory/tool-call-integrity.js";
 import { classifyProviderError } from "../providers/errors.js";
 import { DEFAULT_PROMPT_CACHE, promptCacheProviderOptions } from "../providers/prompt-cache.js";
 import { resultStep } from "./run-step.js";
@@ -91,6 +92,28 @@ export async function runAgent(agent, initial, session, opts) {
     const logFinish = (level, reason, cappedOut) => {
         log[level]("run finished", { iterations, reason, cappedOut, truncationRecoveries, toolCalls: toolCallCount, toolErrors: toolErrorCount, usage });
     };
+    /**
+     * Settle the transcript on the way out — called at every return. A reply can
+     * carry a complete tool call beside ANY finish reason, because the call
+     * streams before the stop reason arrives, and only the dispatching branches
+     * (`tool-calls`, a call-carrying `stop`, and `length`) run one. A call this
+     * run never dispatched is stripped
+     * rather than executed (a filtered or aborted reply must not act) or answered
+     * with an invented result (the model would read a fabrication as ground
+     * truth). Without the strip, the unanswered call violates the wire contract —
+     * every tool call carries a result — and the provider boundary then refuses
+     * the whole transcript on every later turn of the thread. Scoped past
+     * `initial`: the caller's prefix is not this run's to repair.
+     */
+    const settleTranscript = () => {
+        const droppedCalls = stripUnansweredToolCalls(messages, initial.length);
+        if (droppedCalls.length === 0)
+            return;
+        log.warn("undispatched tool calls stripped at run exit", {
+            toolCallIds: droppedCalls.map((d) => d.toolCallId),
+            tools: droppedCalls.map((d) => d.toolName),
+        });
+    };
     const usageRecorder = opts.usageRecorder ?? createNoopUsageRecorder();
     /**
      * Fold one completed call into both rollups and hand it to the recorder.
@@ -135,6 +158,7 @@ export async function runAgent(agent, initial, session, opts) {
     // lands in a dispatch round — after the concurrent siblings in that same round
     // have completed and been appended. Mirrors the clean-stop terminal path.
     const stopOnDenial = async (i) => {
+        settleTranscript();
         await emit({ type: "iteration", source, index: i, final: true });
         recordAgentRun({ agentId: agent.id, iterations, cappedOut: false, usage });
         logFinish("warn", "denied", false);
@@ -195,6 +219,7 @@ export async function runAgent(agent, initial, session, opts) {
         return errored;
     };
     const stopOnResolved = async (i) => {
+        settleTranscript();
         await emit({ type: "iteration", source, index: i, final: true });
         recordAgentRun({ agentId: agent.id, iterations, cappedOut: false, usage });
         return { messages, finish: { reason: "stop", cappedOut: false, truncationRecoveries } };
@@ -266,7 +291,19 @@ export async function runAgent(agent, initial, session, opts) {
                 return stopOnResolved(i);
             continue;
         }
-        if (reply.finishReason !== "tool-calls") {
+        // A local model behind an OpenAI-compatible server routinely labels a
+        // tool-calling reply `stop`. The calls are complete and the model waits
+        // on their results, thus the mislabeled round dispatches like a
+        // `tool-calls` one. Every other terminal keeps the strip: a filtered or
+        // aborted reply must not act.
+        const dispatchesRound = reply.finishReason === "tool-calls" || (reply.finishReason === "stop" && toolCalls.length > 0);
+        if (!dispatchesRound) {
+            settleTranscript();
+            // The settle can remove a call-only aborted partial whole; the
+            // interruption marker then rides the last assistant that survived,
+            // matching the no-output abort contract above.
+            if (reply.finishReason === "aborted")
+                markLastLoopAssistant(messages, initial.length);
             await emit({ type: "iteration", source, index: i, final: true });
             recordAgentRun({ agentId: agent.id, iterations, cappedOut: false, usage });
             logFinish("info", reply.finishReason, false);
@@ -307,6 +344,7 @@ export async function runAgent(agent, initial, session, opts) {
         // exhausted its iterations, while the reason carries the abort.
         if (assistantHasContent(wrapUp.message))
             messages.push(wrapUp.message);
+        settleTranscript();
         markLastLoopAssistant(messages, initial.length);
         await emit({ type: "iteration", source, index: agent.maxIterations, final: true });
         recordAgentRun({ agentId: agent.id, iterations, cappedOut: true, usage });
@@ -314,6 +352,7 @@ export async function runAgent(agent, initial, session, opts) {
         return { messages, finish: { reason: "aborted", cappedOut: true, truncationRecoveries, ...finishUsage() } };
     }
     messages.push(wrapUp.message);
+    settleTranscript();
     await emit({ type: "iteration", source, index: agent.maxIterations, final: true });
     recordAgentRun({ agentId: agent.id, iterations, cappedOut: true, usage });
     logFinish("warn", "max_iterations", true);

package/dist/memory/conversation-display-storage.d.ts

@@ -15,7 +15,7 @@
  * reconstruction.
  */
 import { type DataUIPart, type UIMessage } from "ai";
-import type { AskPart, FileReferencePart, PlanPart, PresentationPart, PreviewPart, DataPreviewFailedPart, RunCardPart } from "../contracts/chat-parts.js";
+import type { AskPart, FileReferencePart, PlanPart, PresentationPart, PreviewPart, DataPreviewFailedPart, ReportSessionStartedPart, RunCardPart } from "../contracts/chat-parts.js";
 import type { ToolCallOutcome } from "../contracts/chat-events.js";
 import type { CortexMessage, CortexPart, ToolCallPart } from "../contracts/message.js";
 export declare const SUPPORTED_DISPLAY_SCHEMA_VERSION = 1;
@@ -40,6 +40,7 @@ export type ConversationUIData = {
     ask: Payload<AskPart>;
     "report-preview": Payload<PreviewPart>;
     "report-preview-failed": Payload<DataPreviewFailedPart>;
+    "report-session-started": Payload<ReportSessionStartedPart>;
 };
 export interface ConversationDisplayMetadata {
     interrupted?: boolean;

package/dist/memory/conversation-display-storage.js

@@ -16,7 +16,7 @@
  */
 import { validateUIMessages } from "ai";
 import { z } from "zod";
-import { AskPartSchema, DataPreviewFailedPartSchema, FileReferencePartSchema, PlanPartSchema, PresentationPartSchema, PreviewPartSchema, RunCardPartSchema, } from "../contracts/schemas/chat-parts.js";
+import { AskPartSchema, DataPreviewFailedPartSchema, FileReferencePartSchema, PlanPartSchema, PresentationPartSchema, PreviewPartSchema, ReportSessionStartedPartSchema, RunCardPartSchema, } from "../contracts/schemas/chat-parts.js";
 import { ToolCallOutcomeSchema } from "../contracts/schemas/chat-events.js";
 export const SUPPORTED_DISPLAY_SCHEMA_VERSION = 1;
 const DisplayEnvelopeHeaderSchema = z.object({
@@ -56,6 +56,7 @@ const dataSchemas = {
     ask: AskPartSchema.omit({ type: true }).strict(),
     "report-preview": PreviewPartSchema.omit({ type: true }).strict(),
     "report-preview-failed": DataPreviewFailedPartSchema.omit({ type: true }).strict(),
+    "report-session-started": ReportSessionStartedPartSchema.omit({ type: true }).strict(),
 };
 export function envelopeDisplayMessages(messages) {
     if (messages.length === 0)

package/dist/memory/tool-call-integrity.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Transcript integrity for tool calls.
+ *
+ * The wire contract of every provider is that each tool call in an assistant
+ * message has a matching tool result. A transcript that violates it is refused
+ * WHOLE — the AI SDK throws at prompt conversion, and the Anthropic API answers
+ * 400 — so a single unanswered call makes a thread unable to take any further
+ * turn. An unanswered call is a reachable state, not a hypothetical: a reply
+ * can carry a complete tool call beside ANY finish reason, because the call
+ * streams before the stop reason arrives, and only a `tool-calls` (and, for its
+ * leading calls, a `length`) finish dispatches it.
+ *
+ * The repair is a STRIP, never an invented result. A call that was not
+ * dispatched did not happen, and a fabricated result would record an execution
+ * that did not occur — the model would read it as ground truth on the next
+ * turn. The prose of the message survives the strip; a message left with
+ * nothing the wire can render disappears entirely.
+ */
+import type { ModelMessage } from "ai";
+/** One tool call removed by {@link stripUnansweredToolCalls}, identified for the caller's diagnostic record. */
+export interface DroppedToolCall {
+    readonly toolCallId: string;
+    readonly toolName: string;
+}
+/**
+ * Remove, in place, every tool-call part at or past `fromIndex` that has no
+ * matching tool result anywhere in `messages`. Returns the removed calls in
+ * transcript order — empty on the healthy path — so the caller can log what
+ * a reader of the stored thread would otherwise never learn.
+ *
+ * Results are matched by id across the whole array, not by adjacency: the loop
+ * appends a round's results directly after its assistant message, but a
+ * deferred-image user message can ride between rounds, and the stored shape is
+ * not this function's to assume.
+ *
+ * A message that keeps a text or file part survives the strip — refusal prose
+ * is the one account the reader has of a filtered reply. A message left with
+ * no such part (a call-only message, or reasoning beside the removed call) is
+ * removed whole: reasoning without the output it preceded is not replayable,
+ * and an empty assistant message is itself a wire violation.
+ *
+ * `fromIndex` bounds the REPAIR, not the result scan. The loop passes its
+ * `initial.length` so it never rewrites the caller's prefix; the assembly
+ * repair passes nothing and covers the whole stored window.
+ */
+export declare function stripUnansweredToolCalls(messages: ModelMessage[], fromIndex?: number): DroppedToolCall[];

package/dist/memory/tool-call-integrity.js

@@ -0,0 +1,92 @@
+/**
+ * Transcript integrity for tool calls.
+ *
+ * The wire contract of every provider is that each tool call in an assistant
+ * message has a matching tool result. A transcript that violates it is refused
+ * WHOLE — the AI SDK throws at prompt conversion, and the Anthropic API answers
+ * 400 — so a single unanswered call makes a thread unable to take any further
+ * turn. An unanswered call is a reachable state, not a hypothetical: a reply
+ * can carry a complete tool call beside ANY finish reason, because the call
+ * streams before the stop reason arrives, and only a `tool-calls` (and, for its
+ * leading calls, a `length`) finish dispatches it.
+ *
+ * The repair is a STRIP, never an invented result. A call that was not
+ * dispatched did not happen, and a fabricated result would record an execution
+ * that did not occur — the model would read it as ground truth on the next
+ * turn. The prose of the message survives the strip; a message left with
+ * nothing the wire can render disappears entirely.
+ */
+/**
+ * Whether this tool call needs a client-supplied result. A provider-executed
+ * call is answered by the provider inside the same assistant message, so the
+ * wire contract makes no demand on the client for it — the AI SDK's own
+ * missing-result validation skips these, and so does the strip.
+ */
+function needsClientResult(part) {
+    return part.providerExecuted !== true;
+}
+/**
+ * Remove, in place, every tool-call part at or past `fromIndex` that has no
+ * matching tool result anywhere in `messages`. Returns the removed calls in
+ * transcript order — empty on the healthy path — so the caller can log what
+ * a reader of the stored thread would otherwise never learn.
+ *
+ * Results are matched by id across the whole array, not by adjacency: the loop
+ * appends a round's results directly after its assistant message, but a
+ * deferred-image user message can ride between rounds, and the stored shape is
+ * not this function's to assume.
+ *
+ * A message that keeps a text or file part survives the strip — refusal prose
+ * is the one account the reader has of a filtered reply. A message left with
+ * no such part (a call-only message, or reasoning beside the removed call) is
+ * removed whole: reasoning without the output it preceded is not replayable,
+ * and an empty assistant message is itself a wire violation.
+ *
+ * `fromIndex` bounds the REPAIR, not the result scan. The loop passes its
+ * `initial.length` so it never rewrites the caller's prefix; the assembly
+ * repair passes nothing and covers the whole stored window.
+ */
+export function stripUnansweredToolCalls(messages, fromIndex = 0) {
+    const resultIds = new Set();
+    for (const message of messages) {
+        if (message.role === "tool") {
+            for (const part of message.content) {
+                if (part.type === "tool-result")
+                    resultIds.add(part.toolCallId);
+            }
+        }
+        else if (message.role === "assistant" && typeof message.content !== "string") {
+            for (const part of message.content) {
+                if (part.type === "tool-result")
+                    resultIds.add(part.toolCallId);
+            }
+        }
+    }
+    const dropped = [];
+    // Backward, so a whole-message removal cannot shift an index this loop has
+    // yet to visit.
+    for (let idx = messages.length - 1; idx >= fromIndex; idx--) {
+        const message = messages[idx];
+        if (message.role !== "assistant" || typeof message.content === "string")
+            continue;
+        const removed = [];
+        for (const part of message.content) {
+            if (part.type === "tool-call" && needsClientResult(part) && !resultIds.has(part.toolCallId))
+                removed.push(part);
+        }
+        if (removed.length === 0)
+            continue;
+        // Prepended as a batch: the walk visits messages tail-first, but the
+        // caller's record reads in transcript order.
+        dropped.unshift(...removed.map((part) => ({ toolCallId: part.toolCallId, toolName: part.toolName })));
+        const removedParts = new Set(removed);
+        const kept = message.content.filter((part) => !removedParts.has(part));
+        if (kept.some((part) => part.type === "text" || part.type === "file" || part.type === "tool-call" || part.type === "tool-result")) {
+            messages[idx] = { ...message, content: kept };
+        }
+        else {
+            messages.splice(idx, 1);
+        }
+    }
+    return dropped;
+}

package/dist/tools/start-report-session.js

@@ -167,13 +167,23 @@ export function createStartReportSessionTool(deps) {
                 }
             }
             const spawned = await spawn.spawnReportSession(parentThreadId, brief);
-            return ok(spawned.match((child) => ({ outcome: "started", threadId: child.threadId, title: child.title }), (fault) => {
-                const outcome = toOutcome(fault);
-                if (outcome.outcome === "failed") {
-                    logger.warn("the report session did not start", { parentThreadId, reason: fault.type, ...logger.errorFields(causeOf(fault)) });
-                }
-                return outcome;
-            }));
+            if (spawned.isOk()) {
+                const child = spawned.value;
+                // The part rides the started arm only. The existing-session arm
+                // names a session that an earlier turn announced, thus a second
+                // part would put a second entry into the transcript.
+                await ctx.emit({
+                    type: "data-report-session-started",
+                    data: { threadId: child.threadId, parentThreadId },
+                });
+                return ok({ outcome: "started", threadId: child.threadId, title: child.title });
+            }
+            const fault = spawned.error;
+            const outcome = toOutcome(fault);
+            if (outcome.outcome === "failed") {
+                logger.warn("the report session did not start", { parentThreadId, reason: fault.type, ...logger.errorFields(causeOf(fault)) });
+            }
+            return ok(outcome);
         },
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@inflexa-ai/harness",
-    "version": "0.22.1",
+    "version": "0.23.0",
     "description": "Host-agnostic bioinformatics agent harness — hand-rolled agent loop, DBOS-durable workflows, sandboxed compute.",
     "license": "Apache-2.0",
     "type": "module",