Merge branch 'feature/summon-title' into predev

2 files changed, 227 insertions, 2 deletions

diff --git a/packages/session-orchestrator/src/orchestrator.test.ts b/packages/session-orchestrator/src/orchestrator.test.ts
index e67d1b7..c4be03c 100644
--- a/packages/session-orchestrator/src/orchestrator.test.ts
+++ b/packages/session-orchestrator/src/orchestrator.test.ts
@@ -3879,6 +3879,194 @@ describe("system prompt: regular turn flow", () => {
   });
 });
 
+describe("title (summon-title): deferred until after workspace initialization", () => {
+  // Regression: an earlier implementation set the title in the HTTP /chat
+  // route BEFORE the turn started, which pre-created the conversation meta
+  // and made the orchestrator's `meta === null` newness check falsely report
+  // an EXISTING conversation — so ensureWorkspace / setWorkspaceId / the
+  // first-turn system-prompt construct were ALL skipped. The fix defers the
+  // title set into workspaceSetupPromise, AFTER the newness check + workspace
+  // assignment, so a titled new conversation is still initialized correctly.
+
+  /** Wrap the in-memory store to record the ORDER of init-relevant calls. */
+  function createCallRecordingStore() {
+    const base = createInMemoryStore();
+    const calls: string[] = [];
+    const titleCalls: { conversationId: string; title: string }[] = [];
+    return {
+      store: {
+        ...base,
+        async getConversationMeta(conversationId: string) {
+          calls.push(`getMeta:${conversationId}`);
+          return base.getConversationMeta(conversationId);
+        },
+        async ensureWorkspace(id: string) {
+          calls.push(`ensureWorkspace:${id}`);
+          return base.ensureWorkspace(id);
+        },
+        async setWorkspaceId(conversationId: string, workspaceId: string) {
+          calls.push(`setWorkspaceId:${workspaceId}`);
+          await base.setWorkspaceId(conversationId, workspaceId);
+        },
+        async setConversationTitle(conversationId: string, title: string) {
+          calls.push(`setTitle:${title}`);
+          titleCalls.push({ conversationId, title });
+          await base.setConversationTitle(conversationId, title);
+        },
+      } as ConversationStore,
+      calls,
+      titleCalls,
+    };
+  }
+
+  it("titled new conversation: workspace assigned, system prompt constructed, title set", async () => {
+    const { store, calls, titleCalls } = createCallRecordingStore();
+    const provider: ProviderContract = { id: "p", stream: async function* () {} };
+    const { captureRunTurn } = createCapturingRunTurn();
+    const constructCalls: string[] = [];
+
+    const { orchestrator } = createSessionOrchestrator({
+      conversationStore: store,
+      resolveProvider: () => provider,
+      resolveTools: () => [],
+      applyToolsFilter: identityApplyToolsFilter,
+      runTurn: captureRunTurn,
+      resolveSystemPrompt: () =>
+        createFakeSystemPromptService(async (conversationId) => {
+          constructCalls.push(conversationId);
+          return "CONSTRUCTED_PROMPT";
+        }),
+    });
+
+    await orchestrator.handleMessage({
+      conversationId: "conv-title-new",
+      text: "hi",
+      onEvent: () => {},
+      title: "My Task",
+      workspaceId: "my-workspace",
+    });
+
+    // The bug: workspace init was skipped. It must NOT be.
+    expect(calls).toContain("ensureWorkspace:my-workspace");
+    expect(calls).toContain("setWorkspaceId:my-workspace");
+    // First-turn system prompt construct runs (proves isNewConversation was
+    // true — the newness check was not fooled by a pre-created meta).
+    expect(constructCalls).toEqual(["conv-title-new"]);
+    // The title is persisted.
+    expect(titleCalls).toEqual([{ conversationId: "conv-title-new", title: "My Task" }]);
+  });
+
+  it("title is set AFTER the newness check + workspace assignment (order)", async () => {
+    const { store, calls } = createCallRecordingStore();
+    const provider: ProviderContract = { id: "p", stream: async function* () {} };
+    const { captureRunTurn } = createCapturingRunTurn();
+
+    const { orchestrator } = createSessionOrchestrator({
+      conversationStore: store,
+      resolveProvider: () => provider,
+      resolveTools: () => [],
+      applyToolsFilter: identityApplyToolsFilter,
+      runTurn: captureRunTurn,
+    });
+
+    await orchestrator.handleMessage({
+      conversationId: "conv-title-order",
+      text: "hi",
+      onEvent: () => {},
+      title: "Ordered",
+    });
+
+    const getMetaIdx = calls.findIndex((c) => c.startsWith("getMeta:"));
+    const ensureIdx = calls.findIndex((c) => c.startsWith("ensureWorkspace:"));
+    const setWsIdx = calls.findIndex((c) => c.startsWith("setWorkspaceId:"));
+    const setTitleIdx = calls.findIndex((c) => c.startsWith("setTitle:"));
+    expect(getMetaIdx).toBeGreaterThanOrEqual(0);
+    expect(ensureIdx).toBeGreaterThan(getMetaIdx);
+    expect(setWsIdx).toBeGreaterThan(ensureIdx);
+    expect(setTitleIdx).toBeGreaterThan(setWsIdx);
+  });
+
+  it("no title: setConversationTitle is not called", async () => {
+    const { store, calls } = createCallRecordingStore();
+    const provider: ProviderContract = { id: "p", stream: async function* () {} };
+    const { captureRunTurn } = createCapturingRunTurn();
+
+    const { orchestrator } = createSessionOrchestrator({
+      conversationStore: store,
+      resolveProvider: () => provider,
+      resolveTools: () => [],
+      applyToolsFilter: identityApplyToolsFilter,
+      runTurn: captureRunTurn,
+    });
+
+    await orchestrator.handleMessage({
+      conversationId: "conv-no-title",
+      text: "hi",
+      onEvent: () => {},
+    });
+
+    expect(calls.some((c) => c.startsWith("setTitle:"))).toBe(false);
+  });
+
+  it("existing conversation with a title: workspace NOT re-assigned, title still set", async () => {
+    const { store, calls, titleCalls } = createCallRecordingStore();
+    // Seed an existing conversation (meta non-null, workspace already set).
+    await store.setWorkspaceId("conv-title-existing", "prior-workspace");
+    const provider: ProviderContract = { id: "p", stream: async function* () {} };
+    const { captureRunTurn } = createCapturingRunTurn();
+
+    const { orchestrator } = createSessionOrchestrator({
+      conversationStore: store,
+      resolveProvider: () => provider,
+      resolveTools: () => [],
+      applyToolsFilter: identityApplyToolsFilter,
+      runTurn: captureRunTurn,
+    });
+
+    await orchestrator.handleMessage({
+      conversationId: "conv-title-existing",
+      text: "hi",
+      onEvent: () => {},
+      title: "Renamed",
+    });
+
+    // Existing conversation: workspace init must not run again.
+    expect(calls.some((c) => c.startsWith("ensureWorkspace:"))).toBe(false);
+    // But the title is still applied (rename on an existing conversation).
+    expect(titleCalls).toEqual([{ conversationId: "conv-title-existing", title: "Renamed" }]);
+  });
+
+  it("turn still completes if setConversationTitle throws", async () => {
+    const base = createInMemoryStore();
+    const store: ConversationStore = {
+      ...base,
+      async setConversationTitle() {
+        throw new Error("title store unavailable");
+      },
+    };
+    const provider: ProviderContract = { id: "p", stream: async function* () {} };
+    const { captured, captureRunTurn } = createCapturingRunTurn();
+
+    const { orchestrator } = createSessionOrchestrator({
+      conversationStore: store,
+      resolveProvider: () => provider,
+      resolveTools: () => [],
+      applyToolsFilter: identityApplyToolsFilter,
+      runTurn: captureRunTurn,
+    });
+
+    await orchestrator.handleMessage({
+      conversationId: "conv-title-throws",
+      text: "hi",
+      onEvent: () => {},
+      title: "Resilient",
+    });
+
+    // The turn ran despite the title-set failure.
+    expect(captured).toHaveLength(1);
+  });
+});
+
 describe("system prompt: compaction flow", () => {
   function seedHistory(
     store: ReturnType<typeof createInMemoryStore>,
diff --git a/packages/session-orchestrator/src/orchestrator.ts b/packages/session-orchestrator/src/orchestrator.ts
index ffc5d58..badb8dd 100644
--- a/packages/session-orchestrator/src/orchestrator.ts
+++ b/packages/session-orchestrator/src/orchestrator.ts
@@ -131,6 +131,16 @@ export interface StartTurnInput {
    * system-prompt service when loaded).
    */
   readonly systemPrompt?: string;
+  /**
+   * A human-readable title for the conversation tab. When provided, it is
+   * persisted via `setConversationTitle` AFTER the new-conversation workspace
+   * setup resolves (so the `meta === null` newness detection still fires and
+   * `ensureWorkspace` / `setWorkspaceId` / first-turn system-prompt
+   * construction are NOT skipped) and BEFORE the first message append (so the
+   * append's auto-title does not overwrite it). Omit to keep the auto-derived
+   * title. The caller is responsible for trimming/validation.
+   */
+  readonly title?: string;
 }
 
 export type StartTurnResult =
@@ -396,6 +406,8 @@ export interface SessionOrchestrator {
     systemPrompt?: string;
     /** Images attached to this turn — see {@link StartTurnInput.images}. */
     images?: readonly ImageInput[];
+    /** Conversation tab title — see {@link StartTurnInput.title}. */
+    title?: string;
   }): Promise<void>;
 }
 
