@davait/aipictury 1.10.3 → 1.10.4

package/ext/accountUi.js

@@ -212,10 +212,23 @@ function register(context, { registry, sessionsView, serverUrl }) {
   async function deleteCloudData() {
     const yes = 'Delete everything'
     const ok = await vscode.window.showWarningMessage('Delete everything of yours kept with your AIPictury account?', {
-      modal: true, detail: 'Conversations, projects, rules, preferences and usage kept in the cloud, from every machine. What is on this machine stays.' }, yes)
+      modal: true, detail: 'Conversations and projects, rules, preferences, usage, your pictures and clips (Renders, and every file kept '
+        + 'with them), remote-control links and the list of your machines — from every machine and the web app. What is on this '
+        + 'machine stays, and is not sent back up by itself: only what you do from now on is kept again (while its switch is on).' }, yes)
     if (ok !== yes) return null
     const n = await cloud.deleteEverything()
-    return `Deleted (${n} records). Your account stays — sign out or keep using it.`
+    return `Deleted (${n} records and files). Your account stays — sign out or keep using it.`
+  }
+
+  const KIND_LABEL = { conversations: 'conversations', memory: 'rules', settings: 'preferences', usage: 'usage' }
+  /** A switch turned off: also delete what is already kept of that kind? Asked; null to keep it. */
+  async function deleteKind(kind) {
+    const yes = 'Delete them too'
+    const ok = await vscode.window.showWarningMessage(`No longer keeping your ${KIND_LABEL[kind] || kind} with your account. Delete the ones already kept?`, {
+      modal: true, detail: 'From every machine and the web app. What is on this machine stays.' }, yes, 'Keep them')
+    if (ok !== yes) return null
+    const n = await cloud.deleteKind(kind)
+    return `No longer sent, and the ${KIND_LABEL[kind] || kind} kept before are deleted (${n} records).`
   }
 
   function localPreferences() {
@@ -235,7 +248,7 @@ function register(context, { registry, sessionsView, serverUrl }) {
   context.subscriptions.push({ dispose: () => { globalThis.fetch = plainFetch } })
 
   account.user().then(changed).catch(() => changed(null))
-  return { account, cloud, signedIn, signIn, signOut, deleteCloudData, keeps, user: () => user }
+  return { account, cloud, signedIn, signIn, signOut, deleteCloudData, deleteKind, keeps, user: () => user }
 }
 
 async function projectRulesText() {
@@ -265,7 +278,7 @@ function accountSpec(ctl, note) {
       { title: 'Kept with your account', items: kinds.map(([id, label, detail]) => ({ id: `keep:${id}`, label, detail, toggle: { on: config().get(`cloud.${id}`, true) } })) },
       { title: 'Account', items: [
         { id: 'signout', label: 'Sign out', detail: 'Forgets the session on this machine: nothing of the account stays here.', actions: [{ id: 'signout', label: 'Sign out', always: true }] },
-        { id: 'delete', label: 'Delete what is kept in the cloud', detail: 'Everything above, from every machine. Local files stay.', actions: [{ id: 'delete', label: 'Delete…', danger: true, always: true }] },
+        { id: 'delete', label: 'Delete what is kept in the cloud', detail: 'Everything above, and your pictures and clips (Renders), from every machine and the web app. Local files stay.', actions: [{ id: 'delete', label: 'Delete…', danger: true, always: true }] },
       ] },
     ] }
 }
