@prestyj/cli 5.2.0 → 5.3.0

package/dist/app-sidecar.js

@@ -23,6 +23,9 @@ import { AgentSession } from "./core/agent-session.js";
 import { buildNolanSystemPrompt, buildNolanAutopilotSystemPrompt } from "./core/nolan-prompt.js";
 import { buildNolanDigest, buildNolanAutopilotContext } from "./core/nolan-context.js";
 import { parseAutopilotVerdict } from "./core/autopilot-verdict.js";
+import { isWorkflowCommandText, countAssistantMessages, shouldStartAutopilotCycle, } from "./core/autopilot-gate.js";
+import { driveAutopilotCycle } from "./core/autopilot-cycle.js";
+import { validateNolanModelPref, effectiveNolanModel, } from "./core/nolan-model.js";
 import { collectProjectContext } from "./system-prompt.js";
 import { AuthStorage } from "./core/auth-storage.js";
 import { MOONSHOT_OAUTH_KEY, XIAOMI_CREDITS_KEY } from "@prestyj/core";
@@ -82,6 +85,7 @@ async function loadAppSettings() {
             // model/thinking handlers below).
             projectModels: raw.projectModels && typeof raw.projectModels === "object" ? raw.projectModels : undefined,
             autopilot: raw.autopilot && typeof raw.autopilot === "object" ? raw.autopilot : undefined,
+            nolanModels: raw.nolanModels && typeof raw.nolanModels === "object" ? raw.nolanModels : undefined,
         };
     }
     catch {
@@ -105,6 +109,24 @@ async function saveProjectModelPrefs(cwd, prefs) {
     s.projectModels = { ...(s.projectModels ?? {}), [key]: prefs };
     await saveAppSettings(s);
 }
+/** Read this project's persisted Nolan model override, if any. */
+async function loadNolanModelPref(cwd) {
+    const s = await loadAppSettings();
+    return s.nolanModels?.[projectModelKey(cwd)];
+}
+/** Persist (or with null, clear) this project's Nolan model override via
+ *  read-modify-write so the rest of the settings file is preserved. */
+async function saveNolanModelPref(cwd, pref) {
+    const s = await loadAppSettings();
+    const key = projectModelKey(cwd);
+    const next = { ...(s.nolanModels ?? {}) };
+    if (pref)
+        next[key] = pref;
+    else
+        delete next[key];
+    s.nolanModels = next;
+    await saveAppSettings(s);
+}
 /** Read this project's persisted autopilot flag (default off). */
 async function loadAutopilot(cwd) {
     const s = await loadAppSettings();
@@ -378,12 +400,23 @@ async function runJsonModeIfRequested() {
             model: { type: "string" },
             "max-turns": { type: "string" },
             "system-prompt": { type: "string" },
+            tools: { type: "string" },
             "prompt-cache-key": { type: "string" },
         },
         allowPositionals: true,
         strict: true,
     });
     const maxTurnsRaw = values["max-turns"];
