@visual-z/xeno 0.4.0 → 0.6.0

package/src/apps/session-hub.ts

@@ -0,0 +1,84 @@
+/** Local clients open sessions through the same resource/credential loader as the terminal. */
+import { basename } from "node:path";
+import { createHash } from "node:crypto";
+import { createSession, copyAncestryTo, listSessions } from "../store/sessions.ts";
+import { readCursor, writeCursor } from "../store/log.ts";
+import { SessionHub } from "../runtime/session-hub.ts";
+import { sessionControl, type SessionControl } from "../runtime/session-control.ts";
+import { openSessionFor, sessionDirFor, type App } from "./startup.ts";
+import { interactiveHooks } from "./shell.ts";
+import { parseMcpServers } from "../core/mcp-config.ts";
+import { reloadAppResources } from "./resources.ts";
+
+export function createAppSessionHub(initial: App): SessionHub {
+  const apps = new Map<string, App>([[sessionControl(initial.session).threadId, initial]]);
+  // Aliases resolve to one durable log before construction: two cold resumes
+  // must never append through independent Session owners (D5/D6).
+  const opening = new Map<string, { result: Promise<SessionControl>; configuration: string }>();
+  return new SessionHub(sessionControl(initial.session), {
+    list: async () => ({ ...await listSessions(initial.workspace, sessionDirFor(initial.args, initial.workspace)), live: [...apps.keys()] }),
+    open: async (kind, params) => {
+      const clientMcp = params["acpMcpServers"] === undefined ? undefined : parseMcpServers(params["acpMcpServers"]);
+      const configuration = JSON.stringify(clientMcp ?? initial.args.clientMcp ?? null);
+      let source: string | undefined;
+      if (kind !== "new") {
+        const requested = String(params["session"]);
+        const live = [...apps.values()].find(app => sessionControl(app.session).threadId === requested || app.logDir === requested || basename(app.logDir) === requested);
+        if (kind === "resume" && live) {
+          if (clientMcp !== undefined) await sessionControl(live.session).withIdleChange(async () => {
+            const args = structuredClone(live.args); args.clientMcp = clientMcp;
+            await reloadAppResources(live, { ownerLocked: true, args }); await interactiveHooks.bindExtensions(live);
+          });
+          return sessionControl(live.session);
+        }
+        const found = (await listSessions(initial.workspace, sessionDirFor(initial.args, initial.workspace))).sessions
+          .find(item => item.ok && (createHash("sha256").update(item.path).digest("hex") === requested || item.path === requested || item.id === requested));
+        if (!live && !found) throw Error("session must belong to this app-server workspace");
+        source = live?.logDir ?? found!.path;
+        if (kind === "fork" && live?.session.running) throw Error("fork requires an idle source session");
+      }
+      if (kind === "resume") {
+        const pending = opening.get(source!);
+        if (pending) {
+          if (pending.configuration !== configuration) throw Error("a session resume with different MCP configuration is already opening; retry after it settles");
+          return pending.result;
+        }
+        const live = [...apps.values()].find(app => app.logDir === source);
+        if (live) return sessionControl(live.session);
+      }
+      const created = kind === "resume" ? undefined : await createSession(initial.workspace, undefined, sessionDirFor(initial.args, initial.workspace));
+      const logDir = created?.path ?? source!;
+      const construct = async () => {
+      if (kind === "fork") await copyAncestryTo(source!, logDir, new Date().toISOString());
+      const args = { ...structuredClone(initial.args), workspace: initial.workspace, logDir, prompt: "", print: true, fresh: kind === "new" };
+      if (clientMcp !== undefined) args.clientMcp = clientMcp;
+      delete args.resume; delete args.continueLatest; delete args.session; delete args.forkFrom;
+      const opened = await openSessionFor({ args, workspace: initial.workspace, logDir, blobDir: initial.blobDir, io: initial.io,
+        askSlot: {}, catalog: initial.catalog, auth: initial.auth, credentialOf: initial.credentialOf, effects: initial.effects,
+        interactive: false, projectTrusted: initial.projectTrusted === true, settings: initial.ui?.settings ?? {},
+        fallback: initial.providerConfig });
+      const app: App = { ...initial, args, ...opened, loadedContext: opened.resources.loadedContext, ui: opened.resources.ui,
+        slash: opened.resources.slash, extensions: opened.resources.extensions, resources: opened.resources.index,
+        foundation: opened.resources.foundation, projectTrusted: opened.resources.trusted, askSlot: opened.session.config.tools.askSlot ?? {} };
+      const control: SessionControl = sessionControl(app.session);
+      try {
+      app.askSlot.current = request => control.ask(request);
+      if (typeof params["name"] === "string") { const cursor = await readCursor(logDir); if (cursor) await writeCursor(logDir, { ...cursor, name: params["name"] }); }
+      await interactiveHooks.bindExtensions(app);
+      apps.set(control.threadId, app);
+      return control;
+      } catch (error) {
+        await app.session.dispose().catch(() => {}); await app.extensions?.dispose().catch(() => {}); throw error;
+      }
+      };
+      const result = construct();
+      if (kind === "resume") opening.set(logDir, { result, configuration });
+      try { return await result; }
+      finally { if (opening.get(logDir)?.result === result) opening.delete(logDir); }
+    },
+    dispose: async control => {
+      const app = apps.get(control.threadId);
+      await control.session.dispose(); await app?.extensions?.dispose(); apps.delete(control.threadId);
+    },
+  });
+}

