@stigmer/react 3.1.1 → 3.1.2

package/src/library/__tests__/detect-streaming-plan.test.ts

@@ -0,0 +1,234 @@
+import { describe, it, expect } from "vitest";
+import { create } from "@bufbuild/protobuf";
+import {
+  AgentExecutionSchema,
+  AgentExecutionStatusSchema,
+  type AgentExecution,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import {
+  AgentExecutionSpecSchema,
+  ExecutionConfigSchema,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/spec_pb";
+import { AgentMessageSchema } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/message_pb";
+import {
+  ExecutionPhase,
+  InteractionMode,
+  MessageType,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { findStreamingPlan } from "../detect-streaming-plan";
+
+function makeMessage(type: MessageType, content: string) {
+  const msg = create(AgentMessageSchema);
+  msg.type = type;
+  msg.content = content;
+  return msg;
+}
+
+function makeExecution(opts: {
+  phase?: ExecutionPhase;
+  interactionMode?: InteractionMode;
+  messages?: ReturnType<typeof makeMessage>[];
+}): AgentExecution {
+  const exec = create(AgentExecutionSchema);
+
+  const spec = create(AgentExecutionSpecSchema);
+  if (opts.interactionMode !== undefined) {
+    const config = create(ExecutionConfigSchema);
+    config.interactionMode = opts.interactionMode;
+    spec.executionConfig = config;
+  }
+  exec.spec = spec;
+
+  const status = create(AgentExecutionStatusSchema);
+  status.phase = opts.phase ?? ExecutionPhase.EXECUTION_IN_PROGRESS;
+  if (opts.messages) {
+    status.messages = opts.messages;
+  }
+  exec.status = status;
+
+  return exec;
+}
+
+/** A live Plan-mode execution with the given messages — the common case. */
+function livePlanExecution(...messages: ReturnType<typeof makeMessage>[]) {
+  return makeExecution({
+    phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+    interactionMode: InteractionMode.PLAN,
+    messages,
+  });
+}
+
+describe("findStreamingPlan — mode and phase gating", () => {
+  const planMessage = makeMessage(MessageType.MESSAGE_AI, "# The Plan\n\nBody");
+
+  it("detects a plan on a live Plan-mode execution", () => {
+    const plan = findStreamingPlan(livePlanExecution(planMessage));
+    expect(plan).toBeDefined();
+    expect(plan!.messageIndex).toBe(0);
+    expect(plan!.displayText).toBe("# The Plan\n\nBody");
+  });
+
+  it("returns undefined for null/undefined executions", () => {
+    expect(findStreamingPlan(null)).toBeUndefined();
+    expect(findStreamingPlan(undefined)).toBeUndefined();
+  });
+
+  it("returns undefined for an Agent-mode execution, even with a plan-shaped message", () => {
+    const exec = makeExecution({
+      phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+      interactionMode: InteractionMode.AGENT,
+      messages: [planMessage],
+    });
+    expect(findStreamingPlan(exec)).toBeUndefined();
+  });
+
+  it("returns undefined when no interaction mode is set", () => {
+    const exec = makeExecution({
+      phase: ExecutionPhase.EXECUTION_IN_PROGRESS,
+      messages: [planMessage],
+    });
+    expect(findStreamingPlan(exec)).toBeUndefined();
+  });
+
+  it.each([
+    ExecutionPhase.EXECUTION_COMPLETED,
+    ExecutionPhase.EXECUTION_FAILED,
+    ExecutionPhase.EXECUTION_CANCELLED,
+    ExecutionPhase.EXECUTION_TERMINATED,
+  ])("returns undefined for terminal phase %s", (phase) => {
+    const exec = makeExecution({
+      phase,
+      interactionMode: InteractionMode.PLAN,
+      messages: [planMessage],
+    });
+    expect(findStreamingPlan(exec)).toBeUndefined();
+  });
+
+  it("detects during a non-terminal wait (approval gate mid-turn)", () => {
+    const exec = makeExecution({
+      phase: ExecutionPhase.EXECUTION_WAITING_FOR_APPROVAL,
+      interactionMode: InteractionMode.PLAN,
+      messages: [planMessage],
+    });
+    expect(findStreamingPlan(exec)).toBeDefined();
+  });
+});
+
+describe("findStreamingPlan — candidate selection", () => {
+  it("considers only the LAST content-bearing AI message", () => {
+    // The earlier plan-shaped message is settled narration once a later AI
+    // message exists — falling back to it would promote the wrong text.
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "# Early heading in narration"),
+      makeMessage(MessageType.MESSAGE_AI, "Now let me check the tests."),
+    );
+    expect(findStreamingPlan(exec)).toBeUndefined();
+  });
+
+  it("skips trailing empty AI messages (extractFinalPlanText's rule)", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "# The Plan\n\nBody"),
+      makeMessage(MessageType.MESSAGE_AI, "   "),
+    );
+    expect(findStreamingPlan(exec)?.messageIndex).toBe(0);
+  });
+
+  it("ignores non-AI message types when selecting the candidate", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "# The Plan\n\nBody"),
+      makeMessage(MessageType.MESSAGE_THINKING, "hmm, one more thing"),
+      makeMessage(MessageType.MESSAGE_TOOL, "tool output"),
+    );
+    expect(findStreamingPlan(exec)?.messageIndex).toBe(0);
+  });
+
+  it("returns undefined when there are no messages", () => {
+    expect(findStreamingPlan(livePlanExecution())).toBeUndefined();
+  });
+});
+
+describe("findStreamingPlan — H1 convention", () => {
+  it("does not detect narration (no leading H1)", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "Let me explore the codebase."),
+    );
+    expect(findStreamingPlan(exec)).toBeUndefined();
+  });
+
+  it("does not detect a lone '#' first token (title not started yet)", () => {
+    const exec = livePlanExecution(makeMessage(MessageType.MESSAGE_AI, "#"));
+    expect(findStreamingPlan(exec)).toBeUndefined();
+  });
+
+  it("detects the moment the H1 gains its first title character", () => {
+    const exec = livePlanExecution(makeMessage(MessageType.MESSAGE_AI, "# T"));
+    expect(findStreamingPlan(exec)?.displayText).toBe("# T");
+  });
+
+  it("does not detect an H2-led message (## is a section, not a plan title)", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "## Notes\n\nSome section"),
+    );
+    expect(findStreamingPlan(exec)).toBeUndefined();
+  });
+
+  it("tolerates leading blank lines before the H1", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "\n\n# The Plan\n\nBody"),
+    );
+    expect(findStreamingPlan(exec)).toBeDefined();
+  });
+});
+
+describe("findStreamingPlan — unterminated-fence tolerance", () => {
+  it("unwraps an unterminated ```markdown fence", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "```markdown\n# The Plan\n\nBody"),
+    );
+    expect(findStreamingPlan(exec)?.displayText).toBe("# The Plan\n\nBody");
+  });
+
+  it("unwraps an unterminated ```md fence", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "```md\n# The Plan"),
+    );
+    expect(findStreamingPlan(exec)?.displayText).toBe("# The Plan");
+  });
+
+  it("unwraps an unterminated bare ``` fence (plan surfaces are markdown by contract)", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "```\n# The Plan"),
+    );
+    expect(findStreamingPlan(exec)?.displayText).toBe("# The Plan");
+  });
+
+  it("strips the closing fence once it streams in as the final line", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "```markdown\n# The Plan\n\nBody\n```"),
+    );
+    expect(findStreamingPlan(exec)?.displayText).toBe("# The Plan\n\nBody");
+  });
+
+  it("keeps a code-block fence inside the plan intact", () => {
+    const content = "```markdown\n# The Plan\n\n```ts\nconst x = 1;\n```\n\nMore";
+    const exec = livePlanExecution(makeMessage(MessageType.MESSAGE_AI, content));
+    // Only the ENCLOSING fence is stripped; the ts block's fences are content.
+    expect(findStreamingPlan(exec)?.displayText).toBe(
+      "# The Plan\n\n```ts\nconst x = 1;\n```\n\nMore",
+    );
+  });
+
+  it("never unwraps a fence with another language tag (a real code block)", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "```python\n# not a heading, a comment"),
+    );
+    expect(findStreamingPlan(exec)).toBeUndefined();
+  });
+
+  it("does not detect a fenced message whose body has no H1", () => {
+    const exec = livePlanExecution(
+      makeMessage(MessageType.MESSAGE_AI, "```\nplain fenced text"),
+    );
+    expect(findStreamingPlan(exec)).toBeUndefined();
+  });
+});

