@davait/aipictury 1.19.5 → 1.20.1

package/ext/mediagen.js

@@ -3,16 +3,20 @@
 // into the workspace — to add one, or to replace one the code already uses. A replaced
 // file keeps its size and format, so whatever references it still fits.
 
+const crypto = require('crypto')
 const vscode = require('vscode')
 const { resolve, root } = require('./tools')
 
 const IMAGE_EXT = new Set(['png', 'jpg', 'jpeg', 'webp', 'gif', 'bmp'])
 const VIDEO_EXT = new Set(['mp4', 'webm', 'mov', 'm4v'])
-/** fn(server, jobId, keep) after a render the agent asked for is done (the account keeps it;
- *  keep(state) shows its progress and figures on the card). */
+/** fn(server, jobId) after a render the agent asked for is done: the account keeps it (keeping.js),
+ *  its card following by the job id in its media. */
 const rendered = new Set()
 function onRendered(fn) { rendered.add(fn); return { dispose: () => rendered.delete(fn) } }
 const STALL = 120_000           // the server repeats its progress every 10s; this is a lost link
+// A render followed by its job id (its stream lost): looked at every `poll` ms; the server silent
+// for `unreachable` ms meanwhile, it is left pending for next time. (A check shortens them.)
+const timing = { poll: 5000, unreachable: 10 * 60_000 }
 
 /** The width and height of a PNG, JPEG, GIF or WebP, read from its header; null if unknown. */
 function imageSize(bytes) {
@@ -94,12 +98,78 @@ async function follow(response, onCard, signal) {
   return last
 }
 
+const pause = (ms, signal) => new Promise((done) => {
+  const stop = () => { clearTimeout(timer); done() }
+  const timer = setTimeout(() => { signal?.removeEventListener('abort', stop); done() }, ms)
+  signal?.addEventListener('abort', stop, { once: true })
+})
+
+/** The render's state read back by its job id, in the stream's shape: queued or running with
+ *  its progress, done with its asset, or an error. */
+async function jobState(server, jobId, signal) {
+  // Stop, or 20 s without an answer, ends this one request (AbortSignal.any is not in every Node 20).
+  const ask = new AbortController()
+  const timer = setTimeout(() => ask.abort(), 20_000)
+  const onStop = () => ask.abort()
+  signal?.addEventListener('abort', onStop, { once: true })
+  let r
+  try {
+    r = await fetch(`${server}/api/jobs/${encodeURIComponent(jobId)}`, { signal: ask.signal })
+  } finally { clearTimeout(timer); signal?.removeEventListener('abort', onStop) }
+  if (r.status === 404) return { status: 'error', error: 'the render is no longer on the server' }
+  if (!r.ok) throw new Error(`the server answered ${r.status}`)
+  const job = await r.json()
+  if (job.status === 'queued' || job.status === 'running') return { status: job.status, progress: job.progress || 0 }
+  if (job.status === 'done') return job.assets?.[0] ? { status: 'done', asset: job.assets[0] } : { status: 'error', error: 'the render finished without a file' }
+  return { status: 'error', error: job.error || `the render ${job.status || 'failed'}` }
+}
+
+/** Follows a render by its job id until it ends — after its stream was lost (a dropped link, the
+ *  45-minute limit of the stream) or after a reload or an exit cut the run (1.20.0): the job goes
+ *  on on the server whatever happens to the editor. A server that does not answer (restarting,
+ *  the Wi-Fi) is waited for; null when stopped. */
+async function settle(server, jobId, onCard, signal) {
+  let silentSince = null
+  while (!signal?.aborted) {
+    let card = null
+    try {
+      card = await jobState(server, jobId, signal)
+      silentSince = null
+    } catch (error) {
+      if (signal?.aborted) break
+      silentSince ??= Date.now()
+      if (Date.now() - silentSince > timing.unreachable) {
+        const lost = new Error(`the server could not be reached to finish the render (${error.message})`)
+        lost.unreachable = true
+        throw lost
+      }
+    }
+    if (card?.status === 'done' || card?.status === 'error') return card
+    if (card) onCard(card)
+    await pause(timing.poll, signal)
+  }
+  return null
+}
+
+/** Stop pressed mid-render: the GPU job is cancelled too. Only the reading of it stopped before,
+ *  and the GPU went on making a picture nobody would collect (1.20.0). */
+async function cancel(server, jobId) {
+  if (!jobId) return false
+  try {
+    const r = await fetch(`${server}/api/jobs/${encodeURIComponent(jobId)}/cancel`, { method: 'POST', signal: AbortSignal.timeout(10_000) })
+    return r.ok
+  } catch { return false }
+}
+
+const progressOf = (update) => Math.round((update.progress || 0) * (update.progress > 1 ? 1 : 100))
+
 /**
  * Makes the picture or clip and writes it into the workspace.
- * `ask(question)` is the approval — true to go ahead. `report(update)` keeps the panel's
- * card current. Returns what to tell the model.
+ * `ask(question, { path })` is the approval — true to go ahead. `report(update)` keeps the
+ * panel's card current. `onJob(pending)`, once the server has queued it: what is needed to
+ * deliver it later by its job id (resume), for the caller to keep. Returns what to tell the model.
  */
-async function generate(server, args, { ask, report, signal }) {
+async function generate(server, args, { ask, report, signal, onJob }) {
   const prompt = String(args.prompt || '').trim()
   if (!prompt) throw new Error('prompt is required: describe the picture or clip in full')
   const { kind, path, format } = target(args)
@@ -120,30 +190,57 @@ async function generate(server, args, { ask, report, signal }) {
   }
 
   const verb = existing ? 'Replace' : 'Create'
-  if (!(await ask(`${verb} ${path} with a generated ${kind}?\n\n${prompt.slice(0, 300)}`))) {
+  if (!(await ask(`${verb} ${path} with a generated ${kind}?\n\n${prompt.slice(0, 300)}`, { path }))) {
     return { refused: true, text: 'the user declined this' }
   }
 
   report({ status: 'running', progress: 0, path })
-  const body = { kind, prompt, aspect: args.aspect || 'landscape', seconds: Number(args.seconds) || 5 }
+  // A seed of its own, sent with the request and kept with the pending call: /api/agent/media
+  // renders with it rather than one of its own from the clock (1.20.0: its request model dropped
+  // the field without a word, so the seed sent did nothing).
+  const seed = crypto.randomInt(1, 2 ** 31 - 1)
+  const body = { kind, prompt, aspect: args.aspect || 'landscape', seconds: Number(args.seconds) || 5, seed }
   if (width && height) Object.assign(body, { width, height })
   if (source) Object.assign(body, { source: Buffer.from(source).toString('base64'), source_name: args.source })
   const response = await fetch(`${server}/api/agent/media`, {
     method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body), signal,
   })
   if (!response.ok) throw new Error(`the server could not start it (${response.status}): ${(await response.text()).slice(0, 200)}`)
-  const card = await follow(response, (update) => {
+  // Its job id, from the first line: kept by the caller at once, so a render cut off by a reload,
+  // an exit or a lost link is delivered later instead of being lost or made a second time (1.20.0).
+  const job = { job: null, seed, path, kind, format, width, height, existing: !!existing, saved: !!args.save_to }
+  const onCard = (update) => {
+    if (update.job_id && !job.job) {
+      job.job = update.job_id
+      try { onJob?.({ ...job }) } catch { /* kept or not, the render goes on */ }
+    }
     if (update.status === 'queued' || update.status === 'running') {
-      report({ status: 'running', progress: Math.round((update.progress || 0) * (update.progress > 1 ? 1 : 100)), path, queued: update.status === 'queued' })
+      report({ status: 'running', progress: progressOf(update), path, queued: update.status === 'queued' })
     }
-  }, signal)
-  if (signal?.aborted) return { stopped: true, text: 'stopped by the user' }
+  }
+  let card = null
+  try {
+    card = await follow(response, onCard, signal)
+  } catch (error) {
+    // Stopped: the job is cancelled below. The stream lost: the job goes on, followed by its id.
+    if (!(signal?.aborted || job.job)) throw error
+  }
+  if (job.job && !signal?.aborted && card?.status !== 'done') card = await settle(server, job.job, onCard, signal)
+  if (signal?.aborted) {
+    const cancelled = await cancel(server, job.job)
+    return { stopped: true, text: cancelled ? 'stopped by the user: the render was cancelled on the server' : 'stopped by the user' }
+  }
   if (!card || card.status !== 'done') throw new Error(card?.error || 'the render ended without a file')
+  return deliver(server, job, card.asset, { report, signal })
+}
 
-  // The file, at the size and in the format the project needs.
+/** A render, finished, written into the workspace: the file at the size and in the format the
+ *  project needs, a preview for the card, the account told. Returns what to tell the model. */
+async function deliver(server, job, asset, { report, signal }) {
+  const { kind, path, format, width, height, existing } = job
   const query = new URLSearchParams({ format })
   if (width && height && kind === 'image') { query.set('width', width); query.set('height', height) }
-  const file = await fetch(`${server}/api/agent/media/${card.asset}?${query}`, { signal })
+  const file = await fetch(`${server}/api/agent/media/${asset}?${query}`, { signal })
   if (!file.ok) throw new Error(`could not fetch the result (${file.status}): ${(await file.text()).slice(0, 200)}`)
   const bytes = new Uint8Array(await file.arrayBuffer())
   await vscode.workspace.fs.createDirectory(vscode.Uri.joinPath(resolve(path), '..'))
@@ -155,20 +252,89 @@ async function generate(server, args, { ask, report, signal }) {
   try {
     const w = 320
     const h = size ? Math.max(16, Math.round(w * size.height / size.width)) : 180
-    const still = await fetch(`${server}/api/agent/media/${card.asset}?format=jpg&width=${w}&height=${h}`, { signal })
+    const still = await fetch(`${server}/api/agent/media/${asset}?format=jpg&width=${w}&height=${h}`, { signal })
     if (still.ok) preview = `data:image/jpeg;base64,${Buffer.from(await still.arrayBuffer()).toString('base64')}`
   } catch { /* the card shows the path without a picture */ }
 
   const described = `${size ? `${size.width}×${size.height} ` : ''}${format.toUpperCase()}, ${Math.round(bytes.length / 1024)} KB`
-  const media = { kind, path, preview, width: size?.width, height: size?.height, bytes: bytes.length }
+  // Its job, so its card can follow its keeping with the account after a reload (keeping.js).
+  const media = { kind, path, preview, width: size?.width, height: size?.height, bytes: bytes.length, job: job.job || undefined }
   report({ status: 'done', path, media })
-  // Kept with the account now (accountUi): its progress, then the figures, on this card.
-  const keep = (state) => report({ status: 'done', path, media, keep: state })
-  for (const fn of rendered) { try { fn(server, card.job_id, keep) } catch { /* the account's own problem */ } }
+  // Kept with the account now (keeping.js): its progress, then the figures, on this card.
+  for (const fn of rendered) { try { fn(server, job.job) } catch { /* the account's own problem */ } }
   return {
     text: `Saved ${path} (${described})${existing ? ', replacing the previous file' : ''}.`
-      + (args.save_to ? '' : ' It was saved under .aipictury/media/ to show the user; move it into the project if it belongs there.'),
+      + (job.saved ? '' : ' It was saved under .aipictury/media/ to show the user; move it into the project if it belongs there.'),
+  }
+}
+
+// Renders being delivered by their job id, so the panel (on reopening) and the run (carrying on)
+// asking for the same one share a single delivery: one follow, one write, every caller told.
+const delivering = new Map()
+
+/**
+ * A render a cut-off run left pending (what onJob gave): followed by its job id to the end and
+ * written where it was asked for. Resolves to what to tell the model — "Saved …", or what went
+ * wrong — or null when stopped or the server is out of reach (it stays pending for next time).
+ *
+ * Each caller's own signal is its own: the delivery shared with the panel was made with the
+ * panel's signal, so Stop in a run waiting on it did nothing until the render ended — up to ten
+ * minutes with the server out of reach (1.20.0). Now a caller that stops leaves at once with
+ * null; the follow itself stops only when the last caller has left.
+ */
+function resume(server, pending, { report = () => {}, signal } = {}) {
+  if (!pending?.job) return Promise.resolve('error: the render was cut off before the server had queued it')
+  if (signal?.aborted) return Promise.resolve(null)
+  let shared = delivering.get(pending.job)
+  if (!shared) {
+    const stop = new AbortController()
+    const callers = new Set()
+    const tell = (update) => { for (const fn of callers) { try { fn(update) } catch { /* one caller's row */ } } }
+    const path = pending.path
+    const running = (async () => {
+      tell({ status: 'running', progress: 0, path })
+      let card
+      try {
+        card = await settle(server, pending.job, (update) => tell({ status: 'running', progress: progressOf(update), path, queued: update.status === 'queued' }), stop.signal)
+      } catch (error) {
+        if (error.unreachable) return null
+        throw error
+      }
+      if (!card) return null
+      if (card.status !== 'done') {
+        tell({ status: 'failed', path, result: card.error })
+        return `error: ${card.error}`
+      }
+      return (await deliver(server, pending, card.asset, { report: tell, signal: stop.signal })).text
+    })().catch((error) => {
+      if (stop.signal.aborted || error.name === 'AbortError') return null
+      tell({ status: 'failed', path, result: error.message })
+      return `error: ${error.message}`
+    }).finally(() => { if (delivering.get(pending.job) === shared) delivering.delete(pending.job) })
+    shared = { running, stop, callers }
+    delivering.set(pending.job, shared)
   }
+  const mine = (update) => report(update)     // a function of its own, even for the same report twice
+  shared.callers.add(mine)
+  const joined = shared
+  return new Promise((resolve) => {
+    const leave = (value) => {
+      signal?.removeEventListener('abort', stopped)
+      joined.callers.delete(mine)
+      resolve(value)
+    }
+    const stopped = () => {
+      leave(null)
+      // The last one gone: nobody waits for it, so it is not followed further — and a later
+      // caller starts a delivery of its own rather than joining this stopping one.
+      if (!joined.callers.size) {
+        if (delivering.get(pending.job) === joined) delivering.delete(pending.job)
+        joined.stop.abort()
+      }
+    }
+    signal?.addEventListener('abort', stopped, { once: true })
+    joined.running.then(leave)
+  })
 }
 
-module.exports = { generate, imageSize, target, root, onRendered }
+module.exports = { generate, resume, imageSize, target, root, onRendered, timing }

package/ext/memory.js

@@ -59,8 +59,13 @@ async function request(server, path, init = {}) {
 }
 
 // Your rules live with your AIPictury account when you are signed in (accountUi.js gives this
-// module the account's list), else on the AIPictury server, as before.
-let accountRules = null              // { active: async () => bool, get: async () => [...], set: async ([...]) }
+// module the account's list), else on the AIPictury server, as before. A rule is added or removed
+// on the account in one step (cloud.addRules / removeRule), never by writing back the list read a
+// moment before: two machines saving a rule at once kept only one of them (1.20.0).
+let accountRules = null              // { active: async () => bool, get: async () => [...], add: async (rule), remove: async (id) }
+// The account keeps 500 at most (firestore.rules): one appended past that is refused with a
+// permission error, and the rule was lost with no word of why (1.20.0) — said before it is tried.
+const MAX_ACCOUNT_RULES = 500
 function useAccountRules(adapter) { accountRules = adapter }
 
 async function userRules(server) {
@@ -70,10 +75,15 @@ async function userRules(server) {
 
 async function addUserRule(server, text) {
   if (await accountRules?.active()) {
+    const clean = String(text).trim()
+    // Refused with a reason, never clipped: what GET /api/memory says as max_chars (1.20.0).
+    if (clean.length > 2000) throw new Error(`not remembered: a rule is at most 2,000 characters and this one is ${clean.length.toLocaleString('en')}`)
     const rules = await accountRules.get()
-    const clean = String(text).trim().slice(0, 2000)
-    if (!rules.some((r) => r.text === clean)) rules.push({ id: `r${Date.now().toString(36)}`, text: clean, created: Date.now() })
-    await accountRules.set(rules)
+    if (rules.some((r) => r.text === clean)) return 'remembered for you, in every project — kept with your AIPictury account'
+    if (rules.length >= MAX_ACCOUNT_RULES) {
+      throw new Error(`not remembered: your account keeps ${MAX_ACCOUNT_RULES} rules at most and has ${rules.length} — remove one (/memory) and add it again`)
+    }
+    await accountRules.add({ id: `r${Date.now().toString(36)}`, text: clean, created: Date.now() })
     return 'remembered for you, in every project — kept with your AIPictury account'
   }
   await request(server, '/api/memory', {
@@ -84,7 +94,7 @@ async function addUserRule(server, text) {
 
 async function deleteUserRule(server, id) {
   if (await accountRules?.active()) {
-    await accountRules.set((await accountRules.get()).filter((r) => String(r.id) !== String(id)))
+    await accountRules.remove(id)
     return
   }
   await request(server, `/api/memory/${encodeURIComponent(id)}`, { method: 'DELETE' })
@@ -114,4 +124,4 @@ async function block(server) {
 }
 
 module.exports = { PROJECT_FILE, projectUri, projectRules, addProjectRule, removeProjectRule,
-  userRules, addUserRule, deleteUserRule, block, useAccountRules, onProjectRules }
+  userRules, addUserRule, deleteUserRule, block, useAccountRules, onProjectRules, MAX_ACCOUNT_RULES }

package/ext/package.json

@@ -2,7 +2,7 @@
   "name": "aipictury",
   "displayName": "AIPictury",
   "description": "A coding agent and a generation studio running on your own GPU, with uncensored local models.",
-  "version": "1.19.5",
+  "version": "1.20.1",
   "publisher": "aipictury",
   "license": "SEE LICENSE IN LICENSE.md",
   "engines": {

package/ext/plans.js

@@ -12,7 +12,10 @@ const { home, projectKey } = require('./sessions')
 const MODES = [
   { id: 'edits', label: 'Approve — and edit automatically', detail: 'File changes go ahead; commands are asked' },
   { id: 'ask', label: 'Approve — and ask before each change', detail: 'Manual mode' },
-  { id: 'never', label: 'Approve — in Auto mode', detail: 'Routine work goes ahead; anything risky is asked' },
+  // Said as Auto works since 1.10.4: it asks nothing (only your own ask rules and hooks do), and
+  // what would have been asked is listed at the end. "Anything risky is asked" promised a question
+  // Auto never stops for (1.20.0).
+  { id: 'never', label: 'Approve — in Auto mode', detail: 'Asks nothing: what would have been asked goes ahead and is listed at the end' },
 ]
 
 function planFile(folder, id) {

package/ext/remote.js

@@ -17,6 +17,7 @@ const TEXT_CAP = 8000                  // characters of one entry
 const LIVE_CAP = 20_000
 const DEBOUNCE = 150
 const RETRY = [1000, 2000, 5000, 10_000, 30_000]
+const KEEP = 10 * 60_000               // as long as the server waits for its editor (remote.py KEEP)
 
 const cut = (text, n) => { const t = String(text ?? ''); return t.length > n ? `${t.slice(0, n)}…` : t }
 
@@ -26,13 +27,16 @@ function toolLabel(t) {
   return cut(a.command || a.path || a.url || a.pattern || a.query || a.description || a.title || a.action || '', 160)
 }
 
-/** What an approval asks, for the remote view: kind, the command or file, why. */
+/** What an approval asks, for the remote view: kind, the command or file, why — and the question
+ *  as the editor words it, which every client can show when it does not know the kind: a render
+ *  (kind 'media') read "Use generate_media?" on aipictury.com, with no file and no prompt (1.20.0). */
 function approvalOf(id, request = {}) {
   return {
     id, kind: request.kind,
     tool: request.tool, command: cut(request.command, 2000), path: request.path, site: request.site,
     because: request.because, description: request.description,
-    args: request.kind === 'tool' || request.kind === 'mcp' ? cut(JSON.stringify(request.args || {}), 1200) : undefined,
+    question: request.question ? cut(request.question, 1200) : undefined,
+    args: ['tool', 'mcp', 'media'].includes(request.kind) ? cut(JSON.stringify(request.args || {}), 1200) : undefined,
     // An edit as a diff: each changed part, its removed lines (-) and added ones (+), from line n.
     diff: request.kind === 'edit' ? cut((request.hunks || []).map((h) => [`@@ line ${h.line}`, ...h.removed.map((l) => `- ${l}`),
       ...h.added.map((l) => `+ ${l}`)].join('\n')).join('\n') || request.after, 6000) : undefined,
@@ -56,18 +60,21 @@ function snapshot(panel, live) {
     question: panel.pendingAsk ? { id: panel.pendingAsk.id, questions: panel.pendingAsk.questions } : null,
     plan: panel.pendingPlan ? { id: panel.pendingPlan.id, plan: cut(panel.pendingPlan.plan, 20_000) } : null,
     queue: (panel.queue || []).map((q) => cut(q.text, 400)),
+    // How the last run ended: the relay tells the account's devices (remote.py), knowing a stop from a finish.
+    ended: panel.ended || undefined,
   }
 }
 
 class RemoteLink {
-  /** `panel`: the AgentPanel; `server`: its http(s) address. */
-  constructor(panel, server, { log = () => {}, onViewers = () => {}, webApp = 'https://aipictury.com', token = async () => null } = {}) {
+  /** `panel`: the AgentPanel; `server`: its http(s) address. `id` and `key`: a link kept from
+   *  before a reload (SavedLinks), hosted again so the same address carries on. */
+  constructor(panel, server, { log = () => {}, onViewers = () => {}, webApp = 'https://aipictury.com', token = async () => null, id = null, key = null } = {}) {
     this.webApp = webApp
     this.token = token                  // the account's ID token: the server may ask for it
     this.panel = panel
     this.server = server.replace(/\/+$/, '')
-    this.id = crypto.randomUUID()
-    this.key = crypto.randomBytes(24).toString('base64url')
+    this.id = id || crypto.randomUUID()
+    this.key = key || crypto.randomBytes(24).toString('base64url')
     this.log = log
     this.onViewers = onViewers
     this.live = ''
@@ -106,7 +113,7 @@ class RemoteLink {
     this.ws = ws
     const opened = Date.now()
     logs.event('debug', 'ws.connecting', { path: '/ws/remote/host', attempt: this.tries + 1, signedIn: Boolean(token) })
-    ws.onopen = () => { logs.event('debug', 'ws.open', { path: '/ws/remote/host', ms: Date.now() - opened }); ws.send(JSON.stringify({ type: 'hello', id: this.id, key: this.key })) }
+    ws.onopen = () => { logs.event('debug', 'ws.open', { path: '/ws/remote/host', ms: Date.now() - opened }); ws.send(JSON.stringify({ type: 'hello', id: this.id, key: this.key, notify: 'server', server: this.server })) }
     ws.onmessage = (event) => {
       let msg
       try { msg = JSON.parse(String(event.data)) } catch { logs.event('debug', 'ws.message', { path: '/ws/remote/host', unreadable: true }); return }
@@ -117,8 +124,10 @@ class RemoteLink {
     }
     ws.onclose = (event) => {
       this.connected = false
-      const refused = event.code === 4403 || event.code === 4409
+      // 4401: not signed in, or an account this server does not let in: trying again changes nothing.
+      const refused = event.code === 4401 || event.code === 4403 || event.code === 4409
       logs.event(refused ? 'warn' : 'debug', 'ws.close', { path: '/ws/remote/host', code: event.code, reason: event.reason || undefined, seconds: Math.round((Date.now() - opened) / 1000), retrying: this.active && !refused })
+      if (refused && this.active) this.log?.(`remote control refused: ${event.reason || 'sign in, or check that this server lets your account in'}`)
       if (!this.active || refused) return
       const wait = RETRY[Math.min(this.tries, RETRY.length - 1)]
       this.tries += 1
@@ -162,15 +171,66 @@ class RemoteLink {
     this.schedule()
   }
 
-  /** Ends the sharing: the link stops working for everyone. */
-  stop() {
+  /** Ends the sharing: the link stops working for everyone. With `end: false` only this editor
+   *  lets go (its panel closed, the window reloading): the server keeps the conversation for
+   *  KEEP, and the same link carries on once it is hosted again. */
+  stop({ end = true } = {}) {
     this.active = false
     clearTimeout(this.retry)
     clearTimeout(this.pending)
     this.restorePost?.()
-    try { if (this.ws?.readyState === 1) this.ws.send(JSON.stringify({ type: 'end' })) } catch { /* closing anyway */ }
+    try { if (end && this.ws?.readyState === 1) this.ws.send(JSON.stringify({ type: 'end' })) } catch { /* closing anyway */ }
     setTimeout(() => { try { this.ws?.close() } catch { /* gone */ } }, 200)
   }
 }
 
-module.exports = { RemoteLink, snapshot, approvalOf }
+/**
+ * The links of conversations shared by remote control, kept so a reload or a crash no longer ends
+ * them for good — the id and key were never stored, and a restarted editor could not host the same
+ * link again (1.20.0). The id and key go in the secret store (`secrets`: VS Code's), when each was
+ * last hosted in `state` (the workspace's). A link hosted within KEEP is hosted again when its
+ * conversation is on screen; an older one is forgotten, so an old link never wakes days later.
+ */
+class SavedLinks {
+  constructor({ secrets, state, now = () => Date.now() }) {
+    this.secrets = secrets
+    this.state = state
+    this.now = now
+  }
+
+  static secretName(conversation) { return `aipictury.remote.${conversation}` }
+
+  seen() { return { ...(this.state.get('aipictury.remote') || {}) } }
+
+  /** Hosting `link` for `conversation`: kept, and its time refreshed (called now and then while on). */
+  async keep(conversation, link) {
+    if (!conversation || !link) return
+    if (link.keptFor !== conversation) {
+      await this.secrets.store(SavedLinks.secretName(conversation), JSON.stringify({ id: link.id, key: link.key }))
+      link.keptFor = conversation
+    }
+    await this.state.update('aipictury.remote', { ...this.seen(), [conversation]: this.now() })
+  }
+
+  /** The link to host again for `conversation` ({ id, key }), or null: none, or hosted too long ago. */
+  async take(conversation) {
+    const at = this.seen()[conversation]
+    if (!at) return null
+    if (this.now() - at > KEEP) { await this.forget(conversation); return null }
+    try {
+      const saved = JSON.parse(await this.secrets.get(SavedLinks.secretName(conversation)) || 'null')
+      return saved?.id && saved?.key ? saved : null
+    } catch { return null }
+  }
+
+  /** Sharing stopped on purpose: the link is gone for good. */
+  async forget(conversation) {
+    if (!conversation) return
+    const seen = this.seen()
+    delete seen[conversation]
+    await this.state.update('aipictury.remote', seen)
+    await this.secrets.delete(SavedLinks.secretName(conversation))
+  }
+}
+
+module.exports = { RemoteLink, SavedLinks, snapshot, approvalOf, KEEP }

package/ext/voice.js

@@ -119,17 +119,68 @@ class Recording {
   discard() { try { fs.rmSync(this.file, { force: true }) } catch { /* gone */ } }
 }
 
-/** The server writes it: { text, language, duration, seconds }. The file is removed after. */
-async function transcribe(server, file, { language = '', signal } = {}) {
+// Writing a recording waits this long for the server (a 5-minute recording takes Whisper well
+// under a minute; a server that never answers no longer keeps "writing…" on for ever), and a
+// failure that may clear — no answer, a restart (5xx), a busy GPU (423, 429) — is tried again
+// after each of these pauses before it is said (1.20.0).
+const TRANSCRIBE_TIMEOUT = 180_000
+const RETRY_WAITS = [2000, 6000]
+
+const pause = (ms, signal) => new Promise((done) => {
+  const stop = () => { clearTimeout(timer); done() }
+  const timer = setTimeout(() => { signal?.removeEventListener('abort', stop); done() }, ms)
+  signal?.addEventListener('abort', stop, { once: true })
+})
+
+/** One try: the server's answer, or an error that says whether trying again may help (`transient`). */
+async function transcribeOnce(server, file, { language, signal, timeoutMs, fetchImpl }) {
+  const form = new FormData()
+  form.append('audio', new Blob([fs.readFileSync(file)], { type: 'audio/wav' }), 'dictation.wav')
+  if (language) form.append('language', language)
+  // Stop, or no answer within timeoutMs, ends this try (AbortSignal.any is not in every Node 20).
+  const ask = new AbortController()
+  const timer = setTimeout(() => ask.abort(), timeoutMs)
+  const onStop = () => ask.abort()
+  signal?.addEventListener('abort', onStop, { once: true })
+  let response
   try {
-    const form = new FormData()
-    form.append('audio', new Blob([fs.readFileSync(file)], { type: 'audio/wav' }), 'dictation.wav')
-    if (language) form.append('language', language)
-    const response = await fetch(`${server}/api/transcribe`, { method: 'POST', body: form, signal })
-    const data = await response.json().catch(() => ({}))
-    if (!response.ok) throw new Error(data.detail || `the server answered ${response.status}${response.status === 404 ? ' — it is older than dictation; update it' : ''}`)
-    return data
-  } finally { fs.rmSync(file, { force: true }) }
+    response = await fetchImpl(`${server}/api/transcribe`, { method: 'POST', body: form, signal: ask.signal })
+  } catch (error) {
+    if (signal?.aborted) throw error
+    throw Object.assign(new Error(ask.signal.aborted ? `the server did not answer in ${Math.round(timeoutMs / 1000)} s`
+      : `the server could not be reached (${error.cause?.code || error.message})`), { transient: true })
+  } finally { clearTimeout(timer); signal?.removeEventListener('abort', onStop) }
+  const data = await response.json().catch(() => ({}))
+  if (!response.ok) {
+    throw Object.assign(new Error(data.detail || `the server answered ${response.status}${response.status === 404 ? ' — it is older than dictation; update it' : ''}`),
+      { status: response.status, transient: response.status >= 500 || [408, 423, 429].includes(response.status) })
+  }
+  return data
+}
+
+/**
+ * The server writes it: { text, language, duration, seconds }. The recording is removed once it
+ * is written, and only then: a failure leaves it where it is — the error carries it (`file`) — to
+ * be written again. It was removed whatever happened, so a server restarting or out of reach lost
+ * what was said, with no way to try again (1.20.0).
+ */
+async function transcribe(server, file, { language = '', signal, timeoutMs = TRANSCRIBE_TIMEOUT, waits = RETRY_WAITS, fetchImpl = fetch } = {}) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      const data = await transcribeOnce(server, file, { language, signal, timeoutMs, fetchImpl })
+      fs.rmSync(file, { force: true })
+      return data
+    } catch (error) {
+      if (signal?.aborted || !error.transient || attempt >= waits.length) {
+        error.file = fs.existsSync(file) ? file : null
+        throw error
+      }
+      await pause(waits[attempt], signal)
+    }
+  }
 }
 
-module.exports = { recorder, Recording, transcribe, missing, which, soundBytes, MAX_SECONDS }
+/** A recording that was not written, given up on: removed. */
+function discard(file) { try { if (file) fs.rmSync(file, { force: true }) } catch { /* gone */ } }
+
+module.exports = { recorder, Recording, transcribe, discard, missing, which, soundBytes, MAX_SECONDS, TRANSCRIBE_TIMEOUT, RETRY_WAITS }

package/ext/workbench.js

@@ -139,16 +139,23 @@ function uriHandler(registry) {
 
 // ---- telling the user, when VS Code is not in front ----
 
-/** A system notification — only when VS Code is not the focused window, and `notifications` is on. */
+/** A system notification — only when VS Code is not the focused window, and `notifications` is on.
+ *  In the terminal (cli/) the same notification, and the terminal's bell beside it. */
 function notify(title, body) {
-  if (!config().get('notifications', true) || vscode.window.state.focused) return false
   const text = String(body || '').slice(0, 200)
   try {
+    // Inside the try, and asked with ?.: 1.20.0 — the CLI's stand-in had no window.state, and
+    // the TypeError here ended the agent's run.
+    if (!config().get('notifications', true) || vscode.window.state?.focused) return false
+    if (vscode.cli && process.stderr.isTTY) process.stderr.write('\x07')
     if (process.platform === 'darwin') {
       const esc = (s) => String(s).replace(/\\/g, '\\\\').replace(/"/g, '\\"')
       execFile('osascript', ['-e', `display notification "${esc(text)}" with title "${esc(title)}"`], { timeout: 5000 }, () => {})
     } else if (process.platform === 'linux') {
       execFile('notify-send', [title, text], { timeout: 5000 }, () => {})
+    } else if (vscode.cli) {
+      // No system notification to send from a terminal here: the bell is it, if there is one.
+      return !!process.stderr.isTTY
     } else {
       vscode.window.showInformationMessage(`${title}: ${text}`)
     }