tesseract-agent 0.4.20 → 0.4.21

package/dist-bundle/cli.js

@@ -19450,6 +19450,10 @@ var init_ws_protocol = __esm({
       // co-viewers see images the moment the agent generates them
       "agent:canvas_ready",
       // co-viewers dock the HTML canvas the moment the agent renders it
+      "agent:report_ready",
+      // co-viewers see the mission report (and its in-place updates)
+      "agent:mission_progress",
+      // co-viewers see the Mission card's live stage progress
       "agent:elicitation_complete",
       // M5 — co-viewers clear a resolved url-mode card
       "chat:echoed",
@@ -19487,6 +19491,7 @@ var init_plans = __esm({
       advancedBrowser: false,
       hosting: false,
       plugins: false,
+      missions: false,
       scheduling: false,
       api: false,
       sso: false,
@@ -19523,6 +19528,7 @@ var init_plans = __esm({
           "Tesseract cloud server \u2014 a managed always-on agent in the cloud",
           "Deploy to the cloud \u2014 your app on a *.tesseract.dev URL",
           "Includes ~1 always-on service + 20 GB storage + 100 GB bandwidth (overage metered)",
+          "Premium missions \u2014 GDPR, security, UX, performance audits that fix & verify",
           "Sync settings across your devices",
           "Email support"
         ],
@@ -19536,6 +19542,7 @@ var init_plans = __esm({
           voice: true,
           hosting: true,
           plugins: true,
+          missions: true,
           scheduling: true,
           maxMachines: 0
         },
@@ -19570,6 +19577,7 @@ var init_plans = __esm({
           advancedBrowser: true,
           hosting: true,
           plugins: true,
+          missions: true,
           scheduling: true,
           api: true,
           sso: true,
@@ -20407,19 +20415,19 @@ function tokensToTailwindTheme(input) {
   const tokens = normalizeTokens(input);
   const extend2 = {};
   for (const { path: path5, token } of walkTokens(tokens)) {
-    const bucket = TW_BUCKETS.find((b) => b.match.length <= path5.length && b.match.every((seg, i) => path5[i] === seg));
-    if (!bucket)
+    const bucket2 = TW_BUCKETS.find((b) => b.match.length <= path5.length && b.match.every((seg, i) => path5[i] === seg));
+    if (!bucket2)
       continue;
-    const rest = path5.slice(bucket.match.length).map(kebab).filter(Boolean);
+    const rest = path5.slice(bucket2.match.length).map(kebab).filter(Boolean);
     if (rest.length === 0)
       continue;
     const ref = `var(${tokenCssVarName(path5, token)})`;
-    if (!extend2[bucket.key])
-      extend2[bucket.key] = {};
-    if (bucket.flat)
-      extend2[bucket.key][rest.join("-")] = ref;
+    if (!extend2[bucket2.key])
+      extend2[bucket2.key] = {};
+    if (bucket2.flat)
+      extend2[bucket2.key][rest.join("-")] = ref;
     else
-      setNested(extend2[bucket.key], rest, ref);
+      setNested(extend2[bucket2.key], rest, ref);
   }
   return { extend: extend2 };
 }
@@ -21440,7 +21448,7 @@ function slugify3(s) {
 }
 function buildCanvasTools(deps) {
   return [
-    tool4("render_canvas", "Render an HTML document as a live, sandboxed Canvas docked beside the chat (like OpenAI Canvas), for INTERACTIVE or multi-part PROJECTS (apps, tools, dashboards, anything the user will interact with at size). For a SMALL self-contained snippet or animation, do NOT use this \u2014 instead just include it as a fenced ```html (or ```svg) code block in your reply; it renders live inline in the message. To TRANSFORM an existing canvas, call again with the SAME id and the full updated HTML \u2014 it re-renders in place. Returns the canvas file path.", {
+    tool4("render_canvas", "Render an HTML document as a live, sandboxed Canvas docked beside the chat (like OpenAI Canvas), for INTERACTIVE or multi-part PROJECTS (apps, tools, dashboards, anything the user will interact with at size). For a SMALL self-contained snippet or animation, do NOT use this \u2014 instead just include it as a fenced ```html (or ```svg) code block in your reply; it renders live inline in the message. To TRANSFORM an existing canvas, call again with the SAME id and the full updated HTML \u2014 it re-renders in place. Before composing the HTML, consult the canvas-design skill for design fundamentals (and chart-design / diagram-design when the canvas is a chart or a diagram) so the result looks deliberately designed. Returns the canvas file path.", {
       html: external_exports.string().describe("The full HTML document to render (include <html>/<body>; put CSS/JS inline)."),
       title: external_exports.string().optional().describe("Short title for the canvas tab."),
       id: external_exports.string().optional().describe("Stable id to UPDATE an existing canvas; omit to create a new one.")
@@ -21462,6 +21470,132 @@ var init_canvas_tools = __esm({
   }
 });
 
+// ../../packages/agent-core/dist/report-tools.js
+import { tool as tool5 } from "@anthropic-ai/claude-agent-sdk";
+function slug(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 40) || "mission";
+}
+function buildReportTools(deps) {
+  return [
+    tool5("emit_report", `Deliver the structured findings of a mission playbook run as a Report card in the chat (this is the deliverable \u2014 do NOT just write findings as prose). Call it ONCE near the end with all findings grouped into the playbook's sections. To UPDATE after fixing/verifying a finding (Fix / Re-run), call again with the SAME id and finding ids, changing each finding's status \u2014 it re-renders in place. For "legal" bucket reports, never claim the site is compliant/certified; describe risks and route the verdict to a human.`, {
+      id: external_exports.string().optional().describe("Stable report id to UPDATE an existing report; omit on the first call to create one."),
+      playbookId: external_exports.string().describe("The playbook id this report belongs to."),
+      title: external_exports.string().describe("Report title (usually the playbook name)."),
+      summary: external_exports.string().describe("Plain-language overview of what was found."),
+      bucket: bucket.describe("Overall verifiability bucket for the report."),
+      sections: external_exports.array(external_exports.object({ id: external_exports.string(), title: external_exports.string(), description: external_exports.string().optional() })).describe("Ordered layout sections; findings reference these by id."),
+      findings: external_exports.array(finding)
+    }, async (args) => {
+      const id = args.id ? slug(args.id) : `report-${slug(args.playbookId)}-${Date.now()}`;
+      const report = {
+        id,
+        playbookId: args.playbookId,
+        title: args.title,
+        summary: args.summary,
+        bucket: args.bucket,
+        sections: args.sections,
+        findings: args.findings,
+        ts: Date.now()
+      };
+      deps.emitReport(report);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Report "${args.title}" delivered (${args.findings.length} finding(s)). To update a finding's status after fixing it, call emit_report again with id "${id}" and the same finding ids.`
+          }
+        ]
+      };
+    })
+  ];
+}
+var bucket, finding;
+var init_report_tools = __esm({
+  "../../packages/agent-core/dist/report-tools.js"() {
+    "use strict";
+    init_zod();
+    bucket = external_exports.enum(["deterministic", "heuristic", "legal"]);
+    finding = external_exports.object({
+      id: external_exports.string().describe("Stable id for this finding \u2014 REUSE it across updates so status changes land in place."),
+      severity: external_exports.enum(["high", "medium", "low", "info"]),
+      title: external_exports.string().describe("Short headline."),
+      description: external_exports.string().describe("Plain-language explanation a non-technical user understands."),
+      section: external_exports.string().optional().describe("Id of the report section this belongs under (matches a sections[].id)."),
+      location: external_exports.object({ selector: external_exports.string().optional(), xpath: external_exports.string().optional(), file: external_exports.string().optional(), line: external_exports.number().optional() }).optional().describe("Where it is \u2014 a CSS selector/xpath on the page, or a source file+line."),
+      suggestedFix: external_exports.string().optional().describe("Plain-language suggested fix."),
+      bucket: bucket.describe("Verifiability: deterministic (auto-fixable+verifiable), heuristic (advisory), or legal (readiness only \u2014 never certify)."),
+      status: external_exports.enum(["open", "fixed", "wontfix"]).describe('Current status; start as "open".')
+    });
+  }
+});
+
+// ../../packages/agent-core/dist/interactive-ui-tools.js
+import { tool as tool6 } from "@anthropic-ai/claude-agent-sdk";
+function buildInteractiveUiTools(deps) {
+  return [
+    tool6("ask_form", "Show the user a FORM in the chat and wait for them to fill it in. Use this to collect structured input mid-task (settings, scope, details) instead of asking in prose. Returns the submitted values (or that the user cancelled). Prefer this over free-text questions when the answer is structured.", {
+      title: external_exports.string().describe("Form heading (plain language)."),
+      description: external_exports.string().optional().describe("Short explanation shown above the fields."),
+      submitLabel: external_exports.string().optional().describe('Submit button label (default "Submit").'),
+      fields: external_exports.array(formField).min(1),
+      frozen: external_exports.boolean().optional().describe("Pin this card to the top of the chat so it does not scroll away while you keep working; it unpins once answered. Use true for input you NEED answered.")
+    }, async (args) => {
+      const spec = { component: "form", title: args.title, description: args.description, submitLabel: args.submitLabel, fields: args.fields, frozen: args.frozen };
+      const res = await deps.raiseUiRequest(spec);
+      if (res.cancelled)
+        return { content: [{ type: "text", text: "The user cancelled the form (no values submitted)." }] };
+      return { content: [{ type: "text", text: `The user submitted the form:
+${JSON.stringify(res.values ?? {}, null, 2)}` }] };
+    }),
+    tool6("present_choices", "Show the user a CHOICE picker in the chat and wait for them to choose. Use this to let the user make a decision or pick from options (single or multi-select). Returns the selected value(s) (or cancellation).", {
+      title: external_exports.string().describe("The question / heading."),
+      description: external_exports.string().optional(),
+      options: external_exports.array(choiceOption).min(1),
+      multiSelect: external_exports.boolean().optional().describe("Allow selecting more than one."),
+      frozen: external_exports.boolean().optional().describe("Pin this card to the top of the chat so it does not scroll away while you keep working; it unpins once answered.")
+    }, async (args) => {
+      const spec = { component: "choices", title: args.title, description: args.description, options: args.options, multiSelect: args.multiSelect, frozen: args.frozen };
+      const res = await deps.raiseUiRequest(spec);
+      if (res.cancelled)
+        return { content: [{ type: "text", text: "The user cancelled the choice (nothing selected)." }] };
+      return { content: [{ type: "text", text: `The user selected: ${JSON.stringify(res.selected ?? [])}` }] };
+    }),
+    tool6("update_progress", `Update the live Mission card so the user sees ongoing status. Call this whenever you move between stages (and once at the start). Pass the FULL ordered stage list each time with each stage's current status, plus a short "what I'm doing now" note. This is a one-way feedback channel \u2014 it returns immediately, does not wait for the user.`, {
+      stages: external_exports.array(external_exports.object({
+        label: external_exports.string(),
+        status: external_exports.enum(["pending", "active", "done"])
+      })).min(1).describe("The full ordered list of stages with each one's current status."),
+      note: external_exports.string().optional().describe("A short present-tense line about what is happening right now.")
+    }, async (args) => {
+      deps.emitProgress(args.stages, args.note);
+      return { content: [{ type: "text", text: "Progress updated." }] };
+    })
+  ];
+}
+var formField, choiceOption;
+var init_interactive_ui_tools = __esm({
+  "../../packages/agent-core/dist/interactive-ui-tools.js"() {
+    "use strict";
+    init_zod();
+    formField = external_exports.object({
+      key: external_exports.string().describe("Stable key the answer is returned under."),
+      label: external_exports.string(),
+      help: external_exports.string().optional().describe("Help text shown under the field."),
+      kind: external_exports.enum(["text", "textarea", "select", "multiselect", "toggle", "number"]),
+      options: external_exports.array(external_exports.object({ value: external_exports.string(), label: external_exports.string() })).optional().describe("For select / multiselect."),
+      default: external_exports.union([external_exports.string(), external_exports.array(external_exports.string()), external_exports.boolean(), external_exports.number()]).optional(),
+      required: external_exports.boolean().optional(),
+      placeholder: external_exports.string().optional()
+    });
+    choiceOption = external_exports.object({
+      value: external_exports.string(),
+      label: external_exports.string(),
+      description: external_exports.string().optional(),
+      preview: external_exports.string().optional().describe("Optional markdown preview shown when this option is focused.")
+    });
+  }
+});
+
 // ../../packages/agent-core/dist/session-transfer.js
 import { homedir as homedir2 } from "node:os";
 import { join as join6, dirname as dirname3, sep, resolve as resolve3 } from "node:path";
@@ -21634,6 +21768,21 @@ async function appendCanvasArtifact(sessionId, projectDir, a) {
     await writeManifest(dir, list);
   });
 }
+async function appendReportArtifact(sessionId, projectDir, report) {
+  const dir = await sessionSidecarDir(sessionId, projectDir);
+  if (!dir)
+    return;
+  await withManifestLock(dir, async () => {
+    const list = await readManifest(dir);
+    const entry = { id: `report-${report.id}`, kind: "report", ts: report.ts, title: report.title, report };
+    const at = list.findIndex((x) => x.kind === "report" && x.report?.id === report.id);
+    if (at >= 0)
+      list[at] = entry;
+    else
+      list.push(entry);
+    await writeManifest(dir, list);
+  });
+}
 async function readSessionArtifacts(sessionId, projectDir) {
   const dir = await sessionSidecarDir(sessionId, projectDir);
   if (!dir)
@@ -21649,7 +21798,8 @@ async function readSessionArtifacts(sessionId, projectDir) {
     images: a.images?.filter((im) => inDir(im.rel)).map((im) => ({ path: toAbs(dir, im.rel), mime: im.mime })),
     canvasId: a.canvasId,
     title: a.title,
-    path: a.file && inDir(a.file) ? toAbs(dir, a.file) : void 0
+    path: a.file && inDir(a.file) ? toAbs(dir, a.file) : void 0,
+    report: a.report
   })).sort((x, y) => x.ts - y.ts);
 }
 var MANIFEST, toRel, toAbs, manifestLocks;
@@ -22566,6 +22716,8 @@ var init_agent_manager = __esm({
     init_design_tools();
     init_imagegen_tools();
     init_canvas_tools();
+    init_report_tools();
+    init_interactive_ui_tools();
     init_session_artifacts();
     init_design_tokens2();
     init_narrator();
@@ -22620,7 +22772,7 @@ var init_agent_manager = __esm({
         };
       }
     };
-    IDLE_REAP_MS = 5 * 60 * 1e3;
+    IDLE_REAP_MS = 15 * 60 * 1e3;
     MODERATE_IDLE_MS = 60 * 1e3;
     STEER_COALESCE_MS = 500;
     STOP_HARD_KILL_AFTER_MS = 1200;
@@ -22635,6 +22787,17 @@ var init_agent_manager = __esm({
       liveSessions = /* @__PURE__ */ new Map();
       /** Sessions whose canonical sessionId is not yet known (first frame pending) */
       pendingLiveSessions = /* @__PURE__ */ new Set();
+      /** PRE-WARM (tab-driven): a single standby NEW-session instance — its cli.js process
+       *  is already spawned + booted and idling on an empty pump, so the next NEW conversation
+       *  whose construction-config matches `warmEmptyKey` is adopted instantly (skips the
+       *  ~1.6–3.4s spawn/boot). system/init only fires on the first push, so an un-adopted
+       *  warm instance stays silent and writes no transcript. */
+      warmEmpty = null;
+      warmEmptyKey = null;
+      /** The session backing the currently-FOCUSED tab — pinned against idle reap via the
+       *  'tab' keep-alive holder. Switching tabs releases the previous one (arming its 15-min
+       *  idle clock) and pins the new one (see setActiveSession). */
+      activeTabSession = null;
       /** requestId → the originating browser-cli socket, for unicast responses.
        *  browser-cli is one-shot, so the entry is deleted on the first write. */
       pendingResponses = /* @__PURE__ */ new Map();
@@ -22650,6 +22813,11 @@ var init_agent_manager = __esm({
       /** M5 H6 — parked MCP elicitation prompts, resolved when the client replies via
        *  chat:elicitation (→ respondToElicitation) or denied on abort. */
       pendingElicitations = /* @__PURE__ */ new Map();
+      /** Skill-driven interactive UI requests (ask_form / present_choices), resolved when
+       *  the client replies via chat:ui_response (→ respondToUiRequest) or the owning
+       *  session is torn down (→ cancelled). Keyed by requestId; `sessionId` lets a
+       *  teardown sweep cancel a session's parked cards. */
+      pendingUiRequests = /* @__PURE__ */ new Map();
       browserCliPath;
       /** Plugin-contributed agent tools (Epic G). The host loads enabled plugins and sets
        *  these; at session start they're aggregated behind ONE in-process MCP server and
@@ -22665,6 +22833,9 @@ var init_agent_manager = __esm({
       /** Local plugin bundling the enabled ClawHub skills (Epic H), loaded via query()'s
        *  `plugins` option so the SDK discovers their SKILL.md files. */
       skillsPlugin = null;
+      /** Bundled first-party mission-skills plugin (Part B). Attached per-session only
+       *  when a turn carries missionSkillId. Set once by the host from app resources. */
+      missionSkillsPlugin = null;
       /** Host-injected image-generation backend (keys + provider call + disk save live
        *  in the host; secrets never reach agent-core). Non-null ⇒ NEW conversations get
        *  the in-process 'tesseract-imagegen' tools. */
@@ -22688,6 +22859,12 @@ var init_agent_manager = __esm({
       setSkillsPlugin(config2) {
         this.skillsPlugin = config2;
       }
+      /** Set (or clear) the bundled MISSION-skills local-plugin (first-party mission
+       *  procedures). Attached only to sessions launched with a missionSkillId, so it
+       *  doesn't bloat normal chats and stays out of the user's Skills list. */
+      setMissionSkillsPlugin(config2) {
+        this.missionSkillsPlugin = config2;
+      }
       /** Inject (or clear) the host's image-generation backend. When set, NEW
        *  conversations get the in-process 'tesseract-imagegen' tools. The runner is
        *  read fresh per call, so a key the user adds later applies without a restart. */
@@ -22937,6 +23114,41 @@ ${full.slice(-8e3)}`;
         entry.cleanup();
         entry.resolve({ action: decision.action, ...decision.action === "accept" && decision.content ? { content: decision.content } : {} });
       }
+      /** Skill UI: park a promise, raise an interactive card (agent:ui_request), and
+       *  resolve it from chat:ui_response (respondToUiRequest). A session teardown
+       *  cancels any still-parked cards (cancelSessionUiRequests). Mirrors onElicitation. */
+      raiseUiRequest(live, spec) {
+        return new Promise((resolve10) => {
+          const requestId = randomUUID2();
+          this.pendingUiRequests.set(requestId, { resolve: resolve10, sessionId: live.sessionId, origin: live.origin });
+          const evt = { type: "agent:ui_request", sessionId: live.sessionId, requestId, spec, ts: Date.now() };
+          if (!live.sessionId && live.clientRequestId)
+            this.send({ ...evt, clientRequestId: live.clientRequestId }, live.origin);
+          else
+            this.send(evt, live.origin);
+        });
+      }
+      /** Resolve a parked skill-UI request (client replied via chat:ui_response).
+       *  Driver-only, same origin guard as respondToElicitation. */
+      respondToUiRequest(requestId, response, callerOrigin) {
+        const entry = this.pendingUiRequests.get(requestId);
+        if (!entry)
+          return;
+        if (entry.origin && callerOrigin && entry.origin !== callerOrigin)
+          return;
+        this.pendingUiRequests.delete(requestId);
+        entry.resolve(response);
+      }
+      /** Cancel (resolve as cancelled) any interactive cards still parked for a session
+       *  that's being torn down / aborted, so the awaiting tool calls unblock. */
+      cancelSessionUiRequests(sessionId) {
+        for (const [requestId, entry] of this.pendingUiRequests) {
+          if (entry.sessionId !== sessionId)
+            continue;
+          this.pendingUiRequests.delete(requestId);
+          entry.resolve({ cancelled: true });
+        }
+      }
       /** M5 — per-connector live status from the running Query. Returns [] if the
        *  session isn't resident or the SDK call throws (idle/closed). */
       async mcpServerStatus(sessionId) {
@@ -23086,6 +23298,135 @@ ${t}`)
       setConfig(projectDir) {
         this.projectDir = projectDir;
       }
+      // ── Tab-driven pre-warming ──────────────────────────────────────────────────
+      // Warming = spawn the cli.js process EARLY (the SDK spawns eagerly at query()) so its
+      // ~1.6–3.4s node+cli.js boot overlaps idle time; the first user message is pushed only
+      // when the user actually sends, by which point boot is done → first token is fast. The
+      // warm process emits nothing (system/init is gated on the first push) so warming is
+      // fire-and-forget and never worse than a cold start.
+      /** Stable key over the CONSTRUCTION-immutable config a NEW conversation bakes into its
+       *  query(). A warm empty instance may be adopted only by a send whose key matches —
+       *  model/permissionMode/sources are reconciled live at adoption; `url` is excluded
+       *  (warmed with '' so browser navigation doesn't invalidate the standby). */
+      warmKey(p) {
+        const cwd = p.projectDir ?? this.projectDir ?? p.sources?.[0] ?? "";
+        return JSON.stringify({
+          cwd,
+          effort: p.effort ?? "",
+          mcp: Object.keys(p.mcpServers ?? {}).sort(),
+          agents: p.agents ? Object.keys(p.agents).sort() : [],
+          settings: p.settings ?? null,
+          settingSources: [...p.settingSources ?? []].sort(),
+          sandbox: p.sandbox ?? null,
+          env: p.env ?? null,
+          thinking: p.thinking ?? null,
+          engineEnv: p.engineEnv ?? null,
+          maxTurns: p.maxTurns ?? null,
+          maxBudgetUsd: p.maxBudgetUsd ?? null,
+          outputStyle: p.outputStyle ?? null
+        });
+      }
+      /** Pre-warm a session (no user message pushed). Two kinds:
+       *   • RESUME (params.sessionId): the resumed session becomes resident, so a later
+       *     chat:send for it just pushes — no spawn/boot wait. Idempotent if already resident.
+       *   • EMPTY (no sessionId): the single standby new-session instance (warmEmpty), adopted
+       *     by the next matching NEW conversation. Replaced if the config key changed.
+       *  Best-effort: no open project ⇒ no-op; a spawn failure is swallowed (warm=true keeps
+       *  createLiveSession from emitting a client chat:error). */
+      async warmSession(params) {
+        const cwd = params.projectDir ?? this.projectDir ?? params.sources?.[0];
+        if (!cwd)
+          return;
+        if (params.sessionId) {
+          if (this.liveSessions.has(params.sessionId))
+            return;
+        } else {
+          const key2 = this.warmKey(params);
+          if (this.warmEmpty && this.warmEmptyKey === key2)
+            return;
+          if (this.warmEmpty)
+            this.discardWarmEmpty();
+        }
+        let live;
+        try {
+          live = await this.createLiveSession({ ...params, message: "", clientRequestId: void 0, origin: void 0, url: "", warm: true });
+        } catch (err) {
+          log("warmSession failed (best-effort):", err instanceof Error ? err.message : String(err));
+          return;
+        }
+        if (params.sessionId) {
+          if (this.activeTabSession !== params.sessionId)
+            this.scheduleIdleReap(live);
+        } else {
+          this.warmEmpty = live;
+          this.warmEmptyKey = this.warmKey(params);
+        }
+      }
+      /** A tab gained focus (sessionId set) or a NEW-conversation tab is focused (sessionId
+       *  omitted). Pins the focused session against idle reap and releases the previously
+       *  focused one so its 15-min idle clock starts ("time since last switched-to"). A
+       *  focused session that isn't resident (e.g. switched back to a reaped tab) is
+       *  warm-resumed so it's ready before the user types; a focused new-conversation tab
+       *  ensures the standby empty instance exists. */
+      async setActiveSession(sessionId, params) {
+        const prev = this.activeTabSession;
+        if (prev && prev !== sessionId)
+          this.setSessionKeepAlive(prev, false, "tab");
+        this.activeTabSession = sessionId ?? null;
+        if (sessionId) {
+          if (!this.liveSessions.has(sessionId))
+            await this.warmSession({ ...params, sessionId });
+          this.setSessionKeepAlive(sessionId, true, "tab");
+        } else {
+          await this.warmSession({ ...params, sessionId: void 0 });
+        }
+      }
+      /** Bind the standby empty instance to a brand-new conversation: set its routing/title,
+       *  reconcile the live-settable config the warm query couldn't bake, and re-seed a fresh
+       *  standby. The caller (sendMessage) then pushes the user message as usual. */
+      adoptWarmEmpty(params) {
+        const live = this.warmEmpty;
+        this.warmEmpty = null;
+        this.warmEmptyKey = null;
+        live.clientRequestId = params.clientRequestId;
+        live.origin = params.origin;
+        if (params.browserId !== void 0)
+          live.browserId = params.browserId;
+        if (params.windowId !== void 0)
+          live.windowId = params.windowId;
+        live.pendingTitle = params.message.trim().slice(0, 80);
+        if (params.model)
+          void live.query.setModel(params.model || void 0).catch(() => {
+          });
+        if (params.permissionMode)
+          void live.query.setPermissionMode(params.permissionMode).catch(() => {
+          });
+        const nextSources = params.sources ?? [];
+        if (!sourcesEqual(live.sources, nextSources)) {
+          void live.query.applyFlagSettings({ permissions: { additionalDirectories: nextSources } }).then(() => {
+            live.sources = nextSources;
+          }).catch((err) => log("adoptWarmEmpty applyFlagSettings failed:", err instanceof Error ? err.message : String(err)));
+        }
+        void this.warmSession({ ...params, sessionId: void 0, clientRequestId: void 0 });
+        return live;
+      }
+      /** Tear down the standby empty instance (no sessionId ⇒ not in liveSessions / never
+       *  idle-reaped). Used when its config key goes stale or on dispose. */
+      discardWarmEmpty() {
+        const live = this.warmEmpty;
+        this.warmEmpty = null;
+        this.warmEmptyKey = null;
+        if (!live || live.reaped)
+          return;
+        live.reaped = true;
+        this.pendingLiveSessions.delete(live);
+        try {
+          live.abort.abort();
+        } catch {
+        }
+        killProcessTree(live.child, "SIGKILL");
+        live.pump.end();
+      }
       buildSystemPrompt(url2) {
         const cli = `ELECTRON_RUN_AS_NODE=1 "${process.execPath}" "${this.browserCliPath}"`;
         const pageInfo = url2 ? `
@@ -23192,7 +23533,11 @@ CRITICAL RULES:
           return;
         }
         if (!live) {
-          live = await this.createLiveSession(params);
+          if (!params.sessionId && this.warmEmpty && this.warmEmptyKey === this.warmKey(params)) {
+            live = this.adoptWarmEmpty(params);
+          } else {
+            live = await this.createLiveSession(params);
+          }
         } else {
           live.streaming = true;
           live.lastActivity = Date.now();
@@ -23387,11 +23732,33 @@ CRITICAL RULES:
                   });
                   mcp["tesseract-canvas"] = createSdkMcpServer({ name: "tesseract-canvas", version: "0.1.0", tools: canvasTools });
                 }
+                {
+                  const projectDir = this.projectDir;
+                  const reportTools = buildReportTools({
+                    emitReport: (report) => {
+                      const ts = Date.now();
+                      this.send({ type: "agent:report_ready", sessionId: live.sessionId, report, ts }, live.origin);
+                      void appendReportArtifact(live.sessionId, projectDir, report).catch(() => {
+                      });
+                    }
+                  });
+                  mcp["tesseract-report"] = createSdkMcpServer({ name: "tesseract-report", version: "0.1.0", tools: reportTools });
+                }
+                {
+                  const uiTools = buildInteractiveUiTools({
+                    raiseUiRequest: (spec) => this.raiseUiRequest(live, spec),
+                    emitProgress: (stages, note) => this.send({ type: "agent:mission_progress", sessionId: live.sessionId, stages, note, ts: Date.now() }, live.origin)
+                  });
+                  mcp["tesseract-interactive-ui"] = createSdkMcpServer({ name: "tesseract-interactive-ui", version: "0.1.0", tools: uiTools });
+                }
                 return Object.keys(mcp).length > 0 ? { mcpServers: mcp } : {};
               })(),
               // Skills (Epic H): a local plugin bundling the enabled ClawHub skills, so the SDK
               // discovers their SKILL.md files (isolated from ~/.claude + the edited project).
-              ...this.skillsPlugin ? { plugins: [this.skillsPlugin] } : {},
+              ...(() => {
+                const plugins = [this.skillsPlugin, params.missionSkillId ? this.missionSkillsPlugin : null].filter(Boolean);
+                return plugins.length > 0 ? { plugins } : {};
+              })(),
               ...params.maxTurns && params.maxTurns > 0 ? { maxTurns: params.maxTurns } : {},
               ...params.maxBudgetUsd && params.maxBudgetUsd > 0 ? { maxBudgetUsd: params.maxBudgetUsd } : {},
               // Surface every gated tool call to the client for approval. The SDK only
@@ -23528,7 +23895,8 @@ CRITICAL RULES:
                 const nodeExe2 = resolveNodeExecutable();
                 const exe = nodeExe2 ?? process.execPath;
                 const runAsNode = exe === process.execPath && !!process.versions.electron;
-                const spawnEnv = { ...options.env, ...params.env ?? {}, ...params.engineEnv ?? {}, CCB_IPC_PORT: String(live.ipcPort), ...runAsNode ? { ELECTRON_RUN_AS_NODE: "1" } : {} };
+                const compileCache = process.env.NODE_COMPILE_CACHE || join9(process.env.CCB_TESSERACT_DIR ?? join9(homedir4(), ".tesseract"), "node-compile-cache");
+                const spawnEnv = { NODE_COMPILE_CACHE: compileCache, ...options.env, ...params.env ?? {}, ...params.engineEnv ?? {}, CCB_IPC_PORT: String(live.ipcPort), ...runAsNode ? { ELECTRON_RUN_AS_NODE: "1" } : {} };
                 const child = spawn2(exe, [cliJs, ...options.args], {
                   cwd: options.cwd,
                   env: spawnEnv,
@@ -23547,7 +23915,9 @@ CRITICAL RULES:
               // restores the SDK's dynamic command list, gitStatus/date context,
               // env-info and memory/CLAUDE.md preamble that a bare custom string
               // prompt suppresses — while `append` keeps the Tesseract browser tools.
-              systemPrompt: { type: "preset", preset: "claude_code", append: this.buildSystemPrompt(params.url) },
+              systemPrompt: { type: "preset", preset: "claude_code", append: this.buildSystemPrompt(params.url) + (params.appendSystemPrompt ? `
+
+${params.appendSystemPrompt}` : "") },
               includePartialMessages: true,
               // Opt into AskUserQuestion option previews. Without a previewFormat the
               // SDK omits the preview-field guidance from the tool prompt, so the
@@ -23585,10 +23955,12 @@ CRITICAL RULES:
             live.ipcServer?.close();
           } catch {
           }
-          const sid = live.sessionId || "";
-          const crid = live.sessionId ? void 0 : live.clientRequestId;
-          this.send({ type: "chat:error", sessionId: sid, clientRequestId: crid, error: err instanceof Error ? err.message : "Failed to start the agent session." }, params.origin);
-          this.send({ type: "agent:status", sessionId: sid, clientRequestId: crid, status: "error" }, params.origin);
+          if (!params.warm) {
+            const sid = live.sessionId || "";
+            const crid = live.sessionId ? void 0 : live.clientRequestId;
+            this.send({ type: "chat:error", sessionId: sid, clientRequestId: crid, error: err instanceof Error ? err.message : "Failed to start the agent session." }, params.origin);
+            this.send({ type: "agent:status", sessionId: sid, clientRequestId: crid, status: "error" }, params.origin);
+          }
           throw err;
         }
         if (params.sessionId)
@@ -24038,6 +24410,8 @@ ${err.stack}` : ""}` : String(err);
             live.steerFlushTimer = void 0;
           }
           this.clearStopWatchdog(live);
+          if (live.sessionId)
+            this.cancelSessionUiRequests(live.sessionId);
           if (live.sessionId)
             this.liveSessions.delete(live.sessionId);
           this.pendingLiveSessions.delete(live);
@@ -24298,6 +24672,9 @@ ${err.stack}` : ""}` : String(err);
         this.cronToolsDeps = null;
         this.cronTaskSessions.clear();
         this.cronRequestTask.clear();
+        this.warmEmpty = null;
+        this.warmEmptyKey = null;
+        this.activeTabSession = null;
         for (const live of [...this.liveSessions.values(), ...this.pendingLiveSessions]) {
           if (live.reaped)
             continue;
@@ -24311,6 +24688,8 @@ ${err.stack}` : ""}` : String(err);
             live.steerFlushTimer = void 0;
           }
           this.clearStopWatchdog(live);
+          if (live.sessionId)
+            this.cancelSessionUiRequests(live.sessionId);
           if (live.sessionId)
             this.liveSessions.delete(live.sessionId);
           this.pendingLiveSessions.delete(live);
@@ -24324,6 +24703,8 @@ ${err.stack}` : ""}` : String(err);
       }
       /** Memory-pressure entrypoint: moderate trims long-idle sessions; critical reaps all idle. */
       reclaim(level) {
+        if (level === "critical")
+          this.discardWarmEmpty();
         const n = level === "critical" ? this.reapAllIdle() : this.reapIdleSessions(MODERATE_IDLE_MS);
         if (n > 0)
           log(`Memory reclaim (${level}): reaped ${n} idle session(s)`);
@@ -42755,7 +43136,7 @@ var require_selfsigned = __commonJS({
 import tls from "node:tls";
 import { X509Certificate, timingSafeEqual } from "node:crypto";
 import { readFileSync as readFileSync9, writeFileSync as writeFileSync9, existsSync as existsSync10, mkdirSync as mkdirSync8 } from "node:fs";
-import { dirname as dirname10 } from "node:path";
+import { dirname as dirname9 } from "node:path";
 function fingerprintOf(certPem) {
   return new X509Certificate(certPem).fingerprint256;
 }
@@ -42775,7 +43156,7 @@ async function loadOrCreateIdentity(certPath, keyPath) {
   const tenYears = new Date(Date.now() + 10 * 365 * 24 * 60 * 60 * 1e3);
   const pems = await (0, import_selfsigned.generate)([{ name: "commonName", value: "tesseract-peer" }], { keySize: 2048, notAfterDate: tenYears, algorithm: "sha256" });
   try {
-    mkdirSync8(dirname10(certPath), { recursive: true });
+    mkdirSync8(dirname9(certPath), { recursive: true });
   } catch {
   }
   try {
@@ -44301,12 +44682,12 @@ import { createHash as createHash5 } from "node:crypto";
 import { spawn as spawn8 } from "node:child_process";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { homedir as homedir16 } from "node:os";
-import { dirname as dirname18, join as join38, resolve as resolve9 } from "node:path";
+import { dirname as dirname17, join as join38, resolve as resolve9 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // ../../packages/host-core/dist/control-link.js
 import { hostname as hostname3 } from "node:os";
-import { join as join30, basename as basename7 } from "node:path";
+import { join as join30, basename as basename6 } from "node:path";
 import { mkdirSync as mkdirSync11 } from "node:fs";
 
 // ../../node_modules/ws/wrapper.mjs
@@ -44733,7 +45114,7 @@ import { join as join18 } from "node:path";
 
 // ../../packages/host-core/dist/agent-backend.js
 async function createClaudeCodeBackend(send2, onBrowserRequest, loadPluginRuntime2) {
-  const { AgentManager: AgentManager2, SessionStore: SessionStore2, resolveSessionFile: resolveSessionFile2, readSessionArtifacts: readSessionArtifacts2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports));
+  const { AgentManager: AgentManager2, SessionStore: SessionStore2, readSessionArtifacts: readSessionArtifacts2 } = await Promise.resolve().then(() => (init_dist4(), dist_exports));
   const manager2 = new AgentManager2(send2, onBrowserRequest);
   const store = new SessionStore2();
   const refreshPlugins = async (projectDir) => {
@@ -44761,8 +45142,6 @@ async function createClaudeCodeBackend(send2, onBrowserRequest, loadPluginRuntim
     getMessages: (sessionId) => store.getSessionMessages(sessionId),
     getSessionArtifacts: (sessionId, projectDir) => readSessionArtifacts2(sessionId, projectDir),
     summarizeSession: async (sessionId) => manager2.summarizeSession(await store.getSessionMessages(sessionId)),
-    isSessionBusy: (sessionId) => manager2.isSessionBusy(sessionId),
-    resolveSessionFile: (sessionId, projectDir) => resolveSessionFile2(sessionId, projectDir),
     setConfig: (projectDir) => {
       manager2.setConfig(projectDir);
       void refreshPlugins(projectDir);
@@ -44773,9 +45152,12 @@ async function createClaudeCodeBackend(send2, onBrowserRequest, loadPluginRuntim
     setImageGen: (runner) => manager2.setImageGen(runner),
     setRunMode: (sessionId, opts) => manager2.setRunMode(sessionId, opts),
     setSessionKeepAlive: (sessionId, keep, holder) => manager2.setSessionKeepAlive(sessionId, keep, holder),
+    warmSession: (params) => manager2.warmSession(params),
+    setActiveSession: (sessionId, params) => manager2.setActiveSession(sessionId, params),
     clearSessionOrigin: (sessionId) => manager2.clearSessionOrigin(sessionId),
     stopTask: (sessionId, taskId, callerOrigin) => manager2.stopTask(sessionId, taskId, callerOrigin),
     respondToElicitation: (requestId, decision, callerOrigin) => manager2.respondToElicitation(requestId, decision, callerOrigin),
+    respondToUiRequest: (requestId, response, callerOrigin) => manager2.respondToUiRequest(requestId, response, callerOrigin),
     mcpServerStatus: (sessionId) => manager2.mcpServerStatus(sessionId),
     reconnectMcpServer: (sessionId, name) => manager2.reconnectMcpServer(sessionId, name),
     toggleMcpServer: (sessionId, name, enabled) => manager2.toggleMcpServer(sessionId, name, enabled),
@@ -45361,8 +45743,8 @@ function createOpenClawAdapter(pluginId, config2, secretResolver, registry2) {
     pluginId,
     config: config2,
     secret: (envKey2) => secretResolver(pluginId, envKey2),
-    registerTool: (tool5) => {
-      const got = typeof tool5 === "function" ? tool5({}) : tool5;
+    registerTool: (tool7) => {
+      const got = typeof tool7 === "function" ? tool7({}) : tool7;
       const arr = Array.isArray(got) ? got : got ? [got] : [];
       for (const t of arr) {
         const c = convertTool(t);
@@ -45431,10 +45813,10 @@ var HostPluginApi = class {
   secret(envKey2) {
     return this.secretResolver(this.pluginId, envKey2);
   }
-  registerTool(tool5) {
+  registerTool(tool7) {
     const prefix = this.pluginId.replace(/[^a-zA-Z0-9_]/g, "_");
-    const name = tool5.name.startsWith(`${prefix}_`) ? tool5.name : `${prefix}_${tool5.name}`;
-    this.registry.tools.push({ ...tool5, name });
+    const name = tool7.name.startsWith(`${prefix}_`) ? tool7.name : `${prefix}_${tool7.name}`;
+    this.registry.tools.push({ ...tool7, name });
   }
   registerHook(reg) {
     this.registry.hooks.push(reg);
@@ -46061,9 +46443,9 @@ function augmentedPath() {
   return parts.join(sep8);
 }
 function which(bin, path5) {
-  const tool5 = process.platform === "win32" ? "where" : "which";
+  const tool7 = process.platform === "win32" ? "where" : "which";
   try {
-    const out = execFileSync(tool5, [bin], { env: { ...process.env, PATH: path5 }, timeout: 4e3, encoding: "utf-8" });
+    const out = execFileSync(tool7, [bin], { env: { ...process.env, PATH: path5 }, timeout: 4e3, encoding: "utf-8" });
     return out.split(/\r?\n/).map((l) => l.trim()).find(Boolean) || void 0;
   } catch {
     return void 0;
@@ -46179,12 +46561,12 @@ async function loadPluginRuntime(opts) {
 function buildDaemonPluginLoader(pluginsDir) {
   return async () => {
     const skillsPlugin = daemonSkillsPluginConfig();
-    const scan2 = join16(pluginsDir, "node_modules");
-    if (!existsSync7(scan2))
+    const scan = join16(pluginsDir, "node_modules");
+    if (!existsSync7(scan))
       return { tools: [], hooks: [], engines: [], skillsPlugin };
     writeOpenClawShim(pluginsDir);
     const rt = await loadPluginRuntime({
-      roots: [{ dir: scan2, trusted: true, relaxHardlink: true }],
+      roots: [{ dir: scan, trusted: true, relaxHardlink: true }],
       secretResolver: (_pluginId, envKey2) => process.env[envKey2]
     });
     return { ...rt, skillsPlugin };
@@ -46196,7 +46578,7 @@ function daemonSkillsPluginConfig() {
     return null;
   const enabled = join16(root, "skills");
   try {
-    const hasSkill = readdirSync(enabled).some((slug) => existsSync7(join16(enabled, slug, "SKILL.md")));
+    const hasSkill = readdirSync(enabled).some((slug2) => existsSync7(join16(enabled, slug2, "SKILL.md")));
     return hasSkill ? { type: "local", path: root } : null;
   } catch {
     return null;
@@ -47556,125 +47938,6 @@ function unwatchAllRemote() {
   remoteWatches.clear();
 }
 
-// ../../packages/host-core/dist/session-watch.js
-import { watch as watch2 } from "node:fs";
-import { dirname as dirname8, basename as basename3 } from "node:path";
-var DEBOUNCE_MS = 120;
-var BUSY_GRACE_MS = 2e3;
-var watches = /* @__PURE__ */ new Map();
-var sessionToFile = /* @__PURE__ */ new Map();
-async function watchSession(sessionId, key2, projectDir, deps) {
-  let filePath = sessionToFile.get(sessionId);
-  if (!filePath) {
-    const resolved = await deps.resolveFile?.(sessionId, projectDir);
-    if (!resolved)
-      return;
-    filePath = resolved;
-    sessionToFile.set(sessionId, filePath);
-  }
-  const baseline = await deps.getMessages(sessionId).then((m) => m.length).catch(() => 0);
-  const existing = watches.get(filePath);
-  if (existing) {
-    existing.listeners.set(key2, { emittedCount: baseline, deps });
-    return;
-  }
-  const fileName = basename3(filePath);
-  const fw = {
-    watcher: void 0,
-    sessionId,
-    listeners: /* @__PURE__ */ new Map([[key2, { emittedCount: baseline, deps }]]),
-    timer: null,
-    lastBusyAt: 0
-  };
-  try {
-    fw.watcher = watch2(dirname8(filePath), (_event, changed) => {
-      if (changed && basename3(String(changed)) !== fileName)
-        return;
-      scheduleScan(filePath);
-    });
-  } catch {
-    return;
-  }
-  watches.set(filePath, fw);
-}
-function unwatchSession(sessionId, key2) {
-  const filePath = sessionToFile.get(sessionId);
-  if (!filePath)
-    return;
-  const fw = watches.get(filePath);
-  if (!fw)
-    return;
-  fw.listeners.delete(key2);
-  if (fw.listeners.size === 0)
-    closeWatch(filePath);
-}
-function unwatchSessionClient(key2) {
-  for (const [filePath, fw] of [...watches]) {
-    if (fw.listeners.delete(key2) && fw.listeners.size === 0)
-      closeWatch(filePath);
-  }
-}
-function unwatchAllSessions() {
-  for (const [filePath] of [...watches])
-    closeWatch(filePath);
-}
-function closeWatch(filePath) {
-  const fw = watches.get(filePath);
-  if (!fw)
-    return;
-  if (fw.timer)
-    clearTimeout(fw.timer);
-  try {
-    fw.watcher.close();
-  } catch {
-  }
-  watches.delete(filePath);
-  sessionToFile.delete(fw.sessionId);
-}
-function scheduleScan(filePath) {
-  const fw = watches.get(filePath);
-  if (!fw)
-    return;
-  if (fw.timer)
-    clearTimeout(fw.timer);
-  fw.timer = setTimeout(() => {
-    fw.timer = null;
-    void scan(filePath);
-  }, DEBOUNCE_MS);
-}
-async function scan(filePath) {
-  const fw = watches.get(filePath);
-  if (!fw)
-    return;
-  const { sessionId } = fw;
-  const any2 = fw.listeners.values().next().value;
-  if (!any2)
-    return;
-  const busy = any2.deps.isSessionBusy?.(sessionId) === true;
-  const now = Date.now();
-  if (busy)
-    fw.lastBusyAt = now;
-  const inGrace = busy || now - fw.lastBusyAt < BUSY_GRACE_MS;
-  const messages = await any2.deps.getMessages(sessionId).catch(() => null);
-  if (!messages)
-    return;
-  const len = messages.length;
-  const willCompact = !inGrace && [...fw.listeners.values()].some((l) => len < l.emittedCount);
-  const artifacts = willCompact ? await (any2.deps.getSessionArtifacts?.(sessionId).catch(() => []) ?? Promise.resolve([])) : [];
-  for (const [key2, listener] of fw.listeners) {
-    if (inGrace) {
-      listener.emittedCount = len;
-      continue;
-    }
-    if (len < listener.emittedCount) {
-      listener.deps.emit(key2, { type: "session:messages", sessionId, messages, artifacts });
-    } else if (len > listener.emittedCount) {
-      listener.deps.emit(key2, { type: "session:appended", sessionId, messages: messages.slice(listener.emittedCount) });
-    }
-    listener.emittedCount = len;
-  }
-}
-
 // ../../packages/host-core/dist/fs-datachannel-host.js
 var SCTP_BUF = 16 * 1024 * 1024;
 var ndcPromise = null;
@@ -47887,7 +48150,7 @@ function dynamicMetrics() {
 // ../../packages/host-core/dist/fs-transfer.js
 import { readdir as readdir4, lstat as lstat2, mkdir as mkdir6, chmod, rm as rm2, readlink, symlink, stat as stat3 } from "node:fs/promises";
 import { openSync as openSync3, readSync as readSync2, closeSync as closeSync3, existsSync as existsSync9, createWriteStream } from "node:fs";
-import { dirname as dirname9, join as join22, relative as relative6, sep as sep6 } from "node:path";
+import { dirname as dirname8, join as join22, relative as relative6, sep as sep6 } from "node:path";
 
 // ../../packages/host-core/dist/active-link/paths.js
 import { homedir as homedir11 } from "node:os";
@@ -48234,9 +48497,9 @@ async function writeInboundChunk(msg, send2) {
   try {
     if (msg.kind === "symlink") {
       const target = Buffer.from(msg.base64, "base64").toString("utf-8");
-      const resolved = join22(dirname9(abs), target);
+      const resolved = join22(dirname8(abs), target);
       if (isInsideRoot(resolved, s.destRoot)) {
-        await mkdir6(dirname9(abs), { recursive: true }).catch(() => {
+        await mkdir6(dirname8(abs), { recursive: true }).catch(() => {
         });
         await symlink(target, abs).catch(() => {
         });
@@ -48249,7 +48512,7 @@ async function writeInboundChunk(msg, send2) {
     if (s.curIx !== msg.fileIx || !s.curStream) {
       if (s.curStream)
         await new Promise((r) => s.curStream.end(r));
-      await mkdir6(dirname9(abs), { recursive: true }).catch(() => {
+      await mkdir6(dirname8(abs), { recursive: true }).catch(() => {
       });
       s.curStream = createWriteStream(abs);
       s.curIx = msg.fileIx;
@@ -48766,13 +49029,13 @@ async function openPeerLink(peerHostId, ctx) {
 // ../../packages/host-core/dist/active-link/engine.js
 import { lstat as lstat7, readlink as readlink4, rm as rm3, mkdir as mkdir8, symlink as symlink2, rename as rename2, utimes as utimes2, writeFile as writeFile6 } from "node:fs/promises";
 import { existsSync as existsSync12 } from "node:fs";
-import { dirname as dirname14, join as join28, resolve as resolve8 } from "node:path";
+import { dirname as dirname13, join as join28, resolve as resolve8 } from "node:path";
 
 // ../../packages/host-core/dist/active-link/blocks.js
 import { createHash as createHash3 } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { open, mkdir as mkdir7, rename, chmod as chmod2, utimes, unlink } from "node:fs/promises";
-import { dirname as dirname11 } from "node:path";
+import { dirname as dirname10 } from "node:path";
 var CHUNK3 = 1024 * 1024;
 var MAX_INFLIGHT2 = 8 * CHUNK3;
 var IDLE_MS2 = 6e4;
@@ -48900,7 +49163,7 @@ var StagingWriter = class {
   }
   async ensureOpen() {
     if (!this.fh) {
-      await mkdir7(dirname11(this.stagingPath), { recursive: true });
+      await mkdir7(dirname10(this.stagingPath), { recursive: true });
       this.fh = await open(this.stagingPath, "w");
     }
     return this.fh;
@@ -48930,7 +49193,7 @@ var StagingWriter = class {
     });
     await fh.close();
     this.fh = null;
-    await mkdir7(dirname11(dest), { recursive: true });
+    await mkdir7(dirname10(dest), { recursive: true });
     await chmod2(this.stagingPath, mode & 511).catch(() => {
     });
     const secs = mtimeMs / 1e3;
@@ -48963,7 +49226,7 @@ var BlockAssembler = class {
     this.stagingPath = stagingPath;
   }
   async open() {
-    await mkdir7(dirname11(this.stagingPath), { recursive: true });
+    await mkdir7(dirname10(this.stagingPath), { recursive: true });
     this.fh = await open(this.stagingPath, "w");
   }
   /** Write a received block at its byte offset (index * CHUNK). */
@@ -49007,7 +49270,7 @@ var BlockAssembler = class {
       });
       return false;
     }
-    await mkdir7(dirname11(dest), { recursive: true });
+    await mkdir7(dirname10(dest), { recursive: true });
     await chmod2(this.stagingPath, mode & 511).catch(() => {
     });
     const secs = mtimeMs / 1e3;
@@ -49593,10 +49856,10 @@ var ReaddirpStream = class extends Readable {
   }
   async _formatEntry(dirent, path5) {
     let entry;
-    const basename8 = this._isDirent ? dirent.name : dirent;
+    const basename7 = this._isDirent ? dirent.name : dirent;
     try {
-      const fullPath = presolve(pjoin(path5, basename8));
-      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename8 };
+      const fullPath = presolve(pjoin(path5, basename7));
+      entry = { path: prelative(this._root, fullPath), fullPath, basename: basename7 };
       entry[this._statsProp] = this._isDirent ? dirent : await this._stat(fullPath);
     } catch (err) {
       this._onError(err);
@@ -50135,9 +50398,9 @@ var NodeFsHandler = class {
   _watchWithNodeFs(path5, listener) {
     const opts = this.fsw.options;
     const directory = sysPath.dirname(path5);
-    const basename8 = sysPath.basename(path5);
+    const basename7 = sysPath.basename(path5);
     const parent = this.fsw._getWatchedDir(directory);
-    parent.add(basename8);
+    parent.add(basename7);
     const absolutePath = sysPath.resolve(path5);
     const options = {
       persistent: opts.persistent
@@ -50147,7 +50410,7 @@ var NodeFsHandler = class {
     let closer;
     if (opts.usePolling) {
       const enableBin = opts.interval !== opts.binaryInterval;
-      options.interval = enableBin && isBinaryPath(basename8) ? opts.binaryInterval : opts.interval;
+      options.interval = enableBin && isBinaryPath(basename7) ? opts.binaryInterval : opts.interval;
       closer = setFsWatchFileListener(path5, absolutePath, options, {
         listener,
         rawEmitter: this.fsw._emitRaw
@@ -50169,11 +50432,11 @@ var NodeFsHandler = class {
     if (this.fsw.closed) {
       return;
     }
-    const dirname19 = sysPath.dirname(file2);
-    const basename8 = sysPath.basename(file2);
-    const parent = this.fsw._getWatchedDir(dirname19);
+    const dirname18 = sysPath.dirname(file2);
+    const basename7 = sysPath.basename(file2);
+    const parent = this.fsw._getWatchedDir(dirname18);
     let prevStats = stats;
-    if (parent.has(basename8))
+    if (parent.has(basename7))
       return;
     const listener = async (path5, newStats) => {
       if (!this.fsw._throttle(THROTTLE_MODE_WATCH, file2, 5))
@@ -50198,9 +50461,9 @@ var NodeFsHandler = class {
             prevStats = newStats2;
           }
         } catch (error51) {
-          this.fsw._remove(dirname19, basename8);
+          this.fsw._remove(dirname18, basename7);
         }
-      } else if (parent.has(basename8)) {
+      } else if (parent.has(basename7)) {
         const at = newStats.atimeMs;
         const mt = newStats.mtimeMs;
         if (!at || at <= mt || mt !== prevStats.mtimeMs) {
@@ -51124,7 +51387,7 @@ var FSWatcher = class extends EventEmitter2 {
     return stream;
   }
 };
-function watch3(paths, options = {}) {
+function watch2(paths, options = {}) {
   const watcher = new FSWatcher(options);
   watcher.add(paths);
   return watcher;
@@ -51142,7 +51405,7 @@ var LinkWatcher = class {
     this.debounceMs = opts.debounceMs ?? 500;
   }
   async start() {
-    this.fsw = watch3(this.opts.root, {
+    this.fsw = watch2(this.opts.root, {
       ignoreInitial: true,
       // the engine does its own hashing scan on start
       followSymlinks: false,
@@ -51643,13 +51906,13 @@ var ActiveLinkEngine = class {
    *  file so the path still exists — recorded as a FILE matching disk so the local
    *  watcher doesn't churn. The target is containment-checked, never dereferenced. */
   async applySymlink(rel, dest, target, mtimeMs, mode) {
-    const resolved = resolve8(dirname14(dest), target);
+    const resolved = resolve8(dirname13(dest), target);
     if (!isInsideRoot(resolved, this.opts.localRoot))
       return;
     const hash2 = hashString(target);
     const secs = mtimeMs / 1e3;
     try {
-      await mkdir8(dirname14(dest), { recursive: true });
+      await mkdir8(dirname13(dest), { recursive: true });
       await rm3(dest, { force: true, recursive: true });
       try {
         await symlink2(target, dest);
@@ -51701,7 +51964,7 @@ var ActiveLinkEngine = class {
       return;
     if (fromRec && fromRec.kind === "file") {
       try {
-        await mkdir8(dirname14(toAbs2), { recursive: true });
+        await mkdir8(dirname13(toAbs2), { recursive: true });
         await rename2(fromAbs, toAbs2);
         const secs = mtimeMs / 1e3;
         await utimes2(toAbs2, secs, secs).catch(() => {
@@ -51901,7 +52164,7 @@ var ActiveLinkEngine = class {
 };
 
 // ../../packages/host-core/dist/active-link/config.js
-import { readFileSync as readFileSync11, writeFileSync as writeFileSync11, mkdirSync as mkdirSync10, existsSync as existsSync13, renameSync as renameSync6, watch as watch4 } from "node:fs";
+import { readFileSync as readFileSync11, writeFileSync as writeFileSync11, mkdirSync as mkdirSync10, existsSync as existsSync13, renameSync as renameSync6, watch as watch3 } from "node:fs";
 import { join as join29 } from "node:path";
 function configPath2() {
   return join29(activeLinkRoot(), "links.json");
@@ -51975,7 +52238,7 @@ function watchLinkConfigs(onChange) {
   let timer = null;
   let watcher = null;
   try {
-    watcher = watch4(dir, (_evt, file2) => {
+    watcher = watch3(dir, (_evt, file2) => {
       if (file2 && file2 !== "links.json")
         return;
       if (timer)
@@ -52384,7 +52647,7 @@ function clampDim(v, dflt) {
 init_dist2();
 
 // ../../packages/host-core/dist/voice-control.js
-import { basename as basename6 } from "node:path";
+import { basename as basename5 } from "node:path";
 
 // ../../packages/voice-core/dist/providers/tool-adapters.js
 function toELClientTool(t) {
@@ -53707,7 +53970,7 @@ var VoiceControl = class {
       voice: msg.voice,
       language: msg.language,
       turnSensitivity: msg.turnSensitivity,
-      instructions: buildGuidePrompt({ projectName: projectDir ? basename6(projectDir) : void 0, sessions: msg.sessions }),
+      instructions: buildGuidePrompt({ projectName: projectDir ? basename5(projectDir) : void 0, sessions: msg.sessions }),
       greeting: DEFAULT_GREETING
     };
     const orchestrator = new VoiceGuideOrchestrator({
@@ -54081,7 +54344,7 @@ function sendActiveLinkProvision(cfg2) {
     type: "provision",
     linkId: cfg2.linkId,
     fromHost: ownHostId(),
-    projectName: cfg2.remoteSubfolder ?? basename7(cfg2.localRoot),
+    projectName: cfg2.remoteSubfolder ?? basename6(cfg2.localRoot),
     ...cfg2.remoteParent ? { remoteParent: cfg2.remoteParent } : {},
     ...cfg2.remoteSubfolder ? { remoteSubfolder: cfg2.remoteSubfolder } : {},
     ...cfg2.workspaceLinkId ? { workspaceLinkId: cfg2.workspaceLinkId } : {}
@@ -54288,8 +54551,11 @@ async function handleInboundAgent(msg, driverClientId) {
         ...msg.permissionMode ? { permissionMode: msg.permissionMode } : {},
         ...msg.effort ? { effort: msg.effort } : {},
         ...msg.model ? { model: msg.model } : {},
-        ...msg.jsonSchema ? { jsonSchema: msg.jsonSchema } : {}
+        ...msg.jsonSchema ? { jsonSchema: msg.jsonSchema } : {},
         // M7 structured output
+        ...msg.appendSystemPrompt ? { appendSystemPrompt: msg.appendSystemPrompt } : {},
+        // mission hidden launch
+        ...msg.missionSkillId ? { missionSkillId: msg.missionSkillId } : {}
       })).catch(() => {
       });
       break;
@@ -54316,21 +54582,6 @@ async function handleInboundAgent(msg, driverClientId) {
       send("agent", { type: "session:summary", clientRequestId: msg.clientRequestId, ...res }, route2);
       break;
     }
-    case "session:watch":
-      if (driverClientId) {
-        void watchSession(msg.sessionId, driverClientId, msg.projectDir, {
-          getMessages: (sid) => b.getMessages(sid),
-          isSessionBusy: (sid) => b.isSessionBusy?.(sid) ?? false,
-          resolveFile: (sid, dir) => b.resolveSessionFile?.(sid, dir) ?? Promise.resolve(null),
-          getSessionArtifacts: (sid) => b.getSessionArtifacts?.(sid) ?? Promise.resolve([]),
-          emit: (key2, m) => send("agent", m, { clientId: key2 })
-        });
-      }
-      break;
-    case "session:unwatch":
-      if (driverClientId)
-        unwatchSession(msg.sessionId, driverClientId);
-      break;
     case "session:fork": {
       const newId = await b.forkSession?.(msg.sessionId, { projectDir: msg.projectDir, upToMessageId: msg.upToMessageId, title: msg.title }).catch(() => null);
       if (newId)
@@ -54378,6 +54629,9 @@ async function handleInboundAgent(msg, driverClientId) {
     case "chat:elicitation":
       b.respondToElicitation?.(msg.requestId, { action: msg.action, content: msg.content }, origin);
       break;
+    case "chat:ui_response":
+      b.respondToUiRequest?.(msg.requestId, msg.response, origin);
+      break;
     case "agent:mcp_reconnect":
       void b.reconnectMcpServer?.(msg.sessionId, msg.name);
       break;
@@ -54466,7 +54720,6 @@ function releaseDriver(clientId) {
   sealChains.delete(clientId);
   voiceControls.get(clientId)?.stop("disconnected");
   voiceControls.delete(clientId);
-  unwatchSessionClient(clientId);
   releaseClientPtys(clientId);
   releaseDcClient(clientId);
   for (const [sid, cid] of [...driverBySession]) {
@@ -54506,7 +54759,6 @@ function teardownHostRole() {
   driverBySession.clear();
   driverByRequest.clear();
   unwatchAllRemote();
-  unwatchAllSessions();
   releaseRemotePtys();
   try {
     hostBackend?.reclaim("critical");
@@ -54992,6 +55244,7 @@ async function startLocalServer(opts) {
       exit: (ptyId, exitCode, signal) => send2("term", { type: "term:exit", ptyId, exitCode, signal })
     };
     const heldSessions = /* @__PURE__ */ new Set();
+    let focusedTab;
     let voiceControl = null;
     const unregisterSink = registerAgentSink((msg, origin2) => {
       const isCron = origin2 === "cron" && (MIRRORED_AGENT_EVENTS.has(msg.type) || msg.type === "session:created");
@@ -55023,13 +55276,16 @@ async function startLocalServer(opts) {
       unregisterSink();
       voiceControl?.stop("disconnected");
       voiceControl = null;
-      unwatchSessionClient(loopbackOrigin);
       clearBrowserOrigin(loopbackOrigin);
-      if (heldSessions.size) {
+      if (heldSessions.size || focusedTab) {
         const b = peekSharedBackend();
         for (const sid of heldSessions)
           b?.setSessionKeepAlive?.(sid, false, loopbackOrigin);
         heldSessions.clear();
+        if (focusedTab) {
+          b?.setSessionKeepAlive?.(focusedTab, false, "tab");
+          focusedTab = void 0;
+        }
       }
       releaseClientPtys(termClientId);
     });
@@ -55062,8 +55318,11 @@ async function startLocalServer(opts) {
             ...msg.permissionMode ? { permissionMode: msg.permissionMode } : {},
             ...msg.effort ? { effort: msg.effort } : {},
             ...msg.model ? { model: msg.model } : {},
-            ...msg.jsonSchema ? { jsonSchema: msg.jsonSchema } : {}
+            ...msg.jsonSchema ? { jsonSchema: msg.jsonSchema } : {},
             // M7 structured output
+            ...msg.appendSystemPrompt ? { appendSystemPrompt: msg.appendSystemPrompt } : {},
+            // mission hidden launch
+            ...msg.missionSkillId ? { missionSkillId: msg.missionSkillId } : {}
           })).catch(() => {
           });
           break;
@@ -55088,18 +55347,6 @@ async function startLocalServer(opts) {
           send2("agent", { type: "session:summary", clientRequestId: msg.clientRequestId, ...res });
           break;
         }
-        case "session:watch":
-          void watchSession(msg.sessionId, loopbackOrigin, msg.projectDir, {
-            getMessages: (sid) => b.getMessages(sid),
-            isSessionBusy: (sid) => b.isSessionBusy?.(sid) ?? false,
-            resolveFile: (sid, dir) => b.resolveSessionFile?.(sid, dir) ?? Promise.resolve(null),
-            getSessionArtifacts: (sid) => b.getSessionArtifacts?.(sid) ?? Promise.resolve([]),
-            emit: (_key, m) => send2("agent", m)
-          });
-          break;
-        case "session:unwatch":
-          unwatchSession(msg.sessionId, loopbackOrigin);
-          break;
         case "session:fork": {
           const newId = await b.forkSession?.(msg.sessionId, { projectDir: msg.projectDir, upToMessageId: msg.upToMessageId, title: msg.title }).catch(() => null);
           if (newId)
@@ -55146,6 +55393,9 @@ async function startLocalServer(opts) {
         case "chat:elicitation":
           b.respondToElicitation?.(msg.requestId, { action: msg.action, content: msg.content }, loopbackOrigin);
           break;
+        case "chat:ui_response":
+          b.respondToUiRequest?.(msg.requestId, msg.response, loopbackOrigin);
+          break;
         case "agent:mcp_reconnect":
           void b.reconnectMcpServer?.(msg.sessionId, msg.name);
           break;
@@ -55162,6 +55412,28 @@ async function startLocalServer(opts) {
             heldSessions.delete(msg.sessionId);
           b.setSessionKeepAlive?.(msg.sessionId, msg.keep, loopbackOrigin);
           break;
+        case "session:focus": {
+          const warmParams = mergeDaemonAgentSettings({
+            message: "",
+            url: msg.url ?? "",
+            sessionId: msg.sessionId,
+            projectDir: msg.projectDir ?? opts.hostRoot,
+            sources: msg.sources,
+            agents: msg.agents,
+            browserId: msg.browserId ?? loopbackOrigin,
+            origin: loopbackOrigin,
+            ...msg.permissionMode ? { permissionMode: msg.permissionMode } : {},
+            ...msg.effort ? { effort: msg.effort } : {},
+            ...msg.model ? { model: msg.model } : {}
+          });
+          if (msg.focused === false) {
+            void b.warmSession?.(warmParams);
+          } else {
+            focusedTab = msg.sessionId;
+            void b.setActiveSession?.(msg.sessionId, warmParams);
+          }
+          break;
+        }
         case "config:set":
           b.setConfig(msg.projectDir);
           refreshDaemonScheduling(b);
@@ -55560,7 +55832,7 @@ import { platform as platform2 } from "node:os";
 
 // ../../packages/host-core/dist/service/launchd.js
 import { writeFileSync as writeFileSync14, existsSync as existsSync17, mkdirSync as mkdirSync14, unlinkSync as unlinkSync3 } from "node:fs";
-import { dirname as dirname15, join as join33 } from "node:path";
+import { dirname as dirname14, join as join33 } from "node:path";
 import { homedir as homedir14, userInfo } from "node:os";
 
 // ../../packages/host-core/dist/service/exec.js
@@ -55627,8 +55899,8 @@ ${env}
   }
   return {
     async install(spec) {
-      mkdirSync14(dirname15(plistPath()), { recursive: true });
-      mkdirSync14(dirname15(spec.logPath), { recursive: true });
+      mkdirSync14(dirname14(plistPath()), { recursive: true });
+      mkdirSync14(dirname14(spec.logPath), { recursive: true });
       writeFileSync14(plistPath(), buildPlist(spec));
       await run("launchctl", ["bootout", serviceTarget()]).catch(() => {
       });
@@ -55680,7 +55952,7 @@ ${env}
 
 // ../../packages/host-core/dist/service/systemd.js
 import { writeFileSync as writeFileSync15, existsSync as existsSync18, mkdirSync as mkdirSync15, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname16, join as join34 } from "node:path";
+import { dirname as dirname15, join as join34 } from "node:path";
 import { homedir as homedir15, userInfo as userInfo2 } from "node:os";
 function shq(s) {
   return `"${s.replace(/(["\\$`])/g, "\\$1")}"`;
@@ -55714,8 +55986,8 @@ WantedBy=default.target
   }
   return {
     async install(spec) {
-      mkdirSync15(dirname16(unitPath()), { recursive: true });
-      mkdirSync15(dirname16(spec.logPath), { recursive: true });
+      mkdirSync15(dirname15(unitPath()), { recursive: true });
+      mkdirSync15(dirname15(spec.logPath), { recursive: true });
       writeFileSync15(unitPath(), buildUnit(spec));
       await run("loginctl", ["enable-linger", userInfo2().username]).catch(() => {
       });
@@ -55760,7 +56032,7 @@ WantedBy=default.target
 
 // ../../packages/host-core/dist/service/windows.js
 import { writeFileSync as writeFileSync16, existsSync as existsSync19, mkdirSync as mkdirSync16, unlinkSync as unlinkSync5 } from "node:fs";
-import { dirname as dirname17, join as join35 } from "node:path";
+import { dirname as dirname16, join as join35 } from "node:path";
 function makeWindowsTask(instanceId) {
   const task = `Fineguide\\TesseractHost${instanceId ? `-${instanceId}` : ""}`;
   const wrapperPath = () => join35(daemonDir(), `run-host${instanceId ? `-${instanceId}` : ""}.cmd`);
@@ -55778,8 +56050,8 @@ start "" /b ${cmd} >> "${oneLine2(spec.logPath).replace(/"/g, "")}" 2>&1\r
   }
   return {
     async install(spec) {
-      mkdirSync16(dirname17(spec.logPath), { recursive: true });
-      mkdirSync16(dirname17(wrapperPath()), { recursive: true });
+      mkdirSync16(dirname16(spec.logPath), { recursive: true });
+      mkdirSync16(dirname16(wrapperPath()), { recursive: true });
       writeFileSync16(wrapperPath(), buildWrapper(spec));
       await run("schtasks", ["/Create", "/TN", task, "/SC", "ONLOGON", "/RL", "LIMITED", "/F", "/TR", `"${wrapperPath()}"`]);
       await run("schtasks", ["/Run", "/TN", task]).catch(() => {
@@ -56272,7 +56544,7 @@ async function logs(instanceId, follow) {
 // src/cli.ts
 function pkgVersion() {
   try {
-    const p = join38(dirname18(fileURLToPath2(import.meta.url)), "..", "package.json");
+    const p = join38(dirname17(fileURLToPath2(import.meta.url)), "..", "package.json");
     return JSON.parse(readFileSync15(p, "utf8")).version ?? "0.0.0";
   } catch {
     return "0.0.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tesseract-agent",
-  "version": "0.4.20",
+  "version": "0.4.21",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public",