+    // Optional tool allow-list forwarded by the subagent spawner from an agent
+    // definition's `tools:` frontmatter. Mirrors the identical parsing in
+    // cli.ts's `values.json` branch — keep both in sync (see subagent.ts).
+    const parsedTools = values.tools
+        ? values.tools
+            .split(",")
+            .map((t) => t.trim())
+            .filter(Boolean)
+        : [];
+    const allowedTools = parsedTools.length > 0 ? parsedTools : undefined;
     await runJsonMode({
         message: positionals[0] ?? "",
         provider: (values.provider ?? "anthropic"),
@@ -391,6 +424,7 @@ async function runJsonModeIfRequested() {
         cwd: process.cwd(),
         systemPrompt: values["system-prompt"],
         maxTurns: maxTurnsRaw ? parseInt(maxTurnsRaw, 10) : undefined,
+        allowedTools,
         promptCacheKey: values["prompt-cache-key"],
     }).catch((err) => {
         process.stderr.write((err instanceof Error ? err.message : String(err)) + "\n");
@@ -591,9 +625,11 @@ function lastAssistantText(messages) {
 /**
  * Assemble Nolan's context digest for one `@Nolan` question: project docs (up the
  * tree) + git/env + the build session's compaction summary + recent activity.
- * Prepended to the user's question as Nolan's prompt body each turn.
+ * Prepended to the user's question as Nolan's prompt body each turn. Workflow
+ * commands + autopilot-injected prompts are passed through so the digest
+ * labels them as what they are instead of user-authored asks.
  */
-async function buildNolanContext(buildSession, cwd, gitBranch, question) {
+async function buildNolanContext(buildSession, cwd, gitBranch, question, workflowCommands, injectedPrompts) {
     const projectContext = await collectProjectContext(cwd).catch(() => []);
     return buildNolanDigest({
         question,
@@ -601,6 +637,8 @@ async function buildNolanContext(buildSession, cwd, gitBranch, question) {
         cwd,
         gitBranch,
         messages: buildSession.getMessages(),
+        workflowCommands,
+        injectedPrompts,
     });
 }
 /**
@@ -798,6 +836,23 @@ async function createSession(deps, opts) {
     let autopilotCancelled = false;
     // Hard cap on review→prompt→review rounds per user turn (loop safety).
     const MAX_AUTOPILOT_ROUNDS = 3;
+    // Prompt bodies Autopilot Nolan injected into the BUILD session this
+    // conversation. Passed into every Nolan digest so injected prompts render as
+    // "Nolan autopilot (injected)" instead of `**User:**` — otherwise multi-round
+    // cycles drift into Nolan reviewing against his own last prompt. Cleared
+    // whenever the conversation resets (new session / plan accept / task run).
+    let injectedAutopilotPrompts = [];
+    // Workflow (prompt-template) commands: built-in + the project's custom
+    // `.ezcoder/commands/*.md`. Used to gate autopilot off command turns and to label
+    // expanded templates in Nolan's digests. Loaded fresh so a newly added custom
+    // command is picked up without a restart (mirrors GET /commands).
+    async function loadWorkflowCommandSpecs() {
+        const custom = await loadCustomCommands(cwd).catch(() => []);
+        return [
+            ...PROMPT_COMMANDS.map((c) => ({ name: c.name, aliases: c.aliases, prompt: c.prompt })),
+            ...custom.map((c) => ({ name: c.name, aliases: [], prompt: c.prompt })),
+        ];
+    }
     // ── Telegram serve (remote control via Telegram) ───────────
     // A single embedded serve session lives in this sidecar process. Only the main
     // window's home screen exposes the controls, so there's one bot per app.
@@ -813,6 +868,35 @@ async function createSession(deps, opts) {
     let nolanRunning = false;
     let pendingNolanModel = null;
     const nolanToolCallNames = new Map();
+    // Nolan's per-project model override. null → Nolan (chat + autopilot) follows GG
+    // Coder's model, including live switches (the historical behavior). Set → Nolan
+    // is pinned to his own model and EZ Coder switches no longer touch him. A
+    // stale persisted pin (model dropped from the registry / provider logged
+    // out) validates to null so Nolan degrades to following instead of erroring.
+    let nolanModelOverride = validateNolanModelPref(await loadNolanModelPref(cwd), {
+        modelExists: (id) => getModel(id) !== undefined,
+        providerConnected: () => true, // async auth checked below
+    });
+    if (nolanModelOverride && !(await auth.hasProviderAuth(nolanModelOverride.provider))) {
+        log("WARN", "app-sidecar", "ken model override provider not connected — following GG", {
+            provider: nolanModelOverride.provider,
+            model: nolanModelOverride.model,
+        });
+        nolanModelOverride = null;
+    }
+    /** The model Nolan uses next turn: the pin when set, else EZ Coder's. */
+    function nolanCurrentModel() {
+        if (nolanModelOverride)
+            return nolanModelOverride;
+        const st = session.getState();
+        return { provider: st.provider, model: st.model };
+    }
+    /** Footer payload: Nolan's effective model + whether it's a pin. Merged into
+     *  /state, the SSE ready frame, and every ken_model_change broadcast. */
+    function nolanStatePayload() {
+        const st = session.getState();
+        return effectiveNolanModel(nolanModelOverride, { provider: st.provider, model: st.model });
+    }
     async function syncNolanModel(provider, model) {
         if (nolanRunning) {
             pendingNolanModel = { provider, model };
@@ -829,10 +913,10 @@ async function createSession(deps, opts) {
     async function ensureNolanSession() {
         if (nolanSession)
             return nolanSession;
-        const st = session.getState();
+        const target = nolanCurrentModel();
         const ken = new AgentSession({
-            provider: st.provider,
-            model: st.model,
+            provider: target.provider,
+            model: target.model,
             cwd,
             systemPrompt: buildNolanSystemPrompt(),
             allowedTools: NOLAN_ALLOWED_TOOLS,
@@ -863,7 +947,10 @@ async function createSession(deps, opts) {
             broadcastError("nolan_error", "ken error", d.error);
         });
         nolanSession = ken;
-        log("INFO", "app-sidecar", "ken session ready", { provider: st.provider, model: st.model });
+        log("INFO", "app-sidecar", "ken session ready", {
+            provider: target.provider,
+            model: target.model,
+        });
         return ken;
     }
     // ── Autopilot Nolan (auto-reviewer) ──────────────────────────
@@ -892,10 +979,10 @@ async function createSession(deps, opts) {
     async function ensureNolanAutoSession() {
         if (nolanAutoSession)
             return nolanAutoSession;
-        const st = session.getState();
+        const target = nolanCurrentModel();
         const ken = new AgentSession({
-            provider: st.provider,
-            model: st.model,
+            provider: target.provider,
+            model: target.model,
             cwd,
             systemPrompt: buildNolanAutopilotSystemPrompt(),
             allowedTools: NOLAN_ALLOWED_TOOLS,
@@ -908,8 +995,8 @@ async function createSession(deps, opts) {
         // runAutopilotReview try/catch as autopilot_error frames.
         nolanAutoSession = ken;
         log("INFO", "app-sidecar", "ken autopilot session ready", {
-            provider: st.provider,
-            model: st.model,
+            provider: target.provider,
+            model: target.model,
         });
         return ken;
     }
@@ -974,7 +1061,9 @@ async function createSession(deps, opts) {
     // One review = prompt the nolanAuto session with the review digest, read its
     // final assistant text, parse a verdict. Returns null on failure (surfaced as
     // an autopilot_error frame) so the cycle stops rather than looping blind.
-    async function runAutopilotReview() {
+    // `originalRequest` is the user prompt that started the turn under review —
+    // pinned in the digest so it can't scroll out during multi-round cycles.
+    async function runAutopilotReview(originalRequest) {
         autopilotReviewing = true;
         broadcast("autopilot_review_start", {});
         try {
@@ -985,6 +1074,9 @@ async function createSession(deps, opts) {
                 cwd,
                 gitBranch,
                 messages: session.getMessages(),
+                originalRequest,
+                injectedPrompts: [...injectedAutopilotPrompts],
+                workflowCommands: await loadWorkflowCommandSpecs(),
             });
             await ken.prompt(digest);
             return parseAutopilotVerdict(lastAssistantText(ken.getMessages()));
@@ -1003,44 +1095,101 @@ async function createSession(deps, opts) {
         }
     }
     // Drive the review→prompt→review loop for one finished user turn. Only ever
-    // called from POST /prompt after the user's own run resolves — never from the
-    // task runner, resume, /ken, or error paths, so there's no recursion and no
-    // guard tangle. Bounded by MAX_AUTOPILOT_ROUNDS and cancellable between steps.
-    async function runAutopilotCycle() {
+    // called after shouldStartAutopilotCycle approves the turn (POST /prompt or
+    // the stranded-queue drain) — never from the task runner, resume, /ken, or
+    // error paths, so there's no recursion and no guard tangle. The loop's
+    // control flow lives in driveAutopilotCycle (core/autopilot-cycle.ts) so
+    // every exit path is unit-tested; this only wires the real dependencies.
+    async function runAutopilotCycle(originalRequest) {
         if (!autopilot || autopilotCancelled)
             return;
         autopilotActive = true;
         try {
-            // Lean context per user turn: wipe prior review history so each new turn
-            // starts cheap, while within this cycle the few review messages persist so
-            // Nolan remembers what he already asked EZ Coder to fix.
-            await nolanAutoSession?.newSession().catch(() => { });
-            for (let round = 1; round <= MAX_AUTOPILOT_ROUNDS; round++) {
-                if (autopilotCancelled)
-                    return;
-                const verdict = await runAutopilotReview();
-                if (!verdict || autopilotCancelled)
-                    return;
-                if (verdict.kind === "all_clear") {
-                    broadcast("autopilot_done", {});
-                    return;
+            await driveAutopilotCycle({
+                maxRounds: MAX_AUTOPILOT_ROUNDS,
+                isCancelled: () => autopilotCancelled,
+                // An injected run entering plan mode halts the cycle (autopilot_human
+                // with the plan-hold reason) — Nolan never prompts into a read-only
+                // plan-mode session or answers the plan modal for the user.
+                isPlanMode: () => session.getPlanMode(),
+                // Lean context per user turn: wipe prior review history so each new
+                // turn starts cheap, while within this cycle the few review messages
+                // persist so Nolan remembers what he already asked EZ Coder to fix.
+                resetReviewer: async () => {
+                    await nolanAutoSession?.newSession().catch(() => { });
+                },
+                review: () => runAutopilotReview(originalRequest),
+                // prompt → record the injected body (so later digests label it as
+                // Nolan's, not the user's), show a compact Nolan-tinted marker (not the
+                // prompt body), then feed EZ Coder bracketed by runAgent so the run
+                // streams normally; the shared finally never re-triggers autopilot,
+                // so this can't recurse.
+                onInjected: (body, round) => {
+                    injectedAutopilotPrompts.push(body);
+                    broadcast("autopilot_prompted", { round, body });
+                },
+                runPrompt: (body) => runAgent(body, () => session.prompt(body)),
+                emit: (event) => broadcast(event.type, event.data),
+            });
+        }
+        finally {
+            autopilotActive = false;
+        }
+    }
+    // ── Stranded-queue drain ───────────────────────────────
+    // A prompt POSTed while an autopilot cycle is between injected runs (build
+    // idle, Nolan reviewing) queues — but the queue only drains INTO a running
+    // turn as steering. If the cycle ends without another run (ALL_CLEAR /
+    // IGNORE / HUMAN / error), that message would sit stranded until the next
+    // unrelated prompt, then land mislabeled as "concurrent steering" of an
+    // unrelated run. Drain it here as a fresh turn of its own (with its own
+    // gated review). Also covers the non-autopilot tail window: a message queued
+    // after the run's last steering drain but before run_end.
+    let drainingStrandedQueue = false;
+    async function runStrandedQueue() {
+        if (drainingStrandedQueue)
+            return;
+        drainingStrandedQueue = true;
+        try {
+            for (;;) {
+                if (running || autopilotActive)
+                    return;
+                const next = session.takeNextQueuedMessage();
+                if (!next)
+                    return;
+                broadcast("queued", { count: session.getQueuedCount() });
+                if (!next.text.trim() && next.attachments.length === 0)
+                    continue;
+                const workflowCommand = next.attachments.length === 0 &&
+                    isWorkflowCommandText(next.text, await loadWorkflowCommandSpecs());
+                const assistantsBefore = countAssistantMessages(session.getMessages());
+                await runAgent(next.text, async () => {
+                    if (next.attachments.length > 0) {
+                        await session.promptWithAttachments(next.text, next.attachments);
+                    }
+                    else {
+                        await session.prompt(next.text);
+                    }
+                });
+                const decision = shouldStartAutopilotCycle({
+                    enabled: autopilot,
+                    cancelled: autopilotCancelled,
+                    planMode: session.getPlanMode(),
+                    workflowCommand,
+                    assistantMessagesAdded: countAssistantMessages(session.getMessages()) - assistantsBefore,
+                });
+                if (decision.start) {
+                    await runAutopilotCycle(next.text);
                 }
-                if (verdict.kind === "human") {
-                    broadcast("autopilot_human", { reason: verdict.reason });
-                    return;
+                else if (autopilot) {
+                    log("INFO", "app-sidecar", "autopilot skipped (queued turn)", {
+                        reason: decision.reason,
+                    });
                 }
-                // prompt → show a compact Nolan-tinted marker (not the prompt body), then
-                // feed EZ Coder. Bracketed by runAgent so the run streams normally; the
-                // shared finally no longer re-triggers autopilot, so this can't recurse.
-                broadcast("autopilot_prompted", { round, body: verdict.body });
-                await runAgent(verdict.body, () => session.prompt(verdict.body));
-                if (autopilotCancelled)
-                    return;
             }
-            broadcast("autopilot_capped", { rounds: MAX_AUTOPILOT_ROUNDS });
         }
         finally {
-            autopilotActive = false;
+            drainingStrandedQueue = false;
         }
     }
     // ── Task runner (project task list → sessions) ──────────────
@@ -1054,6 +1203,7 @@ async function createSession(deps, opts) {
             return false;
         // Fresh session per task so one task's context never bleeds into the next.
         await session.newSession();
+        injectedAutopilotPrompts = [];
         titleGenerated = false;
         broadcast("session_reset", {});
         markTaskInProgress(cwd, task.id);
@@ -1164,6 +1314,7 @@ async function createSession(deps, opts) {
                 supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
                 supportsVideo: getModel(st.model)?.supportsVideo ?? false,
                 autopilot,
+                ...nolanStatePayload(),
                 ...footerExtras(),
             });
             return;
@@ -1188,6 +1339,7 @@ async function createSession(deps, opts) {
                     supportedThinkingLevels: getSupportedThinkingLevels(st.provider, st.model),
                     supportsVideo: getModel(st.model)?.supportsVideo ?? false,
                     autopilot,
+                    ...nolanStatePayload(),
                     ...footerExtras(),
                 },
             })}\n\n`);
@@ -1528,6 +1680,13 @@ async function createSession(deps, opts) {
                 // Fresh user turn: clear any cancel flag left from a prior cycle so this
                 // turn's autopilot review can run.
                 autopilotCancelled = false;
+                // Gate inputs captured around the run: whether this turn is a workflow
+                // slash command (attachment prompts skip slash expansion entirely), and
+                // how many assistant messages the run actually adds. Computed even when
+                // autopilot is currently off — the toggle can flip ON mid-run, and the
+                // gate reads the post-run value.
+                const workflowCommand = attachments.length === 0 && isWorkflowCommandText(text, await loadWorkflowCommandSpecs());
+                const assistantsBefore = countAssistantMessages(session.getMessages());
                 await runAgent(text, async () => {
                     if (attachments.length > 0) {
                         // Persist each attachment under .ezcoder/uploads so files are inspectable
@@ -1543,11 +1702,31 @@ async function createSession(deps, opts) {
                         await session.prompt(text);
                     }
                 });
-                // After the user's run settles, kick off Nolan's auto-review loop. This is
-                // the ONLY entry point into the cycle — it drives any follow-up EZ Coder
-                // runs itself, so the shared runAgent finally never recurses.
-                if (autopilot && !autopilotCancelled)
-                    await runAutopilotCycle();
+                // After the user's run settles, kick off Nolan's auto-review loop — but
+                // only when the turn is actually reviewable (shouldStartAutopilotCycle):
+                // workflow commands (/compare, /bullet-proof, …) end with reports or
+                // A/B/C choices reserved for the USER; registry commands (/help) and
+                // failed runs add no assistant work to judge; a turn that ended in plan
+                // mode has a pending Accept/Reject modal Nolan must not preempt. This is
+                // the ONLY entry point into the cycle besides the stranded-queue drain —
+                // it drives any follow-up EZ Coder runs itself, so the shared runAgent
+                // finally never recurses.
+                const decision = shouldStartAutopilotCycle({
+                    enabled: autopilot,
+                    cancelled: autopilotCancelled,
+                    planMode: session.getPlanMode(),
+                    workflowCommand,
+                    assistantMessagesAdded: countAssistantMessages(session.getMessages()) - assistantsBefore,
+                });
+                if (decision.start) {
+                    await runAutopilotCycle(text);
+                }
+                else if (autopilot) {
+                    log("INFO", "app-sidecar", "autopilot skipped", { reason: decision.reason });
+                }
+                // A prompt sent while Nolan was reviewing (build idle) queued but had no
+                // run to steer into — run it now as a fresh turn so it never strands.
+                await runStrandedQueue();
             });
             return;
         }
@@ -1578,7 +1757,7 @@ async function createSession(deps, opts) {
                 broadcast("nolan_run_start", { text });
                 try {
                     const ken = await ensureNolanSession();
-                    const digest = await buildNolanContext(session, cwd, gitBranch, text);
+                    const digest = await buildNolanContext(session, cwd, gitBranch, text, await loadWorkflowCommandSpecs(), injectedAutopilotPrompts);
                     await ken.prompt(digest);
                     // Record the turn against the BUILD session so it persists + survives
                     // resume (advisory custom entry, never an LLM message). Reply is Nolan's
@@ -1861,8 +2040,12 @@ async function createSession(deps, opts) {
                 // new model's credentials, so switching to a just-added provider works.
                 await auth.reload();
                 await session.switchModel(target.provider, target.id);
-                await syncNolanModel(target.provider, target.id);
-                await syncNolanAutoModel(target.provider, target.id);
+                // Nolan follows EZ Coder's model only while un-pinned; a user-set Nolan
+                // override survives GG model switches untouched.
+                if (!nolanModelOverride) {
+                    await syncNolanModel(target.provider, target.id);
+                    await syncNolanAutoModel(target.provider, target.id);
+                }
                 // Clamp the reasoning level to what the new model supports (mirrors the
                 // CLI): keep thinking on at the first supported tier if it was on but
                 // the prior level is unsupported here; leave it off if it was off.
@@ -1889,6 +2072,12 @@ async function createSession(deps, opts) {
                 // model_change is emitted by switchModel; follow with thinking_change so
                 // the footer toggle reflects the new model's supported levels.
                 broadcast("thinking_change", payload);
+                // Un-pinned Nolan just followed the switch — update his footer chip too.
+                // When Nolan is pinned, his effective model did not change, so skip the
+                // no-op event (keeps footer/event tests from treating a GG switch as a
+                // Nolan switch).
+                if (!nolanModelOverride)
+                    broadcast("ken_model_change", nolanStatePayload());
                 // The new model usually has a different context window — push extras so
                 // the footer's context meter rescales immediately.
                 broadcast("extras", footerExtras());
@@ -1896,6 +2085,54 @@ async function createSession(deps, opts) {
             });
             return;
         }
+        // Set or clear Nolan's model pin. Body: { model: "<id>" } to pin, or
+        // { model: null } / "" to clear (Nolan resumes following EZ Coder). Applies
+        // to BOTH Nolan sessions (chat + autopilot reviewer); a switch landing while
+        // either is mid-run defers via the pending-model mechanics.
+        if (method === "POST" && url === "/ken/model") {
+            void readBody(req).then(async (raw) => {
+                let modelId;
+                try {
+                    const parsed = JSON.parse(raw).model;
+                    modelId = typeof parsed === "string" && parsed.trim() ? parsed.trim() : null;
+                }
+                catch {
+                    json(res, 400, { error: "invalid JSON body" });
+                    return;
+                }
+                if (modelId === null) {
+                    // Clear the pin → follow EZ Coder again, syncing both sessions back.
+                    nolanModelOverride = null;
+                    await saveNolanModelPref(cwd, null);
+                    const st = session.getState();
+                    await syncNolanModel(st.provider, st.model);
+                    await syncNolanAutoModel(st.provider, st.model);
+                    log("INFO", "app-sidecar", "ken model pin cleared — following GG", {
+                        provider: st.provider,
+                        model: st.model,
+                    });
+                }
+                else {
+                    const target = getModel(modelId);
+                    if (!target) {
+                        json(res, 404, { error: `unknown model: ${modelId}` });
+                        return;
+                    }
+                    nolanModelOverride = { provider: target.provider, model: target.id };
+                    await saveNolanModelPref(cwd, nolanModelOverride);
+                    await syncNolanModel(target.provider, target.id);
+                    await syncNolanAutoModel(target.provider, target.id);
+                    log("INFO", "app-sidecar", "ken model pinned", {
+                        provider: target.provider,
+                        model: target.id,
+                    });
+                }
+                const payload = nolanStatePayload();
+                broadcast("ken_model_change", payload);
+                json(res, 200, payload);
+            });
+            return;
+        }
         if (method === "POST" && url === "/kill") {
             void readBody(req).then(async (raw) => {
                 let id;
@@ -1967,6 +2204,7 @@ async function createSession(deps, opts) {
             void session
                 .newSession()
                 .then(() => {
+                injectedAutopilotPrompts = [];
                 broadcast("session_reset", {});
                 json(res, 200, { ok: true });
             })
@@ -2000,6 +2238,7 @@ async function createSession(deps, opts) {
                 }
                 try {
                     await session.newSession();
+                    injectedAutopilotPrompts = [];
                     titleGenerated = false;
                     await session.setApprovedPlan(planPath);
                     broadcast("session_reset", {});