package/src/apps/shell.ts

@@ -58,14 +58,15 @@ import { registerSessionRoot } from "../store/session-browser.ts";
 import { createSession, findSessionByPrefix, listSessions, truncationNote, sessionsDir } from "../store/sessions.ts";
 import { exportSessionArchive, importSessionArchive } from "../store/session-archive.ts";
 import { resolveTuiMode } from "../core/tui-mode.ts";
-import { recordRecent } from "../core/model-picker.ts";
+import { modelPreferencePatch, thinkingPreferencePatch } from "../core/model-preferences.ts";
 import { flattenTree, treeFromPoints, LEFT_BRANCH_MARK, EMPTY_TREE_MESSAGE, type TreeNode, type NodeParent, type TreePoint } from "../core/session-tree.ts";
 import { cycle } from "../core/cycle.ts";
 import { THINKING_LEVELS, asThinkingLevel as asEffort, supportedThinkingLevels, clampThinkingLevel } from "../core/thinking.ts";
 import { modelKey } from "../core/session-position.ts";
 import { defaultKeymap, listBindings } from "../core/keymap.ts";
-import { settingPatch, mergeSettings } from "../core/settings.ts";
-import { writeUserSettings, resolveTheme } from "../store/resources.ts";
+import { settingPatch } from "../core/settings.ts";
+import { resolveTheme } from "../store/resources.ts";
+import { commitUserSettings, type PreferenceOrigin } from "./preferences.ts";
 import { colorEnabled } from "./render.ts";
 import { createStyle, IDENTITY } from "../tui/style.ts";
 import { lastAssistantText, toHtml } from "../core/export.ts";
@@ -80,6 +81,11 @@ import {
   openSessionFor, sessionDirFor, retryHandler, whyNot, splitModelPatterns, runModelsRefresh, sessionToolCatalog, type App,
 } from "./startup.ts";
 import type { TurnSurface, Ui } from "./ui/surface.ts";