package/src/library/detect-plan-artifact.ts

@@ -2,6 +2,18 @@ import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexe
 import type { ExecutionArtifact } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/artifact_pb";
 import { ExecutionArtifactKind } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
 
+/**
+ * The session's current plan: the published `plan.md` artifact of the most
+ * recent execution that produced one, plus the execution it belongs to
+ * (artifact content RPCs are execution-scoped).
+ */
+export interface SessionPlan {
+  /** ID of the execution that published the plan. */
+  readonly executionId: string;
+  /** The published `plan.md` artifact. */
+  readonly artifact: ExecutionArtifact;
+}
+
 /**
  * Canonical filename a Plan-mode execution publishes its plan under. Kept in
  * sync with the runner's `publishPlanArtifact` (shared/plan-artifact.ts).
@@ -41,3 +53,26 @@ export function findPlanArtifact(
   }
   return undefined;
 }
+
+/**
+ * Finds the session's LATEST plan across all executions — the plan the panel's
+ * plan document tab edits and "Build from plan" implements. Executions are
+ * scanned newest-first (the array is chronological), mirroring the thread's
+ * latest-plan-owns-the-build-action rule so every surface agrees on which
+ * plan is current.
+ *
+ * Returns `undefined` when no execution in the session published a plan.
+ */
+export function findLatestSessionPlan(
+  executions: readonly AgentExecution[],
+): SessionPlan | undefined {
+  for (let i = executions.length - 1; i >= 0; i--) {
+    const execution = executions[i];
+    const artifact = findPlanArtifact(execution);
+    const executionId = execution.metadata?.id;
+    if (artifact && executionId) {
+      return { executionId, artifact };
+    }
+  }
+  return undefined;
+}

