@davait/aipictury 1.19.4 → 1.20.1

package/ext/extension.js

@@ -16,7 +16,9 @@ const files = require('./files')
 const shell = require('./shell')
 const mcp = require('./mcp')
 const voice = require('./voice')
-const { RemoteLink } = require('./remote')
+const attachmentShelf = require('./attachments')
+const { RemoteLink, SavedLinks } = require('./remote')
+const { remoteLive, REMOTE_BEAT } = require('./cloud')
 const context = require('./context')
 const { showAbout } = require('./about')
 const { stripInvisible } = require('./text')
@@ -24,6 +26,7 @@ const sessions = require('./sessions')
 const log = require('./log')
 const workbench = require('./workbench')
 const dialogs = require('./dialogs')
+const feedback = require('./feedback')
 const userHooks = require('./hooks')
 const scheduler = require('./scheduler')
 const usageLog = require('./usage')
@@ -93,6 +96,7 @@ function appendText(message, text) {
 
 const STORE = 'aipictury.conversations'
 const LIVE = 'aipictury.live'            // the conversation on screen, and whether it was mid-run
+const DICTATION = 'aipictury.dictation'  // a recording not written yet: { file, at } (voice.js keeps it)
 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',
@@ -100,6 +104,7 @@ const ATTACH_TYPES = ['png', 'jpg', 'jpeg', 'webp', 'gif', 'bmp', 'pdf', 'txt',
 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
+const FLUSH_BUDGET = 4000                // ms the account's last pushes get when VS Code closes (it allows ~5 s)
 
 // 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.
@@ -160,13 +165,17 @@ const REVIEW_PROMPT = 'Review the uncommitted changes in this repository (git st
   + 'Do not change any file.'
 
 class AgentPanel {
-  constructor(context, { kind = 'sidebar', registry } = {}) {
+  constructor(context, { kind = 'sidebar', registry, slot } = {}) {
     this.context = context
     this.kind = kind
+    // Where this panel's unsent attachments are kept across a reload (attachments.js): the side
+    // bar has one; a tab its own, carried in its webview state (postSession).
+    this.slot = kind === 'sidebar' ? 'sidebar' : slot || attachmentShelf.newSlot()
     this.registry = registry
     this.history = []
     this.session = { allowAll: false }
     this.host = null        // the WebviewView or WebviewPanel showing this conversation
+    this.recording = null   // dictation in progress (dictate)
     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
@@ -228,6 +237,7 @@ class AgentPanel {
       usage: this.usage,
     }
     this.store.save(entry)
+    if (this.remote && !this.remote.keptFor) this.savedLinks?.keep(this.id, this.remote).catch(() => {})
     await this.saveCheckpoints()
     if (this.kind === 'tab' && this.host) this.host.title = `AIPictury: ${entry.title.slice(0, 30)}`
     this.postSession()
@@ -281,7 +291,9 @@ class AgentPanel {
     const found = this.store.get(id)
     if (!found) return false
     if (this.abort) { vscode.window.showInformationMessage('Stop the agent before switching conversations.'); return false }
+    this.stopDelivering()                  // the last one's render goes on: delivered when it is opened again
     await this.remember()                  // do not lose the one on screen
+    if (this.remote && this.remote.keptFor !== id) this.letGoOfRemote()   // its link goes with it
     this.id = found.id
     this.created = found.created || found.updated
     this.history = found.history
@@ -295,6 +307,14 @@ class AgentPanel {
     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)
+    // A row the window closed on mid-step said "rendering 40%" for ever: a render with its job id
+    // is followed again below, anything else is said to be cut off (1.20.0).
+    const followed = new Set(this.history.filter((m) => m.pending).map((m) => m.pending.row))
+    for (const t of this.transcript) {
+      if (t.kind === 'tool' && ['running', 'asking'].includes(t.status) && !followed.has(t.key)) {
+        Object.assign(t, { status: 'failed', result: 'cut off: the window was closed or reloaded while this ran' })
+      }
+    }
     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)}`
@@ -302,6 +322,9 @@ class AgentPanel {
     if (this.btw.length) this.post({ type: 'btwThread', items: this.btw })
     this.postSession()
     this.registry?.sessionsView?.refresh()
+    this.deliverPending()
+    this.refreshKeeping().catch(() => {})
+    this.rehostRemote(found.id).catch((error) => log.warn('remote control not hosted again', error))
     if (focus && this.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
     return true
   }
@@ -333,9 +356,11 @@ class AgentPanel {
       clearInterval(poll); clearInterval(ticker); subs.forEach((s) => s.dispose())
       clearInterval(this.gpuWatch); this.gpuWatch = null
       this.abort?.abort()
+      this.delivering?.abort()
       this.recording?.cancel()
-      if (this.remote) this.registry?.account?.cloud?.dropRemote?.(this.remote.id).catch(() => {})
-      this.remote?.stop()
+      // The panel going (closed, or the window reloading) is not "stop sharing": its link is kept
+      // and the same address carries on when the conversation is on screen again (1.20.0).
+      this.letGoOfRemote()
       this.remember().catch(() => {})
       this.registry?.remove(this)
     })
@@ -399,7 +424,7 @@ class AgentPanel {
   }
 
   postSession() {
-    this.post({ type: 'session', id: this.id, title: this.conversationTitle, kind: this.kind })
+    this.post({ type: 'session', id: this.id, title: this.conversationTitle, kind: this.kind, slot: this.slot })
   }
 
   postCommands() {
@@ -415,6 +440,7 @@ class AgentPanel {
         this.postAccount(this.registry?.account?.user?.() ?? null)
         this.refreshStatus(); this.postMode(); this.refreshCache(); this.postCommands(); this.postSession()
         editorTracker.post(this)
+        this.restoreAttachments()
         // 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 })
@@ -585,6 +611,7 @@ class AgentPanel {
   async reset() {
     if (this.remote) await this.remoteControl('stop')        // the link was for the conversation that ends here
     if (this.abort) this.abort.abort()
+    this.stopDelivering()                    // the render goes on: delivered when that one is opened again
     await this.remember()
     if (this.id) this.fireHook('SessionEnd', { reason: 'clear' }).catch(() => {})
     this.startSource = 'clear'
@@ -635,7 +662,7 @@ class AgentPanel {
     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*/, '')))
+      try { say(await memory.addUserRule(serverUrl(), text.replace(/^##\s*/, ''))) } catch (e) { say(e.message) }
       return true
     }
     if (/^#\s*\S/.test(text)) {
@@ -1011,6 +1038,21 @@ class AgentPanel {
     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 })) })
+    // Every change to what is attached comes through here: kept as it now is, so a reload before
+    // Send brings the chips back and the message still carries them (1.20.0).
+    if (this.attachmentsRestored) attachmentShelf.save(workspaceRoot()?.fsPath, this.slot, this.attachments)
+  }
+
+  /** The panel (re)loaded: what was attached and not sent before a reload is back, once — and
+   *  shown again whenever the webview itself reloads (it forgets its chips). */
+  restoreAttachments() {
+    if (!this.attachmentsRestored) {
+      this.attachmentsRestored = true
+      const here = new Set(this.attachments.map((a) => a.id))
+      const kept = attachmentShelf.load(workspaceRoot()?.fsPath, this.slot).filter((a) => !here.has(a.id))
+      this.attachments = [...this.attachments, ...kept].slice(0, MAX_ATTACH)
+    }
+    this.postAttachments()
   }
 
   /** Tells the panel which model is answering, so the user is never guessing. */
@@ -1057,22 +1099,41 @@ class AgentPanel {
 
   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(() => {})
+  /** Where the links shared by remote control are kept across reloads (remote.js). */
+  get savedLinks() {
+    return (this._savedLinks ||= this.context.secrets ? new SavedLinks({ secrets: this.context.secrets, state: this.context.workspaceState }) : null)
+  }
+
+  /** This panel stops hosting its link without ending it: the server keeps the conversation a
+   *  while, the link is kept (SavedLinks) and hosted again with its conversation. */
+  letGoOfRemote() {
+    if (!this.remote) return
+    clearInterval(this.remoteBeat)
+    const link = this.remote
+    this.remote = null
+    if (link.keptFor) this.savedLinks?.keep(link.keptFor, link).catch(() => {})     // hosted until now
+    link.stop({ end: false })
+    this.registry?.account?.cloud?.dropRemote?.(link.id).catch(() => {})   // listed again when hosted again
+    try { this.post({ type: 'remote', on: false }) } catch { /* the panel itself is going */ }
+  }
+
+  /** A conversation on screen again whose link was hosted until a moment ago (a reload, a crash,
+   *  its panel closed): the same link is hosted again, so whoever has it carries on (1.20.0). */
+  async rehostRemote(conversation) {
+    if (this.remote || !conversation) return
+    const saved = await this.savedLinks?.take(conversation).catch(() => null)
+    if (!saved || this.remote || this.id !== conversation) return
+    await this.remoteControl('start', { restored: saved })
   }
 
   /** Remote control: this conversation, carried on from a browser (remote.js). */
-  async remoteControl(action, { asked = false } = {}) {
+  async remoteControl(action, { asked = false, restored = null } = {}) {
     if (action === 'stop') {
       if (!this.remote) { this.say('remote control is not on', 'remote'); return }
+      clearInterval(this.remoteBeat)
       this.remote.stop()
       this.registry?.account?.cloud?.dropRemote?.(this.remote.id).catch(() => {})
+      this.savedLinks?.forget(this.remote.keptFor || this.id).catch(() => {})     // stopped on purpose: gone for good
       this.remote = null
       this.post({ type: 'remote', on: false })
       this.say('remote control ended — the link no longer works', 'remote')
@@ -1084,19 +1145,43 @@ class AgentPanel {
         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 }),
+        id: restored?.id, key: restored?.key,
       }).start()
+      // Kept with its conversation, and its time refreshed while on: a reload or a crash can then
+      // host the same link again (rehostRemote). A conversation with no id yet is kept at its first save.
+      // Its listing with the account is written again on the same beat: one a crash left behind
+      // stops being fresh, and aipictury.com no longer offers it (cloud.remoteLive, 1.20.0).
+      const link = this.remote
+      this.savedLinks?.keep(this.id, link).catch(() => {})
+      this.remoteBeat = setInterval(() => {
+        if (this.remote !== link) return
+        this.savedLinks?.keep(this.id, link).catch(() => {})
+        this.listRemote()
+      }, REMOTE_BEAT)
+    }
+    if (restored) {
+      this.post({ type: 'remote', on: true, viewers: this.remote.viewers, url: this.remote.url })
+      this.listRemote()
+      this.say('remote control is on again — the link from before still works. /remote-control stop ends it.', 'remote')
+      return
     }
     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}`))
+    this.listRemote()
     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')
   }
 
+  /** Listed with the account, so aipictury.com offers to control it (Live in VS Code). */
+  listRemote() {
+    if (!this.remote) return
+    const title = this.title || String(this.history.find((m) => m.role === 'user')?.content || 'A conversation').split('\n')[0]
+    this.remote.listedAt ||= Date.now()
+    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 || '', started: this.remote.listedAt }).catch((e) => log.warn(`remote not listed with the account: ${e.message}`))
+  }
+
   /** 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) {
@@ -1117,12 +1202,59 @@ class AgentPanel {
     if (!rec) return
     this.recording = null
     say('writing')
+    let file
+    try { file = await rec.stop() } catch (error) { say('idle', { error: `Not written: ${error.message}` }); return }
+    await this.writeDictation(file)
+  }
+
+  /** A recording written by the server into the input. Not written (the server away, restarting,
+   *  too slow), it is kept and the user is offered to try again — noted in the workspace, so a
+   *  reload offers it too. It used to be deleted whatever happened, and what was said was lost (1.20.0). */
+  async writeDictation(file) {
+    const say = (state, extra = {}) => {
+      this.post({ type: 'dictation', state, text: extra.text })
+      if (extra.error) this.say(extra.error, 'dictation')
+    }
+    say('writing')
+    await this.context.workspaceState.update(DICTATION, { file, at: Date.now() })
+    let r
     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}` }) }
+      r = await voice.transcribe(serverUrl(), file)
+    } catch (error) {
+      say('idle', { error: `Not written: ${error.message}.${error.file ? ' The recording is kept — try again when the server answers.' : ''}` })
+      if (!error.file) { await this.context.workspaceState.update(DICTATION, undefined); return }
+      // Not awaited: the question waits for the user, the panel does not.
+      this.offerDictation(error.file, error.message).catch((e) => log.warn('dictation not offered again', e))
+      return
+    }
+    await this.context.workspaceState.update(DICTATION, undefined)
+    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.' })
+  }
+
+  /** A recording the server did not write: tried again, or let go — never lost without asking. */
+  async offerDictation(file, why) {
+    const again = 'Try again'
+    const drop = 'Discard'
+    const choice = await vscode.window.showWarningMessage(`AIPictury: your dictation was not written (${why}). It is kept on this machine.`, again, drop)
+    if (choice === again) return this.writeDictation(file)
+    if (choice === drop) {
+      voice.discard(file)
+      await this.context.workspaceState.update(DICTATION, undefined)
+    }
+    // Closed without a choice: kept, and offered again after the next reload.
+  }
+
+  /** After a reload: a recording that was being written, or was not, is offered again (once a day at most old). */
+  async resumeDictation() {
+    const left = this.context.workspaceState.get(DICTATION)
+    if (!left?.file) return
+    if (Date.now() - (left.at || 0) > 24 * 3600_000 || !fs.existsSync(left.file)) {
+      voice.discard(left.file)
+      await this.context.workspaceState.update(DICTATION, undefined)
+      return
+    }
+    await this.offerDictation(left.file, 'the window was reloaded before it was')
   }
 
   /** Queued messages, handed to the running agent at its next step — as Claude Code
@@ -1403,6 +1535,7 @@ class AgentPanel {
       return
     }
     if (action === 'fork' || action === 'fork-code') {
+      this.stopDelivering()                  // followed again below, for the fork
       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),
@@ -1418,6 +1551,7 @@ class AgentPanel {
       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.deliverPending()
       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
@@ -1485,7 +1619,6 @@ class AgentPanel {
       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`)
     })
   }
 
