@davait/aipictury 1.9.2

package/ext/sessions.js

@@ -0,0 +1,228 @@
+'use strict'
+// Conversations kept on disk, one file each, per project:
+//
+//   ~/.aipictury/projects/<project>/index.json          what the lists show (no history)
+//   ~/.aipictury/projects/<project>/groups.json         named groups of conversations
+//   ~/.aipictury/projects/<project>/sessions/<id>.json  the whole conversation
+//   ~/.aipictury/projects/<project>/sessions/<id>.checkpoints.json
+//
+// Not VS Code's workspace state: every window of the same folder — and the `aipictury` CLI —
+// sees the same conversations, and a change in one reaches the others through a watch.
+// AIPICTURY_HOME moves the whole tree (the tests use a scratch one).
+const fs = require('fs')
+const os = require('os')
+const path = require('path')
+const crypto = require('crypto')
+
+const home = () => process.env.AIPICTURY_HOME || path.join(os.homedir(), '.aipictury')
+
+/** A folder's own directory name: readable, and unique per path. */
+function projectKey(folder) {
+  const base = path.basename(folder || 'no-folder').replace(/[^\w.-]+/g, '-').slice(0, 40) || 'root'
+  const hash = crypto.createHash('sha1').update(path.resolve(folder || '/')).digest('hex').slice(0, 10)
+  return `${base}-${hash}`
+}
+
+/** Written whole or not at all: a reader never sees half a file. */
+function writeAtomic(file, text) {
+  fs.mkdirSync(path.dirname(file), { recursive: true })
+  const tmp = `${file}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`
+  fs.writeFileSync(tmp, text)
+  fs.renameSync(tmp, file)
+}
+
+function readJson(file, fallback) {
+  try { return JSON.parse(fs.readFileSync(file, 'utf8')) } catch { return fallback }
+}
+
+// What the lists keep of a conversation; everything else is only in its own file.
+const META = ['id', 'title', 'renamed', 'created', 'updated', 'server', 'model', 'status', 'group',
+  'archived', 'unread', 'mode', 'questions']
+
+// Who hears of every change to a conversation (the cloud copy): { type: 'save' | 'patch' |
+// 'remove', folder, id, entry? }. One place, so every path — the panel, the Sessions view, the
+// CLI — keeps the copy in step.
+const writeListeners = new Set()
+function onWrite(fn) { writeListeners.add(fn); return { dispose: () => writeListeners.delete(fn) } }
+function told(event) { for (const fn of writeListeners) { try { fn(event) } catch { /* a listener's own problem */ } } }
+
+class SessionStore {
+  constructor(folder) {
+    this.folder = folder
+    this.dir = path.join(home(), 'projects', projectKey(folder))
+    this.sessions = path.join(this.dir, 'sessions')
+    this.indexFile = path.join(this.dir, 'index.json')
+    this.groupsFile = path.join(this.dir, 'groups.json')
+    this.listeners = new Set()
+    this.watcher = null
+  }
+
+  // ---- the list ----
+
+  /** Every conversation's summary, newest first. */
+  list() {
+    const index = readJson(this.indexFile, [])
+    return (Array.isArray(index) ? index : []).sort((a, b) => (b.updated || 0) - (a.updated || 0))
+  }
+
+  writeIndex(entries) {
+    writeAtomic(this.indexFile, JSON.stringify(entries, null, 1))
+    this.changed()
+  }
+
+  /** One conversation whole, with what the list knows of it on top (a rename, a group). */
+  get(id) {
+    const entry = readJson(this.file(id), null)
+    if (!entry) return null
+    const meta = this.list().find((m) => m.id === id) || {}
+    return { ...entry, ...pick(meta, META) }
+  }
+
+  file(id) { return path.join(this.sessions, `${String(id).replace(/[^\w-]/g, '')}.json`) }
+  checkpointsFile(id) { return path.join(this.sessions, `${String(id).replace(/[^\w-]/g, '')}.checkpoints.json`) }
+
+  /** Saves a conversation. What only the lists set — its group, archived, unread — is kept. */
+  save(entry) {
+    if (Array.isArray(entry.history)) entry = { ...entry, questions: entry.history.filter((m) => m.role === 'user').length }
+    writeAtomic(this.file(entry.id), JSON.stringify(entry))
+    const index = this.list()
+    const old = index.find((m) => m.id === entry.id) || {}
+    const meta = { ...old, ...pick(entry, META) }
+    for (const key of ['group', 'archived', 'unread']) if (old[key] !== undefined && entry[key] === undefined) meta[key] = old[key]
+    this.writeIndex([meta, ...index.filter((m) => m.id !== entry.id)])
+    told({ type: 'save', folder: this.folder, id: entry.id, entry: { ...entry, group: meta.group, archived: meta.archived } })
+  }
+
+  /** Changes what the lists show of a conversation: title, group, archived, unread, status. */
+  patch(id, fields) {
+    const index = this.list()
+    const at = index.findIndex((m) => m.id === id)
+    if (at < 0) return false
+    index[at] = { ...index[at], ...fields }
+    for (const [key, value] of Object.entries(fields)) if (value === undefined) delete index[at][key]
+    this.writeIndex(index)
+    if ('title' in fields || 'renamed' in fields) {
+      const entry = readJson(this.file(id), null)
+      if (entry) writeAtomic(this.file(id), JSON.stringify({ ...entry, title: index[at].title, renamed: index[at].renamed }))
+    }
+    // What the cloud keeps of a conversation's summary: its title, group, archived.
+    if (['title', 'renamed', 'group', 'archived'].some((k) => k in fields)) {
+      const entry = readJson(this.file(id), null)
+      if (entry) told({ type: 'patch', folder: this.folder, id, entry: { ...entry, title: index[at].title, renamed: index[at].renamed, group: index[at].group, archived: index[at].archived } })
+    }
+    return true
+  }
+
+  remove(id) {
+    for (const f of [this.file(id), this.checkpointsFile(id)]) { try { fs.unlinkSync(f) } catch { /* gone */ } }
+    this.writeIndex(this.list().filter((m) => m.id !== id))
+    told({ type: 'remove', folder: this.folder, id })
+  }
+
+  // ---- checkpoints ----
+
+  saveCheckpoints(id, checkpoints) {
+    try { writeAtomic(this.checkpointsFile(id), JSON.stringify(checkpoints)) } catch { /* a convenience */ }
+  }
+
+  loadCheckpoints(id) { return readJson(this.checkpointsFile(id), []) }
+
+  // ---- groups ----
+
+  groups() { return readJson(this.groupsFile, []) }
+
+  createGroup(name) {
+    const clean = String(name || '').trim().slice(0, 60)
+    if (!clean) throw new Error('a group needs a name')
+    const groups = this.groups()
+    const found = groups.find((g) => g.name.toLowerCase() === clean.toLowerCase())
+    if (found) return found
+    const group = { id: `g${Date.now().toString(36)}${crypto.randomBytes(2).toString('hex')}`, name: clean }
+    writeAtomic(this.groupsFile, JSON.stringify([...groups, group], null, 1))
+    this.changed()
+    return group
+  }
+
+  renameGroup(id, name) {
+    const clean = String(name || '').trim().slice(0, 60)
+    if (!clean) throw new Error('a group needs a name')
+    writeAtomic(this.groupsFile, JSON.stringify(this.groups().map((g) => (g.id === id ? { ...g, name: clean } : g)), null, 1))
+    this.changed()
+  }
+
+  /** Deleting a group only ungroups its conversations. */
+  deleteGroup(id) {
+    writeAtomic(this.groupsFile, JSON.stringify(this.groups().filter((g) => g.id !== id), null, 1))
+    const index = this.list()
+    for (const m of index) if (m.group === id) delete m.group
+    this.writeIndex(index)
+  }
+
+  // ---- archive ----
+
+  /** Archives what has had no activity for `days`, unless it is open, unread or grouped. */
+  archiveInactive(days, { open = new Set(), now = Date.now() } = {}) {
+    if (!days) return 0
+    const index = this.list()
+    let count = 0
+    for (const m of index) {
+      if (m.archived || m.unread || m.group || open.has(m.id)) continue
+      if (now - (m.updated || m.created || now) > days * 86_400_000) { m.archived = true; count += 1 }
+    }
+    if (count) this.writeIndex(index)
+    return count
+  }
+
+  // ---- moving in from VS Code's workspace state (the store before 1.7) ----
+
+  /** Copies conversations kept the old way; those already on disk are left as they are. */
+  migrate(entries, oldCheckpointsDir) {
+    if (!Array.isArray(entries) || !entries.length) return 0
+    const have = new Set(this.list().map((m) => m.id))
+    let moved = 0
+    for (const entry of [...entries].reverse()) {
+      if (!entry?.id || have.has(entry.id)) continue
+      this.save(entry)
+      if (oldCheckpointsDir) {
+        const old = readJson(path.join(oldCheckpointsDir, `${entry.id}.json`), null)
+        if (old) this.saveCheckpoints(entry.id, old)
+      }
+      moved += 1
+    }
+    return moved
+  }
+
+  // ---- changes from other windows ----
+
+  onChange(listener) {
+    this.listeners.add(listener)
+    if (!this.watcher) {
+      fs.mkdirSync(this.dir, { recursive: true })
+      let timer
+      try {
+        this.watcher = fs.watch(this.dir, () => { clearTimeout(timer); timer = setTimeout(() => this.emit(), 150) })
+      } catch { /* no watching on this system: each window still sees its own changes */ }
+    }
+    return { dispose: () => this.listeners.delete(listener) }
+  }
+
+  changed() { this.emit() }
+  emit() { for (const l of this.listeners) { try { l() } catch { /* a listener's own problem */ } } }
+  dispose() { this.watcher?.close(); this.watcher = null; this.listeners.clear() }
+}
+
+function pick(object, keys) {
+  const out = {}
+  for (const k of keys) if (object[k] !== undefined) out[k] = object[k]
+  return out
+}
+
+const stores = new Map()
+/** The store of a folder (one per folder, shared by every panel of this window). */
+function storeFor(folder) {
+  const key = `${home()}::${path.resolve(folder || '/')}`
+  if (!stores.has(key)) stores.set(key, new SessionStore(folder))
+  return stores.get(key)
+}
+
+module.exports = { SessionStore, storeFor, projectKey, home, onWrite }