package/src/library/detect-streaming-plan.ts

@@ -0,0 +1,108 @@
+import type { AgentExecution } from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/api_pb";
+import {
+  InteractionMode,
+  MessageType,
+} from "@stigmer/protos/ai/stigmer/agentic/agentexecution/v1/enum_pb";
+import { isTerminalPhase } from "@stigmer/sdk";
+
+/**
+ * A plan being written by a live Plan-mode execution, detected mid-stream so
+ * the UI can promote it to a document surface (panel plan tab + compact thread
+ * card) instead of letting it dump into the chat as a giant streaming bubble.
+ */
+export interface StreamingPlan {
+  /** Index of the plan message in `execution.status.messages`. */
+  readonly messageIndex: number;
+  /**
+   * The plan text to render on document surfaces: the message content with
+   * any enclosing plan fence stripped, streaming-tolerantly (an unterminated
+   * opening fence is stripped too — see {@link findStreamingPlan}). Purely a
+   * display projection; the stored message is never mutated.
+   */
+  readonly displayText: string;
+}
+
+/**
+ * Opening line of a whole-message plan fence: ``` with no language tag, or
+ * tagged `markdown`/`md`. Any other tag (```python …) means the message opens
+ * with a genuine code block, not a wrapped plan, and is never unwrapped —
+ * mirroring `unwrapEnclosingMarkdownFence`'s tag rules.
+ */
+const OPENING_PLAN_FENCE_RE = /^(`{3,})(?:markdown|md)?[ \t]*\r?\n/;
+
+/** A streaming plan message qualifies when it opens with an `# H1` title. */
+const LEADING_H1_RE = /^#[ \t]/;
+
+/**
+ * Streaming-tolerant unwrap of a whole-message plan fence.
+ *
+ * `unwrapEnclosingMarkdownFence` deliberately no-ops until the closing fence
+ * arrives (transcripts must stay faithful while a genuine code block is still
+ * open). A plan surface can't wait: mid-stream the closing fence hasn't
+ * streamed yet, and rendering the fence as-is turns the whole live plan into
+ * one giant code block. Because Plan mode's output IS a markdown document by
+ * contract, a message that OPENS with a bare/markdown fence is a wrapped plan
+ * — so this strips the opening fence immediately and the closing fence
+ * whenever it shows up as the final line.
+ */
+function unwrapStreamingPlanFence(content: string): string {
+  const trimmed = content.trim();
+  const open = OPENING_PLAN_FENCE_RE.exec(trimmed);
+  if (!open) return content;
+  const body = trimmed.slice(open[0].length);
+  // Strip the closing fence only when it is the final line (same backtick
+  // run); a fence anywhere else belongs to a code block inside the plan.
+  const close = new RegExp(`(?:^|\\r?\\n)${open[1]}[ \\t]*$`);
+  const closeMatch = close.exec(body);
+  return closeMatch ? body.slice(0, closeMatch.index) : body;
+}
+
+/**
+ * Detects the plan a live Plan-mode execution is currently writing, or
+ * `undefined` when the execution has no recognizable plan in flight.
+ *
+ * This is the third leg of the plan convention, alongside the runner's prompt
+ * directive ("your FINAL message IS the plan, starting with a single `#`
+ * title" — `plan-mode-prompt.ts`) and the completion-time artifact detection
+ * by filename ({@link isPlanArtifact}). Completion makes the plan unambiguous
+ * (the published `plan.md` artifact); mid-stream it must be inferred, and the
+ * directive's mandated shape is the inference:
+ *
+ * - the execution runs in Plan mode and is **non-terminal** (a completed turn
+ *   is owned by the artifact path; a stopped/failed turn has no live plan),
+ * - the candidate is the **last content-bearing `MESSAGE_AI`** — the exact
+ *   selection rule the runner's `extractFinalPlanText` and the thread's
+ *   `findPlanMessageIndex` share, so all three stay in lockstep,
+ * - and that candidate opens with an `# H1` title (after tolerating an
+ *   enclosing plan fence, see {@link unwrapStreamingPlanFence}) — the shape
+ *   the directive mandates and narration essentially never has.
+ *
+ * Degradation is graceful by design: a model that ignores the directive
+ * simply streams its plan in the thread as before, and the completion-time
+ * pipeline is unaffected either way. Only the LAST content-bearing AI message
+ * is ever considered — an earlier message is settled narration, and falling
+ * back to it would promote the wrong text.
+ */
+export function findStreamingPlan(
+  execution: AgentExecution | null | undefined,
+): StreamingPlan | undefined {
+  if (
+    execution?.spec?.executionConfig?.interactionMode !== InteractionMode.PLAN
+  ) {
+    return undefined;
+  }
+  const phase = execution.status?.phase;
+  if (phase === undefined || isTerminalPhase(phase)) return undefined;
+
+  const messages = execution.status?.messages ?? [];
+  for (let i = messages.length - 1; i >= 0; i--) {
+    const msg = messages[i];
+    if (msg.type !== MessageType.MESSAGE_AI) continue;
+    if (msg.content.trim().length === 0) continue;
+    const displayText = unwrapStreamingPlanFence(msg.content);
+    return LEADING_H1_RE.test(displayText.trimStart())
+      ? { messageIndex: i, displayText }
+      : undefined;
+  }
+  return undefined;
+}

package/src/library/index.ts

@@ -27,8 +27,13 @@ export type { SkillPackageDetection } from "./detect-skill-package.js";
 export {
   isPlanArtifact,
   findPlanArtifact,
+  findLatestSessionPlan,
   PLAN_ARTIFACT_NAME,
 } from "./detect-plan-artifact.js";
+export type { SessionPlan } from "./detect-plan-artifact.js";
+
+export { findStreamingPlan } from "./detect-streaming-plan.js";
+export type { StreamingPlan } from "./detect-streaming-plan.js";
 
 export { useDetectSkillPackage } from "./useDetectSkillPackage.js";
 export type { UseDetectSkillPackageReturn } from "./useDetectSkillPackage.js";

package/src/session/NewSessionViewer.tsx

@@ -5,13 +5,19 @@ import { cn } from "@stigmer/theme";
 import type { ResourceRef } from "@stigmer/sdk";
 import type { UseGitHubConnectionReturn } from "../github/useGitHubConnection.js";
 import type { WorkspaceFileLister } from "../workspace/WorkspaceFileLister.js";
+import type { WorkspaceFileReader } from "../workspace/WorkspaceFileReader.js";
+import type { WorkspaceContentSearcher } from "../workspace/WorkspaceContentSearcher.js";
 import type { InteractionModeOption } from "../composer/index.js";
 import { SessionComposer } from "../composer/index.js";
 import type { HarnessOption } from "../models/harness.js";
 import { ResizableSplit } from "../internal/ResizableSplit.js";
-import { SessionInspector } from "./inspector/SessionInspector.js";
-import type { SetupTabProps } from "./inspector/SetupTab.js";
+import { useWorkspaceEditors } from "../internal/store/index.js";
+import { WorkspaceSurface } from "../workspace/WorkspaceSurface.js";
+import type { SetupTabProps } from "./facets/SetupTab.js";
 import { useNewSessionFlow } from "./useNewSessionFlow.js";
+import { useSessionPanel } from "./useSessionPanel.js";
+import { useSessionRailViews } from "./useSessionRailViews.js";
+import { SessionPanelChip } from "./SessionPanelChip.js";
 import type { RuntimeEnvProvider } from "./runtime-env.js";
 import type { SessionAudience } from "./audience.js";
 
@@ -47,6 +53,20 @@ export interface NewSessionViewerProps {
    */
   readonly workspaceFileLister?: WorkspaceFileLister;
 
+  /**
+   * Platform-injected content reader for the read-only file viewer. When set,
+   * clicking a file in the Workspace tree opens it in a contextual "Viewer"
+   * tab — the same capability `SessionViewer` accepts (DD-016 parity).
+   */
+  readonly workspaceFileReader?: WorkspaceFileReader;
+
+  /**
+   * Platform-injected content (text) searcher — the same capability
+   * `SessionViewer` accepts (DD-016 parity). Desktop injects a native
+   * ripgrep-backed searcher; web leaves it undefined (DD-09).
+   */
+  readonly workspaceContentSearcher?: WorkspaceContentSearcher;
+
   /**
    * Supplies host-app environment variables for the session's first
    * execution (e.g. short-lived credentials for MCP tools, minted as
@@ -119,9 +139,10 @@ export interface NewSessionViewerProps {
  * Owns `useNewSessionFlow` internally and composes:
  * - **Centered composer** (primary pane): `SessionComposer` with all
  *   context pickers (agent, workspace, MCP servers, skills)
- * - **SessionInspector** (secondary pane): progressively revealed when
- *   context is attached (workspace/agent/MCP/skills/vars non-empty),
- *   showing only the Setup tab with interactive workspace actions.
+ * - **Session panel** (secondary pane): the unified `WorkspaceSurface` with a
+ *   Config rail view — collapsed by default behind a persistent top-right chip
+ *   and homing on the Config facet when opened. Same layout model as
+ *   `SessionViewer` (DD-016).
  *
  * Framework-agnostic — no Next.js, no Tauri, no routing deps. Host
  * apps inject platform-specific values via props (DD-004/DD-016).
@@ -156,6 +177,8 @@ export function NewSessionViewer({
   enableLocal = false,
   onBrowseLocalFolder,
   workspaceFileLister,
+  workspaceFileReader,
+  workspaceContentSearcher,
   getRuntimeEnv,
   audience = "integrator",
   defaultHarness,
@@ -179,12 +202,25 @@ export function NewSessionViewer({
   const [interactionMode, setInteractionMode] = useState<InteractionModeOption>("agent");
   const isEndUser = audience === "endUser";
 
-  const hasContext =
-    flow.workspace.hasEntries ||
-    flow.agentRef !== null ||
-    flow.mcpServerUsages.length > 0 ||
-    flow.skillRefs.length > 0 ||
-    (flow.sessionVariables != null && !flow.sessionVariables.isEmpty);
+  // The unified-panel controller (shared with SessionViewer, DD-016). The
+  // launcher has no execution yet, so the FSM inputs are static. It has no
+  // streaming column to isolate either, so subscribing to the editor group in
+  // the body is harmless — unlike `SessionViewer`, which subscribes one level
+  // down. Homes on Config: pre-session the Explorer is empty, while Config
+  // carries the run defaults (harness/model) worth seeing before starting.
+  const panel = useSessionPanel({
+    phase: null,
+    hasChanges: false,
+    defaultView: "configure",
+  });
+  const { editors, activeKey, activeFile, reveal } = useWorkspaceEditors(
+    panel.editorsStore,
+  );
+
+  // Honor a jump-to-line reveal only while it targets the active editor
+  // (DD-016 parity with SessionViewer).
+  const activeReveal =
+    reveal && reveal.key === activeKey ? reveal : undefined;
 
   const handleRemoveAgent = useCallback(() => {
     flow.setAgentRef(null);
@@ -240,26 +276,34 @@ export function NewSessionViewer({
     ],
   );
 
-  const workspaceConfig = useMemo(
-    () => ({
-      actions: {
-        workspace: flow.workspace,
-        enableGitHub,
-        enableLocal,
-        gitHubConnection,
-        onBrowseLocalFolder,
-        workspaceFileLister,
-      },
-    }),
-    [flow.workspace, enableGitHub, enableLocal, gitHubConnection, onBrowseLocalFolder, workspaceFileLister],
-  );
+  // Launcher facets: Config only — no executions exist yet, so the
+  // execution-derived facets (Changes/Artifacts/Usage) don't apply.
+  const railViews = useSessionRailViews({
+    allExecutions: [],
+    org,
+    sessionConfig,
+    selectedItem: null,
+    includeExecutionFacets: false,
+  });
+
+  // Explorer-footer folder attach (desktop only — needs the native picker).
+  const canAddLocalFolder = enableLocal && !!onBrowseLocalFolder;
+  const handleAddLocalFolder = useCallback(async () => {
+    const path = await onBrowseLocalFolder?.();
+    if (path) flow.workspace.addLocalPath(path);
+  }, [onBrowseLocalFolder, flow.workspace.addLocalPath]);
 
   const composerNode = (
-    <div className="flex h-full flex-col items-center overflow-y-auto px-4">
-      <div className={cn(
-        "w-full max-w-2xl space-y-6",
-        hasContext ? "my-6" : "my-auto",
-      )}>
+    // `my-auto` centers the composer vertically whether or not context is
+    // attached — safe-centering, not a special case: auto margins absorb free
+    // space when the composer is shorter than the pane and collapse to zero
+    // when it outgrows it, degrading to a normal top-aligned scroll. The
+    // scroll container's `py-6` keeps breathing room in that overflow case.
+    // Do NOT reintroduce a context-driven position flip: the composer must not
+    // move as context is attached (DD-16's layout-stability rationale — chrome
+    // that shifts with attached context reads as instability).
+    <div className="flex h-full flex-col items-center overflow-y-auto px-4 py-6">
+      <div className="my-auto w-full max-w-2xl space-y-6">
         <h1 className="text-center text-lg font-medium text-foreground">
           {heading}
         </h1>
@@ -308,38 +352,62 @@ export function NewSessionViewer({
     </div>
   );
 
-  if (!hasContext) {
-    return (
-      <div className={cn("flex h-full w-full flex-col", className)}>
-        {composerNode}
+  return (
+    <div className={cn("relative flex h-full w-full flex-col", className)}>
+      {/* Persistent chrome: the chip is always mounted, matching SessionViewer
+          (DD-016) rather than the launcher's earlier progressively-revealed
+          inspector. A toggle that appears/disappears with attached context
+          reads as instability and, worse, unmounts the open panel's only
+          collapse control when the last context item is removed. Always-on is
+          the predictable, discoverable shape; opening homes on the Config
+          facet, which carries useful defaults (harness/model) pre-session. */}
+      <div className="absolute top-2 right-6 z-10">
+        <SessionPanelChip
+          isOpen={panel.isOpen}
+          onToggle={panel.isOpen ? panel.closePanel : panel.openPanel}
+        />
       </div>
-    );
-  }
 
