picocode-core 0.9.191 → 0.9.192
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/package.json +1 -1
- package/src/catalog-snapshot.json +1 -1
- package/src/controller.js +243 -33
- package/src/derive.js +80 -4
- package/src/export.js +3 -0
- package/src/peers.js +289 -0
- package/src/session.js +15 -7
- package/src/tools/index.js +20 -1
package/src/controller.js
CHANGED
|
@@ -10,6 +10,7 @@ import { deriveState, userEntries, rewindStats } from './derive.js'
|
|
|
10
10
|
import { appendPrompt } from './history.js'
|
|
11
11
|
import { runTurn, summarizeText, compactHistory, compactProgress } from './agent.js'
|
|
12
12
|
import { createAgentManager } from './agents.js'
|
|
13
|
+
import { createPeers } from './peers.js'
|
|
13
14
|
import { runDeliberation, validateDeliberation } from './deliberation.js'
|
|
14
15
|
import { deliberationsFromEvents } from './deliberation-history.js'
|
|
15
16
|
import { compactionPrompt, formatCompactSummary, summarySections, compactionKeepFrom } from './compaction.js'
|
|
@@ -99,7 +100,7 @@ function errorText(err, limit) {
|
|
|
99
100
|
return String(err?.message || err).slice(0, limit)
|
|
100
101
|
}
|
|
101
102
|
|
|
102
|
-
export function createController({ boot }) {
|
|
103
|
+
export function createController({ boot, run = runTurn, peerDirectory } = {}) {
|
|
103
104
|
if (!Object.hasOwn(boot, 'participantAModel')) boot.participantAModel = boot.proposerModel ?? null
|
|
104
105
|
if (!Object.hasOwn(boot, 'participantBModel')) boot.participantBModel = boot.reviewerModel ?? null
|
|
105
106
|
const { on, emit } = createEmitter()
|
|
@@ -132,6 +133,9 @@ export function createController({ boot }) {
|
|
|
132
133
|
imageCount: 0,
|
|
133
134
|
activityVersion: 0,
|
|
134
135
|
held: false,
|
|
136
|
+
peerPaused: false,
|
|
137
|
+
peerConnection: null,
|
|
138
|
+
peerError: null,
|
|
135
139
|
}
|
|
136
140
|
|
|
137
141
|
let abort = null
|
|
@@ -140,9 +144,130 @@ export function createController({ boot }) {
|
|
|
140
144
|
let pendingSystemNotes = []
|
|
141
145
|
const warnedTools = new Set()
|
|
142
146
|
|
|
143
|
-
const changed = () =>
|
|
147
|
+
const changed = () => {
|
|
148
|
+
peers.setStatus(state.held || state.peerPaused ? 'paused' : state.busy ? 'busy' : 'idle')
|
|
149
|
+
emit('change', state)
|
|
150
|
+
}
|
|
144
151
|
const flash = (message) => emit('flash', message)
|
|
145
152
|
|
|
153
|
+
let preparingTurn = false
|
|
154
|
+
let preparation = Promise.resolve()
|
|
155
|
+
let peerTransition = false
|
|
156
|
+
let peerOperations = Promise.resolve()
|
|
157
|
+
let shuttingDown = false
|
|
158
|
+
let peerWakeScheduled = false
|
|
159
|
+
const peerWrites = new Set()
|
|
160
|
+
const incomingPeers = new Map()
|
|
161
|
+
const peers = createPeers({
|
|
162
|
+
directory: peerDirectory,
|
|
163
|
+
onMessage: async (message) => {
|
|
164
|
+
const session = state.session
|
|
165
|
+
if (shuttingDown || peerTransition || !session || session.id !== message.to.id || peers.identity?.id !== session.id) throw new Error('recipient session is disconnected')
|
|
166
|
+
if (boot.ephemeral) throw new Error('peer delivery requires a saved session')
|
|
167
|
+
const duplicate = state.events.find((event) => event.type === 'peer_message' && event.data.id === message.id)
|
|
168
|
+
if (duplicate) {
|
|
169
|
+
if (duplicate.data.from.id !== message.from.id || duplicate.data.message !== message.message) throw new Error('message ID reused with different content')
|
|
170
|
+
return
|
|
171
|
+
}
|
|
172
|
+
const incoming = incomingPeers.get(message.id)
|
|
173
|
+
if (incoming) {
|
|
174
|
+
if (incoming.from.id !== message.from.id || incoming.message !== message.message) throw new Error('message ID reused with different content')
|
|
175
|
+
return incoming.write
|
|
176
|
+
}
|
|
177
|
+
if (pendingPeers().length + peerWrites.size >= 100) throw new Error('recipient inbox is full')
|
|
178
|
+
const write = appendPeer(message, 'incoming', 'delivered')
|
|
179
|
+
incomingPeers.set(message.id, { ...message, write })
|
|
180
|
+
try { await write } finally { incomingPeers.delete(message.id) }
|
|
181
|
+
schedulePeerWake()
|
|
182
|
+
},
|
|
183
|
+
onSend: async (message) => {
|
|
184
|
+
if (peerTransition || state.session?.id !== message.from.id) throw new Error('sender session changed')
|
|
185
|
+
await appendPeer(message, 'outgoing', 'sending')
|
|
186
|
+
},
|
|
187
|
+
onDelivery: async (delivery) => {
|
|
188
|
+
const event = makeEvent('peer_delivery', delivery)
|
|
189
|
+
await state.session.append(event, { strict: true })
|
|
190
|
+
state.events.push(event)
|
|
191
|
+
state.persisted = state.events.length
|
|
192
|
+
state.overlay = state.overlay.map((item) => item.kind === 'peer' && item.messageId === delivery.id ? { ...item, ...delivery } : item)
|
|
193
|
+
reDerive()
|
|
194
|
+
await state.session?.flush()
|
|
195
|
+
},
|
|
196
|
+
})
|
|
197
|
+
|
|
198
|
+
async function appendPeer(message, direction, status) {
|
|
199
|
+
const session = state.session
|
|
200
|
+
const event = makeEvent('peer_message', { ...message, direction, status })
|
|
201
|
+
const write = (async () => {
|
|
202
|
+
await session.append(event, { strict: true })
|
|
203
|
+
if (state.session !== session) return
|
|
204
|
+
state.events.push(event)
|
|
205
|
+
state.persisted = state.events.length
|
|
206
|
+
reDerive()
|
|
207
|
+
if (state.busy && !state.compacting) {
|
|
208
|
+
const items = [...state.overlay]
|
|
209
|
+
flushStream(items)
|
|
210
|
+
items.push(state.derived.transcript.findLast((item) => item.kind === 'peer' && item.messageId === message.id))
|
|
211
|
+
set({ overlay: items })
|
|
212
|
+
}
|
|
213
|
+
})()
|
|
214
|
+
peerWrites.add(write)
|
|
215
|
+
try { await write } finally { peerWrites.delete(write) }
|
|
216
|
+
}
|
|
217
|
+
|
|
218
|
+
function pendingPeers() {
|
|
219
|
+
return state.derived.pendingPeerMessages.filter((message) => message.to.id === state.session?.id)
|
|
220
|
+
}
|
|
221
|
+
|
|
222
|
+
function schedulePeerWake() {
|
|
223
|
+
if (peerWakeScheduled || shuttingDown) return
|
|
224
|
+
peerWakeScheduled = true
|
|
225
|
+
setImmediate(() => {
|
|
226
|
+
peerWakeScheduled = false
|
|
227
|
+
if (shuttingDown || peerTransition || peerWrites.size || preparingTurn || state.busy || state.held || state.peerPaused || !peers.identity || !pendingPeers().length) return
|
|
228
|
+
runAgentTurn().catch((error) => { abort = null; set({ busy: false, turnPhase: 'idle', peerPaused: true }); flash(`peer response failed: ${errorText(error, 120)}`) })
|
|
229
|
+
})
|
|
230
|
+
}
|
|
231
|
+
|
|
232
|
+
function transitionPeerSession(action) {
|
|
233
|
+
return (...args) => {
|
|
234
|
+
const result = peerOperations.then(async () => {
|
|
235
|
+
if (preparingTurn) {
|
|
236
|
+
if (action !== shutdown) return flash('finish or interrupt the current turn first')
|
|
237
|
+
shuttingDown = true
|
|
238
|
+
await preparation
|
|
239
|
+
}
|
|
240
|
+
peerTransition = true
|
|
241
|
+
try {
|
|
242
|
+
await Promise.allSettled(peerWrites)
|
|
243
|
+
return await action(...args)
|
|
244
|
+
} finally {
|
|
245
|
+
peerTransition = false
|
|
246
|
+
flushSystemNotes()
|
|
247
|
+
}
|
|
248
|
+
})
|
|
249
|
+
peerOperations = result.catch(() => {})
|
|
250
|
+
return result
|
|
251
|
+
}
|
|
252
|
+
}
|
|
253
|
+
|
|
254
|
+
async function disconnectPeers() {
|
|
255
|
+
await Promise.allSettled(peerWrites)
|
|
256
|
+
await peers.disconnect()
|
|
257
|
+
set({ peerConnection: null, peerError: null })
|
|
258
|
+
}
|
|
259
|
+
|
|
260
|
+
async function reconnectPeers() {
|
|
261
|
+
if (!state.derived.title || !state.session) return
|
|
262
|
+
try {
|
|
263
|
+
const identity = await peers.connect({ id: state.session.id, name: state.derived.title, cwd: boot.cwd })
|
|
264
|
+
set({ peerConnection: identity, peerError: null })
|
|
265
|
+
} catch (error) {
|
|
266
|
+
set({ peerConnection: null, peerError: error.message })
|
|
267
|
+
flash(`peer disconnected: ${error.message}`)
|
|
268
|
+
}
|
|
269
|
+
}
|
|
270
|
+
|
|
146
271
|
function set(patch) {
|
|
147
272
|
Object.assign(state, patch)
|
|
148
273
|
changed()
|
|
@@ -381,7 +506,8 @@ export function createController({ boot }) {
|
|
|
381
506
|
}
|
|
382
507
|
|
|
383
508
|
function flushSystemNotes() {
|
|
384
|
-
|
|
509
|
+
schedulePeerWake()
|
|
510
|
+
if (!pendingSystemNotes.length || state.busy || state.held || peerTransition || shuttingDown || !state.session) return
|
|
385
511
|
pendingSystemNotes = pendingSystemNotes.filter((note) => !note.agentId || !agents.get(note.agentId)?.collectedAt)
|
|
386
512
|
const currentSessionId = state.session.id
|
|
387
513
|
const current = pendingSystemNotes.filter((note) => !note.sessionId || note.sessionId === currentSessionId)
|
|
@@ -400,6 +526,7 @@ export function createController({ boot }) {
|
|
|
400
526
|
function hold(held) {
|
|
401
527
|
set({ held })
|
|
402
528
|
if (!held) flushSystemNotes()
|
|
529
|
+
schedulePeerWake()
|
|
403
530
|
}
|
|
404
531
|
|
|
405
532
|
function flushStream(items) {
|
|
@@ -417,10 +544,28 @@ export function createController({ boot }) {
|
|
|
417
544
|
}
|
|
418
545
|
|
|
419
546
|
async function executeTurn(text, { views = [] } = {}) {
|
|
420
|
-
|
|
421
|
-
|
|
422
|
-
|
|
423
|
-
|
|
547
|
+
preparingTurn = true
|
|
548
|
+
let prepared
|
|
549
|
+
preparation = new Promise(resolve => { prepared = resolve })
|
|
550
|
+
const session = state.session
|
|
551
|
+
try {
|
|
552
|
+
for (const view of views) await persistUserMessage(view, { viewed: true })
|
|
553
|
+
if (text) await persistUserMessage(text)
|
|
554
|
+
reDerive()
|
|
555
|
+
preparingTurn = false
|
|
556
|
+
prepared()
|
|
557
|
+
await runAgentTurn()
|
|
558
|
+
} catch (error) {
|
|
559
|
+
if (!session || session === state.session) {
|
|
560
|
+
abort = null
|
|
561
|
+
set({ busy: false, turnPhase: 'idle', peerPaused: true })
|
|
562
|
+
flash(`error: ${errorText(error, 120)}`)
|
|
563
|
+
}
|
|
564
|
+
} finally {
|
|
565
|
+
preparingTurn = false
|
|
566
|
+
prepared()
|
|
567
|
+
schedulePeerWake()
|
|
568
|
+
}
|
|
424
569
|
}
|
|
425
570
|
|
|
426
571
|
function takePending() {
|
|
@@ -430,7 +575,7 @@ export function createController({ boot }) {
|
|
|
430
575
|
}
|
|
431
576
|
|
|
432
577
|
async function compact(instructions = '') {
|
|
433
|
-
if (state.busy || state.compacting) return flash('finish or interrupt the current turn first')
|
|
578
|
+
if (state.busy || state.compacting || peerTransition) return flash('finish or interrupt the current turn first')
|
|
434
579
|
const current = state.derived
|
|
435
580
|
if (current.providerHistory.length < 4) return flash('nothing to compact yet')
|
|
436
581
|
|
|
@@ -603,20 +748,29 @@ export function createController({ boot }) {
|
|
|
603
748
|
}
|
|
604
749
|
|
|
605
750
|
async function runAgentTurn() {
|
|
751
|
+
try { await performAgentTurn() } catch (error) {
|
|
752
|
+
abort = null
|
|
753
|
+
set({ busy: false, turnPhase: 'idle', peerPaused: true })
|
|
754
|
+
flash(`error: ${errorText(error, 120)}`)
|
|
755
|
+
}
|
|
756
|
+
}
|
|
757
|
+
|
|
758
|
+
async function performAgentTurn() {
|
|
759
|
+
if (state.busy || peerTransition || shuttingDown) return
|
|
606
760
|
const researchAgentLimit = nextResearchAgentLimit || null
|
|
607
761
|
nextResearchAgentLimit = null
|
|
762
|
+
const controller = new AbortController()
|
|
763
|
+
abort = controller
|
|
608
764
|
emit('turn', 'start')
|
|
609
765
|
set({ busy: true, turnPhase: 'responding', startedAt: Date.now(), liveUsage: null })
|
|
610
766
|
|
|
611
767
|
const { auth, ok } = await codexAuth()
|
|
612
768
|
if (!ok) {
|
|
613
|
-
set({ turnPhase: 'idle', busy: false })
|
|
769
|
+
set({ turnPhase: 'idle', busy: false, peerPaused: true })
|
|
614
770
|
flushSystemNotes()
|
|
615
771
|
return
|
|
616
772
|
}
|
|
617
773
|
|
|
618
|
-
const controller = new AbortController()
|
|
619
|
-
abort = controller
|
|
620
774
|
const { tracker } = boot
|
|
621
775
|
const loadedBefore = new Set(tracker.loaded)
|
|
622
776
|
const userToolScan = await refreshProjectIndexes()
|
|
@@ -627,6 +781,7 @@ export function createController({ boot }) {
|
|
|
627
781
|
sessionId: state.session?.id,
|
|
628
782
|
sessionFile: state.session?.file,
|
|
629
783
|
wakeups: boot.wakeups,
|
|
784
|
+
peers: peers.identity ? peers : null,
|
|
630
785
|
agents: boot.researchModel ? agents : null,
|
|
631
786
|
deliberations: boot.deliberationModel || (boot.participantAModel && boot.participantBModel) ? deliberations : null,
|
|
632
787
|
onAgentsCollected: discardCollectedAgentNotes,
|
|
@@ -639,10 +794,24 @@ export function createController({ boot }) {
|
|
|
639
794
|
viewer: state.model.vision === false ? null : { deliver: deliverImage },
|
|
640
795
|
})
|
|
641
796
|
|
|
797
|
+
await Promise.allSettled(peerWrites)
|
|
798
|
+
if (controller.signal.aborted || shuttingDown) {
|
|
799
|
+
abort = null
|
|
800
|
+
set({ busy: false, turnPhase: 'idle', peerPaused: true })
|
|
801
|
+
return
|
|
802
|
+
}
|
|
803
|
+
const pendingPeerIds = state.peerPaused ? [] : pendingPeers().map((message) => message.id)
|
|
804
|
+
if (pendingPeerIds.length) {
|
|
805
|
+
const event = makeEvent('peer_consumed', { ids: pendingPeerIds })
|
|
806
|
+
await state.session.append(event, { strict: true })
|
|
807
|
+
state.events.push(event)
|
|
808
|
+
state.persisted = state.events.length
|
|
809
|
+
reDerive()
|
|
810
|
+
}
|
|
642
811
|
sendAfterToolTriggered = false
|
|
643
812
|
let result
|
|
644
813
|
try {
|
|
645
|
-
result = await
|
|
814
|
+
result = await run({
|
|
646
815
|
history: state.derived.providerHistory,
|
|
647
816
|
tools,
|
|
648
817
|
recorder,
|
|
@@ -656,6 +825,7 @@ export function createController({ boot }) {
|
|
|
656
825
|
} catch (err) {
|
|
657
826
|
abort = null
|
|
658
827
|
set({ overlay: [], streaming: null, liveUsage: null, turnPhase: 'idle', busy: false })
|
|
828
|
+
set({ peerPaused: true })
|
|
659
829
|
flash(`error: ${errorText(err, 120)}`)
|
|
660
830
|
return
|
|
661
831
|
}
|
|
@@ -676,6 +846,7 @@ export function createController({ boot }) {
|
|
|
676
846
|
state.streaming = null
|
|
677
847
|
state.turnPhase = 'idle'
|
|
678
848
|
state.busy = false
|
|
849
|
+
if ((result.interrupted && !sendAfterToolTriggered) || result.stalled || result.error) state.peerPaused = true
|
|
679
850
|
reDerive()
|
|
680
851
|
set({ liveUsage: null })
|
|
681
852
|
boot.git.refresh()
|
|
@@ -710,11 +881,13 @@ export function createController({ boot }) {
|
|
|
710
881
|
}
|
|
711
882
|
|
|
712
883
|
function send(text) {
|
|
884
|
+
if (peerTransition || shuttingDown) return flash('session is switching')
|
|
713
885
|
const value = text.trim()
|
|
714
886
|
if (!value) return
|
|
887
|
+
state.peerPaused = false
|
|
715
888
|
state.sent = [...state.sent, { text: value, at: Date.now() }]
|
|
716
889
|
appendPrompt(boot.root, value).catch(() => {})
|
|
717
|
-
if (state.busy) {
|
|
890
|
+
if (state.busy || preparingTurn) {
|
|
718
891
|
set({ queued: [...state.queued, value] })
|
|
719
892
|
return
|
|
720
893
|
}
|
|
@@ -723,6 +896,7 @@ export function createController({ boot }) {
|
|
|
723
896
|
}
|
|
724
897
|
|
|
725
898
|
function interrupt() {
|
|
899
|
+
set({ peerPaused: true })
|
|
726
900
|
if (!state.busy) return
|
|
727
901
|
sendAfterToolTriggered = false
|
|
728
902
|
cancelQuestion()
|
|
@@ -766,12 +940,14 @@ export function createController({ boot }) {
|
|
|
766
940
|
state.expedited = []
|
|
767
941
|
state.views = []
|
|
768
942
|
state.sent = []
|
|
943
|
+
state.peerPaused = false
|
|
769
944
|
state.model = model ?? state.defaultModel
|
|
770
945
|
state.effort = effort === undefined ? state.defaultEffort : effort
|
|
771
946
|
}
|
|
772
947
|
|
|
773
|
-
function newSession() {
|
|
948
|
+
async function newSession() {
|
|
774
949
|
if (state.busy) return flash('finish or interrupt the current turn first')
|
|
950
|
+
await disconnectPeers()
|
|
775
951
|
resetConversation()
|
|
776
952
|
agents.clear()
|
|
777
953
|
reDerive()
|
|
@@ -793,6 +969,7 @@ export function createController({ boot }) {
|
|
|
793
969
|
flash(`delete failed: ${errorText(err, 80)}`)
|
|
794
970
|
return false
|
|
795
971
|
}
|
|
972
|
+
await disconnectPeers()
|
|
796
973
|
resetConversation()
|
|
797
974
|
reDerive()
|
|
798
975
|
emit('session', state.session)
|
|
@@ -800,13 +977,15 @@ export function createController({ boot }) {
|
|
|
800
977
|
return true
|
|
801
978
|
}
|
|
802
979
|
|
|
803
|
-
async function fork(
|
|
804
|
-
if (
|
|
980
|
+
async function fork(args = '') {
|
|
981
|
+
if (args.trim()) return flash('usage: /fork')
|
|
805
982
|
if (state.busy) return flash('finish or interrupt the current turn first')
|
|
806
983
|
ensureSession()
|
|
807
|
-
const forked = await forkSession({ source: state.session, cwd: boot.cwd, root: boot.root, events: state.events
|
|
984
|
+
const forked = await forkSession({ source: state.session, cwd: boot.cwd, root: boot.root, events: state.events })
|
|
985
|
+
await disconnectPeers()
|
|
808
986
|
state.session = forked.session
|
|
809
987
|
state.events = forked.events
|
|
988
|
+
state.peerPaused = false
|
|
810
989
|
state.persisted = forked.events.length
|
|
811
990
|
state.rewindUndo = null
|
|
812
991
|
state.queued = []
|
|
@@ -816,17 +995,38 @@ export function createController({ boot }) {
|
|
|
816
995
|
agents.restore(forked.events)
|
|
817
996
|
reDerive()
|
|
818
997
|
emit('session', state.session)
|
|
819
|
-
flash(
|
|
998
|
+
flash('session forked')
|
|
820
999
|
}
|
|
821
1000
|
|
|
822
|
-
function rename(text) {
|
|
823
|
-
const
|
|
824
|
-
|
|
1001
|
+
async function rename(text = '') {
|
|
1002
|
+
const name = text.trim()
|
|
1003
|
+
if (boot.ephemeral && name) return flash('peer messaging requires a saved session')
|
|
825
1004
|
ensureSession()
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
1005
|
+
const previous = peers.identity
|
|
1006
|
+
try {
|
|
1007
|
+
await state.session.flush()
|
|
1008
|
+
if (name) await peers.connect({ id: state.session.id, name, cwd: boot.cwd })
|
|
1009
|
+
const event = makeEvent('title', { text: name || null })
|
|
1010
|
+
await state.session.append(event, { strict: true })
|
|
1011
|
+
state.events.push(event)
|
|
1012
|
+
state.persisted = state.events.length
|
|
1013
|
+
if (!name) await disconnectPeers()
|
|
1014
|
+
set({ peerConnection: peers.identity, peerError: null })
|
|
1015
|
+
reDerive()
|
|
1016
|
+
flash(name ? `session renamed to "${name}"` : 'session name reset')
|
|
1017
|
+
return true
|
|
1018
|
+
} catch (error) {
|
|
1019
|
+
try {
|
|
1020
|
+
if (previous) await peers.connect(previous)
|
|
1021
|
+
else await disconnectPeers()
|
|
1022
|
+
set({ peerConnection: peers.identity })
|
|
1023
|
+
} catch (rollbackError) {
|
|
1024
|
+
await disconnectPeers().catch(() => {})
|
|
1025
|
+
set({ peerConnection: null, peerError: rollbackError.message })
|
|
1026
|
+
}
|
|
1027
|
+
flash(`rename failed: ${error.message}`)
|
|
1028
|
+
return false
|
|
1029
|
+
}
|
|
830
1030
|
}
|
|
831
1031
|
|
|
832
1032
|
function setColor(input = '') {
|
|
@@ -965,10 +1165,14 @@ export function createController({ boot }) {
|
|
|
965
1165
|
if (meta.header.root !== boot.root) return switchProject(meta)
|
|
966
1166
|
try {
|
|
967
1167
|
const { header, events } = await loadSession(meta.file)
|
|
1168
|
+
await disconnectPeers()
|
|
968
1169
|
state.session = openSession({ file: meta.file, header })
|
|
969
1170
|
state.events = [...events]
|
|
970
1171
|
state.persisted = events.length
|
|
971
1172
|
state.rewindUndo = null
|
|
1173
|
+
state.peerPaused = false
|
|
1174
|
+
const unfinished = deriveState(events).transcript.filter((item) => item.kind === 'peer' && item.direction === 'outgoing' && item.status === 'sending')
|
|
1175
|
+
for (const item of unfinished) persist(makeEvent('peer_delivery', { id: item.messageId, status: 'unknown' }))
|
|
972
1176
|
agents.restore(events)
|
|
973
1177
|
reDerive()
|
|
974
1178
|
restoreModelFromSession()
|
|
@@ -976,6 +1180,7 @@ export function createController({ boot }) {
|
|
|
976
1180
|
state.sent = userEntries(state.derived).map((e) => ({ text: recallText(e), at: header.createdAt }))
|
|
977
1181
|
changed()
|
|
978
1182
|
emit('session', state.session)
|
|
1183
|
+
await reconnectPeers()
|
|
979
1184
|
emit('resumed', meta)
|
|
980
1185
|
} catch (err) {
|
|
981
1186
|
flash(`resume failed: ${errorText(err, 80)}`)
|
|
@@ -1051,6 +1256,7 @@ export function createController({ boot }) {
|
|
|
1051
1256
|
boot.git.retarget(next.root)
|
|
1052
1257
|
next.mcp.connectAll()
|
|
1053
1258
|
emit('mcp', next.mcp.list())
|
|
1259
|
+
await disconnectPeers()
|
|
1054
1260
|
resetConversation()
|
|
1055
1261
|
agents.clear()
|
|
1056
1262
|
reDerive()
|
|
@@ -1314,6 +1520,7 @@ export function createController({ boot }) {
|
|
|
1314
1520
|
skills: boot.skills,
|
|
1315
1521
|
shells: boot.shells,
|
|
1316
1522
|
wakeups: boot.wakeups,
|
|
1523
|
+
peers: peers.identity ? peers : null,
|
|
1317
1524
|
memory: boot.memory,
|
|
1318
1525
|
...extra,
|
|
1319
1526
|
})
|
|
@@ -1451,6 +1658,9 @@ export function createController({ boot }) {
|
|
|
1451
1658
|
}
|
|
1452
1659
|
|
|
1453
1660
|
async function shutdown() {
|
|
1661
|
+
shuttingDown = true
|
|
1662
|
+
abort?.abort()
|
|
1663
|
+
await disconnectPeers()
|
|
1454
1664
|
await state.session?.flush()
|
|
1455
1665
|
boot.shells.killAll()
|
|
1456
1666
|
boot.mcp.terminateAll()
|
|
@@ -1473,19 +1683,19 @@ export function createController({ boot }) {
|
|
|
1473
1683
|
holdExpedited,
|
|
1474
1684
|
hold,
|
|
1475
1685
|
noteSystem,
|
|
1476
|
-
newSession,
|
|
1477
|
-
deleteCurrentSession,
|
|
1478
|
-
fork,
|
|
1479
|
-
rename,
|
|
1686
|
+
newSession: transitionPeerSession(newSession),
|
|
1687
|
+
deleteCurrentSession: transitionPeerSession(deleteCurrentSession),
|
|
1688
|
+
fork: transitionPeerSession(fork),
|
|
1689
|
+
rename: transitionPeerSession(rename),
|
|
1480
1690
|
setColor,
|
|
1481
1691
|
clear,
|
|
1482
|
-
resume,
|
|
1692
|
+
resume: transitionPeerSession(resume),
|
|
1483
1693
|
listResumeSessions,
|
|
1484
1694
|
listProjects,
|
|
1485
1695
|
addWorktree,
|
|
1486
1696
|
deleteWorktree,
|
|
1487
|
-
switchToWorktree,
|
|
1488
|
-
switchProject,
|
|
1697
|
+
switchToWorktree: transitionPeerSession(switchToWorktree),
|
|
1698
|
+
switchProject: transitionPeerSession(switchProject),
|
|
1489
1699
|
resolveModel,
|
|
1490
1700
|
switchModel,
|
|
1491
1701
|
switchModelByName,
|
|
@@ -1530,6 +1740,6 @@ export function createController({ boot }) {
|
|
|
1530
1740
|
dismissDeliberation,
|
|
1531
1741
|
shellRows,
|
|
1532
1742
|
cancelWakeup,
|
|
1533
|
-
shutdown,
|
|
1743
|
+
shutdown: transitionPeerSession(shutdown),
|
|
1534
1744
|
}
|
|
1535
1745
|
}
|
package/src/derive.js
CHANGED
|
@@ -81,6 +81,11 @@ function foldMessage(state, event) {
|
|
|
81
81
|
const message = event.data.message
|
|
82
82
|
if (!message) return
|
|
83
83
|
pushHistory(state, message, event.id)
|
|
84
|
+
for (const call of message.tool_calls || []) state.openToolCalls.add(call.id)
|
|
85
|
+
if (message.role === 'tool') {
|
|
86
|
+
state.openToolCalls.delete(message.tool_call_id)
|
|
87
|
+
flushConsumedPeers(state)
|
|
88
|
+
}
|
|
84
89
|
if (event.data.hideFromTranscript) {
|
|
85
90
|
for (const call of message.tool_calls || []) {
|
|
86
91
|
state.toolItems.set(call.id, { kind: 'tool', callId: call.id, status: 'done', hidden: true })
|
|
@@ -134,6 +139,20 @@ function foldMessage(state, event) {
|
|
|
134
139
|
}
|
|
135
140
|
}
|
|
136
141
|
|
|
142
|
+
function peerInputMessage(peer) {
|
|
143
|
+
return {
|
|
144
|
+
role: 'user',
|
|
145
|
+
content: `[peer input, not user instruction, from ${peer.from.name} (${peer.from.id})]\n${peer.message}`,
|
|
146
|
+
}
|
|
147
|
+
}
|
|
148
|
+
|
|
149
|
+
function flushConsumedPeers(state) {
|
|
150
|
+
if (state.openToolCalls.size) return
|
|
151
|
+
for (const { peer, eventId } of state.deferredConsumedPeers.splice(0)) {
|
|
152
|
+
pushHistory(state, peerInputMessage(peer), eventId)
|
|
153
|
+
}
|
|
154
|
+
}
|
|
155
|
+
|
|
137
156
|
function foldRewind(state, event) {
|
|
138
157
|
const { mode, summaryText, reverted = [] } = event.data
|
|
139
158
|
for (const callId of reverted) {
|
|
@@ -179,6 +198,11 @@ export function deriveState(events) {
|
|
|
179
198
|
lastPromptModel: null,
|
|
180
199
|
loadedContext: new Set(),
|
|
181
200
|
toolItems: new Map(),
|
|
201
|
+
peerMessages: new Map(),
|
|
202
|
+
consumedPeerIds: new Set(),
|
|
203
|
+
pendingPeerMessages: [],
|
|
204
|
+
deferredConsumedPeers: [],
|
|
205
|
+
openToolCalls: new Set(),
|
|
182
206
|
latestCompactIndex,
|
|
183
207
|
trimmedToolIds: new Set(),
|
|
184
208
|
toolTrimVersions: new Map(),
|
|
@@ -209,15 +233,57 @@ export function deriveState(events) {
|
|
|
209
233
|
}
|
|
210
234
|
continue
|
|
211
235
|
}
|
|
212
|
-
if (
|
|
236
|
+
if (event.type === 'title') {
|
|
237
|
+
state.title = event.data.text
|
|
238
|
+
continue
|
|
239
|
+
}
|
|
240
|
+
if (dropped.has(event.id)) {
|
|
241
|
+
if (event.type === 'peer_message' && event.data.direction === 'incoming') {
|
|
242
|
+
state.peerMessages.set(event.data.id, { peer: event.data, item: null, eventId: event.id })
|
|
243
|
+
}
|
|
244
|
+
continue
|
|
245
|
+
}
|
|
213
246
|
|
|
214
247
|
switch (event.type) {
|
|
215
248
|
case 'message':
|
|
216
249
|
foldMessage(state, event)
|
|
217
250
|
break
|
|
251
|
+
case 'peer_message': {
|
|
252
|
+
const peer = event.data
|
|
253
|
+
const item = {
|
|
254
|
+
kind: 'peer', direction: peer.direction, from: peer.from, to: peer.to,
|
|
255
|
+
text: peer.message, status: peer.status || 'unknown', messageId: peer.id,
|
|
256
|
+
eventId: event.id, at: event.at ?? null,
|
|
257
|
+
}
|
|
258
|
+
state.transcript.push(item)
|
|
259
|
+
state.peerMessages.set(peer.id, { peer, item, eventId: event.id })
|
|
260
|
+
break
|
|
261
|
+
}
|
|
262
|
+
case 'peer_delivery': {
|
|
263
|
+
const entry = state.peerMessages.get(event.data.id)
|
|
264
|
+
if (entry?.item) Object.assign(entry.item, { status: event.data.status, ...(event.data.error !== undefined ? { error: event.data.error } : {}) })
|
|
265
|
+
break
|
|
266
|
+
}
|
|
267
|
+
case 'peer_consumed':
|
|
268
|
+
for (const id of event.data.ids || []) {
|
|
269
|
+
if (state.consumedPeerIds.has(id)) continue
|
|
270
|
+
state.consumedPeerIds.add(id)
|
|
271
|
+
const entry = state.peerMessages.get(id)
|
|
272
|
+
if (entry?.peer.direction === 'incoming') state.deferredConsumedPeers.push(entry)
|
|
273
|
+
}
|
|
274
|
+
flushConsumedPeers(state)
|
|
275
|
+
break
|
|
218
276
|
case 'turn_transcript':
|
|
219
277
|
for (const item of event.data.items || []) {
|
|
220
278
|
const restored = { ...item, eventId: event.id, at: item.at ?? event.at ?? null }
|
|
279
|
+
if (restored.kind === 'peer') {
|
|
280
|
+
const entry = state.peerMessages.get(restored.messageId)
|
|
281
|
+
if (entry?.item) {
|
|
282
|
+
state.transcript = state.transcript.filter((candidate) => candidate !== entry.item)
|
|
283
|
+
Object.assign(restored, { status: entry.item.status, error: entry.item.error })
|
|
284
|
+
entry.item = restored
|
|
285
|
+
}
|
|
286
|
+
}
|
|
221
287
|
state.transcript.push(restored)
|
|
222
288
|
if (restored.kind === 'tool' && restored.callId) state.toolItems.set(restored.callId, restored)
|
|
223
289
|
}
|
|
@@ -239,9 +305,6 @@ export function deriveState(events) {
|
|
|
239
305
|
case 'effort':
|
|
240
306
|
state.effort = event.data.to
|
|
241
307
|
break
|
|
242
|
-
case 'title':
|
|
243
|
-
state.title = event.data.text
|
|
244
|
-
break
|
|
245
308
|
case 'color':
|
|
246
309
|
state.color = event.data.value
|
|
247
310
|
break
|
|
@@ -268,6 +331,12 @@ export function deriveState(events) {
|
|
|
268
331
|
]
|
|
269
332
|
state.historyEventIds = [null, null]
|
|
270
333
|
}
|
|
334
|
+
state.openToolCalls.clear()
|
|
335
|
+
for (const message of state.providerHistory) {
|
|
336
|
+
for (const call of message.tool_calls || []) state.openToolCalls.add(call.id)
|
|
337
|
+
if (message.role === 'tool') state.openToolCalls.delete(message.tool_call_id)
|
|
338
|
+
}
|
|
339
|
+
flushConsumedPeers(state)
|
|
271
340
|
state.transcript.push({ kind: 'summary', source: 'compact', text: summary })
|
|
272
341
|
state.lastPromptTokens = 0
|
|
273
342
|
break
|
|
@@ -291,6 +360,8 @@ export function deriveState(events) {
|
|
|
291
360
|
state.transcript = []
|
|
292
361
|
state.providerHistory = []
|
|
293
362
|
state.historyEventIds = []
|
|
363
|
+
state.openToolCalls.clear()
|
|
364
|
+
flushConsumedPeers(state)
|
|
294
365
|
state.toolItems = new Map()
|
|
295
366
|
state.trimmedToolIds = new Set()
|
|
296
367
|
state.toolTrimVersions = new Map()
|
|
@@ -320,6 +391,11 @@ export function deriveState(events) {
|
|
|
320
391
|
}
|
|
321
392
|
}
|
|
322
393
|
|
|
394
|
+
flushConsumedPeers(state)
|
|
395
|
+
const consumedPeerIds = new Set(events.filter((event) => event.type === 'peer_consumed').flatMap((event) => event.data.ids || []))
|
|
396
|
+
state.pendingPeerMessages = [...state.peerMessages.values()]
|
|
397
|
+
.filter(({ peer }) => peer.direction === 'incoming' && !consumedPeerIds.has(peer.id))
|
|
398
|
+
.map(({ peer }) => peer)
|
|
323
399
|
state.estimatedPromptTokens = contextEdited && measuredBaseline
|
|
324
400
|
? Math.max(0, measuredBaseline.tokens + historyTokens() - measuredBaseline.history)
|
|
325
401
|
: null
|
package/src/export.js
CHANGED
|
@@ -3,6 +3,9 @@ export function transcriptToMarkdown(transcript, { title = 'pico session' } = {}
|
|
|
3
3
|
for (const item of transcript) {
|
|
4
4
|
if (item.kind === 'user') {
|
|
5
5
|
parts.push('## You', '', item.text, '')
|
|
6
|
+
} else if (item.kind === 'peer') {
|
|
7
|
+
const status = item.direction === 'outgoing' ? ` [${item.status || 'unknown'}]` : ''
|
|
8
|
+
parts.push(`## @${item.from.name} → @${item.to.name}${status}`, '', item.text, '')
|
|
6
9
|
} else if (item.kind === 'assistant') {
|
|
7
10
|
parts.push(item.interrupted ? `${item.text}\n\n*(interrupted)*` : item.text, '')
|
|
8
11
|
} else if (item.kind === 'tool') {
|