@cueloop/client 0.1.0-alpha.103 → 0.1.0-alpha.105

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cueloop/client",
-  "version": "0.1.0-alpha.103",
+  "version": "0.1.0-alpha.105",
   "description": "The cueloop review UI: projection renderer, keyboard grammar, review rail",
   "homepage": "https://github.com/mmurakaru/cueloop#readme",
   "bugs": {
@@ -27,15 +27,15 @@
     "access": "public"
   },
   "dependencies": {
-    "@cueloop/daemon": "0.1.0-alpha.103",
-    "@cueloop/extension-api": "0.1.0-alpha.103",
-    "@cueloop/integration-obsidian": "0.1.0-alpha.103",
-    "@cueloop/schema": "0.1.0-alpha.103",
-    "@opentui/core": "^0.5.14",
-    "@opentui/keymap": "0.5.14",
-    "@opentui/react": "^0.5.14",
-    "@opentui/ssh": "0.5.14",
-    "@pierre/diffs": "^1.5.1",
+    "@cueloop/daemon": "0.1.0-alpha.105",
+    "@cueloop/extension-api": "0.1.0-alpha.105",
+    "@cueloop/integration-obsidian": "0.1.0-alpha.105",
+    "@cueloop/schema": "0.1.0-alpha.105",
+    "@opentui/core": "^0.5.17",
+    "@opentui/keymap": "0.5.17",
+    "@opentui/react": "^0.5.17",
+    "@opentui/ssh": "0.5.17",
+    "@pierre/diffs": "^1.5.2",
     "@tanstack/virtual-core": "^3.17.11",
     "diff": "^9",
     "puppeteer-core": "^25.12.0",

package/src/app/App.readonly.test.tsx

@@ -5,6 +5,8 @@ import { mkdtempSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import React from "react";
+import { DaemonClient } from "@cueloop/daemon/client";
+import { NERD } from "../ui/components/primitives/icons";
 import { DaemonServer } from "@cueloop/daemon";
 import { makeAnchor, parseBlocks, type Thread } from "@cueloop/schema";
 import { App } from "./App";
@@ -208,3 +210,64 @@ describe("observer navigation still works", () => {
     expect(snapshot().annotations).toBe(1);
   });
 });
+
+for (const role of ["collaborator", "observer"] as const) {
+  test(`${role} shared view shows a conversation snapshot and has no Thread actions menu`, async () => {
+    const client = await DaemonClient.connect({ home });
+    const shared = {
+      ...session,
+      artifact: { ...session.artifact, content: "" },
+      agentSnapshot: {
+        threadId: session.id,
+        phase: { kind: "idle" as const },
+        tools: [],
+        comments: [],
+        messages: [
+          {
+            id: "prompt",
+            role: "user" as const,
+            text: "Shared question",
+            complete: true,
+            revision: 1,
+          },
+          {
+            id: "answer",
+            role: "agent" as const,
+            text: "Shared conversation answer",
+            complete: true,
+            revision: 1,
+          },
+        ],
+      },
+    };
+
+    client.sessionGet = async () => shared;
+    client.sessionList = async () => [shared];
+    const setup = await renderReadyApp(
+      <App
+        home={home}
+        sessionId={shared.id}
+        role={role}
+        openClient={() => Promise.resolve(client)}
+      />,
+      { width: 120, height: 32 },
+    );
+
+    try {
+      await waitForText(setup, "Shared conversation answer");
+      expect(setup.captureCharFrame()).toContain("Shared question");
+      const row = setup
+        .captureCharFrame()
+        .split("\n")
+        .findIndex((line) => line.slice(0, 30).includes("Migration Plan"));
+
+      expect(row).toBeGreaterThanOrEqual(0);
+      await setup.mockMouse.moveTo(12, row);
+      expect(setup.captureCharFrame()).not.toContain(NERD.kebab);
+      expect(setup.captureCharFrame()).not.toContain(" edit ");
+    } finally {
+      setup.renderer.destroy();
+      client.close();
+    }
+  });
+}

package/src/app/App.tsx