+import { runManualUpdate } from "./update-check.ts";
+import { presentQuestions } from "./question-ui.ts";
+import { bindAppWorkflow, setAppWorkflow } from "./workflow.ts";
+import { appReviewSnapshot, runReview, reviewScopeFromText } from "./review.ts";
+import { selectAppAgent, listAppAgents } from "./agent-profiles.ts";
 
 /**
  * One line. Listing all ~40 commands here wrapped into a two-line wall that
@@ -112,6 +118,11 @@ function extensionContext(app: App, tui?: Ui): ExtensionContext {
 }
 
 async function bindExtensions(app: App, tui?: Ui): Promise<void> {
+  bindAppWorkflow(app);
+  if (tui) {
+    const control = sessionControl(app.session);
+    control.questionSlot.current = (request, signal) => control.askQuestion(request, signal, current => presentQuestions(tui.extensionUi, current, signal));
+  }
   tui?.bindExtensionRegistry();
   const registry = app.extensions; if (!registry) return;
   const history = await readNodeHistory(app.logDir, app.session.state.node);
@@ -144,9 +155,9 @@ async function bindExtensions(app: App, tui?: Ui): Promise<void> {
     },
     setModel: async model => {
       if (typeof model !== "object" || !model || !("provider" in model) || !("id" in model)) return false;
-      await switchByPattern(app, String(model.provider) + "/" + String(model.id)); return app.providerConfig.spec.id === model.id && app.providerConfig.spec.provider === model.provider;
+      await switchByPattern(app, String(model.provider) + "/" + String(model.id), "session"); return app.providerConfig.spec.id === model.id && app.providerConfig.spec.provider === model.provider;
     },
-    setThinking: async level => { await applyThinkingCommand(app, level, tui ?? null); },
+    setThinking: async level => { await applyThinkingCommand(app, level, tui ?? null, "session"); },
     exec: (command, args, options) => app.session.runExtensionCommand(command, args, options),
   });
   if (!initializedExtensions.has(registry)) {
@@ -425,6 +436,24 @@ type Outcome = "continue" | "quit" | { login: string };
 
 async function execute(app: App, command: Command, tui: Ui | null): Promise<Outcome> {
   switch (command.kind) {
+    case "workflow":
+      await setAppWorkflow(app, command.mode); app.io.say(`  Workflow: ${command.mode}`); await tui?.refreshResources(); return "continue";
+    case "agent":
+      if (command.name) { await selectAppAgent(app, command.name); await bindExtensions(app, tui ?? undefined); await tui?.refreshResources(); }
+      else app.io.say(await listAppAgents(app)); return "continue";
+    case "mcp": {
+      const manager = app.foundation?.mcp; if (!manager) throw Error("MCP resources are unavailable");
+      if (command.action === "status") app.io.say(JSON.stringify(manager.status(), null, 2));
+      else {
+        if (!command.name) throw Error(`Use /mcp ${command.action} <server>`);
+        if (command.action === "login") await manager.login(command.name, url => { app.io.say(`  Complete MCP login: ${url.href}`); }, tui?.signal);
+        else await manager.logout(command.name);
+        await reloadAppResources(app); await bindExtensions(app, tui ?? undefined); await tui?.refreshResources();
+      }
+      return "continue";
+    }
+    case "diff": { const snapshot = await appReviewSnapshot(app, reviewScopeFromText(command.args), tui?.signal); app.io.say(`${snapshot.label}\n${snapshot.diff || "(no captured changes)"}\n${snapshot.limitations.join("\n")}`); return "continue"; }
+    case "review": await runReview(app, reviewScopeFromText(command.args), tui?.signal); await tui?.syncTranscript(); return "continue";
     case "extension":
       if (tui) tui.runExtensionCommand(command.name, command.args);
       else { await bindExtensions(app); await app.extensions?.command(command.name, command.args); }
@@ -625,6 +654,10 @@ async function execute(app: App, command: Command, tui: Ui | null): Promise<Outc
       if (tui) tui.showDocument("Changelog", text); else app.io.say(text);
       return "continue";
     }
+    case "update":
+      if (tui) tui.checkForUpdate();
+      else await runManualUpdate({ offline: app.args.offline === true }, app.io.say);
+      return "continue";
     case "copy":
       await copyLastReply(app, tui ?? undefined);
       return "continue";
@@ -822,7 +855,8 @@ async function commitSetting(app: App, field: string, value: string, tui: Ui | n
   }
   if (key === "thinking") {
     const effort = asEffort(value);
-    if (!effort || !await applyThinking(app, effort, tui)) return;
+    if (effort) await applyThinking(app, effort, tui);
+    return;
   }
   const parsed = settingPatch(key === "status" ? "statusBar" : field, value);
   if (parsed.diagnostics.length) { app.io.say(C.yellow(parsed.diagnostics.join("\n"))); return; }
@@ -833,12 +867,12 @@ async function commitSetting(app: App, field: string, value: string, tui: Ui | n
     app.ui.theme = theme;
     app.ui.style = colorEnabled() ? createStyle(theme.colors) : IDENTITY;
   }
-  await writeUserSettings(parsed.settings);
-  app.ui.settings = mergeSettings({ builtin: app.ui.settings, user: parsed.settings });
-  app.ui.userOverrides = mergeSettings({ builtin: app.ui.userOverrides, user: parsed.settings });
-  if (key === "enableskillcommands") { await reloadAppResources(app); await tui?.refreshResources(); }
-  if (tui) tui.toast(`${field} · ${value}`, "success");
-  else app.io.say(C.dim(`  ${field} ${value}`));
+  const saved = await commitUserSettings(app, parsed.settings);
+  if (saved && key === "enableskillcommands") { await reloadAppResources(app); await tui?.refreshResources(); }
+  if (saved) {
+    if (tui) tui.toast(`${field} · ${value}`, "success");
+    else app.io.say(C.dim(`  ${field} ${value}`));
+  }
   tui?.applyConfiguration();
   if (key === "theme") tui?.followTheme();
   tui?.redraw();
@@ -856,7 +890,7 @@ function effortSupported(spec: ModelSpec, level: Effort): boolean {
  * must not cut: a cut drops the prefix cache, and thinking blocks stay
  * valid because the model did not change.
  */
