picocode-core 0.9.179 → 0.9.181

package/package.json

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

package/src/agent-transcript.js

@@ -54,6 +54,7 @@ function deliberationTranscript(agent) {
     if (entry.kind === 'turn') {
       const turn = turnFor(entry.value.role, entry.value.round)
       turn.text = entry.value.text
+      if (entry.value.parallelGroup) turn.parallelGroup = entry.value.parallelGroup
       turn.active = false
       continue
     }
@@ -61,23 +62,35 @@ function deliberationTranscript(agent) {
     if (event.type === 'tool_executing') {
       const item = toolItem(event.call || {}, event.at)
       tools.set(item.callId, item)
-      turnFor(event.role, event.round).tools.push(item)
+      const turn = turnFor(event.role, event.round)
+      if (event.parallelGroup) turn.parallelGroup = event.parallelGroup
+      turn.tools.push(item)
     }
     if (event.type === 'tool_complete' || event.type === 'tool_error') settleTool(tools, event)
   }
-  // whoever is speaking right now shows their words as they arrive
-  const live = agent.live
-  if (live?.text && live.role !== 'synthesis') {
+  const liveTurns = agent.live?.turns || (agent.live?.role ? [agent.live] : [])
+  for (const live of liveTurns.filter((turn) => turn.role !== 'synthesis')) {
     const turn = turnFor(live.role, live.round)
-    if (turn.text == null) turn.text = live.text
+    if (live.parallelGroup) turn.parallelGroup = live.parallelGroup
+    if (turn.text == null && live.text) turn.text = live.text
   }
+  const liveSynthesis = liveTurns.find((turn) => turn.role === 'synthesis')
   if (agent.result) {
     items.push({ kind: 'deliberation-turn', role: 'synthesis', text: agent.result, tools: [], interrupted: agent.status === 'cancelled' })
-  } else if (live?.text && live.role === 'synthesis') {
-    items.push({ kind: 'deliberation-turn', role: 'synthesis', text: live.text, tools: [], active: true })
+  } else if (liveSynthesis?.text) {
+    items.push({ kind: 'deliberation-turn', role: 'synthesis', text: liveSynthesis.text, tools: [], active: true })
   } else if (agent.error) {
     items.push({ kind: 'assistant', text: agent.error, interrupted: true })
   }
+  const order = (turn) => turn.role === 'participant-a' ? 0 : 1
+  const grouped = items.filter((turn) => turn.parallelGroup)
+  for (const group of new Set(grouped.map((turn) => turn.parallelGroup))) {
+    const sorted = grouped.filter((turn) => turn.parallelGroup === group).sort((a, b) => order(a) - order(b))
+    let index = 0
+    for (let i = 0; i < items.length; i++) {
+      if (items[i].parallelGroup === group) items[i] = sorted[index++]
+    }
+  }
   return items
 }
 

package/src/config.js

@@ -8,7 +8,12 @@ function configFile() {
 
 export async function readConfig() {
   try {
-    return JSON.parse(await readFile(configFile(), 'utf-8'))
+    const config = JSON.parse(await readFile(configFile(), 'utf-8'))
+    if (config.models) {
+      if (!Object.hasOwn(config.models, 'participantA')) config.models.participantA = config.models.proposer ?? null
+      if (!Object.hasOwn(config.models, 'participantB')) config.models.participantB = config.models.reviewer ?? null
+    }
+    return config
   } catch {
     return {}
   }

package/src/controller.js

@@ -98,6 +98,8 @@ function errorText(err, limit) {
 }
 
 export function createController({ boot }) {
+  if (!Object.hasOwn(boot, 'participantAModel')) boot.participantAModel = boot.proposerModel ?? null
+  if (!Object.hasOwn(boot, 'participantBModel')) boot.participantBModel = boot.reviewerModel ?? null
   const { on, emit } = createEmitter()
 
   const state = {
@@ -238,10 +240,10 @@ export function createController({ boot }) {
       rounds = options.rounds
       const existingIds = deliberationsFromEvents(state.events).map((item) => Number(item.deliberationId)).filter(Number.isFinite)
       const id = String(Math.max(0, ...existingIds) + 1)
-      const roleModel = (role) => (role === 'proposer' ? boot.proposerModel : role === 'reviewer' ? boot.reviewerModel : null) || boot.deliberationModel || boot.proposerModel || boot.reviewerModel
+      const roleModel = (role) => (role === 'participant-a' ? boot.participantAModel : role === 'participant-b' ? boot.participantBModel : null) || boot.deliberationModel || boot.participantAModel || boot.participantBModel
       const roleWorkers = {}
       const roleAuths = {}
-      for (const part of ['proposer', 'reviewer', 'synthesizer']) {
+      for (const part of ['participant-a', 'participant-b', 'synthesizer']) {
         const name = roleModel(part)
         const found = boot.models.find((m) => m.name === name)
         if (!found || found.available === false) throw new Error(`deliberation model unavailable: ${name}`)
@@ -250,17 +252,18 @@ export function createController({ boot }) {
       }
       const sessionId = state.session?.id
       if (!sessionId) throw new Error('deliberation requires an active session')
-      persist(makeEvent('deliberation_start', { deliberationId: id, brief, rounds, model: roleModel('synthesizer'), models: { proposer: roleModel('proposer'), reviewer: roleModel('reviewer') } }))
+      persist(makeEvent('deliberation_start', { deliberationId: id, brief, rounds, model: roleModel('synthesizer'), models: { participantA: roleModel('participant-a'), participantB: roleModel('participant-b') } }))
       bumpActivity()
-      const live = { role: null, round: null, text: '' }
+      const live = { turns: {} }
       liveDeliberations.set(id, live)
-      const speak = (role, round) => (event) => {
+      const speak = (role, round, parallelGroup) => (event) => {
+        const key = `${role}:${round}`
         if (event.type === 'content') {
-          if (live.role !== role || live.round !== round) Object.assign(live, { role, round, text: '' })
-          live.text += event.content
+          const current = live.turns[key] || { role, round, text: '', ...(parallelGroup ? { parallelGroup } : {}) }
+          live.turns[key] = { ...current, text: current.text + event.content }
           bumpActivity()
-        } else if (event.type === 'tool_calls_ready' && live.text) {
-          live.text = ''
+        } else if (event.type === 'tool_calls_ready' && live.turns[key]?.text) {
+          live.turns[key] = { ...live.turns[key], text: '' }
           bumpActivity()
         }
       }
@@ -270,7 +273,7 @@ export function createController({ boot }) {
         bumpActivity()
       }
 
-      const runWorker = async ({ history, role, tools: enabled = true, onStream }) => {
+      const runWorker = async ({ history, role, tools: enabled = true, onStream, workerSignal = signal }) => {
         const scratchpad = ensureDir(agentScratchDir(boot.root, sessionId, `deliberation-${id}-${role}`))
         const scan = await refreshProjectIndexes()
         const context = await createAgentContext(boot, { userTools: scan.tools, isolated: true, instructions: participantSystemPrompt(scratchpad) })
@@ -279,7 +282,7 @@ export function createController({ boot }) {
           env: { ...boot.env, PICO_SCRATCHPAD: scratchpad },
           sessionId,
           sessionFile: state.session?.file,
-          signal,
+          signal: workerSignal,
           maxToolCalls: 30,
           allowNames: enabled ? undefined : [],
         })
@@ -291,7 +294,7 @@ export function createController({ boot }) {
           effort: roleWorkers[role].effort ? 'low' : null,
           auth: roleAuths[role],
           system: context.system,
-          signal,
+          signal: workerSignal,
           onStream,
         })
       }
@@ -300,19 +303,24 @@ export function createController({ boot }) {
         brief,
         rounds,
         signal,
-        runParticipant: ({ history, role, round }) => runWorker({
-          history,
-          role,
-          onStream: (event) => {
-            speak(role, round)(event)
-            if (['tool_executing', 'tool_complete', 'tool_error'].includes(event.type)) {
-              persistDeliberation(makeEvent('deliberation_event', { deliberationId: id, role, round, event }))
-            }
-          },
-        }),
+        runParticipant: ({ history, role, round, parallelGroup, signal: workerSignal }) => {
+          live.turns[`${role}:${round}`] = { role, round, text: '', ...(parallelGroup ? { parallelGroup } : {}) }
+          bumpActivity()
+          return runWorker({
+            workerSignal,
+            history,
+            role,
+            onStream: (event) => {
+              speak(role, round, parallelGroup)(event)
+              if (['tool_executing', 'tool_complete', 'tool_error'].includes(event.type)) {
+                persistDeliberation(makeEvent('deliberation_event', { deliberationId: id, role, round, parallelGroup, event }))
+              }
+            },
+          })
+        },
         runSynthesis: ({ history }) => runWorker({ history, role: 'synthesizer', tools: false, onStream: speak('synthesis', null) }),
         onEvent: (event) => {
-          Object.assign(live, { role: null, round: null, text: '' })
+          delete live.turns[`${event.role}:${event.round}`]
           persistDeliberation(makeEvent('deliberation_turn', { deliberationId: id, ...event }))
         },
       }).finally(() => liveDeliberations.delete(id))
@@ -608,7 +616,7 @@ export function createController({ boot }) {
       sessionFile: state.session?.file,
       wakeups: boot.wakeups,
       agents: boot.researchModel ? agents : null,
-      deliberations: boot.deliberationModel || (boot.proposerModel && boot.reviewerModel) ? deliberations : null,
+      deliberations: boot.deliberationModel || (boot.participantAModel && boot.participantBModel) ? deliberations : null,
       onAgentsCollected: discardCollectedAgentNotes,
       askUser,
       signal: controller.signal,
@@ -1073,8 +1081,8 @@ export function createController({ boot }) {
       flash('usage: /deliberate <decision>')
       return true
     }
-    if (!modelAvailable(boot.proposerModel || boot.deliberationModel)) return false
-    if (!modelAvailable(boot.reviewerModel || boot.deliberationModel)) return false
+    if (!modelAvailable(boot.participantAModel || boot.deliberationModel)) return false
+    if (!modelAvailable(boot.participantBModel || boot.deliberationModel)) return false
     const n = Number(rounds)
     send(deliberatePrompt(decision, Number.isInteger(n) && n >= 1 && n <= MAX_DELIBERATION_ROUNDS ? n : null))
     return true
@@ -1110,17 +1118,17 @@ export function createController({ boot }) {
     changed()
   }
 
-  async function setProposerModel(name) {
+  async function setParticipantAModel(name) {
     if (name && !modelAvailable(name)) return flash(`${name} is not available`)
-    boot.proposerModel = name || null
-    await writeConfig({ models: { proposer: name || null } })
+    boot.participantAModel = name || null
+    await writeConfig({ models: { participantA: name || null } })
     changed()
   }
 
-  async function setReviewerModel(name) {
+  async function setParticipantBModel(name) {
     if (name && !modelAvailable(name)) return flash(`${name} is not available`)
-    boot.reviewerModel = name || null
-    await writeConfig({ models: { reviewer: name || null } })
+    boot.participantBModel = name || null
+    await writeConfig({ models: { participantB: name || null } })
     changed()
   }
 
@@ -1323,7 +1331,7 @@ export function createController({ boot }) {
   function activity() {
     const withLive = (item) => {
       const live = liveDeliberations.get(item.deliberationId)
-      return live?.role ? { ...item, live: { ...live } } : item
+      return live && Object.keys(live.turns).length ? { ...item, live: { turns: Object.values(live.turns) } } : item
     }
     const rows = [...agents.list(), ...deliberationsFromEvents(state.events).map(withLive)]
     return rows.sort((a, b) => (b.startedAt || 0) - (a.startedAt || 0))
@@ -1404,8 +1412,10 @@ export function createController({ boot }) {
     sendInit,
     setResearchModel,
     setDeliberationModel,
-    setProposerModel,
-    setReviewerModel,
+    setParticipantAModel,
+    setParticipantBModel,
+    setProposerModel: setParticipantAModel,
+    setReviewerModel: setParticipantBModel,
     setDefaultModel,
     previewSteer,
     applySteer,

package/src/deliberation-history.js

@@ -35,11 +35,11 @@ export function deliberationsFromEvents(events) {
     item.updatedAt = event.at
 
     if (event.type === 'deliberation_event') {
-      const recorded = { ...data.event, role: data.role, round: data.round, at: event.at }
+      const recorded = { ...data.event, role: data.role, round: data.round, ...(data.parallelGroup ? { parallelGroup: data.parallelGroup } : {}), at: event.at }
       item.events.push(recorded)
       item.timeline.push({ kind: 'event', value: recorded })
     } else if (event.type === 'deliberation_turn') {
-      const turn = { role: data.role, round: data.round, text: data.text }
+      const turn = { role: data.role, round: data.round, text: data.text, ...(data.parallelGroup ? { parallelGroup: data.parallelGroup } : {}) }
       item.turns.push(turn)
       item.timeline.push({ kind: 'turn', value: turn })
       item.usage = mergeUsage(item.usage, data.usage)

package/src/deliberation.js

@@ -2,6 +2,8 @@ import { resultText } from './agents.js'
 
 export const DEFAULT_DELIBERATION_ROUNDS = 3
 export const MAX_DELIBERATION_ROUNDS = 5
+export const INITIAL_PARALLEL_GROUP = 'initial'
+export const PARTICIPANT_ROLES = ['participant-a', 'participant-b']
 
 export function validateDeliberation({ brief, rounds = DEFAULT_DELIBERATION_ROUNDS } = {}) {
   if (!brief?.trim()) throw new Error('deliberation brief is required')
@@ -11,17 +13,14 @@ export function validateDeliberation({ brief, rounds = DEFAULT_DELIBERATION_ROUN
   return { brief: brief.trim(), rounds }
 }
 
-const ROLE_BRIEFS = {
-  proposer: 'You are the proposer: take a position on the decision and argue for it with evidence, laying out the reasoning and the tradeoffs you accept.',
-  reviewer: 'You are the reviewer: scrutinize the proposal, test its evidence and premises, and put forward the strongest alternative where one exists.',
-}
-
 function participantPrompt(brief, role, rounds) {
-  return `${ROLE_BRIEFS[role]} This is a ${rounds}-round deliberation about the following decision:\n\n${brief}\n\nResearch before making claims. Use the available project and web tools whenever they can replace assumption with evidence. Cite URLs and project paths in your response. Challenge weak premises and address the peer's strongest points. Do not seek agreement for its own sake or defend a fixed position. Change your position only when evidence warrants it, and preserve material disagreement and uncertainty. Do not modify project files. Write your own argument and reasoning; never instruct the other participant what to say or conclude. Be concise.`
+  const name = role === 'participant-a' ? 'Participant A' : 'Participant B'
+  return `You are ${name}, one of two equal participants. Independently investigate and reason about this decision. This is a ${rounds}-round deliberation about the following decision:\n\n${brief}\n\nResearch before making claims. Use the available project and web tools whenever they can replace assumption with evidence. Cite URLs and project paths in your response. Challenge weak premises and address the peer's strongest points once their work is available. Do not seek agreement for its own sake or defend a fixed position. Change your position only when evidence warrants it, and preserve material disagreement and uncertainty. Do not modify project files. Write your own argument and reasoning; never instruct the other participant what to say or conclude. Be concise.`
 }
 
 function peerMessage(role, text, round, rounds) {
-  return `Round ${round} of ${rounds}. The ${role} replied:\n\n${text}\n\nResearch and respond to the substance of this message.`
+  const name = role === 'participant-a' ? 'Participant A' : 'Participant B'
+  return `Round ${round} of ${rounds}. ${name} replied:\n\n${text}\n\nResearch and respond to the substance of this message.`
 }
 
 function synthesisPrompt(brief, turns) {
@@ -29,38 +28,66 @@ function synthesisPrompt(brief, turns) {
   return `Synthesize this deliberation into a decision for the main agent. State the recommendation, decisive evidence, unresolved uncertainty, material disagreement, and implementation constraints. Do not manufacture consensus: preserve disagreements that the evidence did not resolve. Preserve useful URLs and project paths. Do not mention the deliberation process unless disagreement remains.\n\nDecision brief:\n${brief}\n\nTranscript:\n${transcript}`
 }
 
+function settledTurn(result, role, round, parallelGroup) {
+  if (result.error) return { error: result.error }
+  const text = resultText(result.messages)
+  if (result.interrupted || !text) return { error: text ? null : 'deliberation participant returned no response' }
+  return { turn: { role, round, text, messages: result.messages || [], usage: result.usage || null, ...(parallelGroup ? { parallelGroup } : {}) } }
+}
+
 export async function runDeliberation({ brief, rounds, runParticipant, runSynthesis, onEvent = () => {}, signal }) {
   const valid = validateDeliberation({ brief, rounds })
-  const participants = {
-    proposer: [{ role: 'user', content: participantPrompt(valid.brief, 'proposer', valid.rounds) }],
-    reviewer: [{ role: 'user', content: participantPrompt(valid.brief, 'reviewer', valid.rounds) }],
-  }
+  const participants = Object.fromEntries(PARTICIPANT_ROLES.map((role) => [role, [{ role: 'user', content: participantPrompt(valid.brief, role, valid.rounds) }]]))
   const turns = []
-  let peer = null
 
-  for (let round = 1; round <= valid.rounds; round++) {
-    for (const role of ['proposer', 'reviewer']) {
+  if (signal?.aborted) return { turns, interrupted: true }
+  const initialController = new AbortController()
+  const abortInitial = () => initialController.abort(signal?.reason)
+  signal?.addEventListener('abort', abortInitial, { once: true })
+  let failure
+  await Promise.allSettled(PARTICIPANT_ROLES.map(async (role) => {
+    try {
+      const result = await runParticipant({
+        role, round: 1, rounds: valid.rounds, history: [...participants[role]],
+        signal: initialController.signal, parallelGroup: INITIAL_PARALLEL_GROUP,
+      })
+      const parsed = settledTurn(result, role, 1, INITIAL_PARALLEL_GROUP)
+      if (!parsed.turn) {
+        failure ??= { interrupted: true, error: parsed.error }
+        initialController.abort()
+        return
+      }
+      participants[role].push(...(result.messages || []))
+      turns.push(parsed.turn)
+      onEvent({ type: 'deliberation_turn', ...parsed.turn })
+    } catch (error) {
+      failure ??= { interrupted: true, error: error?.message || String(error) }
+      initialController.abort(error)
+    }
+  }))
+  signal?.removeEventListener('abort', abortInitial)
+  turns.sort((a, b) => PARTICIPANT_ROLES.indexOf(a.role) - PARTICIPANT_ROLES.indexOf(b.role))
+  if (failure) return { turns, ...failure }
+  if (signal?.aborted) return { turns, interrupted: true }
+
+  participants['participant-b'].push({ role: 'user', content: peerMessage('participant-a', turns[0].text, 1, valid.rounds) })
+  let peer = turns.at(-1)
+  for (let round = 2; round <= valid.rounds; round++) {
+    for (const role of PARTICIPANT_ROLES) {
       if (signal?.aborted) return { turns, interrupted: true }
       const history = participants[role]
-      if (peer) history.push({ role: 'user', content: peerMessage(peer.role, peer.text, round, valid.rounds) })
+      history.push({ role: 'user', content: peerMessage(peer.role, peer.text, round, valid.rounds) })
       const result = await runParticipant({ role, round, rounds: valid.rounds, history: [...history], signal })
       history.push(...(result.messages || []))
-      const text = resultText(result.messages)
-      if (result.error) return { turns, interrupted: true, error: result.error }
-      if (result.interrupted || !text) return { turns, interrupted: true, error: text ? null : 'deliberation participant returned no response' }
-      const turn = { role, round, text, messages: result.messages || [], usage: result.usage || null }
-      turns.push(turn)
-      peer = turn
-      onEvent({ type: 'deliberation_turn', ...turn })
+      const parsed = settledTurn(result, role, round)
+      if (!parsed.turn) return { turns, interrupted: true, error: parsed.error }
+      turns.push(parsed.turn)
+      peer = parsed.turn
+      onEvent({ type: 'deliberation_turn', ...parsed.turn })
     }
   }
 
+  if (signal?.aborted) return { turns, interrupted: true }
   const synthesis = await runSynthesis({ history: [{ role: 'user', content: synthesisPrompt(valid.brief, turns) }], signal })
-  return {
-    turns,
-    result: resultText(synthesis.messages),
-    usage: synthesis.usage || null,
-    interrupted: !!synthesis.interrupted,
-    error: synthesis.error || null,
-  }
+  return { turns, result: resultText(synthesis.messages), usage: synthesis.usage || null, interrupted: !!synthesis.interrupted, error: synthesis.error || null }
 }

package/src/tools/index.js

@@ -229,7 +229,7 @@ export function createToolset({ toolResult, cwd, env, tracker, skills, shells, s
       schema: {
         description: describeParam,
         brief: { type: 'string', description: 'self-contained decision, relevant context, constraints, and desired outcome' },
-        rounds: { type: 'integer', description: 'number of proposer-reviewer exchanges (1-5, default 3)', optional: true },
+        rounds: { type: 'integer', description: 'number of Participant A/B exchange rounds (1-5, default 3)', optional: true },
       },
       execute: ({ brief, rounds }) => deliberations.run({ brief, rounds, sessionId, sessionFile, signal }),
     })