-  return (
-    <div className={cn("flex h-full w-full flex-col", className)}>
+      {/* Same unified-panel layout as SessionViewer (DD-016): collapsed by
+          default (composer fills the row); opening makes the composer the
+          fixed narrow pane and hands the flexible region to the surface.
+          Collapse goes through the split's `collapsedPane` (CSS, not
+          conditional structure), so the composer never remounts across an
+          open/close toggle. */}
       <ResizableSplit
-        defaultSize={320}
-        minSize={240}
-        maxSize={480}
-        storageKey="stgm-new-session-inspector-width"
-        className={cn(
-          "min-h-0 flex-1",
-          "[&>*:nth-child(2)]:max-lg:hidden [&>*:nth-child(3)]:max-lg:hidden",
-        )}
+        resizablePane="primary"
+        collapsedPane={panel.isOpen ? "none" : "secondary"}
+        defaultSize={420}
+        minSize={320}
+        maxSize={640}
+        storageKey="stgm-new-session-chat-width"
+        responsiveCollapse={panel.isOpen ? "primary" : "none"}
+        ariaLabel="Resize composer panel"
+        className="min-h-0 flex-1"
         primary={composerNode}
         secondary={
-          <aside className="flex h-full flex-col overflow-hidden">
-            <SessionInspector
-              displayExecution={null}
-              allExecutions={[]}
-              org={org}
-              selectedItem={null}
-              sessionConfig={sessionConfig}
-              workspaceConfig={workspaceConfig}
-              className="min-h-0 flex-1"
+          panel.isOpen ? (
+            <WorkspaceSurface
+              entries={flow.workspace.entries}
+              lister={workspaceFileLister}
+              reader={workspaceFileReader}
+              searcher={workspaceContentSearcher}
+              view={panel.view}
+              onViewChange={panel.setView}
+              extraViews={railViews}
+              onRemoveEntry={flow.workspace.remove}
+              onAddLocalFolder={canAddLocalFolder ? handleAddLocalFolder : undefined}
+              editors={editors}
+              selectedFile={activeFile}
+              onOpenFile={panel.openFile}
+              onActivateEditor={panel.activateEditor}
+              onPinEditor={panel.pinEditor}
+              onCloseEditor={panel.closeEditor}
+              onCollapse={panel.closePanel}
+              reveal={activeReveal}
+              className="h-full"
             />
-          </aside>
+          ) : null
         }
       />
     </div>