@@ -1,3 +1,4 @@
+import { THREAD_MODEL_DEFAULTS } from "@cueloop/schema";
 import { useThreadHarnessSetting } from "../settings/use-thread-harness-setting";
 import React, {
   useCallback,
@@ -559,7 +560,11 @@ export function App({
   servedArtifact,
   extensionRegistry,
 }: AppProps): React.ReactNode {
-  const { observer, isOwner } = computeRoleCapabilities(readOnly, role);
+  const { observer, isOwner, canManageThreads } = computeRoleCapabilities(
+    readOnly,
+    role,
+    isSharedThreadConnection(openClient, shareTransport),
+  );
   const controller = useMemo(
     () =>
       createReviewController({
@@ -686,6 +691,7 @@ export function App({
   const [identity, setIdentity] = useState<IdentityConfig>({ provider: "typed" });
   const [quickActions, setQuickActions] = useState<QuickAction[]>(DEFAULT_QUICK_ACTIONS);
   const [skills, setSkills] = useState<SlashItem[]>([]);
+  const [threadModelDefaults, setThreadModelDefaults] = useState(THREAD_MODEL_DEFAULTS);
   const [reviewSkill, setReviewSkill] = useState("code-review");
   const [reviewWorkspace, setReviewWorkspace] = useState<ReviewWorkspaceMode>("worktree");
   const paletteNames = useMemo(
@@ -702,6 +708,7 @@ export function App({
     setPrototypePixels(config.experimental.prototypePixels);
     setThreadAgentEnabled(config.experimental.threadAgent);
     setThreadHarness(config.thread.harness);
+    setThreadModelDefaults({ pi: config.thread.pi, fx: config.thread.fx });
     keysRef.current = config.keys;
     keyBindings.setKeys(config.keys);
     setTheme(composeTheme(config.ui.theme, config.themeOverrides, appearance));
@@ -798,6 +805,8 @@ export function App({
     onCategorySelect,
     openSettings,
   } = useSettingsDialog({
+    threadDefaults: threadModelDefaults,
+    setThreadDefaults: setThreadModelDefaults,
     theme,
     appearance,
     autoClose,
@@ -1221,8 +1230,10 @@ export function App({
             onFocusPane={setFocusedPane}
             menuControl={menuControl}
             pinnedIds={pinnedIds}
-            onPin={togglePin}
-            onRename={(id, title) => setMode({ type: "renameThread", sessionId: id, text: title })}
+            onPin={enabledThreadAction(canManageThreads, togglePin)}
+            onRename={enabledThreadAction(canManageThreads, (id: string, title: string) =>
+              setMode({ type: "renameThread", sessionId: id, text: title }),
+            )}
             quickActions={quickActions}
             diffView={diffView}
             onWelcomeComposingChange={setWelcomeComposing}
@@ -1351,13 +1362,15 @@ export function App({
                     width={30}
                     onSelect={openThread}
                     onCreateThread={createEmptyThread}
-                    onPin={togglePin}
-                    onRename={(id, title) =>
-                      setMode({ type: "renameThread", sessionId: id, text: title })
-                    }
-                    onRequestDelete={(id, title) =>
-                      setMode({ type: "confirmDelete", sessionId: id, title })
-                    }
+                    onPin={enabledThreadAction(canManageThreads, togglePin)}
+                    onRename={enabledThreadAction(canManageThreads, (id: string, title: string) =>
+                      setMode({ type: "renameThread", sessionId: id, text: title }),
+                    )}
+                    onRequestDelete={enabledThreadAction(
+                      canManageThreads,
+                      (id: string, title: string) =>
+                        setMode({ type: "confirmDelete", sessionId: id, title }),
+                    )}
                     theme={theme}
                   />
                 </scrollbox>
@@ -1684,7 +1697,10 @@ export function App({
   );
 }
 
-function enabledThreadAction(enabled: boolean, action: () => void): (() => void) | undefined {
+function enabledThreadAction<Arguments extends unknown[]>(
+  enabled: boolean,
+  action: (...args: Arguments) => void,
+): ((...args: Arguments) => void) | undefined {
   return enabled ? action : undefined;
 }
 

package/src/app/app-screens.tsx

@@ -175,8 +175,8 @@ export function NoThreadShell(props: {
   /** App owns the one open-menu id, so the bare shell's menus share App's modal keyboard handling. */
   menuControl: MenuControlApi;
   pinnedIds: ReadonlySet<string>;
-  onPin: (id: string) => void;
-  onRename: (id: string, title: string) => void;
+  onPin?: (id: string) => void;
+  onRename?: (id: string, title: string) => void;
   /** Drives the "/" quick actions and skills in the welcome playground's composer. */
   quickActions: QuickAction[];
   diffView: DiffViewMode;

package/src/app/app-view-model.ts

@@ -12,10 +12,13 @@ import type { BreadcrumbItem } from "./components/Breadcrumb";
 export function computeRoleCapabilities(
   readOnly: boolean,
   role: "owner" | "observer" | "collaborator",
+  shared = false,
 ) {
   const observer = readOnly || role === "observer";
 
-  return { observer, isOwner: !observer && role === "owner" };
+  const isOwner = !observer && role === "owner";
+
+  return { observer, isOwner, canManageThreads: isOwner && !shared };
 }
 
 export function deriveReviewFlags(session: Thread | null) {

package/src/index.ts

@@ -23,6 +23,7 @@ export {
   collaboratorAnnotations,
   mergeFromShare,
   publishShare,
+  snapshotThreadConversation,
   pullShare,
   pushShare,
   shareIdFromLine,

package/src/integrations/share.ts

@@ -19,9 +19,10 @@ import {
   type SharePolicy,
   type ShareLink,
   type Thread,
+  type ThreadAgentState,
 } from "@cueloop/schema";
 import { ThreadRecordSchema } from "@cueloop/daemon/validate";
-import type { SharedMerge } from "@cueloop/daemon/client";
+import type { ThreadClient, SharedMerge } from "@cueloop/daemon/client";
 import * as v from "valibot";
 import { copyToClipboard } from "./clipboard";
 
@@ -240,3 +241,43 @@ async function runShareSsh(
 
   return { stdout, stderr, code };
 }
+
+/** Freeze the visible conversation without owner session IDs, execution data or delivery receipts. */
+export async function snapshotThreadConversation(
+  thread: Thread,
+  client: Pick<ThreadClient, "agentGet">,
+): Promise<Thread> {
+  if (!client.agentGet) return thread;
+
+  let state: ThreadAgentState;
+
+  try {
+    state = await client.agentGet(thread.id);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Thread agent is disabled;"))
+      return thread;
+
+    throw error;
+  }
+
+  if (!state.messages.length && !state.submissions?.length) return thread;
+
+  return {
+    ...thread,
+    agentSnapshot: {
+      threadId: thread.id,
+      harness: state.harness ? { id: state.harness.id, label: state.harness.label } : undefined,
+      phase: { kind: "idle" },
+      messages: state.messages,
+      comments: state.comments,
+      tools: [],
+      submissions: state.submissions?.map(({ id, commentId, prompt, quote, status }) => ({
+        id,
+        commentId,
+        prompt,
+        quote,
+        status,
+      })),
+    },
+  };
+}

package/src/settings/config.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, test } from "bun:test";
-import { mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import {
@@ -12,6 +12,7 @@ import {
   persistLayout,
   persistPins,
   persistReviewSkill,
+  persistThreadModelDefault,
   persistReviewWorkspace,
   persistTheme,
   quickActionBody,
@@ -715,3 +716,39 @@ test("a malformed Thread section does not discard other preferences", () => {
     rmSync(dir, { recursive: true, force: true });
   }
 });
+
+test("Thread model defaults layer independently and persistence stays in the selected table", () => {
+  const directory = mkdtempSync(join(tmpdir(), "cueloop-model-defaults-"));
+  const user = join(directory, "user.toml");
+  const repository = join(directory, "repo");
+
+  try {
+    const defaults = loadConfig({ userConfigPath: user }).thread;
+
+    expect(defaults.pi).toEqual({ model: "openai-codex/gpt-6.1-sol", effort: "medium" });
+    expect(defaults.fx).toEqual({ model: "grok/grok-4.7", effort: "medium" });
+    writeFileSync(
+      user,
+      '[thread.pi]\nmodel = "openai-codex/custom"\neffort = "high"\n\n[thread.fx]\nmodel = "grok/custom"\neffort = "low"\n',
+    );
+    persistThreadModelDefault("pi", "effort", "medium", user);
+    persistThreadModelDefault("fx", "model", "grok/grok-4.7", user);
+
+    const config = loadConfig({ userConfigPath: user });
+
+    expect(config.thread.pi).toEqual({ model: "openai-codex/custom", effort: "medium" });
+    expect(config.thread.fx).toEqual({ model: "grok/grok-4.7", effort: "low" });
+    mkdirSync(join(repository, ".cueloop"), { recursive: true });
+    writeFileSync(
+      join(repository, ".cueloop/config.toml"),
+      '[thread.pi]\neffort = "high"\n[thread.fx]\nmodel = " "\neffort = "invalid"\n',
+    );
+
+    const layered = loadConfig({ userConfigPath: user, repoRoot: repository });
+
+    expect(layered.thread.pi).toEqual({ model: "openai-codex/custom", effort: "high" });
+    expect(layered.thread.fx).toEqual(config.thread.fx);
+  } finally {
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

package/src/settings/config.ts

@@ -9,7 +9,13 @@ import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { OBSIDIAN_DEFAULTS, type ObsidianConfig } from "@cueloop/integration-obsidian";
-import { MESSAGE_OUTCOMES, type MessageOutcome } from "@cueloop/schema";
+import {
+  AGENT_REASONING_EFFORTS,
+  THREAD_MODEL_DEFAULTS,
+  type ThreadModelDefaults,
+  MESSAGE_OUTCOMES,
+  type MessageOutcome,
+} from "@cueloop/schema";
 import { writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
 import * as v from "valibot";
@@ -128,7 +134,7 @@ export interface CueloopConfig {
   actions: QuickAction[];
   skillsPath: string;
   review: ReviewConfig;
-  thread: { harness: "pi" | "fx" };
+  thread: { harness: "pi" | "fx"; pi: ThreadModelDefaults; fx: ThreadModelDefaults };
   integrations: IntegrationsConfig;
   experimental: ExperimentalConfig;
 }
@@ -180,6 +186,11 @@ function skillsPathFrom(
   return raw?.path?.trim() ? raw.path.trim() : fallback;
 }
 
+const ThreadModelDefaultsSchema = v.object({
+  model: v.fallback(v.optional(v.pipe(v.string(), v.trim(), v.minLength(1))), undefined),
+  effort: v.fallback(v.optional(v.picklist(AGENT_REASONING_EFFORTS)), undefined),
+});
+
 const ConfigDocumentSchema = v.object({
   actions: v.optional(v.array(v.unknown())),
   authors: v.optional(v.unknown()),
@@ -192,7 +203,13 @@ const ConfigDocumentSchema = v.object({
   skills: v.fallback(v.optional(SkillsSectionSchema), undefined),
   review: v.optional(v.unknown()),
   thread: v.fallback(
-    v.optional(v.object({ harness: v.fallback(v.optional(v.picklist(["pi", "fx"])), undefined) })),
+    v.optional(
+      v.object({
+        harness: v.fallback(v.optional(v.picklist(["pi", "fx"])), undefined),
+        pi: v.fallback(v.optional(ThreadModelDefaultsSchema), undefined),
+        fx: v.fallback(v.optional(ThreadModelDefaultsSchema), undefined),
+      }),
+    ),
     undefined,
   ),
 });
@@ -324,6 +341,21 @@ function applyReview(review: ReviewConfig, parsed: v.InferOutput<typeof ReviewSc
   if (parsed.workspace !== undefined) review.workspace = parsed.workspace;
 }
 
+function applyThreadDefaults(
+  thread: CueloopConfig["thread"],
+  parsed: v.InferOutput<typeof ConfigDocumentSchema>["thread"],
+): void {
+  if (parsed?.harness) thread.harness = parsed.harness;
+
+  for (const harness of ["pi", "fx"] as const) {
+    const defaults = parsed?.[harness];
+
+    if (defaults?.model) thread[harness].model = defaults.model;
+
+    if (defaults?.effort) thread[harness].effort = defaults.effort;
+  }
+}
+
 function layer(
   base: CueloopConfig,
   raw: v.InferOutput<typeof ConfigDocumentSchema>,
@@ -339,7 +371,7 @@ function layer(
     actions: [...base.actions],
     skillsPath: base.skillsPath,
     review: { ...base.review },
-    thread: { ...base.thread },
+    thread: { ...base.thread, pi: { ...base.thread.pi }, fx: { ...base.thread.fx } },
     integrations: { obsidian: { ...base.integrations.obsidian } },
     experimental: { ...base.experimental },
   };
@@ -390,7 +422,7 @@ function layer(
 
   if (review.success) applyReview(out.review, review.output);
 
-  if (raw.thread?.harness) out.thread.harness = raw.thread.harness;
+  applyThreadDefaults(out.thread, raw.thread);
 
   return out;
 }
@@ -414,7 +446,11 @@ export function loadConfig(
     actions: [...DEFAULT_QUICK_ACTIONS],
     skillsPath: join(homedir(), ".agents", "skills"),
     review: { skill: "code-review", workspace: "worktree" },
-    thread: { harness: "pi" },
+    thread: {
+      harness: "pi",
+      pi: { ...THREAD_MODEL_DEFAULTS.pi },
+      fx: { ...THREAD_MODEL_DEFAULTS.fx },
+    },
     integrations: { obsidian: { ...OBSIDIAN_DEFAULTS } },
     experimental: { prototypePixels: false, threadAgent: false },
   };
@@ -670,3 +706,13 @@ function applyExperimental(
 export function persistThreadHarness(harness: "pi" | "fx", userConfigPath?: string): void {
   persistTableSetting("thread", "harness", tomlString(harness), userConfigPath);
 }
+
+/** Persist one harness's new-Thread defaults without altering other TOML tables. */
+export function persistThreadModelDefault(
+  harness: "pi" | "fx",
+  key: keyof ThreadModelDefaults,
+  value: string,
+  userConfigPath?: string,
+): void {
+  persistTableSetting(`thread.${harness}`, key, tomlString(value), userConfigPath);
+}

package/src/settings/use-settings-dialog.test.tsx

@@ -1,8 +1,13 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { loadConfig } from "./config";
 import { expect, test } from "bun:test";
 import React, { useState } from "react";
+import { useKeyboard } from "@opentui/react";
 import { testRender } from "@opentui/react/test-utils";
 import { DARK } from "../appearance/theme";
-import { settle, locateText } from "../testing/test-support";
+import { settle, locateText, typeText } from "../testing/test-support";
 import { SettingsDialog } from "./components/SettingsDialog";
 import { useSettingsDialog } from "./use-settings-dialog";
 
@@ -14,7 +19,14 @@ function TestThreadSettings({
   onSwitch: (harness: string) => void;
 }) {
   const [harness, setHarness] = useState<"pi" | "fx">("pi");
+  const [threadDefaults, setThreadDefaults] = useState(() => {
+    const config = loadConfig();
+
+    return { pi: config.thread.pi, fx: config.thread.fx };
+  });
   const model = useSettingsDialog({
+    threadDefaults,
+    setThreadDefaults,
     theme: DARK,
     appearance: "dark",
     autoClose: "off",
@@ -42,6 +54,8 @@ function TestThreadSettings({
     },
   });
 
+  useKeyboard((key) => model.handleSettingsKey(key.name));
+
   return (
     <SettingsDialog
       isOpen
@@ -96,3 +110,63 @@ test("Thread settings switches harness by mouse and disappears without owner cap
     disabled.renderer.destroy();
   }
 });
+
+test("Thread settings edits model defaults and effort and persists them to TOML", async () => {
+  const directory = mkdtempSync(join(tmpdir(), "cueloop-settings-model-"));
+  const previous = process.env.CUELOOP_CONFIG;
+  const path = join(directory, "config.toml");
+
+  process.env.CUELOOP_CONFIG = path;
+  const setup = await testRender(<TestThreadSettings enabled onSwitch={() => {}} />, {
+    width: 100,
+    height: 30,
+  });
+
+  try {
+    await settle(setup);
+    const category = locateText(setup, "Thread");
+
+    await setup.mockMouse.click(category.column, category.row);
+    await settle(setup);
+    expect(setup.captureCharFrame()).toContain("gpt-6.1-sol");
+    expect(setup.captureCharFrame()).toContain("grok-4.7");
+    const effort = locateText(setup, "pi default effort");
+
+    await setup.mockMouse.click(effort.column, effort.row);
+    await settle(setup);
+    expect(loadConfig({ userConfigPath: path }).thread.pi.effort).toBe("high");
+    const model = locateText(setup, "pi default model");
+
+    await setup.mockMouse.click(model.column, model.row);
+    await settle(setup);
+    await typeText(setup, "-custom");
+    await settle(setup);
+    const save = locateText(setup, "save");
+
+    await setup.mockMouse.click(save.column, save.row);
+    await settle(setup);
+    expect(loadConfig({ userConfigPath: path }).thread.pi.model).toBe(
+      "openai-codex/gpt-6.1-sol-custom",
+    );
+    expect(setup.captureCharFrame()).toContain("gpt-6.1-sol-custom");
+    const fxModel = locateText(setup, "fx default model");
+
+    await setup.mockMouse.click(fxModel.column, fxModel.row);
+    await settle(setup);
+    await typeText(setup, "-cancelled");
+    setup.mockInput.pressKey("ESC");
+    await settle(setup);
+    expect(setup.captureCharFrame()).not.toContain("Default model for new Threads");
+    expect(loadConfig({ userConfigPath: path }).thread.fx).toEqual({
+      model: "grok/grok-4.7",
+      effort: "medium",
+    });
+  } finally {
+    setup.renderer.destroy();
+
+    if (previous === undefined) delete process.env.CUELOOP_CONFIG;
+    else process.env.CUELOOP_CONFIG = previous;
+
+    rmSync(directory, { recursive: true, force: true });
+  }
+});

package/src/settings/use-settings-dialog.tsx

@@ -1,6 +1,7 @@
 import React, { useState, type Dispatch, type SetStateAction } from "react";
 import {
   DEFAULT_QUICK_ACTIONS,
+  persistThreadModelDefault,
   persistActions,
   persistAutoClose,
   persistDiffView,
@@ -18,6 +19,12 @@ import {
   type Appearance,
   type ThemeName,
 } from "../appearance/theme-presets";
+import {
+  AGENT_REASONING_EFFORTS,
+  type ThreadModelDefaults,
+  type AgentReasoningEffort,
+} from "@cueloop/schema";
+import { PromptDialog } from "../ui/components/PromptDialog";
 import type { Theme } from "../appearance/theme";
 import type { SettingsCategory } from "./components/SettingsDialog";
 import { QuickActionsEditor } from "./components/quick-actions-editor";
@@ -78,6 +85,8 @@ function moveBodyRow(name: string, nav: SettingsNav, rowCount: number): Settings
 }
 
 export function useSettingsDialog(params: {
+  threadDefaults: Record<"pi" | "fx", ThreadModelDefaults>;
+  setThreadDefaults: Dispatch<SetStateAction<Record<"pi" | "fx", ThreadModelDefaults>>>;
   theme: Theme;
   appearance: Appearance;
   autoClose: AutoClose;
@@ -128,6 +137,22 @@ export function useSettingsDialog(params: {
     onSwitchHarness,
   } = params;
 
+  const { threadDefaults, setThreadDefaults } = params;
+  const [modelEditor, setModelEditor] = useState<{ harness: "pi" | "fx"; text: string } | null>(
+    null,
+  );
+
+  const saveModelDefault = (): void => {
+    if (!modelEditor?.text.trim()) return;
+
+    const { harness, text } = modelEditor;
+    const model = text.trim();
+
+    persistThreadModelDefault(harness, "model", model);
+    setThreadDefaults((defaults) => ({ ...defaults, [harness]: { ...defaults[harness], model } }));
+    setModelEditor(null);
+  };
+
   // open focused on the left nav, so up/down browses categories until l/tab/enter enters the body
   const [settingsNav, setSettingsNav] = useState<SettingsNav>({
     categoryId: "general",
@@ -237,7 +262,33 @@ export function useSettingsDialog(params: {
                 kind: "cycle" as const,
                 options: ["pi", "fx"],
               },
+              { key: "piModel", label: "pi default model", kind: "text" as const },
+              {
+                key: "piEffort",
+                label: "pi default effort",
+                kind: "cycle" as const,
+                options: [...AGENT_REASONING_EFFORTS],
+              },
+              { key: "fxModel", label: "fx default model", kind: "text" as const },
+              {
+                key: "fxEffort",
+                label: "fx default effort",
+                kind: "cycle" as const,
+                options: [...AGENT_REASONING_EFFORTS],
+              },
             ],
+            customBody: modelEditor ? (
+              <PromptDialog
+                isOpen
+                title=" Default model for new Threads "
+                label={`${modelEditor.harness} model (provider/model)`}
+                value={modelEditor.text}
+                onInput={(text) => setModelEditor({ ...modelEditor, text })}
+                onSave={saveModelDefault}
+                onCancel={() => setModelEditor(null)}
+                theme={theme}
+              />
+            ) : undefined,
           },
         ]
       : []),
@@ -280,9 +331,28 @@ export function useSettingsDialog(params: {
     reviewSkill,
     reviewWorkspace,
     threadHarness: threadHarness ?? "pi",
+    piModel: threadDefaults.pi.model.replace(/^[^/]+\//, ""),
+    piEffort: threadDefaults.pi.effort,
+    fxModel: threadDefaults.fx.model.replace(/^[^/]+\//, ""),
+    fxEffort: threadDefaults.fx.effort,
   };
   const cycleSetting = (rowKey: string): void => {
-    if (rowKey === "threadHarness") {
+    if (rowKey === "piModel" || rowKey === "fxModel") {
+      const harness = rowKey === "piModel" ? "pi" : "fx";
+
+      setModelEditor({ harness, text: threadDefaults[harness].model });
+    } else if (rowKey === "piEffort" || rowKey === "fxEffort") {
+      const harness = rowKey === "piEffort" ? "pi" : "fx";
+      const efforts = AGENT_REASONING_EFFORTS;
+      const effort: AgentReasoningEffort =
+        efforts[(efforts.indexOf(threadDefaults[harness].effort) + 1) % efforts.length]!;
+
+      persistThreadModelDefault(harness, "effort", effort);
+      setThreadDefaults((defaults) => ({
+        ...defaults,
+        [harness]: { ...defaults[harness], effort },
+      }));
+    } else if (rowKey === "threadHarness") {
       onSwitchHarness?.(threadHarness === "fx" ? "pi" : "fx");
     } else if (rowKey === "autoClose") {
       const next: AutoClose = autoClose === "off" ? 3 : autoClose === 3 ? 10 : "off";
@@ -327,6 +397,13 @@ export function useSettingsDialog(params: {
   };
 
   const handleSettingsKey = (name: string): void => {
+    if (modelEditor) {
+      if (name === "escape") setModelEditor(null);
+      else if (name === "return") saveModelDefault();
+
+      return;
+    }
+
     // an open system-prompt input owns typing; only esc (close it) escapes here
     if (actionsExpandedIndex !== null) {
       if (name === "escape") setActionsExpandedIndex(null);

package/src/thread/components/AgentConfigControls.test.tsx

@@ -110,3 +110,44 @@ test("model and reasoning choices share the existing overlay and close after sel
     setup.renderer.destroy();
   }
 });
+
+for (const harness of ["pi", "fx"]) {
+  test(`${harness} footer identifies its harness, subscription, model and effort`, async () => {
+    const setup = await testRender(
+      <AgentConfigControls
+        theme={DARK}
+        onConfigure={() => {}}
+        state={{
+          ...initial,
+          harness: { id: harness, label: harness },
+          configOptions: [
+            {
+              id: "provider",
+              name: "Provider",
+              currentValue: harness,
+              options: [
+                {
+                  value: harness,
+                  name: harness === "pi" ? "Codex subscription" : "Grok subscription",
+                },
+              ],
+            },
+            ...initial.configOptions!,
+          ],
+        }}
+      />,
+      { width: 100, height: 3 },
+    );
+
+    try {
+      await waitForText(setup, "First model");
+      const frame = setup.captureCharFrame();
+
+      expect(frame).toContain(harness);
+      expect(frame).toContain(harness === "pi" ? "Codex subscription" : "Grok subscription");
+      expect(frame).toContain("Medium");
+    } finally {
+      setup.renderer.destroy();
+    }
+  });
+}

package/src/thread/components/AgentConfigControls.tsx

@@ -18,10 +18,12 @@ export function AgentConfigControls({
 }): React.ReactNode {
   return (
     <box style={{ flexDirection: "row", gap: 2, marginRight: 2 }}>
+      {state.harness ? <text fg={theme.textMuted}>{state.harness.label}</text> : null}
       {state.configOptions
         ?.filter(
           (option) =>
             option.category === "thought_level" ||
+            option.id === "effort" ||
             option.id === "model" ||
             option.id === "provider",
         )
@@ -104,7 +106,11 @@ function AgentConfigMenu({
   return (
     <box
       ref={ref}
-      onMouseUp={disabled ? undefined : () => menu.toggleMenu(`agent-config:${option.id}`)}
+      onMouseUp={
+        disabled || option.options.length < 2
+          ? undefined
+          : () => menu.toggleMenu(`agent-config:${option.id}`)
+      }
     >
       <text fg={disabled ? theme.textDim : theme.textMuted}>
         {option.options.find((choice) => choice.value === option.currentValue)?.name ??

package/src/thread/components/AgentThreadPane.test.tsx

@@ -9,11 +9,12 @@ import {
 } from "@cueloop/schema";
 import { AgentThreadPane, AgentThreadPrototype } from "./AgentThreadPane";
 import { ThreadFooter } from "./ThreadFooter";
-import { ThreadView } from "../../markdown/components/ThreadView";
+import { ThreadView, type ThreadViewProps } from "../../markdown/components/ThreadView";
 import { buildDisplay, marksByDisplay } from "../../markdown/view-plan";
 import { DARK } from "../../appearance/theme";
 import {
   locateText,
+  dragText,
   waitForText,
   pressKey,
   typeText,
@@ -118,6 +119,8 @@ function artifactView(
   value: Thread,
   onReply: (id: string, body: string) => void = noop,
   onUpdateAnnotation: (id: string, body: string) => void = noop,
+  onAnnotate: ThreadViewProps["onAnnotate"] = noop,
+  observer = false,
 ) {
   const display = buildDisplay(value.artifact.content);
 
@@ -127,8 +130,8 @@ function artifactView(
       display={display}
       marks={marksByDisplay(value.annotations, display)}
       quickActions={[]}
-      observer={false}
-      onAnnotate={noop}
+      observer={observer}
+      onAnnotate={onAnnotate}
       onReply={onReply}
       onUpdateAnnotation={onUpdateAnnotation}
       onExit={noop}
@@ -1189,3 +1192,57 @@ test("shared viewers see pending activity without owner permission controls", as
     setup.renderer.destroy();
   }
 });
+
+for (const observer of [false, true]) {
+  test(`shared snapshot preserves artifact annotation permissions (observer=${observer})`, async () => {
+    const value = {
+      ...thread,
+      agentSnapshot: {
+        ...empty,
+        messages: [
+          {
+            id: "answer",
+            role: "agent" as const,
+            text: "Frozen conversation",
+            complete: true,
+            revision: 1,
+          },
+        ],
+      },
+    };
+    const annotations: string[] = [];
+    const setup = await testRender(
+      <AgentThreadPrototype
+        enabled={false}
+        observer={observer}
+        pixelPrototype={false}
+        thread={value}
+        focused
+        theme={DARK}
+        onActiveChange={noop}
+        onOpenFile={noop}
+      >
+        {artifactView(
+          value,
+          noop,
+          noop,
+          (_span, body) => {
+            annotations.push(body);
+          },
+          observer,
+        )}
+      </AgentThreadPrototype>,
+      { width: 100, height: 24, kittyKeyboard: true },
+    );
+
+    try {
+      await waitForText(setup, "Frozen conversation");
+      await dragText(setup, "Original artifact", "Original artifact", "Original artifact".length);
+      await typeText(setup, "Artifact feedback");
+      await pressKey(setup, "RETURN", { meta: true });
+      expect(annotations).toEqual(observer ? [] : ["Artifact feedback"]);
+    } finally {
+      setup.renderer.destroy();
+    }
+  });
+}

package/src/thread/components/AgentThreadPane.tsx

@@ -398,6 +398,55 @@ export function AgentThreadPane(props: AgentThreadPaneProps): React.ReactNode {
 export function AgentThreadPrototype(
   props: AgentThreadPaneProps & { enabled: boolean; observer: boolean; pixelPrototype: boolean },
 ): React.ReactNode {
+  if (
+    (!props.enabled || props.observer) &&
+    props.thread.agentSnapshot &&
+    React.isValidElement<ThreadViewProps>(props.children) &&
+    props.children.type === ThreadView
+  ) {
+    const child = props.children.props;
+    const display =
+      child.display ??
+      buildDisplay(
+        props.thread.artifact.type === "diff"
+          ? (props.thread.artifact.meta.prBrief ?? "")
+          : (props.thread.workingCopy ?? props.thread.artifact.content),
+      );
+    const projection = projectThreadConversation(
+      props.thread,
+      props.thread.agentSnapshot,
+      display,
+      child.marks ?? marksByDisplay(props.thread.annotations, display),
+      false,
+    );
+
+    return (
+      <ThreadView
+        {...child}
+        session={projection.session}
+        display={projection.display}
+        marks={projection.marks}
+        canAnnotateBlock={(index) =>
+          projection.sources[index]?.kind === "artifact" &&
+          (child.canAnnotateBlock?.(index) ?? true)
+        }
+        isAnnotationReadOnly={(id) =>
+          !props.thread.annotations.some((entry) => entry.id === id) ||
+          Boolean(child.isAnnotationReadOnly?.(id))
+        }
+        onAnnotate={(span, body) => {
+          if (
+            projection.sources[span.start.blockIndex]?.kind !== "artifact" ||
+            projection.sources[span.end.blockIndex]?.kind !== "artifact"
+          )
+            return;
+
+          return child.onAnnotate(span, body);
+        }}
+      />
+    );
+  }
+
   if (!props.enabled || props.observer || props.pixelPrototype) return props.children;
 
   return <AgentThreadPane {...props} />;

package/src/thread/thread-controller.share.test.ts

@@ -8,9 +8,16 @@ import {
   SHARE_RECONNECT_MIN_MS,
   type ShareTransport,
 } from "./thread-controller";
-import { mergeFromShare, type ShareWatchHandlers } from "../integrations/share";
+import {
+  snapshotThreadConversation,
+  mergeFromShare,
+  type ShareWatchHandlers,
+} from "../integrations/share";
 
-const publishShare = mock(async () => ({ line: "ssh p_abc123xy@cueloop.dev", copied: true }));
+const publishShare = mock(async (_session: Thread) => ({
+  line: "ssh p_abc123xy@cueloop.dev",
+  copied: true,
+}));
 let remote: Thread;
 const pullShare = mock(async () => remote);
 const pushShare = mock(
@@ -571,3 +578,41 @@ describe("revoke", () => {
     expect(client.sessionDelete).toHaveBeenCalledWith(session.id);
   });
 });
+
+test("share publication captures an empty artifact's separate conversation without execution records", async () => {
+  const thread = sessionFixture({ artifact: { type: "plan", content: "", meta: {} } });
+  const { controller, client } = await connectedController(thread);
+  const state = {
+    threadId: thread.id,
+    phase: { kind: "idle" as const },
+    harness: { id: "pi", label: "pi", sessionId: "private-session" },
+    messages: [
+      {
+        id: "answer",
+        role: "agent" as const,
+        text: "Visible conversation",
+        complete: true,
+        revision: 1,
+      },
+    ],
+    comments: [],
+    tools: [],
+    promptOperations: [
+      { operationId: "private-operation", fingerprint: "private-hash", result: [] },
+    ],
+  };
+
+  client.agentGet = async () => state;
+  publishShare.mockClear();
+  controller.share();
+  await tick();
+  await tick();
+  const shared = publishShare.mock.calls[0]![0];
+
+  expect(shared.agentSnapshot?.messages).toEqual(state.messages);
+  expect(shared.agentSnapshot?.harness).toEqual({ id: "pi", label: "pi" });
+  expect(shared.agentSnapshot?.promptOperations).toBeUndefined();
+  expect(thread.agentSnapshot).toBeUndefined();
+  expect(await snapshotThreadConversation(thread, {})).toBe(thread);
+  controller.close();
+});

package/src/thread/thread-controller.ts

@@ -49,6 +49,7 @@ import {
   collaboratorAnnotations,
   mergeFromShare,
   publishShare,
+  snapshotThreadConversation,
   pullShare,
   pushShare,
   revokeShare,
@@ -1764,12 +1765,13 @@ class Controller implements ReviewController {
   }
 
   /** A workbench thread renders live locally; freeze its diff so a remote reviewer gets a stable snapshot. */
-  private freezeForShare(session: Thread): Promise<Thread> {
+  private async freezeForShare(session: Thread): Promise<Thread> {
     const repoDiff = this.client?.repoDiff;
+    const shared = repoDiff
+      ? await snapshotWorkbench(session, (root, vcs) => repoDiff.call(this.client, root, vcs))
+      : session;
 
-    return repoDiff
-      ? snapshotWorkbench(session, (root, vcs) => repoDiff.call(this.client, root, vcs))
-      : Promise.resolve(session);
+    return this.client ? snapshotThreadConversation(shared, this.client) : shared;
   }
 
   share(): void {