@@ -1527,6 +1660,59 @@ class AgentPanel {
     })
   }
 
+  /** One row per tool call, updated in place as it runs, kept with its output. */
+  toolRow(event) {
+    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 })
+  }
+
+  /** How keeping a render with the account goes (keeping.js), on its card — a render of this
+   *  run, or of an earlier session whose keeping was taken up again after a reload (1.20.0). */
+  keepState(jobId, state) {
+    for (const t of this.transcript) {
+      if (t.kind !== 'tool' || !jobId || t.media?.job !== jobId) continue
+      t.keep = state
+      this.post({ type: 'tool', tool: t.tool, args: t.args, id: t.key, status: 'done', path: t.path, media: t.media, keep: state })
+    }
+  }
+
+  /** Cards of a reopened conversation that said "Compressing for your account" when the window
+   *  went: where their keeping stands now, asked of the account (keeping.js). */
+  async refreshKeeping() {
+    const stale = this.transcript.filter((t) => t.kind === 'tool' && t.media?.job && ['compress', 'upload', 'waiting'].includes(t.keep?.stage))
+    for (const t of stale) {
+      const state = await this.registry?.account?.keptState?.(t.media.job).catch(() => null)
+      this.keepState(t.media.job, state || { stage: 'gone' })
+    }
+  }
+
+  /** A picture or clip the agent asked for was still rendering when the window closed (or the
+   *  run was cut): followed by its job id and written into the workspace now — whether or not
+   *  the run carries on — its row showing how far it is, its result kept for the model (1.20.0). */
+  async deliverPending() {
+    if (this.abort || this.delivering || !serverUrl() || !this.history.some((m) => m.pending)) return
+    const id = this.id
+    const stop = this.delivering = new AbortController()
+    try {
+      const settled = await agent.deliverPending(serverUrl(), this.history, { signal: stop.signal,
+        onTool: (event) => { if (this.id === id) this.toolRow(event) } })
+      if (settled && this.id === id) await this.remember()
+    } catch (error) {
+      log.warn('pending render not delivered', error)
+    } finally { if (this.delivering === stop) this.delivering = null }
+  }
+
+  /** This panel's own delivery stopped (another conversation on screen, a fork, a clear) and
+   *  forgotten at once, so the next one can start without waiting for it to wind down. A run
+   *  waiting on the same render leaves on its own Stop (mediagen.resume, 1.20.0). */
+  stopDelivering() {
+    this.delivering?.abort()
+    this.delivering = null
+  }
+
   markLive(running) {
     if (!this.id || this.kind !== 'sidebar') return
     this.context.workspaceState.update(LIVE, { id: this.id, running, at: Date.now() })
@@ -1572,12 +1758,7 @@ class AgentPanel {
         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 })