@@ -274,8 +287,12 @@ function accountHandler(ctl) {
   return async (action, message) => {
     const item = String(message.item || '')
     if (action === 'toggle' && item.startsWith('keep:')) {
-      await config().update(`cloud.${item.slice(5)}`, !!message.value, vscode.ConfigurationTarget.Global)
-      return accountSpec(ctl, message.value ? 'Kept with your account from now on.' : 'No longer sent. What is in the cloud stays until you delete it.')
+      const kind = item.slice(5)
+      await config().update(`cloud.${kind}`, !!message.value, vscode.ConfigurationTarget.Global)
+      if (message.value) return accountSpec(ctl, 'Kept with your account from now on.')
+      // Off: what is already kept of it can go too — asked, since it goes from every machine.
+      const said = await ctl.deleteKind?.(kind).catch((error) => `No longer sent; deleting what was kept failed: ${error.message}`)
+      return accountSpec(ctl, said || 'No longer sent. What is in the cloud stays until you delete it.')
     }
     if (action === 'signin') { await ctl.signIn(); return accountSpec(ctl) }
     if (action === 'signout') { await ctl.signOut(); return accountSpec(ctl, 'Signed out.') }

package/ext/agent.js

@@ -73,9 +73,9 @@ const MODES = {
   plan:  { label: 'Plan', icon: '\u25F4',
            hint: 'Read-only: investigates and proposes a plan, changes nothing.' },
   never: { label: 'Auto', icon: '\u26A1',
-           hint: 'Goes ahead with routine work; asks before anything risky — judged by fixed rules and the model.' },
+           hint: 'Asks nothing: does the work, takes the recommended choices, and lists at the end what would have been asked and why. Your own ask rules still ask.' },
   bypass: { label: 'Bypass permissions', icon: '\u26A0',
-            hint: 'Does everything without asking, with no checks at all. Only with aipictury.allowDangerouslySkipPermissions.' },
+            hint: 'Does everything without asking, with no checks at all — not even your ask rules. Only with aipictury.allowDangerouslySkipPermissions.' },
 }
 
 /** The mode in force. Bypass needs its own setting: without it, it is Auto. */
@@ -97,11 +97,11 @@ approves it (and you may then make the changes) or asks for changes to it.`
 
 const AUTO_NOTE = `
 
