@davait/aipictury 1.9.2

package/ext/extension.js

@@ -0,0 +1,2483 @@
+'use strict'
+// AIPictury in VS Code: a coding agent in the side bar (and in as many editor tabs as you
+// open), and the generation studio in a tab. Which model does which job is configured on
+// the AIPictury server, so every editor that points at the same server behaves the same.
+
+const vscode = require('vscode')
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const { execFile } = require('child_process')
+const gpuServer = require('./gpuServer')
+const gpuRun = require('./gpuRun')
+const agent = require('./agent')
+const memory = require('./memory')
+const files = require('./files')
+const shell = require('./shell')
+const mcp = require('./mcp')
+const voice = require('./voice')
+const { RemoteLink } = require('./remote')
+const context = require('./context')
+const { showAbout } = require('./about')
+const { stripInvisible } = require('./text')
+const sessions = require('./sessions')
+const log = require('./log')
+const workbench = require('./workbench')
+const dialogs = require('./dialogs')
+const userHooks = require('./hooks')
+const scheduler = require('./scheduler')
+const usageLog = require('./usage')
+const prefs = require('./prefs')
+
+const SCHEME = 'aipictury-proposed'
+const VERSION = require('./package.json').version
+
+/** Any short request to the server. A status check must never be able to hang the
+ *  panel, so it is given a deadline and a failure is simply "not answering". */
+async function ask(route, ms = 10_000) {
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), ms)
+  try {
+    const response = await fetch(`${serverUrl()}${route}`, { signal: controller.signal })
+    if (!response.ok) throw new Error(`the server answered ${response.status}: ${(await response.text().catch(() => '')).slice(0, 300)}`)
+    return await response.json()
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+/** The GPU server (gpuServer.js: this machine's setting, else the account's choice). */
+function serverUrl() {
+  return gpuServer.url()
+}
+
+const config = () => vscode.workspace.getConfiguration('aipictury')
+
+/** A random string for the webview's content security policy. */
+function nonce() {
+  return Array.from({ length: 24 },
+    () => 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'[Math.floor(Math.random() * 62)]
+  ).join('')
+}
+
+const workspaceRoot = () => vscode.workspace.workspaceFolders?.[0]?.uri
+let TRUST_DECLINED = null       // project hooks the user said "not now" to, until VS Code restarts
+
+/** Removes a proposal's copy — a moment later: VS Code's local history copies a file as it is
+ *  saved, and a copy gone mid-way fills its log with errors. */
+// The folder goes with its last file (rmdir refuses one that is not empty).
+function dropReview(file) {
+  setTimeout(() => fs.promises.unlink(file).catch(() => {}).then(() => fs.promises.rmdir(path.dirname(file)).catch(() => {})), 3000).unref?.()
+}
+
+/** Proposal copies left by a VS Code that closed during a review: removed at the next start. */
+function sweepReviews() {
+  const dir = path.join(os.tmpdir(), 'aipictury-review')
+  try {
+    for (const name of fs.readdirSync(dir)) {
+      const file = path.join(dir, name)
+      if (Date.now() - fs.statSync(file).mtimeMs > 3_600_000) fs.rmSync(file, { force: true })
+    }
+    fs.rmdirSync(dir)                         // empty now: nothing left in the temp folder
+  } catch { /* none, or still in use */ }
+}
+
+/** Adds text to a message, whether its content is text or parts (text and pictures). */
+function appendText(message, text) {
+  if (typeof message.content === 'string') message.content += text
+  else if (Array.isArray(message.content)) message.content.push({ type: 'text', text })
+  else message.content = text
+}
+
+// ---------------------------------------------------------------- the agent panel
+
+const STORE = 'aipictury.conversations'
+const LIVE = 'aipictury.live'            // the conversation on screen, and whether it was mid-run
+const MAX_ATTACH = 10      // files per message, as in the web assistant
+const ATTACH_TYPES = ['png', 'jpg', 'jpeg', 'webp', 'gif', 'bmp', 'pdf', 'txt', 'md', 'json', 'csv',
+  'log', 'yaml', 'yml', 'py', 'js', 'jsx', 'ts', 'tsx', 'sh', 'sql', 'html', 'css', 'xml', 'toml',
+  'c', 'h', 'cpp', 'rs', 'go', 'java']
+const CHECKPOINTS = 100    // file snapshots kept per conversation, as Claude Code keeps
+const RESTORE_WINDOW = 10 * 60_000     // a side-bar chat comes back after a reload if this recent
+const CONTINUE_WINDOW = 60 * 60_000    // and a run cut by the reload continues if this recent
+
+// Commands typed after /, handled here without the model. Custom commands from the
+// project's .aipictury/commands or .claude/commands and skills are listed after these.
+const SLASH = [
+  ['clear', 'Start a new conversation', ''],
+  ['compact', 'Summarize the conversation so far, to free context', '[what to focus on]'],
+  ['plan', 'Switch to Plan mode — and plan a task, if given one', '[task]'],
+  ['rewind', 'Restore the code or the conversation to an earlier message', ''],
+  ['btw', 'Ask a side question without adding it to the conversation', '<question>'],
+  ['copy', 'Copy the latest answer (or the nth latest) to the clipboard', '[n]'],
+  ['export', 'Export the conversation as Markdown', '[file]'],
+  ['todos', 'Show the agent\'s to-do list', ''],
+  ['tasks', 'Commands running in the background — see or stop them', ''],
+  ['status', 'Version, server, model, mode, context, MCP servers, instructions', ''],
+  ['usage', 'Tokens and time this conversation has used', ''],
+  ['model', 'Switch the model', '[name]'],
+  ['effort', 'How hard the model reasons: low, medium, high, max or ultra (Ultracode)', '[level]'],
+  ['mcp', 'MCP servers and their tools', ''],
+  ['login', 'Sign in to your AIPictury account (in the browser)', ''],
+  ['logout', 'Sign out of your AIPictury account on this machine', ''],
+  ['account', 'Your AIPictury account: what is kept with it, sign out, delete the cloud copy', ''],
+  ['remote-control', 'Carry this conversation on from a browser or a phone (a private link); stop ends it', '[stop]'],
+  ['init', 'Write an AIPICTURY.md that explains this codebase to the agent', ''],
+  ['review', 'Review the uncommitted changes', ''],
+  ['memory', 'The rules the agent always follows', ''],
+  ['permissions', 'What the agent may do without asking, must ask about, or may never do', ''],
+  ['hooks', 'Your commands that run as the agent works (Claude Code\'s format)', ''],
+  ['loop', 'Do something again and again: /loop 10m <prompt>, /loop <prompt>, /loop stop', '[interval] <prompt>'],
+  ['jobs', 'The prompts scheduled in this conversation', ''],
+  ['sandbox', 'Keep commands to the workspace (and off the internet)', ''],
+  ['bug', 'Report a problem — saved here, and sent to your server if you want', '[what happened]'],
+  ['feedback', 'Send an idea or a wish', '[what you would like]'],
+  ['rename', 'Rename this conversation', '<title>'],
+  ['resume', 'Reopen an earlier conversation', ''],
+  ['skills', 'The skills the project provides — which the model sees', ''],
+  ['plugin', 'Plugins and marketplaces — Claude Code\'s format', ''],
+  ['agents', 'The helpers at work, and the commands in the background', ''],
+  ['pages', 'The pages the agent published on your server', ''],
+  ['output-style', 'How the agent writes its answers (Default, Explanatory, Learning, yours)', ''],
+  ['focus', 'Focus view: hide tool steps and reasoning', ''],
+  ['config', 'Open the AIPictury settings', ''],
+  ['about', 'This agent\'s version, and the server\'s models and GPUs', ''],
+  ['help', 'What the agent can do, and how', ''],
+]
+
+const INIT_PROMPT = 'Analyze this codebase and create an AIPICTURY.md file at the workspace root that '
+  + 'will be given to future coding agents working here. Include: the commands to build, lint and test '
+  + '(and how to run a single test); the high-level architecture — the big picture that takes reading '
+  + 'several files to understand; conventions the code follows. Do not list every file or repeat what '
+  + 'is obvious. If there is already an AIPICTURY.md, AGENTS.md, CLAUDE.md, README or Cursor/Copilot '
+  + 'rules, fold what matters from them in. If AIPICTURY.md exists, improve it instead. Start it with: '
+  + '"# AIPICTURY.md" and a line saying the file guides AI coding agents working in this repository.'
+
+const REVIEW_PROMPT = 'Review the uncommitted changes in this repository (git status and git diff, '
+  + 'staged and unstaged). Look for bugs, missed edge cases, security problems, and code that does not '
+  + 'match the conventions around it. Report what you find with report_findings — most serious first, '
+  + 'each with its file and line, what goes wrong and the fix — then sum it up in a sentence or two. '
+  + 'Do not change any file.'
+
+class AgentPanel {
+  constructor(context, { kind = 'sidebar', registry } = {}) {
+    this.context = context
+    this.kind = kind
+    this.registry = registry
+    this.history = []
+    this.session = { allowAll: false }
+    this.host = null        // the WebviewView or WebviewPanel showing this conversation
+    this.abort = null
+    this.id = null         // which stored conversation this is, once it has content
+    this.model = context.globalState.get('aipictury.model') || null   // override, or the role default
+    this.transcript = []   // what was on screen, kept so a reopened chat is whole
+    this.queue = []        // messages sent while a run is going: {message, text, files}
+    this.attachments = []  // files waiting to go with the next message (at most MAX_ATTACH)
+    this.models = []       // what each installed model can do, from the server
+    this.created = null
+    this.title = null      // set by /rename; otherwise the first question
+    this.checkpoints = []  // per question: the files as they were before the agent changed them
+    this.approvals = new Map()
+    this.todos = []
+    this.jobs = []          // this conversation's scheduled prompts (/loop, the cron tools, wake-ups)
+    this.btw = []           // the side thread: /btw questions and answers, never in the conversation
+    this.usage = { turns: 0, prompt: 0, output: 0, seconds: 0 }
+    this.contextDismissed = null
+    this.focused = false
+  }
+
+  get view() { return this.host }
+  get visible() { return !!this.host?.visible }
+
+  /** Conversations belong to the project they were had in. */
+  /** This folder's conversations on disk, shared with the other windows and the CLI. */
+  get store() { return sessions.storeFor(workspaceRoot()?.fsPath) }
+
+  /** Every stored conversation, whole (the lists use store.list(), which has no history). */
+  get stored() { return this.store.list().map((m) => this.store.get(m.id)).filter(Boolean) }
+
+  get conversationTitle() {
+    const first = this.history.find((m) => m.role === 'user')
+    return this.title || this.aiTitle || (first ? String(first.content).replace(/\[[^\]]*\]\n?/g, '').replace(/\s+/g, ' ').trim().slice(0, 80) : 'New conversation')
+  }
+
+  /** Writes the current exchange into the list, newest first. */
+  async remember() {
+    if (!this.history.length) return
+    const first = this.history.find((m) => m.role === 'user')
+    if (!first) return
+    this.id = this.id || `c${Date.now().toString(36)}`
+    this.created = this.created || Date.now()
+    // Two halves, and both are needed: `history` is the exact context the model is
+    // given, so the conversation can be carried on; `transcript` is what was on the
+    // screen — answers, reasoning, and what each tool did — so reopening shows it whole.
+    const entry = {
+      id: this.id,
+      title: this.conversationTitle,
+      renamed: !!this.title,
+      aiTitle: this.aiTitle || undefined,
+      created: this.created,
+      updated: Date.now(),
+      server: serverUrl(),
+      model: this.lastModel || null,
+      history: this.history,
+      transcript: this.transcript,
+      todos: this.todos,
+      jobs: this.jobs?.length ? this.jobs : undefined,
+      btw: this.btw?.length ? this.btw : undefined,
+      usage: this.usage,
+    }
+    this.store.save(entry)
+    await this.saveCheckpoints()
+    if (this.kind === 'tab' && this.host) this.host.title = `AIPictury: ${entry.title.slice(0, 30)}`
+    this.postSession()
+  }
+
+  /** After the first answer: a title written by the model already loaded (the server makes
+   *  none rather than load one). One you gave it, with /rename or from the list, always wins. */
+  async suggestTitle({ fetchImpl = fetch } = {}) {
+    if (this.title || this.aiTitle || !this.id) return null
+    const questions = this.history.filter((m) => m.role === 'user')
+    const answer = [...this.transcript].reverse().find((t) => t.kind === 'assistant' && String(t.text || '').trim())
+    if (questions.length !== 1 || !answer) return null
+    const id = this.id
+    const controller = new AbortController()
+    const timer = setTimeout(() => controller.abort(), 40_000)
+    try {
+      const response = await fetchImpl(`${serverUrl()}/api/agent/title`, { method: 'POST', signal: controller.signal,
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ text: `${this.conversationTitle}\n\n${String(answer.text).slice(0, 1500)}`,
+          model: this.lastModel || this.model || undefined }) })
+      const { title } = response.ok ? await response.json() : {}
+      // Still the same conversation, and not renamed meanwhile.
+      if (!title || this.id !== id || this.title) return null
+      this.aiTitle = String(title).slice(0, 80)
+      await this.remember()
+      return this.aiTitle
+    } finally { clearTimeout(timer) }
+  }
+
+  /** Saves a little later, at most every second — for saving at every step of a run. */
+  rememberSoon() {
+    if (this.saveTimer) return
+    this.saveTimer = setTimeout(() => { this.saveTimer = null; this.remember().catch(() => {}) }, 1000)
+  }
+
+  // ---- checkpoints: files as they were, per question ----
+  /** Where checkpoints were kept before conversations moved to disk (read once, when moving). */
+  oldCheckpointsDir() {
+    const dir = this.context.storageUri || this.context.globalStorageUri
+    return dir ? path.join(dir.fsPath, 'checkpoints') : null
+  }
+
+  async saveCheckpoints() {
+    if (this.id) this.store.saveCheckpoints(this.id, this.checkpoints.slice(-CHECKPOINTS))
+  }
+
+  loadCheckpoints(id) { return this.store.loadCheckpoints(id) }
+
+  /** Reopens a stored conversation, rebuilt in the panel. */
+  async open(id, { focus = true } = {}) {
+    const found = this.store.get(id)
+    if (!found) return false
+    if (this.abort) { vscode.window.showInformationMessage('Stop the agent before switching conversations.'); return false }
+    await this.remember()                  // do not lose the one on screen
+    this.id = found.id
+    this.created = found.created || found.updated
+    this.history = found.history
+    this.title = found.renamed ? found.title : null
+    this.aiTitle = found.aiTitle || null
+    this.todos = found.todos || []
+    this.jobs = found.jobs || []                  // a reopened conversation keeps its schedule
+    this.btw = found.btw || []                    // and its side thread
+    this.usage = found.usage || { turns: 0, prompt: 0, output: 0, seconds: 0 }
+    this.checkpoints = this.loadCheckpoints(found.id)
+    this.session = { allowAll: false }     // a reopened conversation asks again
+    // Older entries predate the stored transcript; rebuild what can be rebuilt.
+    this.transcript = found.transcript || fromHistory(found.history)
+    if (found.unread) this.store.patch(found.id, { unread: undefined })    // seen now
+    this.startSource = 'resume'                // for the user's SessionStart hooks, at the next run
+    if (this.kind === 'tab' && this.host) this.host.title = `AIPictury: ${String(found.title).slice(0, 30)}`
+    this.post({ type: 'restore', title: found.title, turns: this.transcript, todos: this.todos })
+    if (this.btw.length) this.post({ type: 'btwThread', items: this.btw })
+    this.postSession()
+    this.registry?.sessionsView?.refresh()
+    if (focus && this.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
+    return true
+  }
+
+  /** Shows this conversation in a view (the side bar) or a panel (an editor tab). */
+  attach(host) {
+    this.host = host
+    const webview = host.webview
+    webview.options = {
+      enableScripts: true,
+      localResourceRoots: [vscode.Uri.joinPath(this.context.extensionUri, 'media')],
+    }
+    webview.html = this.html(webview)
+    const subs = [webview.onDidReceiveMessage((message) => this.onMessage(message).catch((error) => {
+      log.error(`panel message ${message?.type}`, error)
+      this.post({ type: 'error', text: `Something went wrong: ${error.message}` })
+    }))]
+    // The prompt cache note is checked against the server every 10s while the panel
+    // is on screen (a render can unload the model at any moment); between checks the
+    // panel counts down every second on its own.
+    const poll = setInterval(() => { if (host.visible) this.refreshCache() }, 10_000)
+    const visibility = host.onDidChangeVisibility
+      ? host.onDidChangeVisibility(() => this.onVisible())
+      : host.onDidChangeViewState(() => { this.onVisible(); if (host.active) this.registry?.activate(this) })
+    subs.push(visibility)
+    // Scheduled prompts: looked at every 15 s, while this panel is open.
+    const ticker = setInterval(() => this.tickJobs(), 15_000)
+    host.onDidDispose(() => {
+      clearInterval(poll); clearInterval(ticker); subs.forEach((s) => s.dispose())
+      clearInterval(this.gpuWatch); this.gpuWatch = null
+      this.abort?.abort()
+      this.recording?.cancel()
+      if (this.remote) this.registry?.account?.cloud?.dropRemote?.(this.remote.id).catch(() => {})
+      this.remote?.stop()
+      this.remember().catch(() => {})
+      this.registry?.remove(this)
+    })
+  }
+
+  onVisible() {
+    if (!this.host?.visible) return
+    this.refreshCache()
+    this.setBadge(null)
+  }
+
+  /** A dot on the icon when the agent needs you (a question) or finished while you were away. */
+  setBadge(reason) {
+    this.registry?.sessionsView?.refresh()     // the Sessions view shows what each one is doing
+    // The status bar and a system notification say it too — whether or not the panel shows.
+    if (reason === 'waiting') {
+      this.fireHook('Notification', { message: `AIPictury is waiting for you: ${this.conversationTitle}` }).catch(() => {})
+      workbench.setState('waiting')
+      workbench.notify('AIPictury is waiting for you', this.conversationTitle)
+    } else if (reason === 'finished') {
+      workbench.setState(this.registry?.all().some((p) => p.abort) ? 'working' : 'finished')
+      workbench.notify('AIPictury has finished', this.conversationTitle)
+      if (this.id && !this.host?.visible) this.store.patch(this.id, { unread: true })
+    } else {
+      workbench.setState(this.registry?.all().some((p) => p.abort) ? 'working' : 'idle')
+    }
+    if (!this.host) return
+    if (reason && this.host.visible) return
+    if (this.kind === 'sidebar') {
+      this.host.badge = reason ? { value: 1, tooltip: reason === 'waiting' ? 'The agent is waiting for you' : 'The agent has finished' } : undefined
+    } else {
+      const title = String(this.host.title || 'AIPictury').replace(/^[●○] /, '')
+      this.host.title = reason ? `${reason === 'waiting' ? '●' : '○'} ${title}` : title
+    }
+  }
+
+  /** Asks the server whether the agent's model is still loaded — its prompt cache warm —
+   *  and for how long, as Ollama itself will unload it. */
+  async refreshCache() {
+    if (this.abort) return                      // mid-run: the model is in use, so warm
+    try {
+      // An empty model means the agent role's default, as the server reads it.
+      const response = await fetch(`${serverUrl()}/api/agent/cache?model=${encodeURIComponent(this.model || '')}`,
+        { signal: AbortSignal.timeout(10_000) })
+      if (!response.ok) return
+      const state = await response.json()
+      this.post({ type: 'cache', warm: state.warm, seconds: state.seconds_left })
+    } catch { /* offline: the status line already says so */ }
+  }
+
+  post(message) { this.host?.webview.postMessage(message) }
+
+  postMode() {
+    // Bypass is offered only when allowDangerouslySkipPermissions is on.
+    const modes = Object.fromEntries(Object.entries(agent.MODES)
+      .filter(([id]) => id !== 'bypass' || config().get('allowDangerouslySkipPermissions', false)))
+    this.post({ type: 'mode', current: agent.modeNow(), modes,
+                reasoning: config().get('showThinking', true), effort: agent.effortOf(config().get('effort', 'high')),
+                focusView: config().get('focusView', false), enterSends: !config().get('useCtrlEnterToSend', false),
+                scrollOnSend: config().get('scrollToBottomOnSend', true), onboarding: !config().get('hideOnboarding', false) })
+  }
+
+  postSession() {
+    this.post({ type: 'session', id: this.id, title: this.conversationTitle, kind: this.kind })
+  }
+
+  postCommands() {
+    const custom = context.commands().map((c) => ({ name: c.name, description: c.description, hint: c.hint, custom: true }))
+    const skills = context.skills().map((s) => ({ name: s.name, description: `skill — ${s.description}`, skill: true }))
+    this.post({ type: 'commands', items: [
+      ...SLASH.map(([name, description, hint]) => ({ name, description, hint })), ...custom, ...skills] })
+  }
+
+  async onMessage(message) {
+    switch (message.type) {
+      case 'ready': {
+        this.postAccount(this.registry?.account?.user?.() ?? null)
+        this.refreshStatus(); this.postMode(); this.refreshCache(); this.postCommands(); this.postSession()
+        editorTracker.post(this)
+        // Reloaded while a question was open: the agent is still waiting for it.
+        if (this.pendingAsk) this.post({ type: 'askUser', id: this.pendingAsk.id, questions: this.pendingAsk.questions })
+        for (const [id, p] of this.approvals) this.post({ type: 'approval', id, request: p.request })
+        if (this.pendingPlan) this.post({ type: 'plan', id: this.pendingPlan.id, plan: this.pendingPlan.plan })
+        if (this.todos.length) this.post({ type: 'todos', items: this.todos })
+        this.post({ type: 'tasks', items: shell.taskList() })
+        // A dialog opened before the panel was ready (or open across a reload) is shown now.
+        if (this.openDialog) this.post({ type: 'dialog', spec: this.openDialog.spec })
+        return undefined
+      }
+      case 'ask': return this.ask(message.text)
+      case 'stop': this.abort?.abort(); return undefined
+      case 'answer': {
+        // The chooser was answered (or closed): hand it to the agent that is waiting.
+        const pending = this.pendingAsk
+        if (pending && pending.id === message.id) {
+          this.pendingAsk = null
+          pending.resolve(message.dismissed ? { dismissed: true } : { answers: message.answers || [] })
+        }
+        return undefined
+      }
+      case 'approval': {
+        const pending = this.approvals.get(message.id)
+        if (!pending) return undefined
+        this.approvals.delete(message.id)
+        let edited
+        if (pending.review) {
+          // The proposal was opened in VS Code's diff, where it can be edited before accepting.
+          const doc = vscode.workspace.textDocuments.find((d) => d.uri.fsPath === pending.review)
+          if (doc?.isDirty) await doc.save()
+          try { edited = fs.readFileSync(pending.review, 'utf8') } catch { /* gone */ }
+          dropReview(pending.review)
+        }
+        pending.resolve({ decision: message.decision, feedback: message.feedback, keep: message.keep,
+          prefix: message.prefix, destination: message.destination, edited: edited !== undefined && edited !== pending.request.after ? edited : undefined })
+        return undefined
+      }
+      case 'reviewDiff': return this.reviewDiff(message.id)
+      case 'openUrl':
+        if (/^https?:\/\//.test(String(message.url))) await vscode.env.openExternal(vscode.Uri.parse(message.url))
+        return undefined
+      case 'userFile': {
+        let uri
+        try { uri = require('./paths').resolve(message.path) } catch (error) { this.say(error.message); return undefined }
+        if (message.action === 'open') await vscode.commands.executeCommand('vscode.open', uri)
+        if (message.action === 'reveal') await vscode.commands.executeCommand('revealFileInOS', uri)
+        if (message.action === 'save') {
+          const to = await vscode.window.showSaveDialog({ defaultUri: vscode.Uri.file(path.join(os.homedir(), path.basename(uri.fsPath))) })
+          if (to) { await vscode.workspace.fs.copy(uri, to, { overwrite: true }); this.say(`saved a copy: ${to.fsPath}`) }
+        }
+        return undefined
+      }
+      case 'onboarding':
+        if (message.action === 'hide') {
+          await config().update('hideOnboarding', true, vscode.ConfigurationTarget.Global)
+          this.say('Hidden — the walkthrough stays in the command palette: AIPictury: Open Walkthrough')
+        }
+        if (message.action === 'walkthrough') await vscode.commands.executeCommand('aipictury.openWalkthrough')
+        return undefined
+      case 'planAnswer': {
+        const pending = this.pendingPlan
+        if (!pending || pending.id !== message.id) return undefined
+        this.pendingPlan = null
+        let plan
+        if (pending.doc && !pending.doc.isClosed) plan = pending.doc.getText()
+        pending.resolve({ approved: !!message.approved, mode: message.mode, feedback: message.feedback, plan })
+        return undefined
+      }
+      case 'openPlan':
+        // The plan as a Markdown file to edit and comment on, line by line (plans.js).
+        await this.registry?.plans?.open(this)
+        return undefined
+      case 'revise':
+        // "Change" on a decision Auto mode took: said to the agent as the user's next message.
+        return this.ask(message.text)
+      case 'unqueue':
+        this.queue.splice(message.index, 1)
+        this.postQueue()
+        return undefined
+      case 'reset': return this.reset()
+      case 'openStudio': return vscode.commands.executeCommand('aipictury.openStudio')
+      case 'exportFile': {
+        // A table as CSV, a diagram as SVG, from an answer: saved where the user says.
+        const name = String(message.name || 'export.txt').replace(/[^\w.-]/g, '_').slice(0, 80)
+        const base = workspaceRoot() || vscode.Uri.file(require('os').homedir())
+        const to = await vscode.window.showSaveDialog({ defaultUri: vscode.Uri.joinPath(base, name), saveLabel: 'Save' })
+        if (!to) return undefined
+        await vscode.workspace.fs.writeFile(to, new TextEncoder().encode(String(message.text || '')))
+        this.say(`saved ${vscode.workspace.asRelativePath(to)}`)
+        return undefined
+      }
+      case 'attach': return this.pickFiles()
+      case 'dictate': return this.dictate(message.action)
+      case 'signIn': return this.registry?.account?.signIn()
+      case 'account': return this.openAccount()
+      case 'remoteMenu': {
+        if (!this.remote) return undefined
+        const pick = await vscode.window.showQuickPick([{ label: '$(copy) Copy the link', id: 'copy' }, { label: '$(debug-stop) Stop remote control', id: 'stop' }],
+          { title: `Remote control — ${this.remote.viewers} viewer(s)`, placeHolder: this.remote.url.replace(/\.[^.]+$/, '.…') })
+        if (pick?.id === 'copy') { await vscode.env.clipboard.writeText(this.remote.url); this.say('the link is copied', 'remote') }
+        if (pick?.id === 'stop') await this.remoteControl('stop')
+        return undefined
+      }
+      case 'pasteFile': return this.addFile(message.name, Buffer.from(message.data, 'base64'))
+      case 'dropUris': return this.dropUris(message.uris || [])
+      case 'removeAttachment':
+        this.attachments = this.attachments.filter((a) => a.id !== message.id)
+        return this.postAttachments()
+      case 'thought': this.pendingThought = message; return undefined
+      case 'openDiff': return agent.openSideBySide(message.key)
+      case 'openImage': return vscode.env.openExternal(vscode.Uri.parse(message.src))
+      case 'setModel':
+        this.model = message.model || null
+        this.context.globalState.update('aipictury.model', this.model)
+        return undefined
+      case 'setEffort':
+        await config().update('effort', agent.effortOf(message.effort), vscode.ConfigurationTarget.Global)
+        return this.postMode()
+      case 'compact': return this.shortcut('/compact')
+      case 'enableReasoning':
+        // Reasoning had been switched off in the settings: the Thinking button turns it back on.
+        await config().update('showThinking', undefined, vscode.ConfigurationTarget.Global)
+        return this.postMode()
+      case 'setMode':
+        await config().update('approval', message.mode, vscode.ConfigurationTarget.Global)
+        return this.postMode()
+      case 'toggleFocusView':
+        await config().update('focusView', !config().get('focusView', false), vscode.ConfigurationTarget.Global)
+        return undefined
+      case 'openSettings': return vscode.commands.executeCommand('aipictury.openSettings')
+      case 'openExternal':
+        // A link from a web search: only http(s), opened in the browser.
+        if (/^https?:\/\//i.test(String(message.url || ''))) return vscode.env.openExternal(vscode.Uri.parse(message.url))
+        return undefined
+      case 'openFile': return openWorkspaceFile(message.path, message.line)
+      case 'copy':
+        await vscode.env.clipboard.writeText(String(message.text || ''))
+        this.post({ type: 'toast', text: 'Copied' })
+        return undefined
+      case 'mentionQuery':
+        this.post({ type: 'mentions', query: message.query, items: await mentionCandidates(message.query) })
+        return undefined
+      case 'dismissContext':
+        this.contextDismissed = editorTracker.key()
+        editorTracker.post(this)
+        return undefined
+      case 'dialogAction': return this.onDialogAction(message)
+      case 'rewind': return this.rewind(message.index, message.action)
+      case 'retry': {
+        // Ask again: back to before the last question, and the question sent once more.
+        if (this.abort) return undefined
+        const index = this.transcript.map((t) => t.kind).lastIndexOf('user')
+        if (index < 0) return undefined
+        const question = this.transcript[index].text
+        await this.rewind(index, 'conversation', { quiet: true })
+        return this.ask(question)
+      }
+      case 'stopTask':
+        try { shell.killShell({ shell_id: message.id }) } catch { /* already gone */ }
+        this.post({ type: 'tasks', items: shell.taskList() })
+        return undefined
+      case 'focus': this.focused = !!message.focused; if (this.focused) this.registry?.activate(this); return undefined
+      case 'command': return this.ask(`/${message.name}${message.args ? ` ${message.args}` : ''}`)
+      default: return undefined
+    }
+  }
+
+  async reset() {
+    if (this.remote) await this.remoteControl('stop')        // the link was for the conversation that ends here
+    if (this.abort) this.abort.abort()
+    await this.remember()
+    if (this.id) this.fireHook('SessionEnd', { reason: 'clear' }).catch(() => {})
+    this.startSource = 'clear'
+    this.history = []
+    this.transcript = []
+    this.id = null
+    this.created = null
+    this.title = null
+    this.aiTitle = null
+    this.todos = []
+    this.jobs = []
+    this.btw = []
+    this.checkpoints = []
+    this.usage = { turns: 0, prompt: 0, output: 0, seconds: 0 }
+    this.session = { allowAll: false }
+    this.post({ type: 'cleared' })
+    this.postSession()
+    this.refreshStatus()
+    if (this.kind === 'tab' && this.host) this.host.title = 'AIPictury Agent'
+    this.context.workspaceState.update(LIVE, null)
+  }
+
+  info(title, lines) { this.post({ type: 'info', title, lines }) }
+  say(text, reason = 'remembered') { this.post({ type: 'nudge', reason, text }) }
+
+  /** The GPU is another app's: the message back to the input, who has it said, and — watched
+   *  every few seconds — when it is free. */
+  gpuBusy(gpu, messages = []) {
+    const hold = gpuRun.busyFor(gpu)
+    const text = messages.map((m) => (typeof m.content === 'string' ? m.content : '')).filter(Boolean).join('\n\n')
+    if (text) this.post({ type: 'draft', text })
+    this.post({ type: 'gpu', gpu, busy: !!hold, said: hold?.said || 'another app' })
+    if (this.gpuWatch) return
+    this.gpuWatch = setInterval(async () => {
+      const now = await gpuRun.state(serverUrl())
+      if (gpuRun.busyFor(now)) return
+      clearInterval(this.gpuWatch); this.gpuWatch = null
+      this.post({ type: 'gpu', gpu: now, busy: false })
+    }, 5000)
+  }
+
+  /** `#` and `/` shortcuts, handled without the model — instant and certain.
+   *   # rule      remember for this project (.aipictury/memory.md)
+   *   ## rule     remember for you, everywhere
+   *   /command    see SLASH above; a custom command expands into a prompt instead.
+   *  Returns true when handled, or { prompt } when it stands for a prompt to the agent. */
+  async shortcut(text) {
+    const say = (note) => this.say(note)
+    if (/^#/.test(text) && /\S/.test(text.replace(/^#+/, ''))) this.post({ type: 'user', text })
+    if (/^##\s*\S/.test(text)) {
+      say(await memory.addUserRule(serverUrl(), text.replace(/^##\s*/, '')))
+      return true
+    }
+    if (/^#\s*\S/.test(text)) {
+      try { say(await memory.addProjectRule(text.replace(/^#\s*/, ''))) } catch (e) { say(e.message) }
+      return true
+    }
+    const m = /^\/([\w:.-]+)(?:\s+([\s\S]*))?$/.exec(text)
+    if (!m) return false
+    const [, name, rawArgs = ''] = m
+    const args = rawArgs.trim()
+    switch (name) {
+      case 'clear': case 'new': case 'reset': await this.reset(); return true
+      case 'memory': await this.openMemory(); return true
+      case 'permissions': case 'allowed-tools': await this.openPermissions(); return true
+      case 'hooks': await this.openHooks(); return true
+      case 'loop': {
+        // /loop 5m <prompt>: every 5 minutes. /loop <prompt>: the agent paces itself (schedule_wakeup).
+        // /loop stop: no more.
+        if (/^stop\b/i.test(args)) {
+          const before = this.jobs.length
+          this.jobs = this.jobs.filter((j) => j.kind !== 'loop' && j.kind !== 'wakeup')
+          this.rememberSoon()
+          say(before === this.jobs.length ? 'no loop is running' : 'the loop is stopped')
+          return true
+        }
+        const m = /^(\S+)\s+([\s\S]+)$/.exec(args)
+        const every = m && scheduler.interval(m[1])
+        if (!args) { say('/loop 10m <what to do> — or /loop <what to do> and the agent chooses when to come back; /loop stop'); return true }
+        if (every) {
+          this.jobs.push(scheduler.job(this.jobs, { schedule: m[1], prompt: m[2], kind: 'loop' }))
+          this.rememberSoon()
+          say(`looping every ${m[1]} — /loop stop to end it`)
+          return { prompt: m[2] }
+        }
+        return { prompt: `${args}\n\n[This is a loop: when you have done it, use schedule_wakeup to come back to it — choose the delay from what you are waiting for. Stop when it no longer needs doing.]` }
+      }
+      case 'jobs': case 'schedule': {
+        this.info('Scheduled prompts', this.jobs.length ? this.jobs.map((j) => scheduler.describe(j))
+          : ['None. /loop 10m <prompt>, or ask the agent to schedule something.'])
+        return true
+      }
+      case 'sandbox': await this.openSandbox(); return true
+      case 'bug': case 'feedback': await this.reportProblem(name, args); return true
+      case 'compact': return this.compact(args)
+      case 'plan':
+        if (args === 'open') {
+          if (!this.pendingPlan) say('no plan is waiting for your answer')
+          else await this.registry?.plans?.open(this)
+          return true
+        }
+        await config().update('approval', 'plan', vscode.ConfigurationTarget.Global)
+        this.postMode()
+        if (!args) { say('Plan mode: the agent investigates and proposes a plan; nothing is changed until you approve it'); return true }
+        return { prompt: args }
+      case 'rewind': await this.rewindPicker(); return true
+      case 'btw': await this.sideQuestion(args); return true
+      case 'remote-control': await this.remoteControl(args === 'stop' ? 'stop' : 'start'); return true
+      case 'login': await this.registry?.account?.signIn(); return true
+      case 'logout': await this.registry?.account?.signOut(); return true
+      case 'account': await this.openAccount(); return true
+      case 'copy': {
+        const n = Math.max(1, Number(args) || 1)
+        const answers = this.transcript.filter((t) => t.kind === 'assistant' && String(t.text || '').trim())
+        const pick = answers[answers.length - n]
+        if (!pick) { say('no answer to copy yet'); return true }
+        await vscode.env.clipboard.writeText(pick.text)
+        say(n === 1 ? 'copied the latest answer' : `copied the answer ${n} from the end`)
+        return true
+      }
+      case 'export': await this.exportConversation(args); return true
+      case 'todos':
+        if (!this.todos.length) say('no to-do list in this conversation yet')
+        else this.post({ type: 'todos', items: this.todos, show: true })
+        return true
+      case 'tasks': case 'bashes': {
+        const tasks = shell.taskList()
+        this.post({ type: 'tasks', items: tasks, show: true })
+        if (!tasks.length) say('no commands are running in the background')
+        return true
+      }
+      case 'status': await this.status(); return true
+      case 'usage': case 'cost': case 'context': await this.showUsage(); return true
+      case 'model': {
+        if (!args) { this.post({ type: 'openModelMenu' }); return true }
+        const found = (this.models || []).find((x) => x.name === args || x.name.startsWith(args))
+        if (!found) { say(`no model called ${args}`); return true }
+        this.model = found.name
+        this.context.globalState.update('aipictury.model', this.model)
+        this.refreshStatus()
+        say(`model: ${found.name}`)
+        return true
+      }
+      case 'effort': {
+        if (!agent.EFFORT[args]) { say(`effort is ${agent.effortOf(config().get('effort', 'high'))} — /effort low, medium, high, max or ultra`); return true }
+        await config().update('effort', args, vscode.ConfigurationTarget.Global)
+        this.postMode()
+        say(`effort: ${args}`)
+        return true
+      }
+      case 'mcp': await this.mcpStatus(); return true
+      case 'init': return { prompt: INIT_PROMPT }
+      case 'review': return { prompt: args ? `${REVIEW_PROMPT}\n\nFocus on: ${args}` : REVIEW_PROMPT }
+      case 'rename': {
+        if (!args) { await vscode.commands.executeCommand('aipictury.renameConversation'); return true }
+        this.title = args.slice(0, 80)
+        await this.remember()
+        say(`renamed: ${this.title}`)
+        return true
+      }
+      case 'resume': case 'history': await showHistory(this); return true
+      case 'skills': await this.openSkills(); return true
+      case 'plugin': case 'plugins': await this.openPlugins(); return true
+      case 'agents': await this.openAgents(); return true
+      case 'pages': await this.openPages(); return true
+      case 'output-style': case 'output-styles': await this.openOutputStyle(); return true
+      case 'focus':
+        await config().update('focusView', !config().get('focusView', false), vscode.ConfigurationTarget.Global)
+        return true
+      case 'config': case 'settings':
+        await vscode.commands.executeCommand('workbench.action.openSettings', 'aipictury')
+        return true
+      case 'help': case 'about': showAbout(this.context, { model: () => this.model, account: () => this.registry?.account }); return true
+      default: {
+        const prompt = context.expandCommand(text)
+        if (prompt) {
+          // Claude Code's command format: allowed-tools hold while this command's run lasts,
+          // and !`command` lines are run first and replaced by their output.
+          const meta = context.commandMeta(text)
+          const folder = workspaceRoot()?.fsPath
+          const permissions = require('./permissions')
+          const allowed = (command) => {
+            const verdict = permissions.decide('run_command', { command }, { folder })
+            if (verdict.decision === 'deny') return false
+            const granted = permissions.decide('run_command', { command }, { rules: { allow: meta.allowedTools, ask: [], deny: [] } }).decision === 'allow'
+            return granted || verdict.decision === 'allow' || shell.isReadOnly(command)
+          }
+          this.session.commandAllow = meta.allowedTools
+          return { prompt: await context.runInline(prompt, { cwd: folder, allowed }) }
+        }
+        const skill = context.skills().find((s) => s.name === name)
+        if (skill) return { prompt: `Use the ${skill.name} skill${args ? ` on: ${args}` : ''}.` }
+        return false
+      }
+    }
+  }
+
+  async compact(focus = '') {
+    // One summary at a time, and never under a running agent: both change the history.
+    const say = (note) => this.say(note)
+    if (this.compacting) return true
+    if (this.abort) { say('the agent is working — summarize once it has finished'); return true }
+    if (this.history.length < 3) { say('nothing to summarize yet'); return true }
+    this.compacting = true
+    await this.fireHook('PreCompact', { trigger: 'manual', custom_instructions: focus || '' }).catch(() => {})
+    this.startSource = 'compact'
+    const before = agent.estimateTokens(this.history)
+    const started = Date.now()
+    const progress = (detail) => this.post({ type: 'nudge', reason: 'summarizing', ...detail })
+    progress({ phase: 'start', tokens: before })
+    let ok = false
+    let error = ''
+    try {
+      const next = await agent.summarizeEarlier(serverUrl(),
+        [{ role: 'system', content: '' }, ...this.history], { model: this.model || undefined, force: true, focus,
+          onProgress: (p) => progress({ phase: 'progress', ...p }) })
+      if (next) {
+        this.history = next.slice(1)
+        await this.remember()
+        ok = true
+      } else {
+        error = 'the conversation is already short — nothing to summarize'
+      }
+    } catch (e) {
+      error = `could not summarize: ${e.message}`
+    } finally {
+      this.compacting = false
+    }
+    const after = agent.estimateTokens(this.history)
+    progress({ phase: 'done', ok, error, before, after, seconds: Math.round((Date.now() - started) / 1000) })
+    if (ok) this.post({ type: 'context', used: after })
+    return true
+  }
+
+  /** /btw: an answer beside the conversation, never in it. */
+  async sideQuestion(question) {
+    if (!question) { this.say('ask something after /btw, e.g. /btw what does parseConfig return?'); return }
+    if (/^clear$/i.test(question.trim())) {
+      this.btw = []
+      this.rememberSoon()
+      this.post({ type: 'btwCleared' })
+      this.say('the side thread is cleared')
+      return
+    }
+    if (this.abort) { this.say('/btw can be asked once the agent has finished this step'); return }
+    const id = `btw-${Date.now()}`
+    this.post({ type: 'btw', id, question, phase: 'start' })
+    const controller = new AbortController()
+    this.btwAbort = controller
+    try {
+      const answer = await agent.sideQuestion(serverUrl(), this.history, question,
+        { model: this.model || undefined, session: this.session, signal: controller.signal, thread: this.btw,
+          onDelta: (d) => this.post({ type: 'btw', id, delta: d }) })
+      this.post({ type: 'btw', id, phase: 'done', answer })
+      // A thread: the next /btw follows on from this one — the last 20, kept with the conversation.
+      this.btw = [...this.btw, { id, question, answer, at: Date.now() }].slice(-20)
+      this.rememberSoon()
+    } catch (error) {
+      this.post({ type: 'btw', id, phase: 'done', error: error.message })
+    } finally {
+      this.btwAbort = null
+    }
+  }
+
+  async exportConversation(target) {
+    if (!this.transcript.length) { this.say('nothing to export yet'); return }
+    const md = toMarkdown(this.conversationTitle, this.transcript)
+    let destination = target
+    if (!destination) {
+      const choice = await vscode.window.showQuickPick(['Copy to the clipboard', 'Save to a file…'], { title: 'Export the conversation' })
+      if (!choice) return
+      if (choice.startsWith('Copy')) { await vscode.env.clipboard.writeText(md); this.say('the conversation is on the clipboard, as Markdown'); return }
+      const uri = await vscode.window.showSaveDialog({ defaultUri: workspaceRoot() && vscode.Uri.joinPath(workspaceRoot(),
+        `${this.conversationTitle.replace(/[^\w-]+/g, '-').slice(0, 40)}.md`), filters: { Markdown: ['md'], Text: ['txt'] } })
+      if (!uri) return
+      await vscode.workspace.fs.writeFile(uri, new TextEncoder().encode(md))
+      this.say(`exported to ${vscode.workspace.asRelativePath(uri)}`)
+      return
+    }
+    const uri = path.isAbsolute(destination) ? vscode.Uri.file(destination) : vscode.Uri.joinPath(workspaceRoot(), destination)
+    await vscode.workspace.fs.writeFile(uri, new TextEncoder().encode(md))
+    this.say(`exported to ${vscode.workspace.asRelativePath(uri)}`)
+  }
+
+  async status() {
+    let online = false
+    let serverVersion = ''
+    let roles = {}
+    try { const c = await ask('/api/vscode/config'); online = true; roles = c.roles || {}; serverVersion = c.server?.version || '' } catch { /* offline */ }
+    const servers = await mcp.ensure({ trust: (list, print) => this.trustMcp(list, print) }).catch(() => mcp.status())
+    const instructions = context.instructions().map((f) => f.name)
+    const tasks = shell.taskList()
+    this.info('Status', [
+      `**AIPictury** ${VERSION} · server ${serverUrl()} — ${online ? `online${serverVersion ? ` (${serverVersion})` : ''}` : 'not answering'}`,
+      `**Model** ${this.model || roles.agent || '—'}${this.model ? ' (chosen here)' : ' (the server\'s agent role)'}`,
+      `**Mode** ${agent.MODES[agent.modeNow()]?.label} · **effort** ${agent.effortOf(config().get('effort', 'high'))}`
+        + ` · **reasoning** ${config().get('showThinking', true) ? 'on' : 'off'}`,
+      `**Context** ${agent.estimateTokens(this.history).toLocaleString()} tokens (estimated) of ${agent.TARGET_TOKENS.toLocaleString()} before auto-compact`,
+      `**Instructions** ${instructions.length ? instructions.join(', ') : 'none (run /init to write AIPICTURY.md)'}`,
+      `**MCP** ${servers.length ? servers.map((s) => `${s.name} — ${s.state}${s.state === 'connected' ? ` (${s.tools.length} tools)` : s.error ? `: ${s.error}` : ''}`).join('; ') : 'no servers (.mcp.json)'}`,
+      `**Skills** ${context.skills().length} · **custom commands** ${context.commands().length}`,
+      `**Background** ${tasks.filter((t) => t.running).length} running`,
+    ])
+  }
+
+  /** /usage: this conversation, today, or this week — by tool, helper, MCP server, skill. */
+  showUsage() {
+    let tab = 'conversation'
+    const spec = () => dialogs.usageSpec(tab, { conversation: this.usage, context: agent.estimateTokens(this.history) })
+    return this.showDialog(spec(), async (action, message) => { if (action === 'tab') { tab = message.value; return spec() } return undefined })
+  }
+
+  /** /mcp: every server, by scope, with its state — on/off, reconnect, add, remove. */
+  async mcpStatus() {
+    const folder = workspaceRoot()?.fsPath
+    const trust = (servers, print) => this.trustMcp(servers, print)
+    await mcp.ensure({ trust }).catch(() => {})
+    return this.showDialog(dialogs.mcpSpec(folder), dialogs.mcpHandler(folder, { trust }))
+  }
+
+  /** Before a project's own MCP servers connect (they start programs from the repository). */
+  async trustMcp(servers, print) {
+    const folder = workspaceRoot()?.fsPath || ''
+    const trusted = this.context.globalState.get('aipictury.trustedMcp', {})
+    if (trusted[folder] === print) return true
+    TRUST_DECLINED ||= new Set()
+    if (TRUST_DECLINED.has(`mcp:${folder}:${print}`)) return false
+    const lines = servers.map((x) => `• ${x.name}: ${x.config.command ? [x.config.command, ...(x.config.args || [])].join(' ') : x.config.url}`)
+    const yes = 'Trust and connect'
+    const ok = await this.confirm('This project has MCP servers: programs it starts, and tools the agent can use.',
+      `${lines.slice(0, 12).join('\n')}\n\nConnect them only if you trust this project. /mcp lists them.`, yes)
+    if (ok) await this.context.globalState.update('aipictury.trustedMcp', { ...trusted, [folder]: print })
+    else TRUST_DECLINED.add(`mcp:${folder}:${print}`)
+    return ok
+  }
+
+  /** Can the model this message goes to see images itself? If not, a vision model
+   *  describes them first — the way the web assistant handles it. */
+  canSee() {
+    const name = this.model || this.roles?.agent
+    return !!this.models.find((m) => m.name === name)?.vision
+  }
+
+  async pickFiles() {
+    const room = MAX_ATTACH - this.attachments.length
+    if (room <= 0) {
+      vscode.window.showInformationMessage(`At most ${MAX_ATTACH} files per message.`)
+      return
+    }
+    const picked = await vscode.window.showOpenDialog({
+      canSelectMany: true, openLabel: 'Attach',
+      defaultUri: workspaceRoot(),
+      filters: { 'Images, PDFs and text': ATTACH_TYPES, 'All files': ['*'] },
+    })
+    for (const uri of (picked || []).slice(0, room)) {
+      await this.addFile(uri.path.split('/').pop(), await vscode.workspace.fs.readFile(uri))
+    }
+    if ((picked || []).length > room) {
+      vscode.window.showInformationMessage(`Only ${room} more file(s) fit — ${MAX_ATTACH} per message.`)
+    }
+  }
+
+  /** Files dragged in from the Explorer (with Shift): inside the workspace they become
+   *  @-mentions — the agent reads them — and anything else is attached. */
+  async dropUris(uris) {
+    const mentions = []
+    for (const raw of uris.slice(0, MAX_ATTACH)) {
+      let uri
+      try { uri = vscode.Uri.parse(raw) } catch { continue }
+      const folder = vscode.workspace.getWorkspaceFolder(uri)
+      if (folder) {
+        const rel = vscode.workspace.asRelativePath(uri, false)
+        let dir = false
+        try { dir = !!((await vscode.workspace.fs.stat(uri)).type & vscode.FileType.Directory) } catch { /* gone */ }
+        mentions.push(`@${rel}${dir ? '/' : ''}`)
+      } else if (uri.scheme === 'file') {
+        try { await this.addFile(path.basename(uri.fsPath), await vscode.workspace.fs.readFile(uri)) } catch { /* unreadable */ }
+      }
+    }
+    if (mentions.length) this.post({ type: 'insert', text: `${mentions.join(' ')} ` })
+  }
+
+  /** Turns one file into something the model can read, on the server. */
+  async addFile(name, bytes) {
+    if (this.attachments.length >= MAX_ATTACH) return
+    const id = `a${Date.now().toString(36)}${this.attachments.length}`
+    this.attachments.push({ id, name, kind: 'loading' })
+    this.postAttachments()
+    try {
+      Object.assign(this.attachments.find((a) => a.id === id) || {}, await this.convert(name, bytes, !this.canSee()))
+    } catch (error) {
+      this.attachments = this.attachments.filter((a) => a.id !== id)
+      vscode.window.showWarningMessage(`Could not attach ${name}: ${error.message}`)
+    }
+    this.postAttachments()
+  }
+
+  /** A PDF as text, a picture as itself or described: the server's conversion. */
+  async convert(name, bytes, describe, pages) {
+    const form = new FormData()
+    form.append('file', new Blob([bytes]), name)
+    form.append('describe', String(describe))
+    if (pages) form.append('pages', String(pages))
+    const response = await fetch(`${serverUrl()}/api/agent/attach`,
+      { method: 'POST', body: form, signal: AbortSignal.timeout(120_000) })
+    const body = await response.json().catch(() => ({}))
+    if (!response.ok) throw new Error(body.detail || `the server answered ${response.status}`)
+    return body
+  }
+
+  /** read_file on a PDF or a picture: converted as an attachment is. */
+  async readSpecial(uri, args) {
+    const bytes = await vscode.workspace.fs.readFile(uri)
+    const name = path.basename(uri.fsPath)
+    const body = await this.convert(name, bytes, !this.canSee(), args.pages)
+    if (body.kind === 'image' && body.image) return { text: `${args.path}: the picture is attached below — look at it.`, images: [body.image] }
+    const text = String(body.text || '')
+    const shown = text.length > 120_000 ? `${text.slice(0, 120_000)}\n… [the rest of ${args.path} is not shown — ${text.length} characters]` : text
+    // A PDF's scanned pages come as pictures beside its text: looked at, not read.
+    return body.images?.length ? { text: shown, images: body.images } : shown
+  }
+
+  postAttachments() {
+    this.post({ type: 'attachments', max: MAX_ATTACH, items: this.attachments.map((a) => ({
+      id: a.id, name: a.name, kind: a.kind,
+      thumb: a.kind === 'image' ? `data:image/*;base64,${a.image}` : undefined })) })
+  }
+
+  /** Tells the panel which model is answering, so the user is never guessing. */
+  async refreshStatus() {
+    try {
+      const cfg = await ask('/api/vscode/config')
+      this.post({ type: 'status', online: true, roles: cfg.roles, server: serverUrl() })
+      // Only models that can call tools can drive the agent; the picker shows those.
+      this.models = cfg.models || []
+      this.roles = cfg.roles || {}
+      const coding = (cfg.models || []).filter((m) => m.tools).map((m) => m.name)
+      // If the stored choice is gone (a model was removed), fall back to the role default.
+      if (this.model && !coding.includes(this.model)) this.model = null
+      const current = this.model || cfg.roles.agent
+      this.post({ type: 'models', models: coding, current, fallback: cfg.roles.agent })
+    } catch (error) {
+      // Why it cannot be used, as the web app says it: none set, your account refused, or no answer.
+      const server = serverUrl()
+      const refused = /answered 401/.test(error.message) ? (/"detail":\s*"([^"]+)"/.exec(error.message)?.[1] || 'refused') : null
+      this.post({ type: 'status', online: false, server, why: !server ? 'none' : refused ? 'refused' : 'unreachable', detail: refused })
+    }
+  }
+
+  /** The user's message with whatever is attached, mentioned or selected, ready for the conversation. */
+  async buildMessage(rawText) {
+    const cleaned = stripInvisible(rawText)
+    if (cleaned.removed) this.say(`removed ${cleaned.removed} invisible character${cleaned.removed === 1 ? '' : 's'} from your message`)
+    const text = cleaned.text
+    const attached = this.attachments.filter((a) => a.kind !== 'loading')
+    this.attachments = []
+    this.postAttachments()
+    const parts = [text]
+    const mentioned = await resolveMentions(text, this.session)
+    if (mentioned.length) parts.push(`Files the user referenced (already read for you):\n\n${mentioned.join('\n\n')}`)
+    const texts = attached.filter((a) => a.kind === 'text').map((a) => a.text)
+    if (texts.length) parts.push(`Attached files:\n\n${texts.join('\n\n')}`)
+    const where = editorTracker.contextFor(this)
+    if (where) parts.push(where)
+    const images = attached.filter((a) => a.kind === 'image').map((a) => a.image)
+    const message = { role: 'user', content: parts.join('\n\n') }
+    if (images.length) message.images = images
+    return { message, text, files: attached.map((a) => ({ name: a.name, kind: a.kind })) }
+  }
+
+  postQueue() { this.post({ type: 'queue', items: this.queue.map((q) => q.text) }) }
+
+  /** While this conversation is worked from elsewhere (remote control): the account's devices
+   *  are told — a step waiting for a yes, a run done (the server's push.py; a click opens it). */
+  notifyAway(title, body) {
+    if (!this.remote?.url) return
+    const server = serverUrl()
+    fetch(`${server}/api/push/notify`, { method: 'POST', headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ title, body: String(body).slice(0, 300), link: this.remote.url, tag: `remote-${this.id || 'new'}` }),
+      signal: AbortSignal.timeout(15_000) }).catch(() => {})
+  }
+
+  /** Remote control: this conversation, carried on from a browser (remote.js). */
+  async remoteControl(action, { asked = false } = {}) {
+    if (action === 'stop') {
+      if (!this.remote) { this.say('remote control is not on', 'remote'); return }
+      this.remote.stop()
+      this.registry?.account?.cloud?.dropRemote?.(this.remote.id).catch(() => {})
+      this.remote = null
+      this.post({ type: 'remote', on: false })
+      this.say('remote control ended — the link no longer works', 'remote')
+      return
+    }
+    if (!this.remote) {
+      this.remote = new RemoteLink(this, serverUrl(), {
+        webApp: config().get('webApp', 'https://aipictury.com'),
+        token: () => this.registry?.account?.account.idToken(),
+        log: (line) => log.warn(line),
+        onViewers: (n) => this.post({ type: 'remote', on: true, viewers: n, url: this.remote?.url }),
+      }).start()
+    }
+    if (!asked) await vscode.env.clipboard.writeText(this.remote.url)   // asked from the web: it has the link
+    this.post({ type: 'remote', on: true, viewers: this.remote.viewers, url: this.remote.url })
+    // Listed with the account, so aipictury.com offers to control it (Live in VS Code).
+    const title = this.title || String(this.history.find((m) => m.role === 'user')?.content || 'A conversation').split('\n')[0]
+    this.registry?.account?.cloud?.putRemote?.(this.remote.id, { url: this.remote.url, title: title.slice(0, 200),
+      device: require('os').hostname().slice(0, 80), conversation: this.id || '' }).catch((e) => log.warn(`remote not listed with the account: ${e.message}`))
+    if (asked) { this.say('remote control is on — asked from aipictury.com, where it is open now. /remote-control stop ends it.', 'remote'); return }
+    this.say(`remote control is on — the link is copied: open it in a browser or on your phone (on your network). Anyone with it `
+      + 'can drive this conversation; yes or no to a step is given there, rules and modes stay here. /remote-control stop ends it.', 'remote')
+  }
+
+  /** Dictation: recorded here (webviews have no microphone), written by the server's Whisper,
+   *  and put into the input — never sent. 'toggle' starts or stops; 'cancel' discards. */
+  async dictate(action) {
+    const say = (state, extra = {}) => {
+      this.post({ type: 'dictation', state, text: extra.text })
+      if (extra.error) this.say(extra.error, 'dictation')         // a note in the conversation, as other notices
+    }
+    if (action === 'toggle') action = this.recording ? 'stop' : 'start'
+    if (action === 'cancel') { this.recording?.cancel(); this.recording = null; say('idle'); return }
+    if (action === 'start') {
+      if (this.recording) return
+      try { this.recording = new voice.Recording().start() } catch (error) { say('idle', { error: error.message }); return }
+      log.info(`dictation: recording with ${this.recording.how.tool}`)
+      say('recording')
+      return
+    }
+    const rec = this.recording
+    if (!rec) return
+    this.recording = null
+    say('writing')
+    try {
+      const file = await rec.stop()
+      const r = await voice.transcribe(serverUrl(), file)
+      log.info(`dictation: ${r.duration} s written in ${r.seconds} s (${r.language})`)
+      say('idle', r.text ? { text: r.text } : { error: 'Nothing was heard — try again, closer to the microphone.' })
+    } catch (error) { say('idle', { error: `Not written: ${error.message}` }) }
+  }
+
+  /** Queued messages, handed to the running agent at its next step — as Claude Code
+   *  does: the model reads them before its next move and corrects course. */
+  /** Delivers the scheduled prompts that are due: a new run when idle, else between steps. */
+  tickJobs(now = Date.now()) {
+    if (!this.jobs?.length) return []
+    const { ready, jobs } = scheduler.due(this.jobs, now)
+    if (!ready.length) return []
+    this.jobs = jobs
+    this.rememberSoon()
+    for (const j of ready) {
+      this.post({ type: 'nudge', reason: 'scheduled', text: `⏰ ${j.id}${j.recurring ? ` (every ${j.schedule})` : ''}: ${j.prompt.slice(0, 80)}` })
+      ;(this.events ||= []).push({ role: 'user', content: `[A scheduled prompt (${j.id}, ${j.recurring ? `every ${j.schedule}` : 'once'}) — do this now:]\n${j.prompt}` })
+    }
+    if (!this.abort && !this.compacting) this.start(this.events.splice(0)).catch((error) => log.warn('scheduled prompt', error))
+    return ready
+  }
+
+  /** The agent's (and /loop's) way into this conversation's schedule. */
+  schedulerHooks() {
+    return { get: () => this.jobs || [], set: (jobs) => { this.jobs = jobs; this.rememberSoon() } }
+  }
+
+  /** A background helper reported: an event for the agent, as a monitor's lines are. */
+  onHelperDone(h, text) {
+    this.post({ type: 'nudge', reason: 'helper', text: `${h.id}${h.name ? ` (${h.name})` : ''} has reported` })
+    ;(this.events ||= []).push({ role: 'user', content: `[The background helper ${h.id}${h.name ? ` (${h.name})` : ''} has finished:]\n${text}` })
+    if (!this.abort && !this.compacting) this.start(this.events.splice(0)).catch((error) => log.warn('helper report', error))
+  }
+
+  /** A monitor's new lines: between the agent's steps while it works, or a new run when it is idle. */
+  onMonitorLines(task, lines, { ended } = {}) {
+    const what = task.monitor?.description ? ` (${task.monitor.description})` : ''
+    this.post({ type: 'nudge', reason: 'monitor', text: `${task.id}${what}: ${lines.length} new line${lines.length === 1 ? '' : 's'}${ended ? ' — it has stopped' : ''}` })
+    this.post({ type: 'tasks', items: shell.taskList() })
+    ;(this.events ||= []).push({ role: 'user', content: `[An event from the monitor ${task.id}${what} — its new output:]\n${lines.join('\n')}` })
+    if (!this.abort && !this.compacting) this.start(this.events.splice(0)).catch((error) => log.warn('monitor event', error))
+  }
+
+  takeQueued() {
+    const events = (this.events || []).splice(0)
+    const taken = this.queue.splice(0)
+    if (taken.length) this.postQueue()
+    return [...events, ...taken.map((q) => {
+      this.transcript.push({ kind: 'user', text: q.text, files: q.files, at: Date.now() })
+      this.post({ type: 'user', text: q.text, files: q.files, at: Date.now() })
+      return { ...q.message, content: '[The user sent this while you were working — take it '
+        + `into account from here on.]\n${q.message.content}` }
+    })]
+  }
+
+  /** Signed in or not: the panel shows the sign-in screen when not. */
+  postAccount(user) {
+    this.post({ type: 'account', user: user ? { email: user.email || '', name: user.displayName || '' } : null })
+  }
+
+  async ask(raw) {
+    const text = String(raw || '').trim()
+    if (!text) return
+    // AIPictury needs the account: signed out, nothing reaches the agent.
+    if (this.registry?.account && !this.registry.account.signedIn()) {
+      this.postAccount(null)
+      this.post({ type: 'draft', text })
+      return
+    }
+    // The history is being rewritten: nothing joins it until the summary is in.
+    if (this.compacting) {
+      this.say('one moment — the conversation is being summarized')
+      this.post({ type: 'draft', text })
+      return
+    }
+    if (this.abort) {
+      // A run is going. A rule is saved on the spot; a command waits; anything else is
+      // queued for the agent's next step.
+      if (/^#/.test(text) && await this.shortcut(text)) return
+      if (text.startsWith('/') && !/^\/btw\b/.test(text)) { this.say(`${text.split(/\s/)[0]} can run once the agent has finished`); return }
+      if (/^\/btw\b/.test(text)) { this.say('/btw can be asked once the agent has finished this step'); return }
+      this.queue.push(await this.buildMessage(text))
+      this.postQueue()
+      // Mid-generation, the answer being written is cut so the model hears this now;
+      // mid-tool, the tool finishes its step first and the message goes in after it.
+      this.steer?.abort()
+      return
+    }
+    let prompt = text
+    const handled = await this.shortcut(text)
+    if (handled === true) return
+    if (handled && handled.prompt) prompt = handled.prompt
+    if (!vscode.workspace.workspaceFolders?.length) {
+      this.post({ type: 'error', text: 'Open a folder first — the agent works inside a workspace.' })
+      return
+    }
+    // The user's UserPromptSubmit hooks: they can stop the message (it goes back to the input,
+    // with their reason) or add context for the model.
+    const submitted = await this.fireHook('UserPromptSubmit', { prompt })
+    if (submitted.block || submitted.stop) {
+      this.post({ type: 'error', text: `A UserPromptSubmit hook stopped this message: ${[...submitted.reasons, submitted.stopReason].filter(Boolean).join('; ')}` })
+      this.post({ type: 'draft', text })
+      return
+    }
+    const built = await this.buildMessage(prompt)
+    if (submitted.context.length) appendText(built.message, `\n\n[Context from your hooks]\n${submitted.context.join('\n')}`)
+    const checkpoint = this.newCheckpoint()
+    this.transcript.push({ kind: 'user', text, files: built.files, at: Date.now(), checkpoint })
+    this.post({ type: 'user', text, files: built.files, at: Date.now(), index: this.transcript.length - 1 })
+    await this.start([built.message])
+  }
+
+  newCheckpoint() {
+    const id = `k${Date.now().toString(36)}`
+    // What the conversation's own state was when the question was asked, so going back to
+    // it (rewind, fork) brings back the to-dos and figures of then, not of a future undone.
+    this.checkpoints.push({ id, at: Date.now(), history: this.history.length, transcript: this.transcript.length, files: {},
+      todos: JSON.parse(JSON.stringify(this.todos || [])), usage: { ...this.usage } })
+    if (this.checkpoints.length > CHECKPOINTS) this.checkpoints.shift()
+    return id
+  }
+
+  /** The files the agent changes are kept as they were, per question — for rewinding. */
+  onFileChange(relPath, before) {
+    const cp = this.checkpoints[this.checkpoints.length - 1]
+    if (cp && !(relPath in cp.files)) cp.files[relPath] = before
+  }
+
+  /** Every file the agent changed from checkpoint `at` onwards, as it was then. */
+  snapshotFrom(at) {
+    const restore = {}
+    for (const cp of this.checkpoints.slice(at)) {
+      for (const [p, before] of Object.entries(cp.files)) if (!(p in restore)) restore[p] = before
+    }
+    return restore
+  }
+
+  async restoreFiles(snapshot) {
+    let restored = 0
+    const skipped = []
+    for (const [p, before] of Object.entries(snapshot)) {
+      try {
+        const uri = vscode.Uri.joinPath(workspaceRoot(), p)
+        let link = false
+        try { link = fs.lstatSync(uri.fsPath).isSymbolicLink() } catch { /* gone */ }
+        if (link) { skipped.push(p); continue }
+        if (before === null) await vscode.workspace.fs.delete(uri).then(() => {}, () => {})
+        else await vscode.workspace.fs.writeFile(uri, new TextEncoder().encode(before))
+        restored += 1
+      } catch { skipped.push(p) }
+    }
+    return { restored, skipped }
+  }
+
+  /** Shows a dialog over the conversation. `handler(action, message)` answers each action
+   *  with the dialog as it now is, or null to close it; undefined leaves it as it is. */
+  dialog(spec, handler) {
+    this.openDialog = { id: spec.id, handler, spec }
+    this.post({ type: 'dialog', spec })
+  }
+
+  /** Brings the panel into view, then opens a dialog in it. */
+  async showDialog(spec, handler) {
+    if (this.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
+    else this.host?.reveal?.()
+    this.dialog(await spec, handler)
+  }
+
+  async openAccount() {
+    const ui = require('./accountUi')
+    return this.showDialog(ui.accountSpec(this.registry.account), ui.accountHandler(this.registry.account))
+  }
+
+  async openPages() { return this.showDialog(await dialogs.pagesSpec(serverUrl()), dialogs.pagesHandler(serverUrl())) }
+  openAgents() { return this.showDialog(dialogs.agentsSpec(this), dialogs.agentsHandler(this)) }
+  openPlugins() {
+    const folder = workspaceRoot()?.fsPath
+    // What a plugin brings is read at once: the / list, and its MCP servers.
+    const changed = () => { this.postCommands(); mcp.ensure({ trust: (l, pr) => this.trustMcp(l, pr) }).catch(() => {}) }
+    return this.showDialog(dialogs.pluginsSpec(folder), dialogs.pluginsHandler(folder, { changed }))
+  }
+  openSkills() { const folder = workspaceRoot()?.fsPath; return this.showDialog(dialogs.skillsSpec(folder), dialogs.skillsHandler(folder)) }
+  openOutputStyle() { const folder = workspaceRoot()?.fsPath; return this.showDialog(dialogs.outputStyleSpec(folder), dialogs.outputStyleHandler(folder)) }
+  openSandbox() { return this.showDialog(dialogs.sandboxSpec(), dialogs.sandboxHandler()) }
+  openHooks() { const folder = workspaceRoot()?.fsPath; return this.showDialog(dialogs.hooksSpec(folder), dialogs.hooksHandler(folder)) }
+  openPermissions() { const folder = workspaceRoot()?.fsPath; return this.showDialog(dialogs.permissionsSpec(folder), dialogs.permissionsHandler(folder)) }
+  openMemory() { return this.showDialog(dialogs.memorySpec(serverUrl()), dialogs.memoryHandler(serverUrl())) }
+  openInstructions() { return this.showDialog(dialogs.instructionsSpec(), dialogs.instructionsHandler(this)) }
+  openSlashCommands() { return this.showDialog(dialogs.slashSpec(SLASH), dialogs.slashHandler(this, SLASH)) }
+  reportProblem(kind = 'bug', description = '') {
+    return this.showDialog(dialogs.reportSpec(kind, description), dialogs.reportHandler({ server: serverUrl(), version: VERSION }))
+  }
+
+  async onDialogAction(message) {
+    const open = this.openDialog
+    if (!open || message.dialog !== open.id) return      // an old dialog's click
+    if (message.action === 'close') { this.openDialog = null; return }
+    let next
+    try {
+      next = await open.handler(message.action, message)
+    } catch (error) {
+      log.error(`dialog ${open.id}: ${message.action}`, error)
+      next = { ...open.spec, form: open.spec.form ? { ...open.spec.form, error: error.message } : undefined,
+        note: open.spec.form ? open.spec.note : `Could not do that: ${error.message}` }
+    }
+    if (next === null) { this.openDialog = null; this.post({ type: 'dialogClose' }); return }
+    if (next) { open.spec = next; this.post({ type: 'dialog', spec: next }) }
+  }
+
+  /** The conversation's own state as it was at a checkpoint: its to-do list and figures.
+   *  A checkpoint older than this (saved before they were recorded) leaves none. */
+  backTo(cp) {
+    this.todos = cp?.todos ? JSON.parse(JSON.stringify(cp.todos)) : []
+    this.usage = cp?.usage ? { ...cp.usage } : { turns: 0, prompt: 0, output: 0, seconds: 0 }
+  }
+
+  /** Before a project's own hooks run (they run commands on this machine): asked once per
+   *  workspace, and again when they change. "Not now" holds until VS Code restarts. */
+  async trustHooks(groups, print) {
+    const folder = workspaceRoot()?.fsPath || ''
+    const trusted = this.context.globalState.get('aipictury.trustedHooks', {})
+    if (trusted[folder] === print) return true
+    TRUST_DECLINED ||= new Set()
+    if (TRUST_DECLINED.has(`${folder}:${print}`)) return false
+    const commands = groups.flatMap((g) => (g.hooks || []).map((h) => `• ${h.command}  (${path.relative(folder, g.file) || g.file})`))
+    const yes = 'Trust and run them'
+    const ok = await this.confirm('This project has hooks: commands that run on your machine while the agent works.',
+      `${commands.slice(0, 12).join('\n')}${commands.length > 12 ? '\n…' : ''}\n\nRun them only if you trust this project. You can change them in AIPictury: Hooks.`, yes)
+    if (ok) await this.context.globalState.update('aipictury.trustedHooks', { ...trusted, [folder]: print })
+    else TRUST_DECLINED.add(`${folder}:${print}`)
+    return ok
+  }
+
+  /** Fires one of the user's hooks for this conversation. */
+  fireHook(event, payload, extra = {}) {
+    return userHooks.fire(event, payload, { folder: workspaceRoot()?.fsPath, sessionId: this.id || '',
+      trust: (g, print) => this.trustHooks(g, print), log: (line) => log.warn(line), ...extra })
+  }
+
+  /** A modal yes/no in VS Code; true only for an explicit yes. Replaceable in tests. */
+  async confirm(title, detail, yes) {
+    return (await vscode.window.showWarningMessage(title, { modal: true, detail }, yes)) === yes
+  }
+
+  /** The rewind menu on a question: restore the code, the conversation, or fork from it. */
+  async rewind(index, action, { quiet = false } = {}) {
+    if (this.abort) { this.say('stop the agent before rewinding'); return }
+    const turn = this.transcript[index]
+    if (!turn || turn.kind !== 'user') return
+    const at = this.checkpoints.findIndex((c) => c.id === turn.checkpoint)
+    const cp = this.checkpoints[at]
+    const code = action === 'code' || action === 'both' || action === 'fork-code'
+    if (code && !cp) { this.say('no file changes were recorded for that message'); return }
+    // Nothing is restored, cut or forked without the user saying yes to exactly what will
+    // happen. `quiet` is the Retry button's own rewind, which is not a menu choice.
+    if (!quiet && !(await this.confirm(...rewindQuestion(action, turn.text, code ? Object.keys(this.snapshotFrom(at)) : [])))) {
+      this.say('nothing was changed')
+      return
+    }
+    let note = ''
+    if (code) {
+      const { restored, skipped } = await this.restoreFiles(this.snapshotFrom(at))
+      note = restored || skipped.length
+        ? `restored ${restored} file${restored === 1 ? '' : 's'} to how they were before that message`
+          + `${skipped.length ? ` (skipped ${skipped.join(', ')})` : ''} — changes made by commands are not tracked`
+        : 'the agent had changed no files since that message'
+    }
+    if (action === 'conversation' || action === 'both') {
+      const historyAt = cp ? cp.history : this.history.findIndex((m) => m.role === 'user' && String(m.content).includes(turn.text.slice(0, 40)))
+      if (historyAt < 0) { this.say('that message can no longer be found in the conversation'); return }
+      this.history = this.history.slice(0, historyAt)
+      this.transcript = this.transcript.slice(0, index)
+      this.checkpoints = this.checkpoints.slice(0, Math.max(0, at))
+      this.backTo(cp)
+      await this.remember()
+      this.post({ type: 'restore', turns: this.transcript, todos: this.todos })
+      this.post({ type: 'context', used: agent.estimateTokens(this.history) })
+      if (quiet) return
+      this.post({ type: 'draft', text: turn.text })
+      this.say(note ? `${note}; the conversation is back to before that message` : 'the conversation is back to before that message — edit and resend')
+      return
+    }
+    if (action === 'fork' || action === 'fork-code') {
+      await this.remember()
+      const historyAt = cp ? cp.history : this.history.length
+      const forked = { history: this.history.slice(0, historyAt), transcript: this.transcript.slice(0, index),
+        checkpoints: this.checkpoints.slice(0, Math.max(0, at)) }
+      this.id = null
+      this.created = null
+      this.title = `${this.conversationTitle.slice(0, 60)} (fork)`
+      this.history = forked.history
+      this.transcript = forked.transcript
+      this.checkpoints = forked.checkpoints
+      this.session = { allowAll: false }
+      this.backTo(cp)
+      if (this.history.length) await this.remember()
+      this.post({ type: 'restore', turns: this.transcript, todos: this.todos })
+      this.post({ type: 'context', used: agent.estimateTokens(this.history) })
+      this.post({ type: 'draft', text: turn.text })
+      this.say(`${note ? `${note}. ` : ''}forked: a new conversation from before that message — the original is kept in history`)
+      return
+    }
+    this.say(note)
+  }
+
+  async rewindPicker() {
+    const questions = this.transcript.map((t, i) => ({ t, i })).filter(({ t }) => t.kind === 'user')
+    if (!questions.length) { this.say('nothing to rewind yet'); return }
+    const chosen = await vscode.window.showQuickPick(questions.reverse().map(({ t, i }) => ({
+      label: String(t.text).slice(0, 80), description: t.at ? ago(t.at) : '', index: i })), { title: 'Rewind to before which message?' })
+    if (!chosen) return
+    const action = await vscode.window.showQuickPick([
+      { label: 'Restore code and conversation', action: 'both' },
+      { label: 'Restore conversation', description: 'keep the code as it is', action: 'conversation' },
+      { label: 'Restore code', description: 'keep the conversation', action: 'code' },
+      { label: 'Fork conversation from here', description: 'a new conversation; the code as it is', action: 'fork' },
+      { label: 'Fork conversation and restore code', action: 'fork-code' },
+    ], { title: 'Rewind' })
+    if (action) await this.rewind(chosen.index, action.action)
+  }
+
+  /** Shows the model's questions in place of the input and waits for the answer.
+   *  Resolves null when the run is stopped while they are open. */
+  askUser(questions, signal) {
+    return new Promise((resolve) => {
+      const id = `ask-${Date.now()}`
+      const done = (value) => {
+        signal?.removeEventListener('abort', onStop)
+        this.setBadge(null)
+        resolve(value)
+      }
+      const onStop = () => {
+        if (this.pendingAsk?.id !== id) return
+        this.pendingAsk = null
+        this.post({ type: 'askClosed', id })
+        done(null)
+      }
+      this.pendingAsk = { id, resolve: done, questions }
+      signal?.addEventListener('abort', onStop, { once: true })
+      this.post({ type: 'askUser', id, questions })
+      this.setBadge('waiting')
+    })
+  }
+
+  /** Asks, in the panel, whether a change or a command may go ahead. */
+  approve(request, signal) {
+    return new Promise((resolve) => {
+      const id = `ap-${Date.now().toString(36)}-${this.approvals.size}`
+      const done = (value) => {
+        signal?.removeEventListener('abort', onStop)
+        this.setBadge(null)
+        resolve(value)
+      }
+      const onStop = () => {
+        const pending = this.approvals.get(id)
+        if (!pending) return
+        this.approvals.delete(id)
+        if (pending.review) dropReview(pending.review)   // the copy under review
+        this.post({ type: 'approvalClosed', id })
+        done(null)
+      }
+      this.approvals.set(id, { request, resolve: done })
+      signal?.addEventListener('abort', onStop, { once: true })
+      this.post({ type: 'approval', id, request })
+      this.setBadge('waiting')
+      this.notifyAway('AIPictury is waiting for you', `${request.title || request.tool || 'A step'} needs your yes or no`)
+    })
+  }
+
+  /** Opens a proposed change in VS Code's diff, its right side editable: what the user
+   *  leaves there when they accept is what gets written. */
+  async reviewDiff(id) {
+    const pending = this.approvals.get(id)
+    if (!pending || pending.request.kind !== 'edit') return
+    const dir = path.join(os.tmpdir(), 'aipictury-review')
+    fs.mkdirSync(dir, { recursive: true })
+    const file = pending.review || path.join(dir, `${Date.now().toString(36)}-${path.basename(pending.request.path)}`)
+    if (!pending.review) fs.writeFileSync(file, pending.request.after ?? '')
+    pending.review = file
+    const current = vscode.Uri.joinPath(workspaceRoot(), pending.request.path)
+    let left = current
+    try { await vscode.workspace.fs.stat(current) } catch {
+      left = vscode.Uri.parse(`${SCHEME}:/${pending.request.path}?empty`)
+      agent.proposedContents.set(left.toString(), '')
+    }
+    await vscode.commands.executeCommand('vscode.diff', left, vscode.Uri.file(file),
+      `${pending.request.path} ← proposed (edit it, then Accept in the panel)`, { preview: false })
+  }
+
+  /** Plan mode's plan, shown for approval. */
+  approvePlan(plan, signal) {
+    return new Promise((resolve) => {
+      const id = `plan-${Date.now()}`
+      const done = (value) => { signal?.removeEventListener('abort', onStop); this.setBadge(null); resolve(value) }
+      const onStop = () => {
+        if (this.pendingPlan?.id !== id) return
+        this.pendingPlan = null
+        this.post({ type: 'planClosed', id })
+        done(null)
+      }
+      this.pendingPlan = { id, plan, resolve: done }
+      signal?.addEventListener('abort', onStop, { once: true })
+      this.post({ type: 'plan', id, plan })
+      this.setBadge('waiting')
+    })
+  }
+
+  markLive(running) {
+    if (!this.id || this.kind !== 'sidebar') return
+    this.context.workspaceState.update(LIVE, { id: this.id, running, at: Date.now() })
+  }
+
+  /** Runs the agent on the conversation with these new user messages appended. */
+  async start(messages) {
+    // Every run starts here — a message, a scheduled prompt, a monitor, a helper's report, remote
+    // control: none runs for a machine signed out of AIPictury.
+    if (this.registry?.account && !this.registry.account.signedIn()) { this.postAccount(null); return undefined }
+    // One run at a time on the GPU: another app holding it, nothing starts — the message goes
+    // back to the input, the panel says who has it and when it is free.
+    const gpuNow = await gpuRun.state(serverUrl())
+    if (gpuRun.busyFor(gpuNow)) { this.gpuBusy(gpuNow, messages); return undefined }
+    // The conversation's first run: the user's SessionStart hooks may give it context.
+    const source = this.startSource || (!this.history.some((m) => m.role === 'user') ? 'startup' : null)
+    if (source && messages.length) {
+      const started = await this.fireHook('SessionStart', { source })
+      this.startSource = null
+      if (started.context.length) appendText(messages[0], `\n\n[Context from your hooks]\n${started.context.join('\n')}`)
+    }
+    this.history.push(...messages)
+    this.post({ type: 'begin' })
+    const decisions = []        // choices Auto mode took without asking, shown at the end
+    const runStarted = Date.now()
+    this.abort = new AbortController()
+    this.markLive(true)
+    workbench.setState('working')
+    this.registry?.sessionsView?.refresh()
+    await syncCommandEnv().catch((error) => log.warn('command environment', error))
+    log.info(`run started in ${this.id || 'a new conversation'} (${agent.modeNow()} mode, model ${this.model || 'the role default'})`)
+    await this.remember()
+    let stopped            // set by whichever way the run ends
+    try {
+      const result = await agent.run({
+        server: serverUrl(),
+        model: this.model || undefined,
+        window: this.models.find((m) => m.name === (this.model || this.roles?.agent))?.window,
+        history: this.history,
+        session: this.session,
+        signal: this.abort.signal,
+        onDelta: (delta) => this.post({ type: 'delta', text: delta }),
+        onThinking: (delta) => this.post({ type: 'thinking', text: delta }),
+        onSpeed: (speed) => this.post({ type: 'speed', ...speed }),
+        onTool: (event) => {
+          // One row per call, updated in place as it runs, kept with its output.
+          const key = event.id || `${event.tool}:${JSON.stringify(event.args)}`
+          const existing = this.transcript.find((t) => t.kind === 'tool' && t.key === key)
+          if (existing) Object.assign(existing, event)
+          else this.transcript.push({ kind: 'tool', key, at: Date.now(), ...event })
+          this.post({ type: 'tool', ...event })
+          if (event.tasks) this.post({ type: 'tasks', items: event.tasks })
+          if (event.status === 'done') {
+            this.rememberSoon()
+            // For /usage: what this turn used — tools, and which skill or helper.
+            const t = (this.turnUse ||= { tools: [], skills: [], helpers: [] })
+            t.tools.push(event.tool)
+            if (event.tool === 'skill' && event.args?.name) t.skills.push(event.args.name)
+            if (event.tool === 'task') t.helpers.push(event.args?.subagent_type || 'explore')
+          }
+        },
+        onNudge: (reason, detail) => this.post({ type: 'nudge', reason, ...(detail || {}) }),
+        takeQueued: () => this.takeQueued(),
+        onSteerable: (steer) => { this.steer = steer },
+        askUser: (questions, signal) => this.askUser(questions, signal),
+        approve: (request, signal) => this.approve(request, signal),
+        approvePlan: (plan, signal) => this.approvePlan(plan, signal),
+        onTodos: (todos) => { this.todos = todos; this.post({ type: 'todos', items: todos }) },
+        onTasks: (tasks) => this.post({ type: 'tasks', items: tasks }),
+        onFileChange: (p, before) => this.onFileChange(p, before),
+        readSpecial: (uri, args) => this.readSpecial(uri, args),
+        trustHooks: (groups, print) => this.trustHooks(groups, print),
+        trustMcp: (servers, print) => this.trustMcp(servers, print),
+        onMonitor: (task, lines, info) => this.onMonitorLines(task, lines, info),
+        schedule: this.schedulerHooks(),
+        onHelperDone: (h, text) => this.onHelperDone(h, text),
+        // Saved at every step, so a crash, a reload or closing VS Code loses nothing.
+        onMessages: (messages) => { this.history = messages.map(withoutImages); this.markLive(true); this.rememberSoon() },
+        onDecision: (picks) => decisions.push(...picks),
+        onWaiting: (event) => this.post({ type: 'waiting', seconds: event.waiting, phase: event.phase }),
+        onTurn: ({ text: said, thinking, meta, calls }) => {
+          if (String(said || '').trim() || String(thinking || '').trim()) {
+            this.transcript.push({ kind: 'assistant', text: said, thinking, meta, at: Date.now(),
+              thoughtSeconds: this.pendingThought?.seconds, thoughtTokens: this.pendingThought?.tokens })
+            this.pendingThought = null
+          }
+          if (meta?.model) this.lastModel = meta.model
+          this.usage.turns += 1
+          this.usage.prompt += meta?.context_used || 0
+          this.usage.output += meta?.eval_tokens || meta?.tokens || 0
+          const used = this.turnUse || { tools: [], skills: [], helpers: [] }
+          this.turnUse = null
+          usageLog.record({ conversation: this.id, models: meta?.model ? [meta.model] : [], context: meta?.context_used || 0,
+            read: meta?.prompt_read ?? null, output: meta?.eval_tokens || meta?.tokens || 0,
+            genSeconds: meta?.eval_tps && meta?.eval_tokens ? meta.eval_tokens / meta.eval_tps : 0, ...used })
+          if (meta?.eval_tps && meta?.eval_tokens) this.usage.genSeconds = (this.usage.genSeconds || 0) + meta.eval_tokens / meta.eval_tps
+          this.post({ type: 'turn', text: said, calls: calls.length, meta })
+        },
+      })
+      if (result.busy && !result.messages.length) {      // taken by another app in the meantime
+        this.history.splice(this.history.length - messages.length, messages.length)
+        this.post({ type: 'end', stopped: true })
+        this.gpuBusy(result.gpu, messages)
+        stopped = true
+        return undefined
+      }
+      this.history = result.messages.map(withoutImages)
+      // An error no longer costs the run: the history above already holds every tool
+      // call and result, so "continue" picks up from the last step, not from scratch.
+      const error = result.error
+        && `${result.error}\n\nEverything up to this point is kept — say **continue** to pick up from the last step.`
+      if (result.error) this.transcript.push({ kind: 'error', text: error, at: Date.now() })
+      this.post({ type: 'end', meta: result.meta, exhausted: result.exhausted,
+                  stopped: result.stopped, stuck: result.stuck, error })
+      // What Auto mode decided on its own, each open to change — option C.
+      if (decisions.length) {
+        this.transcript.push({ kind: 'decisions', items: decisions })
+        this.post({ type: 'decisions', items: decisions })
+      }
+      stopped = !!result.stopped
+      if (!stopped) this.notifyAway(result.error ? 'AIPictury stopped on an error' : 'AIPictury is done',
+        result.error ? String(result.error).split('\n')[0] : (this.title || 'The run finished'))
+    } catch (error) {
+      stopped = error.name === 'AbortError'
+      if (!stopped) log.error('run failed', error)
+      this.post({ type: 'end', stopped, error: stopped ? undefined : error.message })
+    } finally {
+      this.abort = null
+      clearTimeout(this.saveTimer); this.saveTimer = null
+      this.usage.seconds += (Date.now() - runStarted) / 1000
+      log.info(`run ended after ${Math.round((Date.now() - runStarted) / 1000)} s${stopped ? ' (stopped)' : ''}`)
+      if (this.session) delete this.session.commandAllow      // a command's allowed-tools end with its run
+      await this.remember().catch(() => {})
+      this.markLive(false)
+      this.refreshCache()                       // the turn just reset Ollama's timer
+      this.setBadge('finished')
+      if (!stopped) this.suggestTitle().catch((error) => log.warn('no title', error))
+    }
+    // Messages queued after the agent's last step. Stopped: they go back to the input to
+    // edit, as in Claude Code. Otherwise they start the next run straight away.
+    if (this.queue.length) {
+      const left = this.queue.splice(0)
+      this.postQueue()
+      if (stopped) {
+        this.post({ type: 'draft', text: left.map((q) => q.text).join('\n\n') })
+      } else {
+        for (const q of left) {
+          this.transcript.push({ kind: 'user', text: q.text, files: q.files, at: Date.now(), checkpoint: this.newCheckpoint() })
+          this.post({ type: 'user', text: q.text, files: q.files, at: Date.now(), index: this.transcript.length - 1 })
+        }
+        await this.start(left.map((q) => q.message))
+      }
+    }
+    // A monitor spoke after the agent's last step: it carries on with that.
+    if (!stopped && this.events?.length && !this.abort) await this.start(this.events.splice(0))
+  }
+
+  /** After a window reload: the side bar's conversation comes back when it was recent, and
+   *  a run the reload cut off carries on from its last step — as Claude Code does. */
+  async resumeAfterReload() {
+    const live = this.context.workspaceState.get(LIVE)
+    if (!live?.id || Date.now() - live.at > RESTORE_WINDOW && !live.running) return
+    if (!(await this.open(live.id, { focus: false }))) return
+    if (live.running && Date.now() - live.at < CONTINUE_WINDOW && config().get('continueAfterReload', true)) {
+      this.say('the window was reloaded while the agent was working — continuing from its last step')
+      this.transcript.push({ kind: 'user', text: '(continuing after the window reloaded)', at: Date.now(), checkpoint: this.newCheckpoint() })
+      await this.start([{ role: 'user', content: '[The editor window was reloaded while you were working. Nothing you '
+        + 'did is lost — the conversation above is complete. Continue the task from where you left off.]' }])
+    }
+  }
+
+  html(webview) {
+    const uri = (...parts) =>
+      webview.asWebviewUri(vscode.Uri.joinPath(this.context.extensionUri, 'media', ...parts))
+    const key = nonce()
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta http-equiv="Content-Security-Policy" content="default-src 'none';
+  img-src ${webview.cspSource} data: https: http:;
+  style-src ${webview.cspSource} 'unsafe-inline';
+  script-src 'nonce-${key}';
+  font-src ${webview.cspSource};">
+<link rel="stylesheet" href="${uri('vendor', 'katex.css')}">
+<link rel="stylesheet" href="${uri('rich-markdown.css')}">
+<link rel="stylesheet" href="${uri('panel.css')}">
+<title>AIPictury Agent</title>
+</head>
+<body>
+  <div id="status" class="status"></div>
+  <div id="thread" class="thread" role="log" aria-label="Conversation" tabindex="0"></div>
+  <div id="announce" class="sr-only" aria-live="polite"></div>
+  <div id="working" class="working" hidden aria-live="polite">
+    <span class="star">✻</span><span class="word">Working…</span><span class="time"></span>
+  </div>
+  <div id="queue" class="queue" hidden></div>
+  <div id="chooser" class="chooser" hidden role="dialog" aria-label="The agent asks you to decide"></div>
+  <div id="slash" class="slash-menu" hidden role="listbox"></div>
+  <div id="dialog" class="dialog" hidden></div>
+  <div class="composer">
+    <div id="todos" class="todos" hidden></div>
+    <div id="atts" class="atts" hidden></div>
+    <div id="editor-ctx" class="editor-ctx" hidden></div>
+    <textarea id="input" rows="1" placeholder="Ask the agent to build, find or fix something… (@ to mention a file, / for commands)"></textarea>
+    <div class="composer-actions">
+      <button id="attach" class="pick attach" title="Attach images, PDFs or files (up to 10) — or paste / drop them here" aria-label="Attach"><svg class="ico" viewBox="0 0 24 24" width="14" height="14" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 5v14M5 12h14"/></svg></button>
+      <button id="ctx" class="pick ctx" title="Context used" hidden>
+        <svg viewBox="0 0 20 20" width="15" height="15" aria-hidden="true">
+          <circle class="ctx-bg" cx="10" cy="10" r="7"></circle>
+          <circle class="ctx-fg" cx="10" cy="10" r="7"></circle>
+        </svg>
+      </button>
+      <span id="cache" class="cache-note" hidden><svg class="ico" viewBox="0 0 24 24" width="14" height="14" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><circle cx="12" cy="12" r="9"/><path d="M12 7v5l3 2"/></svg><span class="mins"></span></span>
+      <div class="mode-picker model-picker">
+        <button id="model" class="pick" title="Model this message is sent to"></button>
+        <div id="model-menu" class="pick-menu" hidden></div>
+      </div>
+      <button id="think" class="pick toggle" title="Expand or collapse the model's reasoning"><svg class="ico" viewBox="0 0 24 24" width="14" height="14" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><path d="M12 4v16M5.1 8l13.8 8M5.1 16l13.8-8"/></svg><span class="label">Thinking</span></button>
+      <span id="speed" class="speed" hidden title="Generation speed"></span>
+      <button id="remote" class="pick remote" hidden aria-label="Remote control"><svg class="ico" viewBox="0 0 24 24" width="14" height="14" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="7" y="2" width="10" height="20" rx="2"/><path d="M11 18h2"/></svg><span class="remote-n"></span></button>
+      <button id="mic" class="pick mic" title="Dictate — click and speak; click again to write it here (Esc discards)" aria-label="Dictate" aria-pressed="false"><svg class="ico" viewBox="0 0 24 24" width="14" height="14" aria-hidden="true" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"><rect x="9" y="3" width="6" height="11" rx="3"/><path d="M5 11a7 7 0 0 0 14 0M12 18v3"/></svg><span class="mic-time"></span></button>
+      <span class="composer-spacer"></span>
+      <div class="mode-picker">
+        <button id="mode" class="pick" title="What the agent may do on its own — Shift+Tab to cycle"></button>
+        <div id="mode-menu" class="pick-menu" hidden></div>
+      </div>
+      <button id="send" class="pick-send" title="Send (Enter)" aria-label="Send"><svg viewBox="0 0 16 16" width="14" height="14" aria-hidden="true"><path d="M8 13V3.5M3.5 8 8 3.5 12.5 8" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round" stroke-linejoin="round"/></svg></button>
+      <button id="stop" class="pick-send stop" title="Stop (Esc)" aria-label="Stop" hidden><svg viewBox="0 0 16 16" width="14" height="14" aria-hidden="true"><rect x="4" y="4" width="8" height="8" rx="1.5" fill="currentColor"/></svg></button>
+    </div>
+  </div>
+  <script type="module" nonce="${key}" src="${uri('panel.js')}"></script>
+</body>
+</html>`
+  }
+}
+
+/** Pictures are sent once; the kept conversation notes where they were. */
+function withoutImages(m) {
+  if (!m.images) return m
+  const { images, ...rest } = m
+  return { ...rest, content: `${rest.content}\n[${images.length} image(s) were attached here]` }
+}
+
+/** Rebuilds a rough transcript from the model context alone, for conversations saved
+ *  before the transcript itself was kept. */
+function fromHistory(history) {
+  const turns = []
+  for (const message of history) {
+    if (message.role === 'user') {
+      turns.push({ kind: 'user', text: String(message.content || '') })
+    } else if (message.role === 'assistant') {
+      if (String(message.content || '').trim()) {
+        turns.push({ kind: 'assistant', text: message.content })
+      }
+      for (const call of message.tool_calls || []) {
+        turns.push({ kind: 'tool', tool: call.function.name,
+                     args: call.function.arguments || {}, status: 'done' })
+      }
+    }
+  }
+  return turns
+}
+
+/** The conversation as Markdown, as /export writes it. */
+function toMarkdown(title, transcript) {
+  const out = [`# ${title}`, '', `_Exported from AIPictury ${VERSION} on ${new Date().toISOString().slice(0, 16).replace('T', ' ')}_`, '']
+  for (const t of transcript) {
+    if (t.kind === 'user') out.push(`## You`, '', t.text, '')
+    else if (t.kind === 'assistant') {
+      if (String(t.thinking || '').trim()) out.push('<details><summary>Reasoning</summary>', '', t.thinking.trim(), '', '</details>', '')
+      if (String(t.text || '').trim()) out.push('## Agent', '', t.text.trim(), '')
+    } else if (t.kind === 'tool') {
+      const a = t.args || {}
+      out.push(`> **${t.tool}** ${a.command || a.path || a.pattern || a.query || a.url || ''} — ${t.status}`, '')
+    } else if (t.kind === 'error') out.push(`> **Error:** ${t.text}`, '')
+  }
+  return out.join('\n')
+}
+
+// ---------------------------------------------------------------- panels: side bar and tabs
+
+class Registry {
+  constructor(context) {
+    this.context = context
+    this.sidebar = new AgentPanel(context, { kind: 'sidebar', registry: this })
+    this.tabs = new Set()
+    this.last = this.sidebar
+  }
+
+  all() { return [this.sidebar, ...this.tabs] }
+
+  /** Asked from the web: the panel with this conversation shares it by remote control — opened
+   *  first when it is this project's but not on screen. Another project's: some other window's. */
+  async shareAsked(conversation) {
+    let panel = this.all().find((p) => p?.id === conversation)
+    if (!panel) {
+      const idle = this.all().find((p) => p && !p.abort && p.store?.get?.(conversation))
+      if (!idle || !(await idle.open(conversation))) return false
+      panel = idle
+    }
+    await panel.remoteControl('start', { asked: true })
+    return true
+  }
+  activate(panel) { this.last = panel }
+  remove(panel) {
+    this.tabs.delete(panel)
+    if (this.last === panel) this.last = this.sidebar
+    workbench.tabClosed(panel.id)          // for Cmd/Ctrl+Shift+T
+    this.sessionsView?.refresh()             // no longer open
+  }
+  active() { return this.last?.host ? this.last : this.sidebar }
+
+  /** A new conversation in an editor tab — several can run side by side. */
+  openTab(existing) {
+    const host = existing || vscode.window.createWebviewPanel('aipictury.agentTab', 'AIPictury Agent',
+      { viewColumn: vscode.ViewColumn.Beside, preserveFocus: false }, { enableScripts: true, retainContextWhenHidden: true })
+    host.iconPath = vscode.Uri.joinPath(this.context.extensionUri, 'media', 'icon.svg')
+    const panel = new AgentPanel(this.context, { kind: 'tab', registry: this })
+    panel.attach(host)
+    this.tabs.add(panel)
+    this.last = panel
+    return panel
+  }
+
+  broadcast(message) { for (const p of this.all()) p.post(message) }
+}
+
+// ---------------------------------------------------------------- what the user is looking at
+
+/** A files.exclude glob as a regular expression: ** any folders, * within one name. */
+function globToRegExp(glob) {
+  let re = ''
+  for (let i = 0; i < glob.length; i += 1) {
+    const c = glob[i]
+    if (c === '*' && glob[i + 1] === '*') { re += glob[i + 2] === '/' ? '(?:.*/)?' : '.*'; i += glob[i + 2] === '/' ? 2 : 1 }
+    else if (c === '*') re += '[^/]*'
+    else if (c === '?') re += '[^/]'
+    else re += /[.+^$(){}|[\]\\]/.test(c) ? `\\${c}` : c
+  }
+  return new RegExp(`^${re}$`)
+}
+
+/** The file open in the editor and the selection in it: shown in the composer, and sent
+ *  with each message unless dismissed — as Claude Code attaches the open file. Text from a
+ *  file git ignores, or VS Code's files.exclude hides, is withheld: only its name is sent. */
+const editorTracker = {
+  registry: null,
+  timer: null,
+  ignored: new Map(),
+
+  state() {
+    const editor = vscode.window.activeTextEditor
+    if (!editor || editor.document.uri.scheme !== 'file' || !vscode.workspace.getWorkspaceFolder(editor.document.uri)) return null
+    const rel = vscode.workspace.asRelativePath(editor.document.uri, false)
+    const sel = editor.selection
+    const lines = sel.isEmpty ? null : [sel.start.line + 1, sel.end.line + (sel.end.character === 0 && sel.end.line > sel.start.line ? 0 : 1)]
+    return { path: rel, lines, language: editor.document.languageId, text: sel.isEmpty ? '' : editor.document.getText(sel) }
+  },
+
+  key() { const s = this.state(); return s ? `${s.path}#${s.lines?.join('-') || ''}` : null },
+
+  isIgnored(rel) {
+    if (this.ignored.has(rel)) return this.ignored.get(rel)
+    this.ignored.set(rel, false)
+    const root = workspaceRoot()?.fsPath
+    if (root && config().get('respectGitIgnore', true)) {
+      execFile('git', ['check-ignore', '-q', rel], { cwd: root, timeout: 3000 }, (error) => {
+        this.ignored.set(rel, !error)
+        this.update()
+      })
+    }
+    // What VS Code itself hides (files.exclude) or leaves out of searches (search.exclude).
+    const excluded = { ...vscode.workspace.getConfiguration('files').get('exclude', {}),
+      ...vscode.workspace.getConfiguration('search').get('exclude', {}) }
+    if (Object.entries(excluded).some(([glob, on]) => on === true && globToRegExp(glob).test(rel))) {
+      this.ignored.set(rel, true)
+    }
+
+    return this.ignored.get(rel)
+  },
+
+  post(panel) {
+    const s = this.state()
+    const dismissed = !!s && panel.contextDismissed === this.key()
+    panel.post({ type: 'editorContext', file: s?.path || null, lines: s?.lines || null,
+      withheld: !!s && this.isIgnored(s.path), dismissed, attachOpenFile: config().get('attachOpenFile', true) })
+  },
+
+  update() {
+    clearTimeout(this.timer)
+    this.timer = setTimeout(() => { for (const p of this.registry?.all() || []) {
+      if (p.contextDismissed && p.contextDismissed !== this.key()) p.contextDismissed = null
+      this.post(p)
+    } }, 150)
+  },
+
+  /** What goes with a message about where the user is. */
+  contextFor(panel) {
+    const s = this.state()
+    if (!s || panel.contextDismissed === this.key()) return ''
+    const withSelection = !!s.lines && s.text.trim()
+    if (!withSelection && !config().get('attachOpenFile', true)) return ''
+    if (this.isIgnored(s.path)) return `[The user has ${s.path} open — its contents are withheld (ignored by git, files.exclude or search.exclude).]`
+    if (!withSelection) return `[The user has ${s.path} open in the editor.]`
+    const text = s.text.length > 20_000 ? `${s.text.slice(0, 20_000)}\n…` : s.text
+    return `[The user has ${s.path} open, with lines ${s.lines[0]}–${s.lines[1]} selected:]\n\`\`\`${s.language}\n${text}\n\`\`\``
+  },
+}
+
+// ---------------------------------------------------------------- @-mentions
+
+let fileCache = { at: 0, list: [] }
+
+async function workspaceFiles() {
+  if (Date.now() - fileCache.at < 30_000 && fileCache.list.length) return fileCache.list
+  const found = await vscode.workspace.findFiles('**/*', '**/{node_modules,.git,.venv,__pycache__,dist,build,.next,target}/**', 8000)
+  const list = found.map((u) => vscode.workspace.asRelativePath(u, false)).sort()
+  fileCache = { at: Date.now(), list }
+  return list
+}
+
+/** How well `path` matches what was typed: letters in order, ends of words and the file
+ *  name counting most — "authsv" finds "src/auth/service.ts". */
+function fuzzyScore(query, candidate) {
+  const q = query.toLowerCase()
+  const c = candidate.toLowerCase()
+  if (!q) return 1
+  const name = c.slice(c.lastIndexOf('/', c.length - 2) + 1)
+  if (name.startsWith(q)) return 1000 - c.length
+  if (c.includes(q)) return 800 - c.indexOf(q) - c.length / 10
+  let score = 0
+  let at = 0
+  for (const ch of q) {
+    const i = c.indexOf(ch, at)
+    if (i === -1) return 0
+    score += i === at ? 5 : /[/._-]/.test(c[i - 1] || '/') ? 4 : 1
+    at = i + 1
+  }
+  return score * 10 - c.length / 5
+}
+
+async function mentionCandidates(query) {
+  const q = String(query || '').replace(/^@/, '')
+  const out = []
+  if ('terminal:'.startsWith(q.toLowerCase()) || q.toLowerCase().startsWith('terminal:')) {
+    for (const t of vscode.window.terminals) out.push({ path: `terminal:${t.name}`, kind: 'terminal', score: 2000 })
+  }
+  const list = await workspaceFiles().catch(() => [])
+  const folders = new Set()
+  for (const f of list) {
+    const parts = f.split('/')
+    for (let i = 1; i < parts.length; i += 1) folders.add(`${parts.slice(0, i).join('/')}/`)
+  }
+  for (const f of [...folders, ...list]) {
+    const score = fuzzyScore(q, f)
+    if (score > 0) out.push({ path: f, kind: f.endsWith('/') ? 'folder' : 'file', score: score + (f.endsWith('/') ? -5 : 0) })
+  }
+  return out.sort((a, b) => b.score - a.score).slice(0, 12).map(({ path: p, kind }) => ({ path: p, kind }))
+}
+
+// The output of commands run in the editor's terminals, for @terminal:name.
+const terminalOutput = new Map()
+
+function watchTerminals(add) {
+  if (!vscode.window.onDidStartTerminalShellExecution) return
+  add(vscode.window.onDidStartTerminalShellExecution(async (event) => {
+    const name = event.terminal.name
+    let text = `$ ${event.execution.commandLine?.value || ''}\n`
+    try {
+      for await (const chunk of event.execution.read()) {
+        text += chunk
+        if (text.length > 40_000) text = text.slice(-40_000)
+        terminalOutput.set(name, text)
+      }
+    } catch { /* the terminal closed */ }
+    terminalOutput.set(name, text)
+  }))
+}
+
+/** The content behind each @-mention in a message: files (a line range with #L5-10),
+ *  folders (their files), and a terminal's recent output. Files read this way count as
+ *  read, so the agent can edit them straight away. */
+async function resolveMentions(text, session) {
+  const found = [...String(text).matchAll(/(^|\s)@((?:terminal:[^\s]+)|[^\s@]+)/g)].map((m) => m[2].replace(/[.,;:!?)]+$/, ''))
+  const out = []
+  const seen = new Set()
+  for (const ref of found.slice(0, 12)) {
+    if (seen.has(ref)) continue
+    seen.add(ref)
+    if (ref.startsWith('terminal:')) {
+      const name = ref.slice('terminal:'.length)
+      const output = terminalOutput.get(name)
+      out.push(output ? `<terminal name="${name}">\n${output.slice(-20_000)}\n</terminal>`
+        : `(@${ref}: no output captured from that terminal yet — commands run in it after this window opened are captured)`)
+      continue
+    }
+    const m = /^(.+?)(?:#L?(\d+)(?:-L?(\d+))?)?$/.exec(ref)
+    const rel = m[1]
+    try {
+      const uri = vscode.Uri.joinPath(workspaceRoot(), rel)
+      const info = await vscode.workspace.fs.stat(uri)
+      if (info.type & vscode.FileType.Directory) {
+        const listing = await require('./tools').IMPLEMENTATIONS.list_files({ path: rel })
+        out.push(`<folder path="${rel}">\n${listing}\n</folder>`)
+      } else {
+        const start = m[2] ? Number(m[2]) : undefined
+        const end = m[3] ? Number(m[3]) : start
+        const body = await files.readFile({ path: rel, offset: start, limit: start ? end - start + 1 : 2000 }, { session })
+        out.push(`<file path="${rel}"${start ? ` lines="${start}-${end}"` : ''}>\n${body}\n</file>`)
+      }
+    } catch { /* not a path: an @ in ordinary text */ }
+  }
+  return out
+}
+
+/** Opens a workspace file, at a line when given — paths with spaces or accents included,
+ *  which Claude Code's panel failed to open (its links stayed percent-encoded). */
+async function openWorkspaceFile(p, line) {
+  const root = workspaceRoot()
+  if (!root || !p) return
+  let rel = String(p)
+  try { rel = decodeURIComponent(rel) } catch { /* not encoded */ }
+  const uri = path.isAbsolute(rel) ? vscode.Uri.file(rel) : vscode.Uri.joinPath(root, rel)
+  const options = { preview: true }
+  if (line) options.selection = new vscode.Range(Number(line) - 1, 0, Number(line) - 1, 0)
+  // vscode.open picks the right editor: text, or the image and video previews.
+  return vscode.commands.executeCommand('vscode.open', uri, options)
+}
+
+// ---------------------------------------------------------------- the studio tab
+
+/** The studio is the web app at aipictury.com, in the browser: it cannot be framed here (it
+ *  refuses frames, against clickjacking, and Google sign-in needs a real window). */
+function openStudio() {
+  const web = String(config().get('webApp', 'https://aipictury.com') || 'https://aipictury.com').replace(/\/+$/, '')
+  return vscode.env.openExternal(vscode.Uri.parse(web))
+}
+
+// ---------------------------------------------------------------- editor commands
+
+/** The selection, with enough around it for the model to make sense of it. */
+function selectionContext() {
+  const editor = vscode.window.activeTextEditor
+  if (!editor || editor.selection.isEmpty) return null
+  return {
+    path: vscode.workspace.asRelativePath(editor.document.uri),
+    language: editor.document.languageId,
+    text: editor.document.getText(editor.selection),
+    line: editor.selection.start.line + 1,
+  }
+}
+
+async function askAboutSelection(panel, instruction) {
+  const selected = selectionContext()
+  if (!selected) {
+    vscode.window.showInformationMessage('Select some code first.')
+    return
+  }
+  if (panel.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
+  panel.ask(`${instruction}\n\n\`${selected.path}\` from line ${selected.line}:\n\n`
+    + `\`\`\`${selected.language}\n${selected.text}\n\`\`\``)
+}
+
+/** A commit message written from what is actually staged. */
+async function commitMessage() {
+  const folders = vscode.workspace.workspaceFolders
+  if (!folders?.length) return
+  const diff = await new Promise((done) => {
+    execFile('git', ['diff', '--cached'],
+      { cwd: folders[0].uri.fsPath, maxBuffer: 4_000_000, timeout: 20_000 },
+      (error, stdout) => done(error ? '' : stdout))
+  })
+  if (!diff.trim()) {
+    vscode.window.showInformationMessage('Nothing is staged, so there is nothing to describe.')
+    return
+  }
+  const message = await vscode.window.withProgress(
+    { location: vscode.ProgressLocation.SourceControl, title: 'Writing a commit message…',
+      cancellable: true },
+    async (_progress, token) => {
+      const controller = new AbortController()
+      token.onCancellationRequested(() => controller.abort())
+      const { text } = await agent.turn(serverUrl(), [
+        { role: 'system', content: 'Write a git commit message for the diff. A short subject line '
+          + 'in the imperative, under 72 characters; then a blank line and a few bullets only if '
+          + 'the change needs them. No preamble, no code fences — just the message.' },
+        { role: 'user', content: diff.slice(0, 120_000) },
+      ], { role: 'commit', signal: controller.signal })
+      return text.trim()
+    }).catch((error) => {
+      vscode.window.showWarningMessage(`No commit message: ${error.message}`)
+      return ''
+    })
+  if (!message) return
+
+  // Put it where the user is already typing, rather than in a dialog.
+  const git = vscode.extensions.getExtension('vscode.git')?.exports
+  const repository = git?.getAPI(1)?.repositories?.[0]
+  if (repository) {
+    repository.inputBox.value = message
+    vscode.window.showInformationMessage('Commit message written into the Source Control box.')
+  } else {
+    await vscode.env.clipboard.writeText(message)
+    vscode.window.showInformationMessage('Commit message copied to the clipboard.')
+  }
+}
+
+/** The conversations had in this project, most recent first — search, reopen, rename,
+ *  open in a tab, or delete. */
+async function showHistory(panel) {
+  await panel.remember()
+  const conversations = panel.store.list().filter((c) => !c.archived)
+  if (!conversations.length) {
+    vscode.window.showInformationMessage('No conversations yet in this project.')
+    return
+  }
+  const buttons = [
+    { iconPath: new vscode.ThemeIcon('edit'), tooltip: 'Rename', action: 'rename' },
+    { iconPath: new vscode.ThemeIcon('link-external'), tooltip: 'Open in a new tab', action: 'tab' },
+    { iconPath: new vscode.ThemeIcon('trash'), tooltip: 'Delete', action: 'delete' },
+  ]
+  const items = () => panel.store.list().filter((c) => !c.archived).map((c) => ({
+    label: c.title,
+    description: ago(c.updated),
+    detail: `${c.questions ?? '?'} question(s)${c.model ? ` · ${c.model}` : ''}`,
+    id: c.id,
+    buttons,
+  }))
+
+  const picker = vscode.window.createQuickPick()
+  picker.items = items()
+  picker.title = 'AIPictury conversations'
+  picker.placeholder = 'Search, or pick one to reopen'
+  picker.matchOnDescription = true
+  picker.matchOnDetail = true
+
+  picker.onDidTriggerItemButton(async (event) => {
+    const action = event.button.action
+    if (action === 'delete') {
+      panel.store.remove(event.item.id)
+    } else if (action === 'rename') {
+      const title = await vscode.window.showInputBox({ title: 'Rename the conversation', value: event.item.label })
+      if (title) {
+        panel.store.patch(event.item.id, { title, renamed: true })
+        if (panel.id === event.item.id) panel.title = title
+      }
+      picker.show()
+    } else if (action === 'tab') {
+      picker.hide()
+      await panel.registry.openTab().open(event.item.id, { focus: false })
+      return
+    }
+    picker.items = items()
+    if (!picker.items.length) picker.hide()
+  })
+  picker.onDidAccept(async () => {
+    const chosen = picker.selectedItems[0]
+    picker.hide()
+    if (chosen) await panel.open(chosen.id)
+  })
+  picker.onDidHide(() => picker.dispose())
+  picker.show()
+}
+
+/** What a rewind choice will do, said plainly for the confirmation: [title, detail, button]. */
+function rewindQuestion(action, text, files) {
+  const quoted = `“${String(text).replace(/\s+/g, ' ').trim().slice(0, 60)}${String(text).length > 60 ? '…' : ''}”`
+  const restore = files.length
+    ? `The ${files.length} file${files.length === 1 ? '' : 's'} the agent changed since then will be restored to how they were: `
+      + `${files.slice(0, 5).join(', ')}${files.length > 5 ? ', …' : ''}. Changes made by commands are not tracked and stay.`
+    : 'The agent changed no files since then, so no file will change.'
+  const keepFiles = 'Your files are not touched.'
+  const todos = 'The to-do list and the context figures go back to how they were then.'
+  switch (action) {
+    case 'fork': return [`Fork the conversation from before ${quoted}?`,
+      `A new conversation starts from before that message, with your message back in the input. The original conversation is kept in history. ${todos} ${keepFiles}`, 'Fork']
+    case 'fork-code': return [`Fork the conversation and rewind the code to before ${quoted}?`,
+      `A new conversation starts from before that message; the original is kept in history. ${todos} ${restore}`, 'Fork and rewind code']
+    case 'code': return [`Rewind the code to before ${quoted}?`, `${restore} The conversation stays as it is.`, 'Rewind code']
+    case 'conversation': return [`Rewind the conversation to before ${quoted}?`,
+      `That message and everything after it are removed from this conversation, and your message goes back to the input. ${todos} ${keepFiles}`, 'Rewind conversation']
+    default: return [`Rewind the code and the conversation to before ${quoted}?`,
+      `That message and everything after it are removed from this conversation. ${todos} ${restore}`, 'Rewind both']
+  }
+}
+
+function ago(when) {
+  const minutes = Math.round((Date.now() - when) / 60000)
+  if (minutes < 1) return 'just now'
+  if (minutes < 60) return `${minutes} min ago`
+  const hours = Math.round(minutes / 60)
+  if (hours < 24) return `${hours} h ago`
+  return `${Math.round(hours / 24)} d ago`
+}
+
+// ---------------------------------------------------------------- activation
+
+/** 1.5.2's Thinking button switched the model's reasoning off (showThinking = false).
+ *  Since 1.5.3 that button only folds the reasoning, so an "off" it left behind had no way
+ *  back — and without reasoning the model repeats itself and describes changes instead of
+ *  making them. Undone once; an "off" chosen later in the settings is respected. */
+async function undoOldThinkingSwitch(context) {
+  if (context.globalState.get('aipictury.reasoningRestored')) return
+  const settings = vscode.workspace.getConfiguration('aipictury')
+  if (settings.inspect('showThinking')?.globalValue === false) {
+    await settings.update('showThinking', undefined, vscode.ConfigurationTarget.Global)
+  }
+  await context.globalState.update('aipictury.reasoningRestored', true)
+}
+
+let registry = null
+
+/** 1.6.0 made Qwen3.8-27B Heretic the default everywhere. A picker left on a previous
+ *  default would keep the old model for good; that choice is cleared once, so the server's
+ *  default applies. A model chosen on purpose (any other) is kept. */
+const OLD_DEFAULTS = ['qwen38-uncensored', 'qwen38-uncensored:latest', 'gemma4:12b', 'gptoss-neo', 'gptoss-neo:latest',
+  'qwen3.5:27b']
+function adoptNewDefaultModel(context) {
+  if (context.globalState.get('aipictury.defaults160')) return Promise.resolve(false)
+  const cleared = OLD_DEFAULTS.includes(context.globalState.get('aipictury.model'))
+  // Decided now, before any panel reads the choice; saved in the background.
+  return Promise.all([cleared ? context.globalState.update('aipictury.model', undefined) : null,
+    context.globalState.update('aipictury.defaults160', true)]).then(() => cleared)
+}
+
+/** What every command the agent runs gets added to its environment: the Python environment the
+ *  Python extension selected (usePythonEnvironment), the settings files' `env`, and the
+ *  environmentVariables setting. Refreshed before each run, so a change applies to the next one. */
+async function syncCommandEnv() {
+  const root = workspaceRoot()?.fsPath
+  try { shell.setExtraEnv('files', prefs.load(root).merged.env || {}) } catch { shell.setExtraEnv('files', {}) }
+  const vars = config().get('environmentVariables', []) || []
+  shell.setExtraEnv('setting', Object.fromEntries(vars.filter((v) => v && v.name).map((v) => [String(v.name), String(v.value ?? '')])))
+  shell.setExtraEnv('python', config().get('usePythonEnvironment', true) ? await pythonEnvironment() : null)
+}
+
+/** The interpreter the Python extension has selected for this workspace, if it is installed. */
+async function pythonEnvironment() {
+  const ext = vscode.extensions.getExtension('ms-python.python')
+  if (!ext) return null
+  try {
+    const api = ext.isActive ? ext.exports : await ext.activate()
+    const envs = api?.environments
+    if (!envs?.getActiveEnvironmentPath) return null
+    const folder = vscode.workspace.workspaceFolders?.[0]
+    const resolved = await envs.resolveEnvironment(envs.getActiveEnvironmentPath(folder?.uri))
+    const exe = resolved?.executable?.uri?.fsPath
+    if (!exe) return null
+    return { bin: path.dirname(exe), venv: resolved.environment?.folderUri?.fsPath || null }
+  } catch (error) {
+    log.warn('the Python environment could not be read', error)
+    return null
+  }
+}
+
+/** Conversations kept in VS Code's workspace state (before 1.7) move to disk once. The old
+ *  copy is left where it was, untouched, as a fallback. */
+function moveConversationsToDisk(context) {
+  if (context.workspaceState.get('aipictury.onDisk')) return 0
+  const store = sessions.storeFor(workspaceRoot()?.fsPath)
+  const dir = context.storageUri || context.globalStorageUri
+  const moved = store.migrate(context.workspaceState.get(STORE, []), dir ? path.join(dir.fsPath, 'checkpoints') : null)
+  context.workspaceState.update('aipictury.onDisk', true)
+  return moved
+}
+
+function activate(context) {
+  try { moveConversationsToDisk(context) } catch { /* tried again next start */ }
+  syncCommandEnv().catch(() => { /* again before each run */ })
+  undoOldThinkingSwitch(context).catch(() => { /* the setting stays as it was */ })
+  const adopting = adoptNewDefaultModel(context).catch(() => false)
+  registry = new Registry(context)
+  const panel = registry.sidebar
+  // A panel made before the choice was cleared drops the old default too.
+  adopting.then((cleared) => { if (cleared) { panel.model = null; panel.refreshStatus() } })
+  editorTracker.registry = registry
+  const add = (disposable) => context.subscriptions.push(disposable)
+  const active = () => registry.active()
+  // OAuth for remote MCP servers: tokens in VS Code's secret storage; the browser comes back
+  // through vscode://aipictury.aipictury/oauth (workbench.uriHandler).
+  mcp.configureAuth({
+    store: { get: (k) => context.secrets.get(k), set: (k, v) => context.secrets.store(k, v), delete: (k) => context.secrets.delete(k) },
+    open: (url) => vscode.env.openExternal(vscode.Uri.parse(url, true)),
+    redirectUri: async () => (await vscode.env.asExternalUri(vscode.Uri.parse(`${vscode.env.uriScheme}://aipictury.aipictury/oauth`))).toString(true),
+  })
+  require('./review').register(context, registry)      // change by change, in the proposal's diff
+  registry.plans = require('./plans').register(context, registry)   // the plan as a commentable document
+  sweepReviews()
+  registry.sessionsView = require('./sessionsView').register(context, { registry, activePanel: active,
+    store: () => sessions.storeFor(workspaceRoot()?.fsPath), server: serverUrl })
+  // The AIPictury account: needed to use the extension; what is yours is kept with it.
+  registry.account = require('./accountUi').register(context, { registry, sessionsView: registry.sessionsView, serverUrl })
+  add(vscode.commands.registerCommand('aipictury.signIn', () => registry.account.signIn()))
+  add(vscode.commands.registerCommand('aipictury.signOut', () => registry.account.signOut()))
+  add(vscode.commands.registerCommand('aipictury.account', () => active().openAccount()))
+
+  add(vscode.window.registerWebviewViewProvider('aipictury.agent', {
+    resolveWebviewView(view) {
+      panel.attach(view)
+      panel.resumeAfterReload().catch(() => {})
+    },
+  }, { webviewOptions: { retainContextWhenHidden: true } }))
+  // Agent tabs come back after a reload, with their conversations.
+  add(vscode.window.registerWebviewPanelSerializer('aipictury.agentTab', {
+    async deserializeWebviewPanel(host, state) {
+      const tab = registry.openTab(host)
+      if (state?.id) await tab.open(state.id, { focus: false })
+    },
+  }))
+  add(vscode.workspace.registerTextDocumentContentProvider(SCHEME, agent.proposedProvider))
+
+  add(vscode.commands.registerCommand('aipictury.openStudio', () => openStudio()))
+  add(vscode.commands.registerCommand('aipictury.newChat', () => panel.reset()))
+  add(vscode.commands.registerCommand('aipictury.openInNewTab', () => registry.openTab()))
+  add(vscode.commands.registerCommand('aipictury.history', () => showHistory(active())))
+  add(vscode.commands.registerCommand('aipictury.memory', () => active().openMemory()))
+  add(vscode.commands.registerCommand('aipictury.openWalkthrough', () =>
+    vscode.commands.executeCommand('workbench.action.openWalkthrough', 'aipictury.aipictury#start', false)))
+  add(vscode.commands.registerCommand('aipictury.permissions', () => active().openPermissions()))
+  add(vscode.commands.registerCommand('aipictury.hooks', () => active().openHooks()))
+  add(vscode.commands.registerCommand('aipictury.plugins', () => active().openPlugins()))
+  add(vscode.commands.registerCommand('aipictury.agents', () => active().openAgents()))
+  add(vscode.commands.registerCommand('aipictury.pages', () => active().openPages()))
+  add(vscode.commands.registerCommand('aipictury.skills', () => active().openSkills()))
+  add(vscode.commands.registerCommand('aipictury.outputStyle', () => active().openOutputStyle()))
+  add(vscode.commands.registerCommand('aipictury.sandbox', () => active().openSandbox()))
+  add(vscode.commands.registerCommand('aipictury.instructions', () => active().openInstructions()))
+  add(vscode.commands.registerCommand('aipictury.slashCommands', () => active().openSlashCommands()))
+  add(vscode.commands.registerCommand('aipictury.reportProblem', () => active().reportProblem()))
+  // About AIPictury agent: this agent's version and the connected server — its models and GPUs.
+  add(vscode.commands.registerCommand('aipictury.help', () => showAbout(context, { model: () => active().model, account: () => registry.account })))
+  add(vscode.commands.registerCommand('aipictury.rewind', () => active().rewindPicker()))
+  add(vscode.commands.registerCommand('aipictury.exportConversation', () => active().exportConversation()))
+  add(vscode.commands.registerCommand('aipictury.status', () => active().status()))
+  add(vscode.commands.registerCommand('aipictury.showTasks', () => active().shortcut('/tasks')))
+  add(vscode.commands.registerCommand('aipictury.renameConversation', async () => {
+    const target = active()
+    const title = await vscode.window.showInputBox({ title: 'Rename the conversation', value: target.conversationTitle })
+    if (title) { target.title = title; await target.remember() }
+  }))
+  add(vscode.commands.registerCommand('aipictury.showLogs', () => log.show()))
+  add(workbench.statusBar())
+  add(workbench.watchTabs())
+  add(vscode.window.registerUriHandler(workbench.uriHandler(registry)))
+  add(vscode.commands.registerCommand('aipictury.openInSideBar', () => vscode.commands.executeCommand('aipictury.agent.focus')))
+  add(vscode.commands.registerCommand('aipictury.newConversation', async () => {
+    const panel = await workbench.openPreferred(registry)
+    if (panel.kind === 'sidebar' && panel.history.length) await panel.shortcut('/clear')
+  }))
+  add(vscode.commands.registerCommand('aipictury.reopenClosedSession', () => workbench.reopenClosed(registry)))
+  add(vscode.commands.registerCommand('aipictury.focusLastMessage', async () => {
+    const target = active()
+    if (target.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
+    else target.host?.reveal?.()
+    target.post({ type: 'focusLast' })
+  }))
+  add(vscode.commands.registerCommand('aipictury.markUnread', () => {
+    const target = active()
+    if (target.id) target.store.patch(target.id, { unread: true })
+  }))
+  add(vscode.commands.registerCommand('aipictury.toggleFocusView', () =>
+    config().update('focusView', !config().get('focusView', false), vscode.ConfigurationTarget.Global)))
+  // Cmd/Ctrl+Esc: into the agent's input, or back to the editor when already there.
+  add(vscode.commands.registerCommand('aipictury.focusInput', async () => {
+    const target = active()
+    if (target.focused) {
+      target.focused = false
+      await vscode.commands.executeCommand('workbench.action.focusActiveEditorGroup')
+      return
+    }
+    if (target.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
+    else target.host.reveal()
+    target.post({ type: 'focusInput' })
+  }))
+  // Alt+K: the current file and selection, as @file#5-10, into the agent's input.
+  add(vscode.commands.registerCommand('aipictury.remoteControl', async () => {
+    const target = active()
+    if (target.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
+    else target.host.reveal()
+    await target.remoteControl(target.remote ? 'stop' : 'start')
+  }))
+  add(vscode.commands.registerCommand('aipictury.dictate', async () => {
+    const target = active()
+    if (target.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
+    else target.host.reveal()
+    await target.dictate('toggle')
+  }))
+  add(vscode.commands.registerCommand('aipictury.insertMention', async () => {
+    const s = editorTracker.state()
+    if (!s) { vscode.window.showInformationMessage('Open a file of this workspace first.'); return }
+    const target = active()
+    if (target.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
+    else target.host.reveal()
+    target.post({ type: 'insert', text: `@${s.path}${s.lines ? `#${s.lines[0]}-${s.lines[1]}` : ''} ` })
+  }))
+  add(vscode.commands.registerCommand('aipictury.explainSelection',
+    () => askAboutSelection(active(), 'Explain this code: what it does, and anything that looks wrong.')))
+  add(vscode.commands.registerCommand('aipictury.refactorSelection',
+    () => askAboutSelection(active(), 'Refactor this code and apply the change to the file.')))
+  add(vscode.commands.registerCommand('aipictury.writeTests',
+    () => askAboutSelection(active(), 'Write tests for this code and put them in the right file.')))
+  add(vscode.commands.registerCommand('aipictury.commitMessage', commitMessage))
+  add(vscode.commands.registerCommand('aipictury.openSettings',
+    () => vscode.env.openExternal(vscode.Uri.parse(`${serverUrl()}/#settings`))))
+  add(vscode.commands.registerCommand('aipictury.setServer', async () => {
+    const value = await vscode.window.showInputBox({
+      title: 'AIPictury GPU server, for this machine',
+      value: gpuServer.explicit(),
+      prompt: 'Its address on this machine — or leave it empty to use the one chosen with your account at aipictury.com',
+    })
+    if (value !== undefined) {
+      await config().update('server', value.trim() ? value.trim().replace(/\/+$/, '') : undefined, vscode.ConfigurationTarget.Global)
+      for (const p of registry.all()) p.refreshStatus()
+    }
+  }))
+
+  add(vscode.window.onDidChangeActiveTextEditor(() => editorTracker.update()))
+  add(vscode.window.onDidChangeTextEditorSelection(() => editorTracker.update()))
+  add(vscode.workspace.onDidCreateFiles(() => { fileCache.at = 0 }))
+  add(vscode.workspace.onDidDeleteFiles(() => { fileCache.at = 0 }))
+  watchTerminals(add)
+
+  add(vscode.workspace.onDidChangeConfiguration((event) => {
+    for (const p of registry.all()) {
+      if (event.affectsConfiguration('aipictury.server')) p.refreshStatus()
+      if (['approval', 'showThinking', 'effort', 'focusView', 'useCtrlEnterToSend', 'scrollToBottomOnSend', 'hideOnboarding', 'allowDangerouslySkipPermissions']
+        .some((k) => event.affectsConfiguration(`aipictury.${k}`))) p.postMode()
+      if (event.affectsConfiguration('aipictury.attachOpenFile')) editorTracker.update()
+    }
+  }))
+
+  // A new panel in the side bar is easy to miss. Offer it once, then never again.
+  if (!context.globalState.get('aipictury.greeted')) {
+    context.globalState.update('aipictury.greeted', true)
+    vscode.window.showInformationMessage(
+      'AIPictury is installed: a coding agent on your own GPU.', 'Open it')
+      .then((choice) => {
+        if (choice === 'Open it') vscode.commands.executeCommand('aipictury.agent.focus')
+      })
+  }
+  return { registry }
+}
+
+// Anything the agent left running — a dev server, MCP servers — goes when VS Code does,
+// and every conversation on screen is saved first.
+async function deactivate() {
+  agent.stopBackground()
+  mcp.closeAll()
+  await require('./browser').close()
+  await Promise.all((registry?.all() || []).map((p) => p.remember().catch(() => {})))
+}
+
+module.exports = { syncCommandEnv, moveConversationsToDisk, rewindQuestion, activate, deactivate, undoOldThinkingSwitch, adoptNewDefaultModel, fuzzyScore, toMarkdown, resolveMentions, mentionCandidates, INIT_PROMPT, REVIEW_PROMPT }