@@ -574,6 +586,7 @@ export function createSessionOrchestrator(
     workspaceId: string,
     systemPromptOverride: string | undefined,
     images: readonly ImageInput[] | undefined,
+    title: string | undefined,
   ): void {
     const turnId = generateTurnId();
     const promptStartedAt = deps.now?.() ?? Date.now();
@@ -593,14 +606,34 @@ export function createSessionOrchestrator(
     // The newness flag is also reused to decide whether to construct
     // (first turn) or get (subsequent turn) the system prompt — see the
     // providerOpts assembly below.
+    //
+    // An explicit `title` (e.g. the CLI `--title` flag) is persisted HERE,
+    // AFTER the workspace setup resolves — deliberately NOT before the turn.
+    // Setting it earlier (e.g. in the HTTP route) would pre-create the meta
+    // row, make `meta !== null`, and fool this newness check into skipping
+    // `ensureWorkspace` / `setWorkspaceId` / first-turn system-prompt
+    // construction. By deferring it to here, the title lands after the
+    // workspace is assigned but BEFORE the first message append (so the
+    // append's auto-title sees a non-"Untitled" title and preserves it).
     const workspaceSetupPromise = (async (): Promise<boolean> => {
       const meta = await deps.conversationStore.getConversationMeta(conversationId);
       if (meta === null) {
         await deps.conversationStore.ensureWorkspace(workspaceId);
         await deps.conversationStore.setWorkspaceId(conversationId, workspaceId);
-        return true;
       }
-      return false;
+      if (title !== undefined) {
+        // Best-effort: a title-set failure must NOT break the turn (the
+        // workspace setup above already succeeded). Log and continue — the
+        // append's auto-derived title applies instead.
+        try {
+          await deps.conversationStore.setConversationTitle(conversationId, title);
+        } catch (err) {
+          deps.logger?.child({ conversationId }).warn("orchestrator: title set failure", {
+            error: err instanceof Error ? err.message : String(err),
+          });
+        }
+      }
+      return meta === null;
     })();
 
     // ALWAYS resolve the effective cwd through getEffectiveCwd, passing the
@@ -1138,6 +1171,7 @@ export function createSessionOrchestrator(
       workspaceId,
       systemPrompt,
       images,
+      title,
     }) {
       if (activeTurns.has(conversationId)) {
         return { started: false, reason: "already-active" };
@@ -1152,6 +1186,7 @@ export function createSessionOrchestrator(
         workspaceId ?? "default",
         systemPrompt,
         images,
+        title,
       );
       const turn = activeTurns.get(conversationId);
       const turnId = turn !== undefined ? turn.turnId : "";
@@ -1270,6 +1305,7 @@ export function createSessionOrchestrator(
       workspaceId,
       systemPrompt,
       images,
+      title,
     }) {
       const turnInput: StartTurnInput = {
         conversationId,
@@ -1281,6 +1317,7 @@ export function createSessionOrchestrator(
         ...(workspaceId !== undefined ? { workspaceId } : {}),
         ...(systemPrompt !== undefined ? { systemPrompt } : {}),
         ...(images !== undefined ? { images } : {}),
+        ...(title !== undefined ? { title } : {}),
       };
       const result = orchestrator.startTurn(turnInput);
       if (!result.started) {