-You are in AUTO mode: the user is not approving each step. Still call ask_user whenever
-you choose between real options — it keeps a record of the choice. Unless you mark the
-call important, your recommended (first) option is taken at once, you carry on without
-waiting, and the user can change it when you finish. Mark important only a decision that
-would be costly to undo.`
+You are in AUTO mode: the user is not approving each step, and nothing stops to ask them.
+Still call ask_user whenever you choose between real options — it keeps a record of the
+choice: your recommended (first) option is taken at once, you carry on without waiting, and
+the user can change it when you finish. Commands and tools run without asking too, so take
+the careful way yourself when an action would be costly to undo.`
 
 const SYSTEM = `You are AIPictury's coding agent, working inside the user's editor on
 their own machine. You can read and change the workspace with the tools provided.
@@ -319,11 +319,14 @@ async function approve(call, session, signal, hooks = {}, preview = null, { forc
     if (mode === 'bypass') return { ok: true }
     if (mode === 'never') {
       // Auto: edits inside the workspace go ahead (a checkpoint can undo them); anything else
-      // is judged — fixed rules, routine work, then the model — and asked when it is risky.
+      // is judged — fixed rules, routine work, then the model — and what would have been asked
+      // goes ahead all the same, listed at the end of the answer with why.
       if (WRITES.has(name)) return { ok: true }
       const verdict = await judge(call, session, signal, hooks, server)
       if (verdict.verdict === 'allow') return { ok: true, judged: verdict }
-      because = `Auto mode asks: ${verdict.reason || 'it could not tell whether this is safe'}`
+      // Auto never stops to ask: judged risky, it goes ahead too — and is said at the end.
+      hooks.onAutoRan?.({ tool: name, args, reason: verdict.reason || 'it could not tell whether this is safe' })
+      return { ok: true, judged: verdict, auto: true }
     }
     if (mode === 'edits' && !isRun) return { ok: true }
     if (session.allowAll) return { ok: true }
@@ -538,7 +541,9 @@ async function askUser(args, report, signal, hooks) {
   }
   const mode = modeNow()
   const recommended = (q) => q.options[0].label.replace(/\s*\(recommended\)\s*$/i, '')
-  if ((unattended(mode) && !args.important) || !hooks.askUser) {
+  // Auto takes the recommended option of every question, important ones too (listed at the end,
+  // each open to change); the user is never stopped mid-run.
+  if (unattended(mode) || !hooks.askUser) {
     const picks = questions.map((q) => ({ ...q, picked: [q.options[0].label], other: '' }))
     hooks.onDecision?.(picks)
     report({ tool: 'ask_user', args: { questions }, status: 'decided', result: picks })
@@ -935,6 +940,13 @@ async function executeTool(call, session, report, signal, server, hooks = {}) {
       sandbox: box.asked ? 'the agent asks to run this outside the sandbox' : 'the sandbox is on, but this machine has none (sandbox-exec / bubblewrap)' })
   }
   if (hooks.hookPermission === 'ask') Object.assign(rule, { decision: 'ask', rule: null, hook: hooks.hookReason || 'a hook' })
+  // Auto never stops to ask. Only what the user set up to be asked — an ask rule of theirs, a
+  // hook — still asks; the rest (leaving the sandbox, a password field, a new site) goes ahead,
+  // and the answer ends with what was done without asking, and why it would have been asked.
+  if (modeNow() === 'never' && rule.decision === 'ask' && !rule.rule && !rule.hook) {
+    hooks.onAutoRan?.({ tool: name, args, reason: rule.why || rule.sandbox || 'it would have asked' })
+    rule.decision = 'allow'
+  }
   const standing = session.allowTools?.includes(name)
   const needsYes = rule.decision === 'ask'
     || (rule.decision !== 'allow' && !standing && (WRITES.has(name) || (isRun && (!readOnlyRun || readsOutside)) || (isMcp && !mcp.readOnly(name)) || browserAsks))
@@ -1715,6 +1727,9 @@ async function work({ server, model, history, session, signal,
   let known = null           // the dependencies the workspace declares, read when first needed
   const holds = new Map()    // package → times a call bringing it in was held
   const hooks = { askUser: ask, onDecision, approve: approveHook, approvePlan, onTodos, onTasks, onFileChange, readSpecial, model, trustHooks, onMonitor, schedule, onHelperDone,
+    // Auto mode did what would have been asked: listed with the decisions, at the end.
+    onAutoRan: ({ tool, args = {}, reason }) => onDecision?.([{ ran: true, tool, header: tool === 'run_command' ? 'Ran' : tool,
+      question: String(args.command || args.path || args.url || args.page || args.action || JSON.stringify(args)).slice(0, 300), reason: String(reason || '') }]),
     // For helpers: what the user said, so a package is judged chosen by them, not by a task text.
     userSaid: () => deps.saidByUser(messages, fromUser) }
   let steps = 0

package/ext/cloud.js

@@ -122,7 +122,7 @@ class Cloud {
     const now = Date.now()
     const existing = await this.db.get(base)
     await this.db.set(base, { email: user.email || '', displayName: user.displayName || '', photoURL: user.photoURL || '',
-      created: existing?.created || now, lastSeen: now })
+      created: existing?.created || now, lastSeen: now, ...(existing?.cleared ? { cleared: existing.cleared } : {}) })
     await this.db.set(`${base}/devices/${this.device.id}`, { name: this.device.name, app: this.device.app,
       platform: this.device.platform, version: this.device.version, lastSeen: now })
   }
@@ -229,11 +229,21 @@ class Cloud {
 
   /** The conversations of `folder` kept on this machine (`store`: sessions.js) that the account
    *  lacks or has an older copy of, carried up; how many. `still()`: false stops (signed out). */
+  /** When everything kept with the account was last deleted (ms; 0: never), read afresh. What is
+   *  older than that is not carried up again by itself: deleting the cloud copy, the conversations
+   *  still on a machine came straight back at its next start. What is done after it syncs again. */
+  async clearedAt() {
+    const user = await this.db.get(await this.base()).catch(() => null)
+    return Number(user?.cleared) || 0
+  }
+
   async bringUp(folder, store, { still = () => true } = {}) {
     const remote = new Map((await this.listConversations(folder)).map((c) => [c.id, c]))
+    const cleared = await this.clearedAt()
     let up = 0
     for (const meta of store.list().slice(0, 500)) {
       if (!still()) break
+      if ((meta.updated || 0) <= cleared) continue          // from before the cloud copy was deleted
       const there = remote.get(meta.id)
       if (there && (there.updated || 0) >= (meta.updated || 0)) continue
       const entry = store.get(meta.id)
@@ -362,12 +372,44 @@ class Cloud {
 
   async dropRemote(id) { await this.db.delete(`${await this.base()}/remote/${id}`) }
 
+  /** One kind of what is kept, deleted from every machine's cloud copy (its switch turned off):
+   *  'conversations' (with their chunks), 'memory' (your rules and each project's), 'settings'
+   *  (preferences) or 'usage'. Returns how many records went. */
+  async deleteKind(kind) {
+    const base = await this.base()
+    const writes = []
+    if (kind === 'conversations' || kind === 'memory') {
+      for (const p of await this.db.list(`${base}/projects`)) {
+        if (kind === 'memory') { writes.push({ delete: `${base}/projects/${p.id}/memory/current` }); continue }
+        for (const c of await this.db.list(`${base}/projects/${p.id}/conversations`)) {
+          const chunks = new Set([...Array(c.data.chunks || 0).keys()].map(String))
+          for (const k of await this.db.list(`${base}/projects/${p.id}/conversations/${c.id}/chunks`).catch(() => [])) chunks.add(k.id)
+          for (const k of chunks) writes.push({ delete: `${base}/projects/${p.id}/conversations/${c.id}/chunks/${k}` })
+          writes.push({ delete: `${base}/projects/${p.id}/conversations/${c.id}` })
+        }
+      }
+      if (kind === 'memory') writes.push({ delete: `${base}/memory/rules` })
+    } else if (kind === 'settings') {
+      writes.push({ delete: `${base}/settings/preferences` })
+    } else if (kind === 'usage') {
+      for (const d of await this.db.list(`${base}/usage`)) writes.push({ delete: `${base}/usage/${d.id}` })
+    } else {
+      throw new Error(`nothing kept as ${kind}`)
+    }
+    await this.db.batch(writes)
+    if (kind === 'conversations') this.pushed.clear()
+    return writes.length
+  }
+
   async deleteEverything() {
     const base = await this.base()
     const writes = []
     for (const p of await this.db.list(`${base}/projects`)) {
       for (const c of await this.db.list(`${base}/projects/${p.id}/conversations`)) {
-        for (let i = 0; i < (c.data.chunks || 0); i += 1) writes.push({ delete: `${base}/projects/${p.id}/conversations/${c.id}/chunks/${i}` })
+        // Every chunk there is, not as many as the summary says: one left by a save cut short stays otherwise.
+        const chunks = new Set([...Array(c.data.chunks || 0).keys()].map(String))
+        for (const k of await this.db.list(`${base}/projects/${p.id}/conversations/${c.id}/chunks`).catch(() => [])) chunks.add(k.id)
+        for (const k of chunks) writes.push({ delete: `${base}/projects/${p.id}/conversations/${c.id}/chunks/${k}` })
         writes.push({ delete: `${base}/projects/${p.id}/conversations/${c.id}` })
       }
       writes.push({ delete: `${base}/projects/${p.id}/memory/current` }, { delete: `${base}/projects/${p.id}` })
@@ -377,6 +419,8 @@ class Cloud {
     await this.db.batch(writes)
     // The media kept with the account (pictures, clips, attachments) go too.
     if (this.storage) for (const o of await this.storage.list(`${base}/media/`)) { await this.storage.delete(o.name); writes.push(o) }
+    // The moment it was cleared: no app carries back up what it still holds from before.
+    await this.db.set(base, { cleared: Date.now() })
     this.pushed.clear()
     return writes.length
   }

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.10.3",
+  "version": "1.10.4",
   "publisher": "aipictury",
   "license": "SEE LICENSE IN LICENSE.md",
   "engines": {
@@ -848,7 +848,7 @@
             "Manual — ask before every file change and command",
             "Edit Automatically — apply file edits without asking; still ask before running commands",
             "Plan — read-only: investigate and propose a plan, change nothing",
-            "Auto — routine work without asking; anything risky is asked (judged by fixed rules and the model)",
+            "Auto — asks nothing: does the work, takes the recommended choices, lists at the end what would have been asked and why (your own ask rules still ask)",
             "Bypass permissions — everything without asking, no checks (needs allowDangerouslySkipPermissions)"
           ],
           "default": "never",

package/main.js

@@ -387,7 +387,7 @@ async function interactive(o, convo, first, cfg) {
       const view = new T.MarkdownStream()
       view.push(`${plan}\n`)
       view.end()
-      const answer = await ask(`\n  ${bold('y')}es, go ahead (asking as now) · ${bold('a')}uto (go ahead, asking only when risky) · or say what to change › `)
+      const answer = await ask(`\n  ${bold('y')}es, go ahead (asking as now) · ${bold('a')}uto (go ahead, asking nothing) · or say what to change › `)
       spinner.start()
       if (answer === null) return { approved: false, feedback: '' }
       const a = answer.trim()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@davait/aipictury",
-  "version": "1.10.3",
+  "version": "1.10.4",
   "description": "The AIPictury agent in a terminal: the VS Code extension's agent, on your own GPU server, signed in to your AIPictury account.",
   "bin": {
     "aipictury": "main.js"