@inflexa-ai/harness 0.43.1 → 0.45.0

package/dist/agents/report-session-agent.d.ts

@@ -94,7 +94,7 @@ export interface ReportSessionAgentDeps {
     readonly makeResolver?: (scope: {
         analysisId: string;
         auth: AuthContext;
-    }) => ReferenceResolver;
+    }) => Promise<ReferenceResolver>;
     /**
      * Page-asset lookup -- the preview tool maps the module specifier of a manifest
      * entry onto a file on disk. Omitted falls back to the module resolution of the

package/dist/app/approve-plan.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Approve a stored plan by its id, with no model call.
+ *
+ * A host calls this when a person approves a plan. The function refuses a thread or a plan that does
+ * not belong to the analysis, and a plan that a newer plan replaced. Then it starts the run of the plan,
+ * emits the `approve-plan` provenance event, and appends one record to the thread. The record tells the
+ * model that the run started, and it shows the person the approval and the run card.
+ *
+ * The function is an API boundary: it gives a `Result` for each outcome and never rejects for one. The
+ * host gives the identity and the auth of the session, because the harness forwards the auth and never
+ * mints it. The harness gives the provenance of the session.
+ */
+import { ResultAsync } from "neverthrow";
+import type { AuthContext, Identity } from "../auth/types.js";
+import type { ChatMessage } from "../contracts/message.js";
+import { type ProvenanceSeam } from "../provenance/seam.js";
+import { type LaunchPlanRunDeps, type LaunchPlanRunRefusal } from "../tools/execute-analysis.js";
+/** The deps of an approval: the deps of the launch, and the provenance sink of the host. */
+export type ApprovePlanDeps = LaunchPlanRunDeps & {
+    readonly provenance?: ProvenanceSeam;
+};
+export type ApprovePlanInput = {
+    analysisId: string;
+    threadId: string;
+    planId: string;
+    identity: Identity;
+    auth: AuthContext;
+};
+/**
+ * The outcome of an approval. `started` is false when a run of the plan was already active: the
+ * approval then changed nothing, and `message` is `null`. `message` is also `null` when the record
+ * could not be appended, because the run started anyway. It has no `createdAt`: the transcript read
+ * adds the time of the row.
+ */
+export type PlanApproval = {
+    planId: string;
+    runId: string;
+    started: boolean;
+    message: ChatMessage | null;
+};
+export type ApprovePlanRefusal = LaunchPlanRunRefusal | {
+    type: "thread_not_found";
+} | {
+    type: "superseded";
+    supersededBy: string;
+};
+/** Approve the plan `planId` on the thread `threadId` of the analysis, and start its run. */
+export declare function approvePlan(deps: ApprovePlanDeps, input: ApprovePlanInput): ResultAsync<PlanApproval, ApprovePlanRefusal>;

package/dist/app/approve-plan.js