-async function applyThinking(app: App, level: Effort, tui: Ui | null): Promise<boolean> {
+async function applyThinking(app: App, level: Effort, tui: Ui | null, origin: PreferenceOrigin = "user"): Promise<boolean> {
   const C = app.io.palette;
   if (!effortSupported(app.providerConfig.spec, level)) {
     app.io.say(
@@ -874,19 +908,20 @@ async function applyThinking(app: App, level: Effort, tui: Ui | null): Promise<b
   if (app.ui !== undefined) {
     app.ui.settings = { ...app.ui.settings, thinking: level };
   }
+  if (origin === "user") await commitUserSettings(app, thinkingPreferencePatch(app.providerConfig.spec, level));
   app.io.say(C.dim(`  thinking ${level}`));
   tui?.redraw();
   return true;
 }
 
-async function applyThinkingCommand(app: App, level: string | undefined, tui: Ui | null): Promise<Outcome> {
+async function applyThinkingCommand(app: App, level: string | undefined, tui: Ui | null, origin: PreferenceOrigin = "user"): Promise<Outcome> {
   if (level !== undefined) {
     const effort = asEffort(level);
     if (effort === undefined) {
       app.io.say(app.io.palette.yellow("  thinking must be " + THINKING_LEVELS.join("|")));
       return "continue";
     }
-    await applyThinking(app, effort, tui);
+    await applyThinking(app, effort, tui, origin);
     return "continue";
   }
   if (tui) {
@@ -1486,7 +1521,7 @@ async function adoptCredential(app: App, ready: readonly ModelSpec[]): Promise<v
   const got = app.credentialOf(spec);
   if (!got.ok) return;
   if (app.credential.ok || app.session.state.handoff !== null || app.session.state.events.some((e) => e.t === "assistant")) {
-    await switchToModel(app, spec);
+    await switchToModel(app, spec, undefined, "session");
     return;
   }
   const nextConfig: ProviderConfig = {
@@ -1511,7 +1546,7 @@ async function adoptCredential(app: App, ready: readonly ModelSpec[]): Promise<v
   app.io.say(C.green(`  now ${spec.name}`) + C.dim(`  ${spec.id}`));
 }
 
-async function switchByPattern(app: App, pattern: string): Promise<void> {
+async function switchByPattern(app: App, pattern: string, origin: PreferenceOrigin = "user"): Promise<void> {
   const C = app.io.palette;
   const found = scopedModels([pattern], app.catalog, true), selected = found.entries[0];
   if (!selected) {
@@ -1519,16 +1554,11 @@ async function switchByPattern(app: App, pattern: string): Promise<void> {
     app.io.say(C.red(`  ${diagnostic.ok ? found.diagnostics.join("; ") : diagnostic.reason}`));
     return;
   }
-  await switchToModel(app, selected.model, selected.thinking);
+  await switchToModel(app, selected.model, selected.thinking, origin);
 }
 
-export async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort): Promise<void> {
+export async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort, origin: PreferenceOrigin = "user"): Promise<void> {
   const C = app.io.palette;
-  if (spec.id === app.providerConfig.spec.id && spec.provider === app.providerConfig.spec.provider) {
-    if (thinking) await applyThinking(app, clampThinkingLevel(spec, thinking), null);
-    app.io.say(C.dim(`  already on ${spec.id}`));
-    return;
-  }
   const got = app.credentialOf(spec);
   if (!got.ok) {
     app.io.say(C.red(`\n  ${got.reason}\n`));
@@ -1537,6 +1567,12 @@ export async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort
     }
     return;
   }
+  if (spec.id === app.providerConfig.spec.id && spec.provider === app.providerConfig.spec.provider) {
+    if (thinking) await applyThinking(app, clampThinkingLevel(spec, thinking), null, "session");
+    if (origin === "user") await rememberModelSelection(app, spec, thinking);
+    app.io.say(C.dim(`  already on ${spec.id}`));
+    return;
+  }
   const nextConfig: ProviderConfig = {
     spec,
     maxTokens: outputTokenBudget(spec),
@@ -1554,15 +1590,15 @@ export async function switchToModel(app: App, spec: ModelSpec, thinking?: Effort
   app.providerConfig = nextConfig;
   app.credential = got;
   app.io.say(C.green(`  now ${spec.name}`) + C.dim(`  ${spec.id}`));
-  await rememberRecentModel(app, spec);
+  if (origin === "user") await rememberModelSelection(app, spec, thinking);
 }
 
-/** Recency feeds the picker's first section; a write failure only costs ordering. */
-async function rememberRecentModel(app: App, spec: ModelSpec): Promise<void> {
+/** N.8 must accept the checkpoint before a user choice can own the next startup. */
+async function rememberModelSelection(app: App, spec: ModelSpec, explicitThinking: Effort | undefined): Promise<void> {
   if (!app.ui) return;
-  const recentModels = recordRecent(app.ui.settings.recentModels ?? [], modelKey(spec));
-  app.ui.settings = { ...app.ui.settings, recentModels };
-  try { await writeUserSettings({ recentModels }); } catch { /* ordering only */ }
+  const effort = app.providerConfig.effort;
+  const patch = modelPreferencePatch(spec, app.ui.settings.recentModels ?? [], effort);
+  await commitUserSettings(app, explicitThinking === undefined ? patch : { ...patch, ...thinkingPreferencePatch(spec, effort) });
 }
 
 function sessionDirOf(app: App): string | undefined {
@@ -1621,6 +1657,7 @@ async function adoptLogDir(app: App, logDir: string): Promise<boolean> {
     app.resources = opened.resources.index;
     app.projectTrusted = opened.resources.trusted;
     app.extensions = opened.resources.extensions;
+    app.foundation = opened.resources.foundation;
   } catch (err) {
     app.io.say(app.io.palette.red(`  ${describeError(err)}`));
     return false;
@@ -1864,6 +1901,10 @@ export async function runTurn(
   let live = false;
   let skipFinal = false;
   const json = app.args?.mode === "json";
+  const checkedOutput = app.session.config.validateOutput !== undefined;
+  let finalText: string[] = [];
+  let completed = false;
+  let failure: string | undefined;
   const pull = tui?.pullQueued?.bind(tui);
   const registry = app.extensions;
   const before = await registry?.emit("before_agent_start", { prompt: userInputData(prompt).text, systemPrompt: app.session.config.frozen.system }) ?? [];
@@ -1874,6 +1915,14 @@ export async function runTurn(
   await registry?.emit("agent_start");
   await registry?.emit("turn_start", { turnIndex: 0 });
   try { for await (const e of skill ? app.session.sendSkill(skill, prompt, signal) : sessionControl(app.session).send(prompt, signal, pull)) {
+    // The log retains every response, but a script's final answer must be the
+    // accepted last response. A rejected JSON document cannot be unwritten.
+    if (e.kind === "turn_start" || e.kind === "discard") finalText = [];
+    if (e.kind === "assistant_text") finalText.push(e.text ?? "");
+    if (e.kind === "done") {
+      completed = e.outcome?.status === "completed";
+      if (checkedOutput && !completed) failure = e.reason ?? "output schema validation did not complete";
+    }
     tui?.observeEvent?.(e);
     if (e.kind === "text_delta" || e.kind === "thinking_delta") await registry?.emit("message_update", { assistantMessageEvent: { type: e.kind, delta: e.text } });
     if (e.kind === "assistant_text") await registry?.emit("message_end", { message: { role: "assistant", content: [{ type: "text", text: e.text }] } });
@@ -1883,6 +1932,7 @@ export async function runTurn(
       if (payload !== null) process.stdout.write(`${JSON.stringify(payload)}\n`);
       continue;
     }
+    if (checkedOutput && !tui && e.kind === "assistant_text") continue;
     if (e.kind === "progress") { if (e.progress) tui?.pushProgress?.(e.progress); continue; }
     if (tui?.syncTranscript) {
       if (e.kind === "usage" && e.ok === false && e.prefix && app.ui?.settings.showCacheMissNotices === true)
@@ -1936,6 +1986,14 @@ export async function runTurn(
       app.io.say(line);
     }
   } } finally { await registry?.emit("agent_end", { messages: structuredClone(app.session.state.events) }); }
+  if (failure) throw Error(failure);
+  if (completed) {
+    const text = finalText.join("\n");
+    if (checkedOutput && !tui && !json) {
+      if (app.io.answer) app.io.answer(text); else app.io.say(text);
+    }
+    if (app.args?.outputLastMessage) await writeFile(resolve(app.args.outputLastMessage), text.endsWith("\n") ? text : text + "\n", "utf8");
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/apps/startup-input.ts

@@ -7,7 +7,7 @@
 type StartupStdin = Pick<NodeJS.ReadStream, "isTTY" | "isRaw" | "setRawMode" | "setEncoding" | "on" | "off" | "resume" | "pause" | "unshift">;
 export interface StartupInput {
   phase(name: string): void;
-  /** Pause, restore the shell's mode and replay held bytes to the next input owner. */
+  /** Pause and replay held bytes while keeping raw mode for the next input owner. */
   handoff(): void;
   /** Final cleanup discards unsubmitted input instead of leaking it to the shell. */
   restore(): void;
@@ -45,9 +45,14 @@ export function createStartupInput(opts: {
     stdin.off("data", receive);
     signals.off("SIGINT", interrupt); signals.off("SIGTERM", terminate); signals.off("SIGHUP", hangup);
     pasting = false; partial = "";
+  };
+  const restore = () => {
+    if (closed) return;
+    closed = true; release(); pending = [];
+    // D20: ownership transfer must not expose a cooked-mode gap that turns CR into LF.
+    // Final cleanup also restores termios when the next renderer never mounted.
     stdin.setRawMode(wasRaw);
   };
-  const restore = () => { closed = true; release(); pending = []; };
   const cancel = (code: number) => {
     if (!active) return;
     restore();