@stigmer/react 3.0.9-dev.20260616060535 → 3.1.1

package/src/session/inspector/SetupTab.tsx

@@ -2,10 +2,10 @@
 
 import type { McpServerUsageInput, ResourceRef } from "@stigmer/sdk";
 import { cn } from "@stigmer/theme";
-import type { HarnessOption } from "../../models/harness";
-import { HARNESS_META } from "../../models/harness";
-import type { ExecutionTargetOption } from "../execution-target";
-import type { UseSessionVariablesReturn } from "../../execution/useSessionVariables";
+import type { HarnessOption } from "../../models/harness.js";
+import { HARNESS_META } from "../../models/harness.js";
+import type { ExecutionTargetOption } from "../execution-target.js";
+import type { UseSessionVariablesReturn } from "../../execution/useSessionVariables.js";
 
 /** Interactive mutation callbacks for config items in SetupTab. */
 export interface SetupTabMutationCallbacks {

package/src/session/inspector/UsageTab.tsx

@@ -1,8 +1,8 @@
 "use client";
 
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
-import { useSessionUsage } from "../useSessionUsage";
-import { UsageWidget } from "../../execution/UsageWidget";
+import { useSessionUsage } from "../useSessionUsage.js";
+import { UsageWidget } from "../../execution/UsageWidget.js";
 
 export interface UsageTabProps {
   readonly executions: readonly AgentExecution[];

package/src/session/inspector/WorkspaceTab.tsx

@@ -2,10 +2,10 @@
 
 import { useCallback, useState } from "react";
 import { cn } from "@stigmer/theme";
-import type { UseWorkspaceEntriesReturn, WorkspaceEntry } from "../../workspace/useWorkspaceEntries";
-import type { WorkspaceFileLister } from "../../workspace/WorkspaceFileLister";
-import { WorkspaceEntryFiles } from "../../workspace/WorkspaceEntryFiles";
-import type { UseGitHubConnectionReturn } from "../../github/useGitHubConnection";
+import type { UseWorkspaceEntriesReturn, WorkspaceEntry } from "../../workspace/useWorkspaceEntries.js";
+import type { WorkspaceFileLister } from "../../workspace/WorkspaceFileLister.js";
+import { WorkspaceEntryFiles } from "../../workspace/WorkspaceEntryFiles.js";
+import type { UseGitHubConnectionReturn } from "../../github/useGitHubConnection.js";
 
 /**
  * Interactive workspace actions required by the Workspace tab.

package/src/session/inspector/__tests__/ArtifactsTab.test.tsx

@@ -18,7 +18,6 @@ function artifact(name: string) {
     sizeBytes: 1024n,
     sandboxPath: `.stigmer/${name}`,
     storageKey: `artifacts/aex_1/${name}`,
-    downloadUrl: `https://example.test/${name}`,
   });
 }
 

package/src/session/inspector/__tests__/ChangesTab.test.tsx

@@ -0,0 +1,38 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup } from "@testing-library/react";
+
+const writeBacksReturn = { writeBacks: [] as Array<{ writeBack: { workspaceEntryName: string } }>, hasWriteBacks: false };
+
+vi.mock("../../useSessionWriteBacks", () => ({
+  useSessionWriteBacks: () => writeBacksReturn,
+}));
+vi.mock("../../../execution/WriteBackCard", () => ({
+  WriteBackCard: () => <div data-testid="write-back-card" />,
+}));
+
+const { ChangesTab } = await import("../ChangesTab");
+
+beforeEach(() => {
+  writeBacksReturn.writeBacks = [];
+  writeBacksReturn.hasWriteBacks = false;
+});
+
+afterEach(() => cleanup());
+
+describe("ChangesTab", () => {
+  it("renders write-back (PR) cards", () => {
+    writeBacksReturn.writeBacks = [{ writeBack: { workspaceEntryName: "w1" } }];
+    writeBacksReturn.hasWriteBacks = true;
+
+    render(<ChangesTab executions={[]} />);
+    expect(screen.getByTestId("write-back-card")).toBeTruthy();
+  });
+
+  // Local file changes render in the transcript (edit rows + decision bar),
+  // never here — the tab is exclusively the write-back (PR) surface.
+  it("renders the PR-oriented empty state when no write-back exists", () => {
+    render(<ChangesTab executions={[]} />);
+    expect(screen.getByText(/no changes yet/i)).toBeTruthy();
+    expect(screen.getByText(/pull requests/i)).toBeTruthy();
+  });
+});

package/src/session/inspector/__tests__/useSessionInspector.test.ts

@@ -20,25 +20,32 @@ function defaultOpts(overrides?: Partial<UseSessionInspectorOptions>): UseSessio
   };
 }
 
+function tabOpts(
+  overrides?: Partial<Parameters<typeof buildVisibleTabs>[0]>,
+): Parameters<typeof buildVisibleTabs>[0] {
+  return {
+    hasWriteBacks: false,
+    writeBackCount: 0,
+    hasArtifacts: false,
+    artifactCount: 0,
+    hasUsage: false,
+    selectedItem: null,
+    ...overrides,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // buildVisibleTabs
 // ---------------------------------------------------------------------------
 
 describe("buildVisibleTabs", () => {
-  it("always includes Workspace, Config, Plan, and Usage", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: false,
-      writeBackCount: 0,
-      hasArtifacts: false,
-      artifactCount: 0,
-      hasUsage: false,
-      selectedItem: null,
-    });
+  it("always includes Workspace, Config, and Usage (Plan is gone — todos render inline)", () => {
+    const tabs = buildVisibleTabs(tabOpts());
     const ids = tabs.map((t) => t.id);
     expect(ids).toContain("workspace");
     expect(ids).toContain("configure");
-    expect(ids).toContain("plan");
     expect(ids).toContain("usage");
+    expect(ids).not.toContain("plan");
     expect(ids).not.toContain("changes");
     expect(ids).not.toContain("artifacts");
     expect(ids).not.toContain("inspect");
@@ -47,74 +54,52 @@ describe("buildVisibleTabs", () => {
     expect(configTab?.label).toBe("Config");
   });
 
-  it("includes Changes with badge when write-backs exist", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: true,
-      writeBackCount: 3,
-      hasArtifacts: false,
-      artifactCount: 0,
-      hasUsage: false,
-      selectedItem: null,
-    });
+  // The Changes tab is exclusively the write-back (PR) surface: local file
+  // changes render in the transcript (edit rows + decision bar) and no longer
+  // surface — or badge — a tab.
+  it("includes Changes with badge only when write-backs exist", () => {
+    const tabs = buildVisibleTabs(tabOpts({ hasWriteBacks: true, writeBackCount: 3 }));
     const changesTab = tabs.find((t) => t.id === "changes");
     expect(changesTab).toBeDefined();
     expect(changesTab?.badge).toBe(3);
   });
 
   it("includes Artifacts with badge when artifacts exist", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: false,
-      writeBackCount: 0,
-      hasArtifacts: true,
-      artifactCount: 7,
-      hasUsage: false,
-      selectedItem: null,
-    });
+    const tabs = buildVisibleTabs(tabOpts({ hasArtifacts: true, artifactCount: 7 }));
     const artifactsTab = tabs.find((t) => t.id === "artifacts");
     expect(artifactsTab).toBeDefined();
     expect(artifactsTab?.badge).toBe(7);
   });
 
   it("includes Inspect when a thread item is selected", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: false,
-      writeBackCount: 0,
-      hasArtifacts: false,
-      artifactCount: 0,
-      hasUsage: false,
-      selectedItem: { kind: "tool-call", toolCallId: "tc-1" },
-    });
+    const tabs = buildVisibleTabs(
+      tabOpts({ selectedItem: { kind: "tool-call", toolCallId: "tc-1" } }),
+    );
     const inspectTab = tabs.find((t) => t.id === "inspect");
     expect(inspectTab).toBeDefined();
   });
 
-  it("orders tabs as Workspace, Config, Plan, then Usage with Inspect last", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: true,
-      writeBackCount: 2,
-      hasArtifacts: true,
-      artifactCount: 1,
-      hasUsage: true,
-      selectedItem: { kind: "tool-call", toolCallId: "tc-1" },
-    });
+  it("orders tabs as Workspace, Config, then Usage with Inspect last", () => {
+    const tabs = buildVisibleTabs(
+      tabOpts({
+        hasWriteBacks: true,
+        writeBackCount: 2,
+        hasArtifacts: true,
+        artifactCount: 1,
+        hasUsage: true,
+        selectedItem: { kind: "tool-call", toolCallId: "tc-1" },
+      }),
+    );
     const ids = tabs.map((t) => t.id);
     expect(ids.indexOf("workspace")).toBeLessThan(ids.indexOf("configure"));
-    expect(ids.indexOf("configure")).toBeLessThan(ids.indexOf("plan"));
-    expect(ids.indexOf("plan")).toBeLessThan(ids.indexOf("usage"));
+    expect(ids.indexOf("configure")).toBeLessThan(ids.indexOf("usage"));
     expect(ids.indexOf("usage")).toBeLessThan(ids.indexOf("inspect"));
   });
 
   it("base tabs are present even when no optional tabs exist", () => {
-    const tabs = buildVisibleTabs({
-      hasWriteBacks: false,
-      writeBackCount: 0,
-      hasArtifacts: false,
-      artifactCount: 0,
-      hasUsage: false,
-      selectedItem: null,
-    });
+    const tabs = buildVisibleTabs(tabOpts());
     const ids = tabs.map((t) => t.id);
-    expect(ids).toEqual(["workspace", "configure", "plan", "usage"]);
+    expect(ids).toEqual(["workspace", "configure", "usage"]);
   });
 });
 
@@ -137,13 +122,13 @@ describe("useSessionInspector", () => {
     expect(result.current.activeTab).toBe("workspace");
   });
 
-  it("defaults to plan while execution is running", () => {
+  it("defaults to workspace while execution is running (todos render inline, not in a tab)", () => {
     const { result } = renderHook(() =>
       useSessionInspector(
         defaultOpts({ phase: ExecutionPhase.EXECUTION_IN_PROGRESS }),
       ),
     );
-    expect(result.current.activeTab).toBe("plan");
+    expect(result.current.activeTab).toBe("workspace");
   });
 
   it("auto-switches to inspect when a thread item is selected", () => {
@@ -174,7 +159,7 @@ describe("useSessionInspector", () => {
     expect(result.current.activeTab).toBe("workspace");
   });
 
-  it("reverts to plan when selection is cleared while execution is running", () => {
+  it("reverts to workspace when selection is cleared while execution is running", () => {
     const { result, rerender } = renderHook(
       (props: UseSessionInspectorOptions) => useSessionInspector(props),
       {
@@ -192,7 +177,7 @@ describe("useSessionInspector", () => {
         selectedItem: null,
       }),
     );
-    expect(result.current.activeTab).toBe("plan");
+    expect(result.current.activeTab).toBe("workspace");
   });
 
   it("keeps user-picked tab sticky", () => {
@@ -247,7 +232,7 @@ describe("useSessionInspector", () => {
     expect(result.current.activeTab).toBe("workspace");
   });
 
-  it("switches to workspace when execution transitions to terminal phase", () => {
+  it("stays on workspace across the running → terminal transition", () => {
     const { result, rerender } = renderHook(
       (props: UseSessionInspectorOptions) => useSessionInspector(props),
       {
@@ -256,7 +241,7 @@ describe("useSessionInspector", () => {
         }),
       },
     );
-    expect(result.current.activeTab).toBe("plan");
+    expect(result.current.activeTab).toBe("workspace");
 
     rerender(
       defaultOpts({ phase: ExecutionPhase.EXECUTION_COMPLETED }),

package/src/session/inspector/index.ts

@@ -1,36 +1,33 @@
-export { SessionInspector } from "./SessionInspector";
-export type { SessionInspectorProps } from "./SessionInspector";
+export { SessionInspector } from "./SessionInspector.js";
+export type { SessionInspectorProps } from "./SessionInspector.js";
 
-export { useSessionInspector, buildVisibleTabs } from "./useSessionInspector";
+export { useSessionInspector, buildVisibleTabs } from "./useSessionInspector.js";
 export type {
   SessionInspectorTabId,
   UseSessionInspectorOptions,
   UseSessionInspectorReturn,
-} from "./useSessionInspector";
+} from "./useSessionInspector.js";
 
-export { PlanTab } from "./PlanTab";
-export type { PlanTabProps } from "./PlanTab";
+export { ChangesTab } from "./ChangesTab.js";
+export type { ChangesTabProps } from "./ChangesTab.js";
 
-export { ChangesTab } from "./ChangesTab";
-export type { ChangesTabProps } from "./ChangesTab";
+export { ArtifactsTab } from "./ArtifactsTab.js";
+export type { ArtifactsTabProps } from "./ArtifactsTab.js";
 
-export { ArtifactsTab } from "./ArtifactsTab";
-export type { ArtifactsTabProps } from "./ArtifactsTab";
+export { UsageTab } from "./UsageTab.js";
+export type { UsageTabProps } from "./UsageTab.js";
 
-export { UsageTab } from "./UsageTab";
-export type { UsageTabProps } from "./UsageTab";
+export { InspectTab } from "./InspectTab.js";
+export type { InspectTabProps } from "./InspectTab.js";
 
-export { InspectTab } from "./InspectTab";
-export type { InspectTabProps } from "./InspectTab";
-
-export { SetupTab } from "./SetupTab";
+export { SetupTab } from "./SetupTab.js";
 export type {
   SetupTabProps,
   SetupTabMutationCallbacks,
-} from "./SetupTab";
+} from "./SetupTab.js";
 
-export { WorkspaceTab } from "./WorkspaceTab";
+export { WorkspaceTab } from "./WorkspaceTab.js";
 export type {
   WorkspaceTabProps,
   WorkspaceTabActions,
-} from "./WorkspaceTab";
+} from "./WorkspaceTab.js";

package/src/session/inspector/useSessionInspector.ts

@@ -2,14 +2,13 @@
 
 import { useCallback, useRef, useState } from "react";
 import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import type { TabItem } from "../../tabs/Tabs";
-import { isTerminalPhase } from "../../execution/execution-phases";
-import type { SelectedThreadItem } from "../../internal/store/selection-store";
+import type { TabItem } from "../../tabs/Tabs.js";
+import { isTerminalPhase } from "../../execution/execution-phases.js";
+import type { SelectedThreadItem } from "../../internal/store/selection-store.js";
 
 export type SessionInspectorTabId =
   | "workspace"
   | "configure"
-  | "plan"
   | "changes"
   | "artifacts"
   | "usage"
@@ -32,29 +31,34 @@ export interface UseSessionInspectorReturn {
 }
 
 /**
- * Compute the system-suggested tab from execution phase and selection.
+ * Compute the system-suggested tab from selection.
  *
  * Priority:
  * 1. Thread item selected -> "inspect"
- * 2. No execution or terminal phase (idle / ready for follow-up) -> "workspace"
- * 3. Actively running -> "plan"
+ * 2. Otherwise -> "workspace"
+ *
+ * Live execution progress (the agent's plan and todos) now renders inline in
+ * the message thread as a {@link TodoCard}, not in a sidebar tab — so a running
+ * execution no longer steers the inspector to a dedicated facet.
  */
 function deriveAutoTab(
-  phase: ExecutionPhase | null,
   selectedItem: SelectedThreadItem | null,
 ): SessionInspectorTabId {
   if (selectedItem) return "inspect";
-  if (phase === null || isTerminalPhase(phase)) return "workspace";
-  return "plan";
+  return "workspace";
 }
 
 /**
  * Build the contextual tab list with badges.
  *
  * Tab order follows the user's mental model — context before output:
- * Workspace → Config → Plan → Usage. Changes and Artifacts appear
- * after Plan when data exists; Inspect appears last when a thread item
- * is selected.
+ * Workspace → Config → Usage. Changes and Artifacts appear after Config
+ * when data exists; Inspect appears last when a thread item is selected.
+ *
+ * The Changes tab surfaces only when git write-backs (PRs) exist, badged
+ * with their count. Local-workspace file edits never surface a tab: they
+ * render in the transcript (stamped edit rows + the per-turn decision bar),
+ * which is their single review surface.
  */
 export function buildVisibleTabs(opts: {
   hasWriteBacks: boolean;
@@ -67,7 +71,6 @@ export function buildVisibleTabs(opts: {
   const tabs: TabItem[] = [
     { id: "workspace", label: "Workspace" },
     { id: "configure", label: "Config" },
-    { id: "plan", label: "Plan" },
   ];
 
   if (opts.hasWriteBacks) {
@@ -111,12 +114,16 @@ export function useSessionInspector(
 
   const tabs = buildVisibleTabs({ hasWriteBacks, writeBackCount, hasArtifacts, artifactCount, hasUsage, selectedItem });
 
+  // A write-back (the session's only tab-worthy change source) surfaces and
+  // auto-selects the Changes tab on first arrival.
+  const hasChanges = hasWriteBacks;
+
   const [activeTab, setActiveTab] = useState<SessionInspectorTabId>(
-    () => deriveAutoTab(phase, selectedItem),
+    () => deriveAutoTab(selectedItem),
   );
   const [prevPhase, setPrevPhase] = useState(phase);
   const [prevSelected, setPrevSelected] = useState(selectedItem);
-  const [prevHasWriteBacks, setPrevHasWriteBacks] = useState(hasWriteBacks);
+  const [prevHasChanges, setPrevHasChanges] = useState(hasChanges);
   const userPickedTabRef = useRef(false);
 
   // Selection changed → auto-switch to inspect (unless user picked)
@@ -126,7 +133,7 @@ export function useSessionInspector(
       setActiveTab("inspect");
     }
     if (!selectedItem && activeTab === "inspect") {
-      setActiveTab(deriveAutoTab(phase, null));
+      setActiveTab(deriveAutoTab(null));
       userPickedTabRef.current = false;
     }
   }
@@ -138,25 +145,25 @@ export function useSessionInspector(
     setPrevPhase(phase);
     if (wasTerminal !== isNowTerminal) {
       userPickedTabRef.current = false;
-      setActiveTab(deriveAutoTab(phase, selectedItem));
+      setActiveTab(deriveAutoTab(selectedItem));
     }
   }
 
   // First write-back arrived → auto-switch to changes
-  if (hasWriteBacks && !prevHasWriteBacks) {
-    setPrevHasWriteBacks(hasWriteBacks);
+  if (hasChanges && !prevHasChanges) {
+    setPrevHasChanges(hasChanges);
     if (!userPickedTabRef.current) {
       setActiveTab("changes");
     }
   }
-  if (hasWriteBacks !== prevHasWriteBacks) {
-    setPrevHasWriteBacks(hasWriteBacks);
+  if (hasChanges !== prevHasChanges) {
+    setPrevHasChanges(hasChanges);
   }
 
   // Ensure active tab is valid (the selected tab may have been removed)
   const effectiveTab = tabs.some((t) => t.id === activeTab)
     ? activeTab
-    : deriveAutoTab(phase, selectedItem);
+    : deriveAutoTab(selectedItem);
 
   const onTabChange = useCallback((tabId: string) => {
     userPickedTabRef.current = true;

package/src/session/useAgentRefFromSession.ts

@@ -3,8 +3,8 @@
 import { useEffect, useState } from "react";
 import type { ResourceRef } from "@stigmer/sdk";
 import { ApiResourceKind } from "@stigmer/protos/ai/stigmer/commons/apiresource/apiresourcekind/api_resource_kind_pb";
-import { useStigmer } from "../hooks";
-import { toError } from "../internal/toError";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
 
 /** Return value of {@link useAgentRefFromSession}. */
 export interface UseAgentRefFromSessionReturn {

package/src/session/useCreateSession.ts

@@ -7,11 +7,11 @@ import {
   type ResourceRef,
   type WorkspaceEntryInput,
 } from "@stigmer/sdk";
-import { useStigmer } from "../hooks";
-import { toError } from "../internal/toError";
-import { toProtoHarness, type HarnessOption } from "../models/harness";
-import { toProtoExecutionTarget, type ExecutionTargetOption } from "./execution-target";
-import { useExecutionTarget } from "../execution-target-context";
+import { useStigmer } from "../hooks.js";
+import { toError } from "../internal/toError.js";
+import { toProtoHarness, type HarnessOption } from "../models/harness.js";
+import { toProtoExecutionTarget, type ExecutionTargetOption } from "./execution-target.js";
+import { useExecutionTarget } from "../execution-target-context.js";
 
 /** Shared fields present in both variants of {@link CreateSessionInput}. */
 export interface SharedSessionFields {

package/src/session/useEditSessionPrep.ts

@@ -3,12 +3,12 @@
 import { useEffect, useRef, useState } from "react";
 import { create } from "@bufbuild/protobuf";
 import { GetArtifactRequestSchema } from "@stigmer/protos/ai/stigmer/agentic/skill/v1/io_pb";
-import { useStigmer } from "../hooks";
-import { useAgent } from "../agent";
-import { useMcpServer } from "../mcp-server";
-import { useSkill } from "../skill";
-import { serializeAgentYaml, serializeMcpServerYaml } from "../library";
-import type { DraftResourceType } from "./draft";
+import { useStigmer } from "../hooks.js";
+import { useAgent } from "../agent/index.js";
+import { useMcpServer } from "../mcp-server/index.js";
+import { useSkill } from "../skill/index.js";
+import { serializeAgentYaml, serializeMcpServerYaml } from "../library/index.js";
+import type { DraftResourceType } from "./draft.js";
 
 /** Return value of {@link useEditSessionPrep}. */
 export interface UseEditSessionPrepReturn {

package/src/session/useLocalSessionWorker.ts

@@ -3,9 +3,9 @@
 import { useEffect, useMemo } from "react";
 import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
 import { ExecutionTarget } from "@stigmer/protos/ai/stigmer/agentic/session/v1/enum_pb";
-import { useRunnerAdapter } from "../runner-adapter";
-import { useExecutionTarget } from "../execution-target-context";
-import { fromProtoExecutionTarget } from "./execution-target";
+import { useRunnerAdapter } from "../runner-adapter.js";
+import { useExecutionTarget } from "../execution-target-context.js";
+import { fromProtoExecutionTarget } from "./execution-target.js";
 
 /**
  * Drives the local runner worker lifecycle for an open session.

package/src/session/useNewSessionFlow.ts

@@ -2,21 +2,21 @@
 
 import { useCallback, useEffect, useState } from "react";
 import { getUserMessage, type McpServerUsageInput, type ResourceRef } from "@stigmer/sdk";
-import type { AgentResolution } from "../agent";
-import { useDefaultAgent } from "../agent";
-import { useModelRegistry } from "../models";
-import { parseModelKey } from "../models/registry";
-import { DEFAULT_HARNESS, type HarnessOption } from "../models/harness";
-import { useWorkspaceEntries, type UseWorkspaceEntriesReturn } from "../workspace";
-import { useSessionVariables, type UseSessionVariablesReturn } from "../execution/useSessionVariables";
-import type { SessionComposerSubmitContext } from "../composer";
-import { withTimeout } from "../internal/withTimeout";
-import { useCreateSession } from "./useCreateSession";
-import { useCreateAgentExecution } from "../execution/useCreateAgentExecution";
-import type { ExecutionTargetOption } from "./execution-target";
-import { useExecutionTarget } from "../execution-target-context";
-import { useRunnerAdapter } from "../runner-adapter";
-import { resolveExecutionRuntimeEnv, type RuntimeEnvProvider } from "./runtime-env";
+import type { AgentResolution } from "../agent/index.js";
+import { useDefaultAgent } from "../agent/index.js";
+import { useModelRegistry } from "../models/index.js";
+import { parseModelKey } from "../models/registry.js";
+import { DEFAULT_HARNESS, type HarnessOption } from "../models/harness.js";
+import { useWorkspaceEntries, type UseWorkspaceEntriesReturn } from "../workspace/index.js";
+import { useSessionVariables, type UseSessionVariablesReturn } from "../execution/useSessionVariables.js";
+import type { SessionComposerSubmitContext } from "../composer/index.js";
+import { withTimeout } from "../internal/withTimeout.js";
+import { useCreateSession } from "./useCreateSession.js";
+import { useCreateAgentExecution } from "../execution/useCreateAgentExecution.js";
+import type { ExecutionTargetOption } from "./execution-target.js";
+import { useExecutionTarget } from "../execution-target-context.js";
+import { useRunnerAdapter } from "../runner-adapter.js";
+import { resolveExecutionRuntimeEnv, type RuntimeEnvProvider } from "./runtime-env.js";
 
 const DEFAULT_AGENT_TIMEOUT_MS = 10_000;
 

package/src/session/usePersistedModel.ts

@@ -1,9 +1,9 @@
 "use client";
 
 import { useEffect, useRef, useState } from "react";
-import { useModelRegistry } from "../models";
-import { parseModelKey } from "../models/registry";
-import type { HarnessOption } from "../models/harness";
+import { useModelRegistry } from "../models/index.js";
+import { parseModelKey } from "../models/registry.js";
+import type { HarnessOption } from "../models/harness.js";
 
 /** Options for {@link usePersistedModel}. */
 export interface UsePersistedModelOptions {

package/src/session/useSession.ts

@@ -1,8 +1,8 @@
 "use client";
 
 import type { Session } from "@stigmer/protos/ai/stigmer/agentic/session/v1/api_pb";
-import { useStigmer } from "../hooks";
-import { useFetch } from "../internal/useFetch";
+import { useStigmer } from "../hooks.js";
+import { useFetch } from "../internal/useFetch.js";
 
 /** Return value of {@link useSession}. */
 export interface UseSessionReturn {

package/src/session/useSessionArtifacts.ts

@@ -4,7 +4,7 @@ import { useMemo } from "react";
 import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
 import type { ExecutionArtifact } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
 import { ExecutionPhase } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
-import { isTerminalPhase } from "../execution/execution-phases";
+import { isTerminalPhase } from "../execution/execution-phases.js";
 
 /**
  * A single artifact entry enriched with the execution context needed