picocode-core 0.9.200 → 0.9.201

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "picocode-core",
-  "version": "0.9.200",
+  "version": "0.9.201",
   "description": "The agent runtime behind pico: sessions, tools, subagents, MCP, memory, and model access",
   "type": "module",
   "license": "MIT",

package/src/daemon-patch.js

@@ -1,7 +1,7 @@
 import { isDeepStrictEqual } from 'node:util'
 
 export function diffSnapshot(previous, next, path = [], patches = []) {
-  if (isDeepStrictEqual(previous, next)) return patches
+  if (Object.is(previous, next)) return patches
   if (typeof previous === 'string' && typeof next === 'string' && next.startsWith(previous)) {
     patches.push({ op: 'appendText', path, value: next.slice(previous.length) })
   } else if (Array.isArray(previous) && Array.isArray(next)) {
@@ -12,7 +12,7 @@ export function diffSnapshot(previous, next, path = [], patches = []) {
   } else if (previous && next && Object.getPrototypeOf(previous) === Object.prototype && Object.getPrototypeOf(next) === Object.prototype) {
     for (const key of Object.keys(previous)) if (!(key in next)) patches.push({ op: 'delete', path: [...path, key] })
     for (const key of Object.keys(next)) diffSnapshot(previous[key], next[key], [...path, key], patches)
-  } else patches.push({ op: 'set', path, value: next })
+  } else if (!isDeepStrictEqual(previous, next)) patches.push({ op: 'set', path, value: next })
   return patches
 }
 

package/src/daemon-projection.js

@@ -0,0 +1,34 @@
+import { plain } from './daemon-wire.js'
+
+export const defaultTranscriptLimit = 100
+const stateExcluded = new Set(['events', 'persisted', 'derived', 'attachments', 'rewindUndo'])
+const derivedExcluded = new Set(['transcript', 'providerHistory', 'historyEventIds', 'loadedContext', 'toolItems', 'peerMessages', 'consumedPeerIds', 'pendingPeerMessages', 'deferredConsumedPeers', 'openToolCalls', 'trimmedToolIds', 'toolTrimVersions'])
+const agentExcluded = new Set(['events', 'timeline', 'options', 'controller', 'done', 'resolve'])
+const select = (value, excluded) => Object.fromEntries(Object.entries(value || {}).filter(([key]) => !excluded.has(key)))
+
+export function createProjection() {
+  const clones = new WeakMap()
+  const derivedCache = new WeakMap()
+  const windows = new WeakMap()
+  function immutable(value) {
+    if (!value || typeof value !== 'object') return plain(value)
+    if (!clones.has(value)) clones.set(value, plain(value))
+    return clones.get(value)
+  }
+  return {
+    state(source, limit = defaultTranscriptLimit) {
+      const derived = source.derived || {}
+      if (!derivedCache.has(derived)) derivedCache.set(derived, plain(select(derived, derivedExcluded)))
+      const transcript = derived.transcript || []
+      let byLimit = windows.get(derived)
+      if (!byLimit) windows.set(derived, byLimit = new Map())
+      const offset = Math.max(0, transcript.length - limit)
+      if (!byLimit.has(limit)) byLimit.set(limit, transcript.slice(offset).map(immutable))
+      const attachments = new Map([...source.attachments || []].map(([key, value]) => [key, plain(Object.fromEntries(['kind', 'path', 'mediaType', 'hash', 'subject', 'root', 'url', 'selector', 'tag', 'component', 'fromLine', 'toLine', 'fromColumn', 'toColumn'].filter(k => value[k] !== undefined).map(k => [k, value[k]])))]))
+      return { ...plain(select(source, stateExcluded)), attachments, rewindUndo: !!source.rewindUndo, derived: { ...derivedCache.get(derived), transcript: byLimit.get(limit), transcriptOffset: offset, transcriptTotal: transcript.length } }
+    },
+    agents(values) {
+      return values.map(value => ({ ...plain(select(value, agentExcluded)), ...(value.timeline ? { timeline: value.timeline.map(immutable) } : {}), events: (value.events || []).filter(event => ['content', 'tool_executing', 'tool_complete', 'tool_error'].includes(event.type)).map(immutable) }))
+    },
+  }
+}