package/ext/sessionsView.js

@@ -0,0 +1,449 @@
+'use strict'
+// The Sessions view in the Activity Bar: every conversation of this project, in its groups,
+// with what it is doing — needs you, working, finished, unread — live. Filters and a search
+// (which lists everything flat), archive, and the web app's chats, which can be carried on
+// here. The list is the store on disk, so every window shows the same one.
+const vscode = require('vscode')
+const workbench = require('./workbench')
+const log = require('./log')
+
+const FILTER_KEY = 'aipictury.sessionsFilter'
+const STATUSES = [
+  { id: 'waiting', label: 'Needs input', icon: 'bell-dot', color: 'list.warningForeground' },
+  { id: 'working', label: 'Working', icon: 'sync~spin' },
+  { id: 'unread', label: 'Unread', icon: 'circle-filled', color: 'notificationsInfoIcon.foreground' },
+  { id: 'done', label: 'Completed', icon: 'pass' },
+]
+const STATUS = Object.fromEntries(STATUSES.map((s) => [s.id, s]))
+
+/** What a conversation is doing: from its open panel when there is one, else from the store. */
+function statusOf(meta, panel) {
+  if (panel) {
+    if (panel.pendingAsk || panel.approvals?.size || panel.pendingPlan) return 'waiting'
+    if (panel.abort) return 'working'
+  }
+  return meta.unread ? 'unread' : 'done'
+}
+
+function ago(when) {
+  const s = Math.max(0, Math.round((Date.now() - (when || 0)) / 1000))
+  if (s < 60) return 'just now'
+  if (s < 3600) return `${Math.round(s / 60)} min ago`
+  if (s < 86400) return `${Math.round(s / 3600)} h ago`
+  return `${Math.round(s / 86400)} d ago`
+}
+
+class SessionsView {
+  /** registry: the open panels; store(): this workspace's conversations; server(): its URL. */
+  constructor(context, { registry, store, server, fetchImpl = fetch }) {
+    this.context = context
+    this.registry = registry
+    this.store = store
+    this.server = server
+    this.fetch = fetchImpl
+    this.changed = new vscode.EventEmitter()
+    this.onDidChangeTreeData = this.changed.event
+    this.webChats = null         // loaded when the Web section is opened
+    this.cloud = null            // the account's copy (accountUi.js), when signed in
+    this.timer = null
+  }
+
+  get filter() {
+    return { active: false, statuses: [], search: '', ...(this.context.workspaceState.get(FILTER_KEY) || {}) }
+  }
+
+  async setFilter(change) {
+    await this.context.workspaceState.update(FILTER_KEY, { ...this.filter, ...change })
+    this.describe()
+    this.refresh()
+  }
+
+  /** Says in the view what narrows it, so an empty list is never a mystery. */
+  describe() {
+    if (!this.view) return
+    const f = this.filter
+    const parts = [f.search && `matching “${f.search}”`, f.active && 'open only',
+      f.statuses.length && f.statuses.map((s) => STATUS[s]?.label).join(', ')].filter(Boolean)
+    this.view.message = parts.length ? `Showing ${parts.join(' · ')}` : undefined
+    vscode.commands.executeCommand('setContext', 'aipictury.sessionsFiltered', parts.length > 0)
+  }
+
+  /** Redraws soon — many changes in a row are one redraw. */
+  refresh() {
+    clearTimeout(this.timer)
+    this.timer = setTimeout(() => this.changed.fire(), 80)
+  }
+
+  /** The panel holding a conversation, if any — shown or not: what it is doing comes from it. */
+  livePanel(id) { return this.registry.all().find((p) => p.id === id) }
+
+  sessions() {
+    const f = this.filter
+    const needle = f.search.trim().toLowerCase()
+    return this.store().list().map((meta) => ({ meta, panel: this.livePanel(meta.id) }))
+      .map((s) => ({ ...s, status: statusOf(s.meta, s.panel) }))
+      .filter((s) => !needle || `${s.meta.title} ${s.meta.model || ''}`.toLowerCase().includes(needle))
+      .filter((s) => !f.active || s.panel?.host)
+      .filter((s) => !f.statuses.length || f.statuses.includes(s.status))
+  }
+
+  getChildren(node) {
+    const store = this.store()
+    if (!node) {
+      const all = this.sessions()
+      // A search lists every match flat, archived ones too: it is how one is found again.
+      if (this.filter.search.trim()) return all.map((s) => ({ kind: 'session', ...s }))
+      const groups = store.groups()
+      const live = all.filter((s) => !s.meta.archived)
+      const out = groups.map((g) => ({ kind: 'group', group: g, items: live.filter((s) => s.meta.group === g.id) }))
+      out.push(...live.filter((s) => !s.meta.group || !groups.some((g) => g.id === s.meta.group)).map((s) => ({ kind: 'session', ...s })))
+      const archived = all.filter((s) => s.meta.archived)
+      if (archived.length) out.push({ kind: 'archived', items: archived })
+      if (this.cloud) out.push({ kind: 'cloud' })
+      out.push({ kind: 'web' })
+      return out
+    }
+    if (node.kind === 'group' || node.kind === 'archived') return node.items.map((s) => ({ kind: 'session', ...s }))
+    if (node.kind === 'web') return this.loadWeb()
+    if (node.kind === 'cloud') return this.loadCloud()
+    return []
+  }
+
+  /** Signed in: the account's copy; signed out (null): the group and its list go. */
+  setCloud(cloud) {
+    this.cloud = cloud
+    this.webChats = null                 // the last account's list goes with it
+    this.refresh()
+  }
+
+  /** This project's conversations kept with the account but not on this machine. */
+  async loadCloud() {
+    const cloud = this.cloud
+    const folder = this.store().folder
+    if (!cloud || !folder) return []
+    try {
+      const local = new Set(this.store().list().map((m) => m.id))
+      const remote = (await cloud.listConversations(folder)).filter((c) => !local.has(c.id))
+      if (this.cloud !== cloud) return []                  // signed out meanwhile: nothing shown
+      if (!remote.length) return [{ kind: 'note', label: 'Nothing here that is not on this machine' }]
+      return remote.map((c) => ({ kind: 'cloudChat', chat: c }))
+    } catch (error) {
+      return [{ kind: 'note', label: `Your account cannot be reached (${error.message})` }]
+    }
+  }
+
+  async openCloud(node) {
+    const cloud = this.cloud
+    if (!cloud) return null
+    const entry = await cloud.pullConversation(this.store().folder, node.chat.id)
+    if (this.cloud !== cloud) return null
+    this.store().save({ ...entry, server: this.server() })
+    log.info(`conversation ${entry.id} brought from the account`)
+    return this.open({ meta: { id: entry.id } })
+  }
+
+  async loadWeb() {
+    // Signed in, the web app's chats are the account's (its project "web"), wherever they were made.
+    if (this.cloud) {
+      const cloud = this.cloud
+      try {
+        const chats = (await cloud.listProject('web')).map((c) => ({ id: c.id, title: c.title, created_at: (c.updated || 0) / 1000, fromAccount: true }))
+        if (this.cloud !== cloud) return []
+        this.webChats = chats
+        if (!chats.length) return [{ kind: 'note', label: 'No chats at aipictury.com yet' }]
+        return chats.map((chat) => ({ kind: 'webChat', chat }))
+      } catch (error) {
+        return [{ kind: 'note', label: `Your account cannot be reached (${error.message})` }]
+      }
+    }
+    try {
+      const controller = new AbortController()
+      const timer = setTimeout(() => controller.abort(), 8000)
+      const response = await this.fetch(`${this.server()}/api/assistant/chats`, { signal: controller.signal })
+      clearTimeout(timer)
+      const { chats = [] } = response.ok ? await response.json() : {}
+      this.webChats = chats
+      if (!chats.length) return [{ kind: 'note', label: 'No chats in the web app yet' }]
+      return chats.map((chat) => ({ kind: 'webChat', chat }))
+    } catch (error) {
+      return [{ kind: 'note', label: `The server cannot be reached (${error.name === 'AbortError' ? 'no answer' : error.message})` }]
+    }
+  }
+
+  getTreeItem(node) {
+    const T = vscode.TreeItemCollapsibleState
+    if (node.kind === 'group') {
+      const item = new vscode.TreeItem(node.group.name, T.Expanded)
+      item.id = `group:${node.group.id}`
+      item.contextValue = 'group'
+      item.iconPath = new vscode.ThemeIcon('folder')
+      item.description = `${node.items.length}`
+      return item
+    }
+    if (node.kind === 'archived') {
+      const item = new vscode.TreeItem('Archived', T.Collapsed)
+      item.id = 'archived'
+      item.contextValue = 'archivedRoot'
+      item.iconPath = new vscode.ThemeIcon('archive')
+      item.description = `${node.items.length}`
+      return item
+    }
+    if (node.kind === 'web') {
+      const item = new vscode.TreeItem('Web app chats', T.Collapsed)
+      item.id = 'web'
+      item.contextValue = 'webRoot'
+      item.iconPath = new vscode.ThemeIcon('globe')
+      item.tooltip = 'Chats from the AIPictury web app — open one to carry it on here'
+      return item
+    }
+    if (node.kind === 'cloud') {
+      const item = new vscode.TreeItem('In the cloud', T.Collapsed)
+      item.id = 'cloud'
+      item.contextValue = 'cloudRoot'
+      item.iconPath = new vscode.ThemeIcon('cloud')
+      item.tooltip = 'Conversations of this project kept with your AIPictury account, from another machine or the CLI'
+      return item
+    }
+    if (node.kind === 'cloudChat') {
+      const item = new vscode.TreeItem(node.chat.title || 'Untitled', T.None)
+      item.id = `cloud:${node.chat.id}`
+      item.contextValue = 'cloudChat'
+      item.iconPath = new vscode.ThemeIcon('cloud-download')
+      item.description = `${ago(node.chat.updated || 0)}${node.chat.origin === 'cli' ? ' · CLI' : ''}`
+      item.tooltip = 'Open it here: it is brought to this machine, and stays in step with your account'
+      item.command = { command: 'aipictury.sessions.openCloud', title: 'Open', arguments: [node] }
+      return item
+    }
+    if (node.kind === 'note') {
+      const item = new vscode.TreeItem(node.label, T.None)
+      item.iconPath = new vscode.ThemeIcon('info')
+      return item
+    }
+    if (node.kind === 'webChat') {
+      const item = new vscode.TreeItem(node.chat.title || 'Untitled', T.None)
+      item.id = `web:${node.chat.id}`
+      item.contextValue = 'webChat'
+      item.iconPath = new vscode.ThemeIcon('comment')
+      item.description = ago((node.chat.created_at || 0) * 1000)
+      item.tooltip = 'Carry this chat on in VS Code (a copy: the web chat stays as it is)'
+      item.command = { command: 'aipictury.sessions.continueWeb', title: 'Continue here', arguments: [node] }
+      return item
+    }
+    const { meta, status, panel } = node
+    const look = STATUS[status]
+    const item = new vscode.TreeItem(meta.title || 'New conversation', T.None)
+    item.id = `session:${meta.id}`
+    item.contextValue = `session${meta.archived ? '.archived' : ''}${meta.unread ? '.unread' : ''}${meta.group ? '.grouped' : ''}`
+    item.iconPath = new vscode.ThemeIcon(look.icon, look.color ? new vscode.ThemeColor(look.color) : undefined)
+    item.description = `${panel?.host ? '● ' : ''}${ago(meta.updated)}`
+    item.tooltip = new vscode.MarkdownString(`**${meta.title}**\n\n${look.label}${panel?.host ? ' · open' : ''} · `
+      + `${meta.questions ?? '?'} question(s)${meta.model ? ` · ${meta.model}` : ''}\n\nLast active ${ago(meta.updated)}`)
+    item.accessibilityInformation = { label: `${meta.title}, ${look.label}${panel?.host ? ', open' : ''}, ${ago(meta.updated)}` }
+    item.command = { command: 'aipictury.sessions.open', title: 'Open', arguments: [node] }
+    return item
+  }
+
+  getParent() { return undefined }
+
+  // ---- actions ----
+
+  /** The sessions a command acts on: the clicked one, or every selected one. */
+  targets(node, selected) {
+    const list = selected?.length ? selected : node ? [node] : this.view?.selection || []
+    return list.filter((n) => n?.kind === 'session')
+  }
+
+  async open(node, { where = 'preferred' } = {}) {
+    const id = node.meta.id
+    const live = this.livePanel(id)
+    if (live?.host && where === 'preferred') {
+      if (live.kind === 'sidebar') await vscode.commands.executeCommand('aipictury.agent.focus')
+      else live.host.reveal?.()
+      return live
+    }
+    await this.freshen(id)
+    const panel = where === 'tab' || where === 'window' ? await workbench.openTab(this.registry) : await workbench.openPreferred(this.registry)
+    await panel.open(id, { focus: false })
+    if (where === 'window') await vscode.commands.executeCommand('workbench.action.moveEditorToNewWindow')
+    this.refresh()
+    return panel
+  }
+
+  /** Carried on somewhere else (the web app, another machine) since this copy was saved: the
+   *  account's newer copy replaces it before it opens. Not while it runs here. */
+  async freshen(id) {
+    const cloud = this.cloud
+    const store = this.store()
+    if (!cloud || !store.folder || this.livePanel(id)?.abort) return
+    try {
+      const local = store.list().find((m) => m.id === id)
+      const remote = await cloud.summaryOf(store.folder, id)
+      if (!remote || !local || (remote.updated || 0) <= (local.updated || 0) || remote.device === cloud.device.id) return
+      const entry = await cloud.pullConversation(store.folder, id)
+      if (this.cloud !== cloud) return
+      store.save({ ...store.get(id), ...entry, server: this.server() })
+      log.info(`conversation ${id}: the newer copy from the account (${remote.origin || 'elsewhere'})`)
+    } catch (error) { log.warn(`conversation ${id}: the account's copy not checked: ${error.message}`) }
+  }
+
+  async moveToGroup(node, selected) {
+    const sessions = this.targets(node, selected)
+    if (!sessions.length) return
+    const store = this.store()
+    const groups = store.groups()
+    const pick = await vscode.window.showQuickPick([
+      ...groups.map((g) => ({ label: `$(folder) ${g.name}`, id: g.id })),
+      { label: '$(add) New group…', id: '' }], { title: `Move ${sessions.length > 1 ? `${sessions.length} conversations` : 'to a group'}` })
+    if (!pick) return
+    let id = pick.id
+    if (!id) {
+      const name = await vscode.window.showInputBox({ title: 'New group', prompt: 'Its name' })
+      if (!name?.trim()) return
+      id = store.createGroup(name).id
+    }
+    for (const s of sessions) store.patch(s.meta.id, { group: id, archived: undefined })
+    this.refresh()
+  }
+
+  /** Carries a web app chat on here: a copy becomes a new conversation of this project. */
+  async continueWeb(node) {
+    let chat
+    let messages
+    if (node.chat.fromAccount && this.cloud) {
+      // From the account: the chat as aipictury.com keeps it.
+      const got = await this.cloud.pullFrom('web', node.chat.id)
+      chat = { id: node.chat.id, title: got.meta.title, model: got.meta.model }
+      messages = (got.transcript || []).map((t) => ({ role: t.kind, content: t.text, created_at: (t.at || Date.now()) / 1000 }))
+    } else {
+      const response = await this.fetch(`${this.server()}/api/assistant/chats/${encodeURIComponent(node.chat.id)}`)
+      if (!response.ok) throw new Error(`the server answered ${response.status}`)
+      ;({ chat, messages = [] } = await response.json())
+    }
+    const kept = messages.filter((m) => (m.role === 'user' || m.role === 'assistant') && String(m.content || '').trim())
+    if (!kept.length) { vscode.window.showInformationMessage('That chat has nothing to carry on yet.'); return null }
+    const id = `c${Date.now().toString(36)}`
+    const at = (m) => Math.round((m.created_at || Date.now() / 1000) * 1000)
+    this.store().save({
+      id, title: `${chat.title || 'Web chat'} (from the web)`, renamed: true,
+      created: at(kept[0]), updated: Date.now(), server: this.server(), model: chat.model || null,
+      history: kept.map((m) => ({ role: m.role, content: m.content })),
+      transcript: kept.map((m) => ({ kind: m.role, text: m.content, at: at(m) })),
+      todos: [], usage: { turns: 0, prompt: 0, output: 0, seconds: 0 }, from: { web: chat.id },
+    })
+    log.info(`web chat ${chat.id} carried on as ${id}`)
+    return this.open({ meta: { id } })
+  }
+}
+
+/** Registers the view and its commands. Returns the view object (tests drive it). */
+function register(context, { registry, store, server, activePanel }) {
+  const view = new SessionsView(context, { registry, store, server })
+  const tree = vscode.window.createTreeView('aipictury.sessions', { treeDataProvider: view, canSelectMany: true, showCollapseAll: true })
+  view.view = tree
+  view.describe()
+  const add = (d) => context.subscriptions.push(d)
+  add(tree)
+  const safely = (fn) => async (...args) => {
+    try { return await fn(...args) } catch (error) {
+      log.error('sessions view', error)
+      vscode.window.showErrorMessage(`AIPictury: ${error.message}`)
+      return undefined
+    }
+  }
+  const cmd = (name, fn) => add(vscode.commands.registerCommand(`aipictury.sessions.${name}`, safely(fn)))
+  const one = (node) => node || view.targets(null)[0]
+
+  cmd('open', (node) => one(node) && view.open(one(node)))
+  cmd('openInTab', (node) => one(node) && view.open(one(node), { where: 'tab' }))
+  cmd('openInNewWindow', (node) => one(node) && view.open(one(node), { where: 'window' }))
+  cmd('rename', async (node) => {
+    node = one(node); if (!node) return
+    const title = await vscode.window.showInputBox({ title: 'Rename the conversation', value: node.meta.title })
+    if (!title?.trim()) return
+    store().patch(node.meta.id, { title: title.trim().slice(0, 80), renamed: true })
+    const live = view.livePanel(node.meta.id)
+    if (live) { live.title = title.trim().slice(0, 80); live.postSession() }
+    view.refresh()
+  })
+  cmd('delete', async (node, selected) => {
+    const sessions = view.targets(node, selected)
+    if (!sessions.length) return
+    const yes = 'Delete'
+    const what = sessions.length > 1 ? `${sessions.length} conversations` : `“${sessions[0].meta.title}”`
+    if (await vscode.window.showWarningMessage(`Delete ${what}?`, { modal: true, detail: 'This cannot be undone. Your files are not touched.' }, yes) !== yes) return
+    for (const s of sessions) { if (!view.livePanel(s.meta.id)?.abort) store().remove(s.meta.id) }
+    view.refresh()
+  })
+  cmd('archive', (node, selected) => { for (const s of view.targets(node, selected)) store().patch(s.meta.id, { archived: true, group: undefined }); view.refresh() })
+  cmd('unarchive', (node, selected) => { for (const s of view.targets(node, selected)) store().patch(s.meta.id, { archived: undefined }); view.refresh() })
+  cmd('unarchiveAll', () => { for (const m of store().list()) if (m.archived) store().patch(m.id, { archived: undefined }); view.refresh() })
+  cmd('markUnread', (node, selected) => { for (const s of view.targets(node, selected)) store().patch(s.meta.id, { unread: true }); view.refresh() })
+  cmd('markRead', (node, selected) => { for (const s of view.targets(node, selected)) store().patch(s.meta.id, { unread: undefined }); view.refresh() })
+  cmd('moveToGroup', (node, selected) => view.moveToGroup(node, selected))
+  cmd('removeFromGroup', (node, selected) => { for (const s of view.targets(node, selected)) store().patch(s.meta.id, { group: undefined }); view.refresh() })
+  cmd('newGroup', async () => {
+    const name = await vscode.window.showInputBox({ title: 'New group', prompt: 'Its name' })
+    if (name?.trim()) { store().createGroup(name); view.refresh() }
+  })
+  cmd('renameGroup', async (node) => {
+    if (node?.kind !== 'group') return
+    const name = await vscode.window.showInputBox({ title: 'Rename the group', value: node.group.name })
+    if (name?.trim()) { store().renameGroup(node.group.id, name); view.refresh() }
+  })
+  cmd('deleteGroup', async (node) => {
+    if (node?.kind !== 'group') return
+    const yes = 'Delete group'
+    if (await vscode.window.showWarningMessage(`Delete the group “${node.group.name}”?`, { modal: true,
+      detail: 'Its conversations are kept, outside any group.' }, yes) !== yes) return
+    store().deleteGroup(node.group.id)
+    view.refresh()
+  })
+  cmd('addToGroup', async () => {
+    const panel = activePanel()
+    if (!panel?.id) { vscode.window.showInformationMessage('Ask something first: an empty conversation is not saved yet.'); return }
+    await panel.remember()
+    const meta = store().list().find((m) => m.id === panel.id)
+    if (meta) await view.moveToGroup({ kind: 'session', meta })
+  })
+  cmd('search', async () => {
+    const text = await vscode.window.showInputBox({ title: 'Search conversations', value: view.filter.search,
+      prompt: 'Matches titles and models, archived ones included. Empty clears the search.' })
+    if (text !== undefined) await view.setFilter({ search: text.trim() })
+  })
+  cmd('filter', async () => {
+    const f = view.filter
+    const items = [
+      { label: 'Open only', description: 'conversations open in a panel or tab', id: 'active', picked: f.active },
+      ...STATUSES.map((s) => ({ label: `$(${s.icon.replace('~spin', '')}) ${s.label}`, id: s.id, picked: f.statuses.includes(s.id) })),
+    ]
+    const picked = await vscode.window.showQuickPick(items, { canPickMany: true, title: 'Show only…',
+      placeHolder: 'Nothing picked shows everything' })
+    if (!picked) return
+    await view.setFilter({ active: picked.some((p) => p.id === 'active'), statuses: picked.map((p) => p.id).filter((id) => id !== 'active') })
+  })
+  cmd('clearFilter', () => view.setFilter({ active: false, statuses: [], search: '' }))
+  cmd('refresh', () => { view.webChats = null; view.refresh() })
+  cmd('continueWeb', (node) => node?.kind === 'webChat' && view.continueWeb(node))
+  cmd('openCloud', async (node) => {
+    if (node?.kind !== 'cloudChat') return
+    try { await view.openCloud(node) } catch (error) { vscode.window.showErrorMessage(`AIPictury: not opened — ${error.message}`) }
+  })
+
+  // Kept current: the store changes in any window; the panels change as they run.
+  let listening = null
+  const watch = () => { listening?.dispose(); listening = store().onChange(() => view.refresh()) }
+  watch()
+  add({ dispose: () => listening?.dispose() })
+  add(vscode.workspace.onDidChangeWorkspaceFolders(() => { watch(); view.refresh() }))
+
+  // archiveInactiveSessions: what has been idle that many days goes to Archived — never an
+  // open, unread or grouped conversation.
+  const days = Number(vscode.workspace.getConfiguration('aipictury').get('archiveInactiveSessions', 0)) || 0
+  if (days) {
+    const moved = store().archiveInactive(days, { open: new Set(registry.all().map((p) => p.id).filter(Boolean)) })
+    if (moved) log.info(`archived ${moved} conversation(s) idle for more than ${days} day(s)`)
+  }
+  return view
+}
+
+module.exports = { register, SessionsView, statusOf, STATUSES }