picocode-core 0.9.191 → 0.9.193
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 +245 -34
- package/src/derive.js +80 -4
- package/src/export.js +3 -0
- package/src/peers.js +295 -0
- package/src/session.js +15 -7
- package/src/tools/index.js +21 -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 || !!duplicate.data.urgent !== !!message.urgent)) 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 || !!incoming.urgent !== !!message.urgent)) 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
|
|
|
@@ -594,7 +739,8 @@ export function createController({ boot }) {
|
|
|
594
739
|
: item,
|
|
595
740
|
),
|
|
596
741
|
)
|
|
597
|
-
|
|
742
|
+
const urgentPeer = !state.held && !state.peerPaused && !peerTransition && !shuttingDown && pendingPeers().some((message) => message.urgent)
|
|
743
|
+
if (state.expedited.length > 0 || state.views.length > 0 || urgentPeer) {
|
|
598
744
|
sendAfterToolTriggered = true
|
|
599
745
|
controller.abort()
|
|
600
746
|
}
|
|
@@ -603,20 +749,29 @@ export function createController({ boot }) {
|
|
|
603
749
|
}
|
|
604
750
|
|
|
605
751
|
async function runAgentTurn() {
|
|
752
|
+
try { await performAgentTurn() } catch (error) {
|
|
753
|
+
abort = null
|
|
754
|
+
set({ busy: false, turnPhase: 'idle', peerPaused: true })
|
|
755
|
+
flash(`error: ${errorText(error, 120)}`)
|
|
756
|
+
}
|
|
757
|
+
}
|
|
758
|
+
|
|
759
|
+
async function performAgentTurn() {
|
|
760
|
+
if (state.busy || peerTransition || shuttingDown) return
|
|
606
761
|
const researchAgentLimit = nextResearchAgentLimit || null
|
|
607
762
|
nextResearchAgentLimit = null
|
|
763
|
+
const controller = new AbortController()
|
|
764
|
+
abort = controller
|
|
608
765
|
emit('turn', 'start')
|
|
609
766
|
set({ busy: true, turnPhase: 'responding', startedAt: Date.now(), liveUsage: null })
|
|
610
767
|
|
|
611
768
|
const { auth, ok } = await codexAuth()
|
|
612
769
|
if (!ok) {
|
|
613
|
-
set({ turnPhase: 'idle', busy: false })
|
|
770
|
+
set({ turnPhase: 'idle', busy: false, peerPaused: true })
|
|
614
771
|
flushSystemNotes()
|
|
615
772
|
return
|
|
616
773
|
}
|
|
617
774
|
|
|
618
|
-
const controller = new AbortController()
|
|
619
|
-
abort = controller
|
|
620
775
|
const { tracker } = boot
|
|
621
776
|
const loadedBefore = new Set(tracker.loaded)
|
|
622
777
|
const userToolScan = await refreshProjectIndexes()
|
|
@@ -627,6 +782,7 @@ export function createController({ boot }) {
|
|
|
627
782
|
sessionId: state.session?.id,
|
|
628
783
|
sessionFile: state.session?.file,
|
|
629
784
|
wakeups: boot.wakeups,
|
|
785
|
+
peers: peers.identity ? peers : null,
|
|
630
786
|
agents: boot.researchModel ? agents : null,
|
|
631
787
|
deliberations: boot.deliberationModel || (boot.participantAModel && boot.participantBModel) ? deliberations : null,
|
|
632
788
|
onAgentsCollected: discardCollectedAgentNotes,
|
|
@@ -639,10 +795,24 @@ export function createController({ boot }) {
|
|
|
639
795
|
viewer: state.model.vision === false ? null : { deliver: deliverImage },
|
|
640
796
|
})
|
|
641
797
|
|
|
798
|
+
await Promise.allSettled(peerWrites)
|
|
799
|
+
if (controller.signal.aborted || shuttingDown) {
|
|
800
|
+
abort = null
|
|
801
|
+
set({ busy: false, turnPhase: 'idle', peerPaused: true })
|
|
802
|
+
return
|
|
803
|
+
}
|
|
804
|
+
const pendingPeerIds = state.peerPaused ? [] : pendingPeers().map((message) => message.id)
|
|
805
|
+
if (pendingPeerIds.length) {
|
|
806
|
+
const event = makeEvent('peer_consumed', { ids: pendingPeerIds })
|
|
807
|
+
await state.session.append(event, { strict: true })
|
|
808
|
+
state.events.push(event)
|
|
809
|
+
state.persisted = state.events.length
|
|
810
|
+
reDerive()
|
|
811
|
+
}
|
|
642
812
|
sendAfterToolTriggered = false
|
|
643
813
|
let result
|
|
644
814
|
try {
|
|
645
|
-
result = await
|
|
815
|
+
result = await run({
|
|
646
816
|
history: state.derived.providerHistory,
|
|
647
817
|
tools,
|
|
648
818
|
recorder,
|
|
@@ -656,6 +826,7 @@ export function createController({ boot }) {
|
|
|
656
826
|
} catch (err) {
|
|
657
827
|
abort = null
|
|
658
828
|
set({ overlay: [], streaming: null, liveUsage: null, turnPhase: 'idle', busy: false })
|
|
829
|
+
set({ peerPaused: true })
|
|
659
830
|
flash(`error: ${errorText(err, 120)}`)
|
|
660
831
|
return
|
|
661
832
|
}
|
|
@@ -676,6 +847,7 @@ export function createController({ boot }) {
|
|
|
676
847
|
state.streaming = null
|
|
677
848
|
state.turnPhase = 'idle'
|
|
678
849
|
state.busy = false
|
|
850
|
+
if ((result.interrupted && !sendAfterToolTriggered) || result.stalled || result.error) state.peerPaused = true
|
|
679
851
|
reDerive()
|
|
680
852
|
set({ liveUsage: null })
|
|
681
853
|
boot.git.refresh()
|
|
@@ -710,11 +882,13 @@ export function createController({ boot }) {
|
|
|
710
882
|
}
|
|
711
883
|
|
|
712
884
|
function send(text) {
|
|
885
|
+
if (peerTransition || shuttingDown) return flash('session is switching')
|
|
713
886
|
const value = text.trim()
|
|
714
887
|
if (!value) return
|
|
888
|
+
state.peerPaused = false
|
|
715
889
|
state.sent = [...state.sent, { text: value, at: Date.now() }]
|
|
716
890
|
appendPrompt(boot.root, value).catch(() => {})
|
|
717
|
-
if (state.busy) {
|
|
891
|
+
if (state.busy || preparingTurn) {
|
|
718
892
|
set({ queued: [...state.queued, value] })
|
|
719
893
|
return
|
|
720
894
|
}
|
|
@@ -723,6 +897,7 @@ export function createController({ boot }) {
|
|
|
723
897
|
}
|
|
724
898
|
|
|
725
899
|
function interrupt() {
|
|
900
|
+
set({ peerPaused: true })
|
|
726
901
|
if (!state.busy) return
|
|
727
902
|
sendAfterToolTriggered = false
|
|
728
903
|
cancelQuestion()
|
|
@@ -766,12 +941,14 @@ export function createController({ boot }) {
|
|
|
766
941
|
state.expedited = []
|
|
767
942
|
state.views = []
|
|
768
943
|
state.sent = []
|
|
944
|
+
state.peerPaused = false
|
|
769
945
|
state.model = model ?? state.defaultModel
|
|
770
946
|
state.effort = effort === undefined ? state.defaultEffort : effort
|
|
771
947
|
}
|
|
772
948
|
|
|
773
|
-
function newSession() {
|
|
949
|
+
async function newSession() {
|
|
774
950
|
if (state.busy) return flash('finish or interrupt the current turn first')
|
|
951
|
+
await disconnectPeers()
|
|
775
952
|
resetConversation()
|
|
776
953
|
agents.clear()
|
|
777
954
|
reDerive()
|
|
@@ -793,6 +970,7 @@ export function createController({ boot }) {
|
|
|
793
970
|
flash(`delete failed: ${errorText(err, 80)}`)
|
|
794
971
|
return false
|
|
795
972
|
}
|
|
973
|
+
await disconnectPeers()
|
|
796
974
|
resetConversation()
|
|
797
975
|
reDerive()
|
|
798
976
|
emit('session', state.session)
|
|
@@ -800,13 +978,15 @@ export function createController({ boot }) {
|
|
|
800
978
|
return true
|
|
801
979
|
}
|
|
802
980
|
|
|
803
|
-
async function fork(
|
|
804
|
-
if (
|
|
981
|
+
async function fork(args = '') {
|
|
982
|
+
if (args.trim()) return flash('usage: /fork')
|
|
805
983
|
if (state.busy) return flash('finish or interrupt the current turn first')
|
|
806
984
|
ensureSession()
|
|
807
|
-
const forked = await forkSession({ source: state.session, cwd: boot.cwd, root: boot.root, events: state.events
|
|
985
|
+
const forked = await forkSession({ source: state.session, cwd: boot.cwd, root: boot.root, events: state.events })
|
|
986
|
+
await disconnectPeers()
|
|
808
987
|
state.session = forked.session
|
|
809
988
|
state.events = forked.events
|
|
989
|
+
state.peerPaused = false
|
|
810
990
|
state.persisted = forked.events.length
|
|
811
991
|
state.rewindUndo = null
|
|
812
992
|
state.queued = []
|
|
@@ -816,17 +996,38 @@ export function createController({ boot }) {
|
|
|
816
996
|
agents.restore(forked.events)
|
|
817
997
|
reDerive()
|
|
818
998
|
emit('session', state.session)
|
|
819
|
-
flash(
|
|
999
|
+
flash('session forked')
|
|
820
1000
|
}
|
|
821
1001
|
|
|
822
|
-
function rename(text) {
|
|
823
|
-
const
|
|
824
|
-
|
|
1002
|
+
async function rename(text = '') {
|
|
1003
|
+
const name = text.trim()
|
|
1004
|
+
if (boot.ephemeral && name) return flash('peer messaging requires a saved session')
|
|
825
1005
|
ensureSession()
|
|
826
|
-
|
|
827
|
-
|
|
828
|
-
|
|
829
|
-
|
|
1006
|
+
const previous = peers.identity
|
|
1007
|
+
try {
|
|
1008
|
+
await state.session.flush()
|
|
1009
|
+
if (name) await peers.connect({ id: state.session.id, name, cwd: boot.cwd })
|
|
1010
|
+
const event = makeEvent('title', { text: name || null })
|
|
1011
|
+
await state.session.append(event, { strict: true })
|
|
1012
|
+
state.events.push(event)
|
|
1013
|
+
state.persisted = state.events.length
|
|
1014
|
+
if (!name) await disconnectPeers()
|
|
1015
|
+
set({ peerConnection: peers.identity, peerError: null })
|
|
1016
|
+
reDerive()
|
|
1017
|
+
flash(name ? `session renamed to "${name}"` : 'session name reset')
|
|
1018
|
+
return true
|
|
1019
|
+
} catch (error) {
|
|
1020
|
+
try {
|
|
1021
|
+
if (previous) await peers.connect(previous)
|
|
1022
|
+
else await disconnectPeers()
|
|
1023
|
+
set({ peerConnection: peers.identity })
|
|
1024
|
+
} catch (rollbackError) {
|
|
1025
|
+
await disconnectPeers().catch(() => {})
|
|
1026
|
+
set({ peerConnection: null, peerError: rollbackError.message })
|
|
1027
|
+
}
|
|
1028
|
+
flash(`rename failed: ${error.message}`)
|
|
1029
|
+
return false
|
|
1030
|
+
}
|
|
830
1031
|
}
|
|
831
1032
|
|
|
832
1033
|
function setColor(input = '') {
|
|
@@ -965,10 +1166,14 @@ export function createController({ boot }) {
|
|
|
965
1166
|
if (meta.header.root !== boot.root) return switchProject(meta)
|
|
966
1167
|
try {
|
|
967
1168
|
const { header, events } = await loadSession(meta.file)
|
|
1169
|
+
await disconnectPeers()
|
|
968
1170
|
state.session = openSession({ file: meta.file, header })
|
|
969
1171
|
state.events = [...events]
|
|
970
1172
|
state.persisted = events.length
|
|
971
1173
|
state.rewindUndo = null
|
|
1174
|
+
state.peerPaused = false
|
|
1175
|
+
const unfinished = deriveState(events).transcript.filter((item) => item.kind === 'peer' && item.direction === 'outgoing' && item.status === 'sending')
|
|
1176
|
+
for (const item of unfinished) persist(makeEvent('peer_delivery', { id: item.messageId, status: 'unknown' }))
|
|
972
1177
|
agents.restore(events)
|
|
973
1178
|
reDerive()
|
|
974
1179
|
restoreModelFromSession()
|
|
@@ -976,6 +1181,7 @@ export function createController({ boot }) {
|
|
|
976
1181
|
state.sent = userEntries(state.derived).map((e) => ({ text: recallText(e), at: header.createdAt }))
|
|
977
1182
|
changed()
|
|
978
1183
|
emit('session', state.session)
|
|
1184
|
+
await reconnectPeers()
|
|
979
1185
|
emit('resumed', meta)
|
|
980
1186
|
} catch (err) {
|
|
981
1187
|
flash(`resume failed: ${errorText(err, 80)}`)
|
|
@@ -1051,6 +1257,7 @@ export function createController({ boot }) {
|
|
|
1051
1257
|
boot.git.retarget(next.root)
|
|
1052
1258
|
next.mcp.connectAll()
|
|
1053
1259
|
emit('mcp', next.mcp.list())
|
|
1260
|
+
await disconnectPeers()
|
|
1054
1261
|
resetConversation()
|
|
1055
1262
|
agents.clear()
|
|
1056
1263
|
reDerive()
|
|
@@ -1314,6 +1521,7 @@ export function createController({ boot }) {
|
|
|
1314
1521
|
skills: boot.skills,
|
|
1315
1522
|
shells: boot.shells,
|
|
1316
1523
|
wakeups: boot.wakeups,
|
|
1524
|
+
peers: peers.identity ? peers : null,
|
|
1317
1525
|
memory: boot.memory,
|
|
1318
1526
|
...extra,
|
|
1319
1527
|
})
|
|
@@ -1451,6 +1659,9 @@ export function createController({ boot }) {
|
|
|
1451
1659
|
}
|
|
1452
1660
|
|
|
1453
1661
|
async function shutdown() {
|
|
1662
|
+
shuttingDown = true
|
|
1663
|
+
abort?.abort()
|
|
1664
|
+
await disconnectPeers()
|
|
1454
1665
|
await state.session?.flush()
|
|
1455
1666
|
boot.shells.killAll()
|
|
1456
1667
|
boot.mcp.terminateAll()
|
|
@@ -1473,19 +1684,19 @@ export function createController({ boot }) {
|
|
|
1473
1684
|
holdExpedited,
|
|
1474
1685
|
hold,
|
|
1475
1686
|
noteSystem,
|
|
1476
|
-
newSession,
|
|
1477
|
-
deleteCurrentSession,
|
|
1478
|
-
fork,
|
|
1479
|
-
rename,
|
|
1687
|
+
newSession: transitionPeerSession(newSession),
|
|
1688
|
+
deleteCurrentSession: transitionPeerSession(deleteCurrentSession),
|
|
1689
|
+
fork: transitionPeerSession(fork),
|
|
1690
|
+
rename: transitionPeerSession(rename),
|
|
1480
1691
|
setColor,
|
|
1481
1692
|
clear,
|
|
1482
|
-
resume,
|
|
1693
|
+
resume: transitionPeerSession(resume),
|
|
1483
1694
|
listResumeSessions,
|
|
1484
1695
|
listProjects,
|
|
1485
1696
|
addWorktree,
|
|
1486
1697
|
deleteWorktree,
|
|
1487
|
-
switchToWorktree,
|
|
1488
|
-
switchProject,
|
|
1698
|
+
switchToWorktree: transitionPeerSession(switchToWorktree),
|
|
1699
|
+
switchProject: transitionPeerSession(switchProject),
|
|
1489
1700
|
resolveModel,
|
|
1490
1701
|
switchModel,
|
|
1491
1702
|
switchModelByName,
|
|
@@ -1530,6 +1741,6 @@ export function createController({ boot }) {
|
|
|
1530
1741
|
dismissDeliberation,
|
|
1531
1742
|
shellRows,
|
|
1532
1743
|
cancelWakeup,
|
|
1533
|
-
shutdown,
|
|
1744
|
+
shutdown: transitionPeerSession(shutdown),
|
|
1534
1745
|
}
|
|
1535
1746
|
}
|
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, urgent: peer.urgent ?? false, 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') {
|