@@ -0,0 +1,84 @@
+/**
+ * Approve a stored plan by its id, with no model call.
+ *
+ * A host calls this when a person approves a plan. The function refuses a thread or a plan that does
+ * not belong to the analysis, and a plan that a newer plan replaced. Then it starts the run of the plan,
+ * emits the `approve-plan` provenance event, and appends one record to the thread. The record tells the
+ * model that the run started, and it shows the person the approval and the run card.
+ *
+ * The function is an API boundary: it gives a `Result` for each outcome and never rejects for one. The
+ * host gives the identity and the auth of the session, because the harness forwards the auth and never
+ * mints it. The harness gives the provenance of the session.
+ */
+import { ResultAsync, err, ok } from "neverthrow";
+import { createNoopLogger } from "../lib/console-logger.js";
+import { buildRunCardData } from "../memory/card-builders.js";
+import { conversationUIToChatMessages } from "../memory/conversation-display-storage.js";
+import { conversationRecordTurn, createThreadHistory } from "../memory/thread-history.js";
+import { createThreadStore } from "../memory/thread-store.js";
+import { bindSessionEmit } from "../provenance/seam.js";
+import { loadPlanRecord } from "../state/index.js";
+import { launchPlanRun } from "../tools/execute-analysis.js";
+const APPROVAL_PROVENANCE = { agentId: "plan-approval", callPath: ["plan-approval"] };
+function storeFailed(cause) {
+    return err({ type: "store_failed", cause });
+}
+/** The refusals that need no launch: a thread or a plan that does not belong, and a replaced plan. */
+async function checkApprovable(deps, input) {
+    const read = await ResultAsync.combine([
+        createThreadStore(deps.pool).getThread(input.threadId),
+        loadPlanRecord(deps.pool, input.planId, { analysisId: input.analysisId }),
+    ]);
+    if (read.isErr())
+        return storeFailed(read.error);
+    const [thread, record] = read.value;
+    if (thread === null || thread.analysisId !== input.analysisId)
+        return err({ type: "thread_not_found" });
+    if (record === null)
+        return err({ type: "plan_not_found", planId: input.planId });
+    if (record.supersededBy !== null)
+        return err({ type: "superseded", supersededBy: record.supersededBy });
+    return ok(undefined);
+}
+async function approve(deps, input) {
+    const logger = (deps.logger ?? createNoopLogger()).named("approve-plan");
+    const { analysisId, threadId, planId } = input;
+    const approvable = await checkApprovable(deps, input);
+    if (approvable.isErr())
+        return err(approvable.error);
+    // Read before the launch: the kernel writes the approval at this time, and the run writes
+    // `run_started` from its workflow body after the launch, so the approval precedes the start.
+    const approvedAtMs = Date.now();
+    const session = {
+        identity: input.identity,
+        auth: input.auth,
+        scope: { kind: "analysis", analysisId, threadId },
+        provenance: APPROVAL_PROVENANCE,
+    };
+    const launched = await launchPlanRun(deps, { session, planId });
+    if (launched.isErr())
+        return err(launched.error);
+    const { runId, started } = launched.value;
+    if (!started)
+        return ok({ planId, runId, started: false, message: null });
+    bindSessionEmit(deps.provenance, logger)({ type: "approve-plan", analysisId, threadId, planId, runId, atMs: approvedAtMs });
+    const card = await buildRunCardData(deps.pool, { planId, analysisId, runId }).match((data) => data, (cause) => {
+        logger.error("the run card of an approval could not be read", { analysisId, threadId, planId, runId, ...logger.errorFields(cause) });
+        return null;
+    });
+    const approval = { type: "data-plan-approval", planId, runId, approvedAt: new Date(approvedAtMs).toISOString() };
+    const turn = conversationRecordTurn(`The person approved plan ${planId}. Run ${runId} started.`, [
+        approval,
+        ...(card === null ? [] : [{ type: "data-run-card", ...card }]),
+    ]);
+    const appended = await createThreadHistory(deps.pool, logger).appendTurn(threadId, turn);
+    if (appended.isErr()) {
+        logger.error("the approval record could not be appended", { analysisId, threadId, planId, runId, ...logger.errorFields(appended.error) });
+        return ok({ planId, runId, started: true, message: null });
+    }
+    return ok({ planId, runId, started: true, message: conversationUIToChatMessages(turn.displayMessages)[0] ?? null });
+}
+/** Approve the plan `planId` on the thread `threadId` of the analysis, and start its run. */
+export function approvePlan(deps, input) {
+    return new ResultAsync(approve(deps, input));
+}

package/dist/app/data-profile-view.d.ts

@@ -65,6 +65,6 @@ export declare function profileFileRecords(result: DataProfileResult): DataProfi
  * rows fall back to coverage, then to summed kind counts, then to `null`: reporting the
  * described-file count would be a dataset size the row cannot support.
  */
-export declare function profileDatasetFileCount(result: DataProfileResult): number | null;
+export declare function profileDatasetFileCount(result: Pick<DataProfileResult, "partition" | "coverage" | "kinds">): number | null;
 /** Dataset-wide findings the agent wrote, from whichever field the snapshot carries them in. */
 export declare function profileCaveats(result: DataProfileResult): string[];

