picocode-core 0.9.200 → 0.9.202

package/package.json

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

package/src/controller.js

@@ -105,7 +105,7 @@ function errorText(err, limit) {
   return String(err?.message || err).slice(0, limit)
 }
 
-export function createController({ boot, run = runTurn, peerDirectory } = {}) {
+export function createController({ boot, run = runTurn, compactRun = compactHistory, peerDirectory } = {}) {
   if (!Object.hasOwn(boot, 'participantAModel')) boot.participantAModel = boot.proposerModel ?? null
   if (!Object.hasOwn(boot, 'participantBModel')) boot.participantBModel = boot.reviewerModel ?? null
   const { on, emit } = createEmitter()
@@ -599,7 +599,7 @@ export function createController({ boot, run = runTurn, peerDirectory } = {}) {
     return next
   }
 
-  async function compact(instructions = '') {
+  async function compact(instructions = '', { automatic = false } = {}) {
     if (state.busy || state.compacting || peerTransition) return flash('finish or interrupt the current turn first')
     const current = state.derived
     if (current.providerHistory.length < 4) return flash('nothing to compact yet')
@@ -618,7 +618,7 @@ export function createController({ boot, run = runTurn, peerDirectory } = {}) {
     const keepFrom = compactionKeepFrom(current, state.model.context)
     let streamed = ''
     try {
-      const raw = await compactHistory({
+      const raw = await compactRun({
         history: current.providerHistory,
         modelName: state.model.name,
         ...(state.model.provider === 'codex' && { speed: speedApplies() ? state.speed : 'standard' }),
@@ -631,6 +631,7 @@ export function createController({ boot, run = runTurn, peerDirectory } = {}) {
           set({ compactStatus: compactProgress(streamed) })
         },
       })
+      controller.signal.throwIfAborted()
       const summary = formatCompactSummary(raw)
       if (!summary) throw new Error('empty summary')
       if (summarySections(summary) < 5) throw new Error('malformed summary, conversation left untouched')
@@ -638,6 +639,12 @@ export function createController({ boot, run = runTurn, peerDirectory } = {}) {
       reDerive()
       set({ compactOutcome: 'done' })
       flash('compacted · recent messages kept verbatim')
+      if (automatic) {
+        noteSystem(
+          '[system notification] this conversation was automatically compacted to free context. Continue any unfinished work from where you left off. If the task is already complete or you are waiting for user input, stop. Do not recap or acknowledge the compaction.',
+          { wake: true },
+        )
+      }
     } catch (err) {
       set({ compactOutcome: controller.signal.aborted ? 'cancelled' : 'failed' })
       if (controller.signal.aborted) flash('compaction cancelled')
@@ -667,7 +674,7 @@ export function createController({ boot, run = runTurn, peerDirectory } = {}) {
     const ratio = used / limit
     if (ratio >= 0.85) {
       flash(`context ${Math.round(ratio * 100)}% full · auto-compacting`)
-      compact()
+      compact('', { automatic: true })
     }
   }
 

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)