+          this.toolRow(event)
           if (event.tasks) this.post({ type: 'tasks', items: event.tasks })
           if (event.status === 'done') {
             this.rememberSoon()
@@ -1603,8 +1784,12 @@ class AgentPanel {
         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() },
+        // Saved at every step, so a crash, a reload or closing VS Code loses nothing; a render's job id
+        // at once (`now`), as it is what delivers the render if the window goes in the next second.
+        onMessages: (messages, { now = false } = {}) => {
+          this.history = messages.map(withoutImages); this.markLive(true)
+          if (now) this.remember().catch(() => {}); else 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 }) => {
@@ -1647,10 +1832,10 @@ class AgentPanel {
         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'))
+      this.ended = { how: stopped ? 'stopped' : result.error ? 'error' : 'done', why: result.error ? String(result.error).split('\n')[0] : undefined }
     } catch (error) {
       stopped = error.name === 'AbortError'
+      this.ended = { how: stopped ? 'stopped' : 'error', why: stopped ? undefined : error.message }
       if (!stopped) log.error('run failed', error)
       this.post({ type: 'end', stopped, error: stopped ? undefined : error.message })
     } finally {
@@ -1693,8 +1878,15 @@ class AgentPanel {
     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.]' }])
+      // Said as it is: every finished step is above and a render still going is delivered before the
+      // next turn (deliverPending), but a call the reload cut mid-way has no result. "Nothing is
+      // lost" had the model take an unfinished step for done, or do it again blindly (1.20.0).
+      const cut = cutCalls(this.history)
+      await this.start([{ role: 'user', content: '[The editor window was reloaded while you were working. Every step '
+        + 'that finished is in the conversation above, with its result.'
+        + (cut.length ? ` The reload cut off ${cut.join(', ')} before it returned: it has no result, and may or may not `
+          + 'have taken effect — check before doing it again.' : '')
+        + ' Continue the task from where you left off.]' }])
     }
   }
 