package/dist/app/run-activity.js

@@ -4,21 +4,19 @@
  */
 /** Maximum detailed run rows paid into every conversation turn. */
 export const RUN_ACTIVITY_DETAIL_LIMIT = 20;
-function renderRows(label, rows) {
+function renderRows(rows) {
     if (rows.length === 0)
         return [];
-    return [`${label}:`, ...rows.map((run) => `- runId: ${run.runId} | planId: ${run.planId ?? "none"} | startedAt: ${run.startedAt}`)];
+    return ["Running:", ...rows.map((run) => `- runId: ${run.runId} | planId: ${run.planId ?? "none"} | startedAt: ${run.startedAt}`)];
 }
 /** Render the bounded run-activity snapshot of a conversation turn. */
 export function renderRunActivity(activity) {
     const lines = ["[Run Activity]"];
     if (activity.total === 0) {
-        lines.push("No runs are currently running or suspended.");
+        lines.push("No runs are currently running.");
         return lines.join("\n");
     }
-    const running = activity.runs.filter((run) => run.status === "running");
-    const suspended = activity.runs.filter((run) => run.status === "suspended_insufficient_funds");
-    lines.push(...renderRows("Running", running), ...renderRows("Suspended", suspended));
+    lines.push(...renderRows(activity.runs.filter((run) => run.status === "running")));
     const omitted = activity.total - activity.runs.length;
     if (omitted > 0) {
         lines.push(`Showing ${activity.runs.length} of ${activity.total} non-terminal runs; ${omitted} omitted. Use inspect_run to page the full list.`);

package/dist/app/synthesize-run.js

@@ -26,7 +26,7 @@ export async function synthesizeRun(deps, params) {
     const { analysisId, runId, completedSteps, session, emit, onProgress } = params;
     await onProgress("starting", "Beginning literature-grounded synthesis");
     try {
-        const workspaceRoot = resolveWorkspaceRoot(analysisId);
+        const workspaceRoot = await resolveWorkspaceRoot(analysisId);
         const summaries = await loadStepSummariesFromDisk({
             workspaceRoot,
             runId,

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

@@ -20,6 +20,8 @@ import type { TokenUsageRollup } from "./usage.js";
 export interface EventSource {
     agentId: string;
     callPath: string[];
+    /** The id of the tool call that runs this loop. For a data profile, the workflow id of its attempt. */
+    invocationId?: string;
 }
 /** A run of assistant text. Deltas accumulate into the turn's reply. */
 export interface TextDeltaEvent {

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

@@ -16,6 +16,13 @@ export type ChatPartCheck = {
     readonly ok: false;
     readonly error: string;
 };
+/**
+ * The wire shape of a data part, `{ ...data, type }`, which is the flat shape of the part contracts. The chat stream
+ * and the run streams use this one rule.
+ */
+export declare function flattenDataPart(part: Pick<ChatDataPart, "type" | "data">): {
+    type: `data-${string}`;
+} & Record<string, unknown>;
 /**
  * The frame of one emitted event, or `null` for `done` and for an `iteration` of the root agent. A frame of a sub-agent
  * keeps its source, thus a consumer can filter it. A `text-delta` has no source, thus its frame gets `fallbackSource`,

package/dist/contracts/chat-frame.js

@@ -3,7 +3,22 @@ import { isReconciling, PART_REGISTRY } from "./part-registry.js";
 import { EventSourceSchema } from "./schemas/chat-events.js";
 import { ChatPartSchema } from "./schemas/chat-parts.js";
 function toSource(source) {
-    return { agentId: source.agentId, callPath: [...source.callPath] };
+    return {
+        agentId: source.agentId,
+        callPath: [...source.callPath],
+        ...(source.invocationId === undefined ? {} : { invocationId: source.invocationId }),
+    };
+}
+/**
+ * The wire shape of a data part, `{ ...data, type }`, which is the flat shape of the part contracts. The chat stream
+ * and the run streams use this one rule.
+ */
+export function flattenDataPart(part) {
+    // The payload is `unknown`, and the spread is not checked here. The chat stream checks each frame with `checkChatPart`.
+    // On the run stream the producer builds the payload with the fields of its part contract, and the synthesis-sink test
+    // parses the result with `RunSynthesisPartSchema`.
+    const data = (part.data ?? {});
+    return { ...data, type: part.type };
 }
 /**
  * The frame of one emitted event, or `null` for `done` and for an `iteration` of the root agent. A frame of a sub-agent
@@ -39,10 +54,9 @@ export function toChatFrame(event, fallbackSource) {
         case "text-delta":
             return { type: "text-delta", text: event.text, source: toSource(fallbackSource) };
         default: {
-            // A `ChatDataPart`, whose payload the emitter types as `unknown`. The wire part is flat: `{ type, ...data }`.
             // The cast names the frame that the type claims. `checkChatPart` is the check.
-            const data = (event.data ?? {});
-            return { ...data, type: event.type, ...(event.source === undefined ? {} : { source: toSource(event.source) }) };
+            const part = flattenDataPart(event);
+            return { ...part, ...(event.source === undefined ? {} : { source: toSource(event.source) }) };
         }
     }
 }

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

@@ -5,13 +5,16 @@
  * Categories:
  *   Presentation:    data-presentation (agent-synthesized content),
  *                    data-plan (plan by id), data-file-reference (files by path)
- *   Approval:        data-ask (a tool's pending user-approval prompt)
+ *   Approval:        data-ask (a tool's pending user-approval prompt),
+ *                    data-plan-approval (the record of an approved plan)
  *   Compaction:      data-compaction (a compaction of the conversation thread)
  *   Run lifecycle:   run-started, dag-state, run-completed, run-failed, run-synthesis,
  *                    synthesis-progress
  *   Per-step live:   step-activity, step-file-tree
+ *   Activity history: activity-entry (run stream), subagent-activity (conversation)
  *   Per-step final:  step-output, step-summary, step-usage
  */
+import type { ToolCallOutcome } from "./chat-events.js";
 import type { TokenUsageRollup } from "./usage.js";
 export interface PlanStep {
     id: string;
@@ -78,6 +81,8 @@ export interface PlanPart {
     type: "data-plan";
     id: string;
     planId: string;
+    /** The plan that this plan revised. Absent for a first plan. */
+    parentPlanId?: string;
     title?: string;
     steps?: PlanStep[];
     analytical_narrative?: string;
@@ -92,6 +97,14 @@ export interface RunCardPart {
     title: string;
     stepCount: number;
 }
+export interface PlanApprovalPart {
+    type: "data-plan-approval";
+    planId: string;
+    /** The run that the approval started. */
+    runId: string;
+    /** ISO 8601. The instant of the approval, equal to the time of the `approve-plan` provenance event. */
+    approvedAt: string;
+}
 export interface FileReferenceEntry {
     path: string;
     runId?: string;
@@ -119,6 +132,8 @@ export interface AskPart {
     /** Optional additional detail a surface may render. */
     detail?: string;
     status: "pending" | "resolved" | "rejected" | "aborted" | "expired";
+    /** The kind of the ledger reply. Only a `resolved` or `rejected` part carries it, and never the rejection feedback. */
+    reply?: "once" | "always" | "reject";
 }
 export interface RunStartedPart {
     type: "data-run-started";
@@ -152,6 +167,8 @@ export interface DagStepState {
     /** Error message (set on failure). */
     error?: string;
 }
+/** One step of the stored plan graph: the fields of {@link DagStepState} that the plan alone fixes. */
+export type PlanGraphStep = Pick<DagStepState, "id" | "name" | "agent" | "dependsOn" | "level">;
 export interface DagStatePart {
     type: "data-dag-state";
     /** Stable ID for reconciliation — same across all updates for a run. */
@@ -176,6 +193,24 @@ export interface StepActivityPart {
     phase: StepPhase;
     /** Human-readable activity description (e.g., "Running DESeq2 analysis"). */
     activity: string;
+    /** ISO 8601 time of the emission. Absent on a part that an older harness wrote. */
+    at?: string;
+}
+/**
+ * One activity emission of a step or a data profile, kept in the run stream with no reconciliation. The fold
+ * delivers each entry in write order.
+ */
+export interface ActivityEntryPart {
+    type: "data-activity-entry";
+    /** Unique per emission within a stream. */
+    id: string;
+    runId: string;
+    stepId: string;
+    /** A `SynthesisPhase` for the entries of the synthesis step, a `StepPhase` for each other step. */
+    phase: StepPhase | SynthesisPhase;
+    activity: string;
+    /** ISO 8601 time of the emission. */
+    at: string;
 }
 export interface FileTreeEntry {
     path: string;
@@ -290,6 +325,12 @@ export interface RunCompletedPart {
      */
     usage?: TokenUsageRollup;
 }
+export interface FindingReference {
+    pmid: string;
+    citation: string;
+    relevance: string;
+    concordance: "supports" | "contradicts" | "extends" | "contextualizes";
+}
 export interface SynthesizedFinding {
     stepId: string;
     title: string;
@@ -297,6 +338,7 @@ export interface SynthesizedFinding {
     confidence: "high" | "medium" | "low";
     noveltyStatus: "novel" | "confirmed" | "partially_confirmed" | "contradicted" | "expected";
     literatureInterpretation: string;
+    references: FindingReference[];
 }
 export interface BiologicalTheme {
     name: string;
@@ -336,6 +378,8 @@ export interface SynthesisProgressPart {
     phase: SynthesisPhase;
     /** Human-readable activity description. */
     activity: string;
+    /** ISO 8601 time of the emission. Absent in a stream that an older harness wrote. */
+    at?: string;
     /** Number of literature-reviewer delegations started so far. */
     delegationCount?: number;
     /** Agent-provided reason — set when phase === "skipped". */
@@ -407,4 +451,31 @@ export interface CompactionPart {
     /** Before the user message of a turn, or before a later request. */
     trigger?: "turn-start" | "mid-turn";
 }
-export type ChatPart = PresentationPart | PlanPart | RunCardPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | ChildSessionStartedPart | ReportRenderedPart | CompactionPart;
+/** One tool call of a sub-agent. It holds no input, no output, and no text of the sub-agent. */
+export interface SubAgentActivityEntry {
+    agentId: string;
+    callPath: string[];
+    tool: string;
+    /** The one-line detail of the call, normalized, redacted, and capped by the loop. */
+    label?: string;
+    /** ISO 8601. */
+    startedAt: string;
+    /** ISO 8601. Absent while the call is in flight and for an `incomplete` call. */
+    endedAt?: string;
+    /** Absent while the call is in flight. A stored entry always has it. */
+    outcome?: ToolCallOutcome;
+}
+/**
+ * The tool calls of the sub-agents below one root tool call. Re-emitted under the same `id` after each change,
+ * so reconciling readers keep the latest list.
+ */
+export interface SubAgentActivityPart {
+    type: "data-subagent-activity";
+    id: string;
+    /** The id of the root tool call. */
+    toolCallId: string;
+    entries: SubAgentActivityEntry[];
+    /** The count of calls past the cap of the entries. */
+    dropped: number;
+}
+export type ChatPart = PresentationPart | PlanPart | RunCardPart | PlanApprovalPart | FileReferencePart | AskPart | RunStartedPart | DagStatePart | StepActivityPart | ActivityEntryPart | SubAgentActivityPart | StepFileTreePart | StepOutputPart | StepSummaryPart | StepUsagePart | StepBlockedPart | RunSynthesisPart | SynthesisProgressPart | RunCompletedPart | RunFailedPart | ChildSessionStartedPart | ReportRenderedPart | CompactionPart;

package/dist/contracts/chat-parts.js

@@ -5,11 +5,13 @@
  * Categories:
  *   Presentation:    data-presentation (agent-synthesized content),
  *                    data-plan (plan by id), data-file-reference (files by path)
- *   Approval:        data-ask (a tool's pending user-approval prompt)
+ *   Approval:        data-ask (a tool's pending user-approval prompt),
+ *                    data-plan-approval (the record of an approved plan)
  *   Compaction:      data-compaction (a compaction of the conversation thread)
  *   Run lifecycle:   run-started, dag-state, run-completed, run-failed, run-synthesis,
  *                    synthesis-progress
  *   Per-step live:   step-activity, step-file-tree
+ *   Activity history: activity-entry (run stream), subagent-activity (conversation)
  *   Per-step final:  step-output, step-summary, step-usage
  */
 export {};

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, ChildSessionStartedPart, ReportRenderedPart, CompactionPart, ChatPart, } from "./chat-parts.js";
+export type { PlanStep, PresentationContent, PresentationPart, PlanPart, RunCardPart, PlanApprovalPart, FileReferenceEntry, FileReferencePart, AskPart, RunStartedPart, StepStatus, DagStepState, PlanGraphStep, DagStatePart, StepPhase, StepActivityPart, ActivityEntryPart, SubAgentActivityEntry, SubAgentActivityPart, FileTreeEntry, StepFileTreePart, StepOutputFile, StepOutputPart, StepSummaryPart, StepUsagePart, StepBlockedPart, FindingReference, SynthesizedFinding, BiologicalTheme, RunSynthesisPart, SynthesisPhase, SynthesisProgressPart, RunCompletedFinding, RunCompletedPart, RunFailedPart, ChildSessionStartedPart, ReportRenderedPart, CompactionPart, ChatPart, } from "./chat-parts.js";
 export type { EventSource, TextDeltaEvent, IterationEvent, ToolStartedEvent, ToolFinishedEvent, FinishEvent, ChatErrorEvent, ChatEvent, ChatFrame, ChatPartFrame, } from "./chat-events.js";
 export type { TokenUsageRollup } from "./usage.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";
@@ -12,6 +12,8 @@ export type { DimensionCategory, DimensionCategoryEntry, DimensionProbe, Dimensi
 export type { TextPart, ToolCallPart, MessagePart, ChatMessage } from "./message.js";
 export { toChatFrame, applyChatFrame, checkChatPart } from "./chat-frame.js";
 export type { TurnTerminal, ApplyFrameResult, ChatPartCheck } from "./chat-frame.js";
+export { createSubAgentActivityTracker, SUBAGENT_ACTIVITY_MAX_ENTRIES } from "./subagent-activity.js";
+export type { SubAgentActivityTracker } from "./subagent-activity.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./part-registry.js";
 export type { ChatPartType, PartDescriptor, PartEmitter, PartConsumer } from "./part-registry.js";
 export { AnalogyCoverageSchema, AnalogyReportSchema, AnalogyReportErrorSchema, AnalogicalReasonerOutputSchema } from "./analogy-report.js";

package/dist/contracts/index.js

@@ -3,6 +3,7 @@ export { SEVERITIES, SeveritySchema } from "./severity.js";
 export { DATA_PROFILE_RUN_LITERAL } from "./data-profile.js";
 export { DIMENSION_CATEGORIES, DIMENSION_CATEGORY_IDS, DIMENSION_PROBE_IDS, DIMENSION_PROBES, GROUP_CATEGORIES, GROUP_CATEGORY_IDS, GROUP_ROLE_IDS, GROUP_ROLES, PROBE_OUTCOME_IDS, dimensionCategoryEntry, dimensionScope, groupCategoryEntry, } from "./profile-vocabulary.js";
 export { toChatFrame, applyChatFrame, checkChatPart } from "./chat-frame.js";
+export { createSubAgentActivityTracker, SUBAGENT_ACTIVITY_MAX_ENTRIES } from "./subagent-activity.js";
 export { PART_REGISTRY, isTransient, isReconciling, isSidebarPart } from "./part-registry.js";
 export { AnalogyCoverageSchema, AnalogyReportSchema, AnalogyReportErrorSchema, AnalogicalReasonerOutputSchema } from "./analogy-report.js";
 export { buildReportSessionUrl, reportSessionResourceId } from "./content-url.js";

package/dist/contracts/part-registry.js

@@ -2,11 +2,14 @@ export const PART_REGISTRY = {
     "data-presentation": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
     "data-plan": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
     "data-run-card": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
+    "data-plan-approval": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
     "data-file-reference": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: false },
     "data-ask": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: true },
     "data-run-started": { emitter: "workflow", consumer: "sidebar", transient: true, reconciling: false },
     "data-dag-state": { emitter: "workflow", consumer: "sidebar", transient: false, reconciling: true },
     "data-step-activity": { emitter: "workflow", consumer: "sidebar", transient: true, reconciling: true },
+    "data-activity-entry": { emitter: "workflow", consumer: "sidebar", transient: false, reconciling: false },
+    "data-subagent-activity": { emitter: "conversation", consumer: "conversation", transient: false, reconciling: true },
     "data-step-file-tree": { emitter: "workflow", consumer: "sidebar", transient: true, reconciling: true },
     "data-step-output": { emitter: "workflow", consumer: "sidebar", transient: false, reconciling: false },
     "data-step-summary": { emitter: "workflow", consumer: "sidebar", transient: false, reconciling: false },

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

@@ -5,6 +5,7 @@ import { z } from "zod";
 export declare const EventSourceSchema: z.ZodObject<{
     agentId: z.ZodString;
     callPath: z.ZodArray<z.ZodString>;
+    invocationId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const TextDeltaEventSchema: z.ZodObject<{
     type: z.ZodLiteral<"text-delta">;
@@ -12,6 +13,7 @@ export declare const TextDeltaEventSchema: z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const IterationEventSchema: z.ZodObject<{
@@ -19,6 +21,7 @@ export declare const IterationEventSchema: z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 /** Mirrors the `ToolOutcome` union — three states, never a boolean. */
@@ -42,6 +45,7 @@ export declare const ToolStartedEventSchema: z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const ToolFinishedEventSchema: z.ZodObject<{
@@ -58,6 +62,7 @@ export declare const ToolFinishedEventSchema: z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const FinishEventSchema: z.ZodObject<{
@@ -65,6 +70,7 @@ export declare const FinishEventSchema: z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     usage: z.ZodOptional<z.ZodObject<{
         inputTokens: z.ZodOptional<z.ZodNumber>;
@@ -88,6 +94,7 @@ export declare const ChatErrorEventSchema: z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>;
 export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -96,12 +103,14 @@ export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"iteration">;
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"tool-started">;
@@ -111,6 +120,7 @@ export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"tool-finished">;
@@ -126,12 +136,14 @@ export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>, z.ZodObject<{
     type: z.ZodLiteral<"finish">;
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
     usage: z.ZodOptional<z.ZodObject<{
         inputTokens: z.ZodOptional<z.ZodNumber>;
@@ -154,5 +166,6 @@ export declare const ChatEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
     source: z.ZodObject<{
         agentId: z.ZodString;
         callPath: z.ZodArray<z.ZodString>;
+        invocationId: z.ZodOptional<z.ZodString>;
     }, z.core.$strip>;
 }, z.core.$strip>], "type">;

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

@@ -6,6 +6,7 @@ import { TokenUsageRollupSchema } from "./usage.js";
 export const EventSourceSchema = z.object({
     agentId: z.string(),
     callPath: z.array(z.string()),
+    invocationId: z.string().optional(),
 });
 export const TextDeltaEventSchema = z.object({
     type: z.literal("text-delta"),