package/src/daemon-runtime.js

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto'
 import { plain } from './daemon-wire.js'
 import { diffSnapshot } from './daemon-patch.js'
+import { createProjection, defaultTranscriptLimit } from './daemon-projection.js'
 import { forkSession, loadSession } from './session.js'
 
 const events = ['change', 'derived', 'flash', 'input', 'question', 'turn', 'session', 'resumed', 'mcp', 'shells', 'git', 'project', 'image']
@@ -8,7 +9,11 @@ const queries = ['activity', 'shellRows', 'costSummary', 'speedApplies', 'effort
 const busy = ctl => ctl.isWorking?.() || ctl.state.busy || ctl.state.compacting || ctl.agents?.list().some(a => ['running', 'queued'].includes(a.status))
 const named = ctl => !!ctl.state.derived?.title?.trim()
 
-export function snapshot(ctl) {
+const projections = new WeakMap()
+
+export function snapshot(ctl, limit = defaultTranscriptLimit) {
+  if (!projections.has(ctl)) projections.set(ctl, createProjection())
+  const projection = projections.get(ctl)
   const boot = ctl.boot
   const services = {}
   for (const [service, methods] of Object.entries({ shells: ['list', 'running'], wakeups: ['list', 'pending'], git: ['status'], mcp: ['list'], commands: ['list'], skills: ['list'] })) {
@@ -22,7 +27,7 @@ export function snapshot(ctl) {
   }
   const cached = {}
   for (const method of queries) if (typeof ctl[method] === 'function') cached[method] = plain(ctl[method]())
-  return { state: plain(ctl.state), boot: plain(Object.fromEntries(Object.entries(boot).filter(([key]) => !['refs', 'shells', 'wakeups', 'git', 'mcp', 'memory', 'commands', 'skills', 'tracker'].includes(key)))), services, cached, agents: plain(ctl.agents?.list() || []), methods: Object.keys(ctl).filter(k => typeof ctl[k] === 'function' && !['on', 'shutdown'].includes(k)) }
+  return { state: projection.state(ctl.state, limit), boot: plain(Object.fromEntries(Object.entries(boot).filter(([key]) => !['refs', 'shells', 'wakeups', 'git', 'mcp', 'memory', 'commands', 'skills', 'tracker'].includes(key)))), services, cached, agents: projection.agents(ctl.agents?.list() || []), methods: Object.keys(ctl).filter(k => typeof ctl[k] === 'function' && !['on', 'shutdown'].includes(k)) }
 }
 
 export function createDaemonRuntime({ createSession, onEmpty = () => {}, batchMs = 16 }) {
@@ -38,13 +43,13 @@ export function createDaemonRuntime({ createSession, onEmpty = () => {}, batchMs
   async function createRecord(client, options) {
     const created = await createSession(options)
     const ctl = created.controller || created
-    const record = { id: randomUUID(), ctl, dispose: created.dispose, views: new Set([client]), events: [], timer: null, unsub: [], baselines: new Map() }
+    const record = { id: randomUUID(), ctl, dispose: created.dispose, views: new Set([client]), events: [], timer: null, unsub: [], baselines: new Map(), limits: new Map() }
     sessions.set(record.id, record)
     for (const type of events) record.unsub.push(ctl.on(type, payload => publish(record, type, payload)))
     return record
   }
   function fullSnapshot(record, client) {
-    const value = snapshot(record.ctl)
+    const value = snapshot(record.ctl, record.limits.get(client) ?? defaultTranscriptLimit)
     const sequence = (record.baselines.get(client)?.sequence || 0) + 1
     record.baselines.set(client, { snapshot: value, sequence })
     return { snapshot: value, sequence }
@@ -52,11 +57,14 @@ export function createDaemonRuntime({ createSession, onEmpty = () => {}, batchMs
   function flush(record) {
     clearTimeout(record.timer)
     record.timer = null
-    const next = snapshot(record.ctl)
+    const snapshots = new Map()
     const notifications = record.events.splice(0)
     for (const client of record.views) {
       const baseline = record.baselines.get(client)
       if (!baseline) continue
+      const limit = record.limits.get(client) ?? defaultTranscriptLimit
+      if (!snapshots.has(limit)) snapshots.set(limit, snapshot(record.ctl, limit))
+      const next = snapshots.get(limit)
       const sequence = baseline.sequence + 1
       const patches = diffSnapshot(baseline.snapshot, next)
       record.baselines.set(client, { snapshot: next, sequence })
@@ -81,6 +89,7 @@ export function createDaemonRuntime({ createSession, onEmpty = () => {}, batchMs
     if (!record) return
     record.views.delete(client)
     record.baselines.delete(client)
+    record.limits.delete(client)
     if (!record.views.size && !named(record.ctl)) await dispose(record)
   }
   return {
@@ -112,6 +121,13 @@ export function createDaemonRuntime({ createSession, onEmpty = () => {}, batchMs
       if (!record) throw new Error('session is no longer running')
       if (op === 'attach') { record.views.add(client); return { id, ...fullSnapshot(record, client) } }
       if (op === 'snapshot') { if (!record.views.has(client)) throw new Error('attach first'); return fullSnapshot(record, client) }
+      if (op === 'history') {
+        if (!record.views.has(client)) throw new Error('attach first')
+        const [limit] = args
+        if (!Number.isSafeInteger(limit) || limit < 1) throw new Error('history limit must be a positive safe integer')
+        record.limits.set(client, Math.max(record.limits.get(client) ?? defaultTranscriptLimit, limit))
+        return fullSnapshot(record, client)
+      }
       if (op === 'switch') {
         const [method, value] = args
         if (!record.views.has(client)) throw new Error('attach to the session first')

package/src/remote-controller.js

@@ -1,5 +1,4 @@
 import { applyPatches } from './daemon-patch.js'
-import { deriveState } from './derive.js'
 
 export async function createRemoteController(connection, { id, options = {}, localBoot = {} } = {}) {
   const initial = await connection.request(id ? 'attach' : 'create', id, id ? [] : [options])
@@ -62,13 +61,12 @@ export async function createRemoteController(connection, { id, options = {}, loc
       if (nextId === id) { await clearPreview(); return }
       const previous = id
       const previousPreview = previewId
-      const next = await connection.request('attach', nextId)
+      const next = previousPreview === nextId ? null : await connection.request('attach', nextId)
       previewId = null
       if (previousPreview && previousPreview !== nextId) await connection.request('detach', previousPreview)
-      id = next.id
+      id = nextId
       controller.id = id
-      sequences.set(next.id, next.sequence)
-      apply(next.snapshot)
+      if (next) { sequences.set(next.id, next.sequence); apply(next.snapshot) }
       await connection.request('detach', previous)
       emit('project', boot)
       emit('session', state.session)
@@ -91,7 +89,15 @@ export async function createRemoteController(connection, { id, options = {}, loc
     emit('session', state.session)
     emit('change', state)
   }
-  controller.previewSteer = changes => changes?.length ? deriveState([...state.events, { id: '__steer_preview__', at: Date.now(), type: 'steer', data: { changes } }]) : state.derived
+  controller.previewSteer = changes => call('controller', 'previewSteer', changes)
+  controller.loadHistory = async limit => {
+    const target = displayedId()
+    const reply = await connection.request('history', target, [Number.isFinite(limit) ? limit : Number.MAX_SAFE_INTEGER])
+    if (displayedId() !== target) return
+    sequences.set(target, reply.sequence)
+    apply(reply.snapshot)
+    emit('change', state)
+  }
   function show(snapshot) {
     apply(snapshot)
     emit('project', boot)