@@ -1764,6 +1956,14 @@ class AgentPanel {
   }
 }
 
+/** The tool calls of the last step that have no result: what a reload cut off mid-way. */
+function cutCalls(history) {
+  const at = history.findLastIndex((m) => m.role === 'assistant')
+  if (at < 0) return []
+  const answered = history.slice(at + 1).filter((m) => m.role === 'tool').length
+  return (history[at].tool_calls || []).slice(answered).map((c) => c.function?.name).filter(Boolean)
+}
+
 /** Pictures are sent once; the kept conversation notes where they were. */
 function withoutImages(m) {
   if (!m.images) return m
@@ -1819,6 +2019,30 @@ class Registry {
 
   all() { return [this.sidebar, ...this.tabs] }
 
+  /** After a reload or a crash: this machine's listings of this project's shared conversations
+   *  that no panel hosts again are dropped — aipictury.com offered links nobody was at (1.20.0) —
+   *  and any other listing of this machine that its window no longer keeps fresh
+   *  (cloud.remoteLive): a window still hosting it lists it again at its next beat. Another
+   *  machine's listings are its own to drop, and the web's to hide when stale: a window of an
+   *  older version there hosts without a beat, and its live link vanished from aipictury.com
+   *  (1.20.0). The links themselves stay kept: reopening the conversation hosts and lists it again. */
+  async pruneRemote() {
+    const cloud = this.account?.cloud
+    if (!cloud?.listRemote || !this.account.signedIn?.()) return 0
+    const hosted = new Set(this.all().map((p) => p?.remote?.id).filter(Boolean))
+    const store = sessions.storeFor(workspaceRoot()?.fsPath)
+    const here = require('os').hostname().slice(0, 80)
+    let dropped = 0
+    for (const r of await cloud.listRemote()) {
+      if (r.device !== here || hosted.has(r.id)) continue
+      const leftHere = r.conversation && store?.get(r.conversation)
+      if (!leftHere && remoteLive(r)) continue
+      await cloud.dropRemote(r.id).catch(() => {})
+      dropped += 1
+    }
+    return dropped
+  }
+
   /** 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) {
@@ -1841,11 +2065,11 @@ class Registry {
   active() { return this.last?.host ? this.last : this.sidebar }
 
   /** A new conversation in an editor tab — several can run side by side. */
-  openTab(existing) {
+  openTab(existing, { slot } = {}) {
     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 })
+    const panel = new AgentPanel(this.context, { kind: 'tab', registry: this, slot })
     panel.attach(host)
     this.tabs.add(panel)
     this.last = panel
@@ -2325,6 +2549,16 @@ function activate(context) {
     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 })
+  // Remote-control links this window does not host again, unlisted once the panels are back.
+  const pruning = setTimeout(() => registry.pruneRemote().catch((error) => log.warn('remote listings not pruned', error)), 30_000)
+  add({ dispose: () => clearTimeout(pruning) })
+  // Problem reports to send that did not reach the server (feedback.js's outbox): sent once it
+  // answers — a while after the start, then every quarter of an hour (1.20.0).
+  const sendReports = () => feedback.sendWaiting(serverUrl(), dialogs.sendReport)
+    .then((n) => { if (n) log.info(`${n} problem report(s) sent to the server`) }).catch((error) => log.warn('problem reports not sent', error))
+  const reporting = setTimeout(sendReports, 45_000)
+  const reportingAgain = setInterval(sendReports, 15 * 60_000)
+  add({ dispose: () => { clearTimeout(reporting); clearInterval(reportingAgain) } })
   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()))
@@ -2333,12 +2567,13 @@ function activate(context) {
     resolveWebviewView(view) {
       panel.attach(view)
       panel.resumeAfterReload().catch(() => {})
+      panel.resumeDictation().catch((error) => log.warn('dictation not offered again', error))
     },
   }, { 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)
+      const tab = registry.openTab(host, { slot: state?.slot })
       if (state?.id) await tab.open(state.id, { focus: false })
     },
   }))
@@ -2477,12 +2712,16 @@ function activate(context) {
 }
 
 // Anything the agent left running — a dev server, MCP servers — goes when VS Code does,
-// and every conversation on screen is saved first.
+// and every conversation on screen is saved first — then what is still to be pushed to the
+// account is pushed (its saves wait a few seconds to be sent together, and closing dropped
+// them: 1.20.0), within the few seconds VS Code gives an extension to stop.
 async function deactivate() {
   agent.stopBackground()
   mcp.closeAll()
   await require('./browser').close()
   await Promise.all((registry?.all() || []).map((p) => p.remember().catch(() => {})))
+  const cloud = registry?.account?.cloud
+  if (cloud?.flush) await Promise.race([cloud.flush().catch(() => {}), new Promise((r) => setTimeout(r, FLUSH_BUDGET).unref?.())])
 }
 
-module.exports = { syncCommandEnv, moveConversationsToDisk, rewindQuestion, activate, deactivate, undoOldThinkingSwitch, adoptNewDefaultModel, fuzzyScore, toMarkdown, resolveMentions, mentionCandidates, INIT_PROMPT, REVIEW_PROMPT }
+module.exports = { syncCommandEnv, moveConversationsToDisk, rewindQuestion, activate, deactivate, undoOldThinkingSwitch, adoptNewDefaultModel, fuzzyScore, toMarkdown, resolveMentions, mentionCandidates, cutCalls, Registry, INIT_PROMPT, REVIEW_PROMPT }