@sebastianandreasson/pi-autonomous-agents 0.5.2 → 0.6.0

package/src/pi-supervisor.mjs

@@ -337,6 +337,15 @@ async function runAgentInvocation({
   sessionId,
   sessionFile,
 }) {
+  await updateRunOwnership(config, {
+    status: 'agent_running',
+    iteration,
+    phase,
+    activeKind: kind,
+    activeRole: role,
+    activeReason: reason,
+  })
+
   const beforeSnapshot = getRepoSnapshot(config.cwd)
   const resolvedModel = resolveRoleModel(config, role)
   const promptSnapshot = [
@@ -513,6 +522,15 @@ async function runHarnessGitFinalize({
   phase,
   commitPlan,
 }) {
+  await updateRunOwnership(config, {
+    status: 'git_finalize_running',
+    iteration,
+    phase,
+    activeKind: 'git_finalize',
+    activeRole: '',
+    activeReason: '',
+  })
+
   const beforeSnapshot = getRepoSnapshot(config.cwd)
   const dirtyFiles = new Set(listChangedFiles(config.cwd))
   const requestedFiles = Array.isArray(commitPlan.files) ? commitPlan.files.filter(Boolean) : []
@@ -624,6 +642,15 @@ async function runHarnessGitFinalize({
 }
 
 async function runVerificationStep({ config, iteration, phase, kind }) {
+  await updateRunOwnership(config, {
+    status: 'verification_running',
+    iteration,
+    phase,
+    activeKind: kind,
+    activeRole: '',
+    activeReason: '',
+  })
+
   const beforeSnapshot = getRepoSnapshot(config.cwd)
   const verification = await runVerification(config)
   const afterSnapshot = getRepoSnapshot(config.cwd)
@@ -988,6 +1015,15 @@ async function runTesterCommitTurn({
 }
 
 async function runVisualReview({ config, iteration, phase, task, changedFiles }) {
+  await updateRunOwnership(config, {
+    status: 'visual_capture_running',
+    iteration,
+    phase,
+    activeKind: 'visual_capture',
+    activeRole: '',
+    activeReason: '',
+  })
+
   const capture = await runVisualCapture(config, {
     iteration,
     phase,
@@ -1035,6 +1071,15 @@ async function runVisualReview({ config, iteration, phase, task, changedFiles })
     }
   }
 
+  await updateRunOwnership(config, {
+    status: 'visual_review_running',
+    iteration,
+    phase,
+    activeKind: 'visual_review',
+    activeRole: 'visualReview',
+    activeReason: '',
+  })
+
   const visualReviewModel = resolveRoleModel(config, 'visualReview')
   const reviewRequest = {
     iteration,
@@ -1196,6 +1241,9 @@ async function runIteration({ config, state, iteration }) {
     iteration,
     phase,
     task,
+    activeKind: '',
+    activeRole: '',
+    activeReason: '',
   })
   const canResumePriorSession = (
     state.lastTransport === config.transport
@@ -1576,6 +1624,9 @@ async function runIteration({ config, state, iteration }) {
     task,
     lastCompletedIteration: iteration,
     lastStatus: finalStatus,
+    activeKind: '',
+    activeRole: '',
+    activeReason: '',
   })
 
   await appendLog(
@@ -1681,6 +1732,7 @@ async function main() {
   config.runTelemetryCsv = path.join(runDir, 'pi_telemetry.csv')
   config.runStateFile = path.join(runDir, 'state.json')
   config.runLastIterationSummaryFile = path.join(runDir, 'last-iteration.json')
+  config.runLastAgentOutputFile = path.join(runDir, 'last-output.txt')
 
   ensureRepo(config.cwd)
   await ensureFileExists(config.taskFile, 'task file')
@@ -1728,6 +1780,9 @@ async function main() {
       await updateRunOwnership(config, {
         status: 'starting_iteration',
         iteration,
+        activeKind: '',
+        activeRole: '',
+        activeReason: '',
       })
       const result = await runIteration({ config, state, iteration })
       await writeIterationSummary(config, result.iterationSummary ?? result.summary)
@@ -1754,6 +1809,9 @@ async function main() {
     await updateRunOwnership(config, {
       status: stopRequested ? 'stopped' : 'finished',
       heartbeatAt: timestamp(),
+      activeKind: '',
+      activeRole: '',
+      activeReason: '',
     })
     await releaseRunLock(config.activeRunFile, runId)
     delete process.env.PI_RUN_ID

package/src/pi-telemetry.mjs

@@ -10,6 +10,10 @@ function csvEscape(value) {
 
 export async function ensureTelemetryFiles(config) {
   await fs.writeFile(config.lastAgentOutputFile, '', 'utf8')
+  if (config.runLastAgentOutputFile && config.runLastAgentOutputFile !== config.lastAgentOutputFile) {
+    await fs.mkdir(path.dirname(config.runLastAgentOutputFile), { recursive: true })
+    await fs.writeFile(config.runLastAgentOutputFile, '', 'utf8')
+  }
   await fs.writeFile(config.lastVerificationOutputFile, '', 'utf8')
   await fs.writeFile(config.changedFilesFile, '', 'utf8')
   await fs.writeFile(config.lastPromptFile, '', 'utf8')

package/src/pi-visualizer-shared.mjs

@@ -0,0 +1,219 @@
+const FLOW_STEPS = [
+  { key: 'developer', label: 'Developer' },
+  { key: 'verification', label: 'Verification' },
+  { key: 'tester', label: 'Tester' },
+  { key: 'fix', label: 'Fix' },
+  { key: 'git_finalize', label: 'Git Finalize' },
+  { key: 'visual_capture', label: 'Visual Capture' },
+  { key: 'visual_review', label: 'Visual Review' },
+  { key: 'summary', label: 'Summary' },
+]
+
+const KIND_LABELS = {
+  main_agent: 'Developer',
+  developer_verification: 'Verification',
+  developer_reverification: 'Reverification',
+  tester_reverification: 'Tester Reverify',
+  tester_agent: 'Tester',
+  tester_commit: 'Tester Commit',
+  fix_agent: 'Fix',
+  git_finalize: 'Git Finalize',
+  visual_capture: 'Visual Capture',
+  visual_review: 'Visual Review',
+  iteration_summary: 'Summary',
+}
+
+const SUCCESS_STATUSES = new Set(['success', 'passed', 'complete'])
+const ERROR_STATUSES = new Set(['failed', 'timed_out', 'stalled', 'blocked', 'canceled'])
+const SKIP_STATUSES = new Set(['skipped', 'not_run', 'not_needed'])
+
+export function getFlowSteps() {
+  return FLOW_STEPS.map((step) => ({ ...step }))
+}
+
+export function getLabelForKind(kind) {
+  const key = String(kind ?? '').trim()
+  if (key === '') {
+    return 'Unknown'
+  }
+  return KIND_LABELS[key] || key
+}
+
+export function getStepKeyForKind(kind) {
+  switch (String(kind ?? '')) {
+    case 'main_agent':
+      return 'developer'
+    case 'developer_verification':
+    case 'developer_reverification':
+    case 'tester_reverification':
+      return 'verification'
+    case 'tester_agent':
+    case 'tester_commit':
+      return 'tester'
+    case 'fix_agent':
+      return 'fix'
+    case 'git_finalize':
+      return 'git_finalize'
+    case 'visual_capture':
+      return 'visual_capture'
+    case 'visual_review':
+      return 'visual_review'
+    case 'iteration_summary':
+      return 'summary'
+    default:
+      return ''
+  }
+}
+
+export function getStepKeyForActiveRun(activeRun) {
+  const activeKind = String(activeRun?.activeKind ?? '').trim()
+  if (activeKind !== '') {
+    return getStepKeyForKind(activeKind)
+  }
+
+  const status = String(activeRun?.status ?? '').trim()
+  if (status === 'starting_iteration' || status === 'iteration_in_progress' || status === 'agent_running') {
+    return 'developer'
+  }
+  if (status === 'verification_running') {
+    return 'verification'
+  }
+  if (status === 'git_finalize_running') {
+    return 'git_finalize'
+  }
+  if (status === 'visual_capture_running') {
+    return 'visual_capture'
+  }
+  if (status === 'visual_review_running') {
+    return 'visual_review'
+  }
+
+  return ''
+}
+
+function normalizeEventStatus(status) {
+  const value = String(status ?? '').trim().toLowerCase()
+  if (SUCCESS_STATUSES.has(value)) {
+    return 'done'
+  }
+  if (ERROR_STATUSES.has(value)) {
+    return 'error'
+  }
+  if (SKIP_STATUSES.has(value)) {
+    return 'skipped'
+  }
+  return 'pending'
+}
+
+export function deriveCurrentIteration({ activeRun, summary, telemetry }) {
+  const activeIteration = Number(activeRun?.iteration)
+  if (Number.isFinite(activeIteration) && activeIteration > 0) {
+    return activeIteration
+  }
+
+  const summaryIteration = Number(summary?.iteration)
+  if (Number.isFinite(summaryIteration) && summaryIteration > 0) {
+    return summaryIteration
+  }
+
+  const lastTelemetryIteration = Number(telemetry?.at?.(-1)?.iteration)
+  if (Number.isFinite(lastTelemetryIteration) && lastTelemetryIteration > 0) {
+    return lastTelemetryIteration
+  }
+
+  return 0
+}
+
+export function deriveFlowSnapshot({ activeRun, summary, telemetry }) {
+  const currentIteration = deriveCurrentIteration({ activeRun, summary, telemetry })
+  const iterationTelemetry = Array.isArray(telemetry)
+    ? telemetry.filter((event) => Number(event?.iteration) === currentIteration)
+    : []
+  const activeStepKey = getStepKeyForActiveRun(activeRun)
+  const steps = FLOW_STEPS.map((step) => {
+    const matchingEvents = iterationTelemetry.filter((event) => getStepKeyForKind(event?.kind) === step.key)
+    const latestEvent = matchingEvents.at(-1) ?? null
+    const status = activeStepKey === step.key
+      ? 'active'
+      : latestEvent
+        ? normalizeEventStatus(latestEvent.status)
+        : 'pending'
+
+    return {
+      ...step,
+      status,
+      latestEvent,
+    }
+  })
+
+  return {
+    iteration: currentIteration,
+    activeStepKey,
+    steps,
+  }
+}
+
+export function deriveStageGraph({ activeRun, summary, telemetry }) {
+  const flow = deriveFlowSnapshot({ activeRun, summary, telemetry })
+  const currentIteration = flow.iteration
+  const iterationTelemetry = Array.isArray(telemetry)
+    ? telemetry.filter((event) => Number(event?.iteration) === currentIteration)
+    : []
+
+  const nodes = iterationTelemetry.map((event, index) => {
+    const stepKey = getStepKeyForKind(event?.kind)
+    const status = flow.activeStepKey !== '' && flow.activeStepKey === stepKey && index === iterationTelemetry.length - 1
+      ? 'active'
+      : normalizeEventStatus(event?.status)
+
+    return {
+      id: `${String(event?.kind ?? 'event')}-${index}`,
+      index,
+      kind: String(event?.kind ?? ''),
+      label: getLabelForKind(event?.kind),
+      stepKey,
+      status,
+      role: String(event?.role ?? ''),
+      terminalReason: String(event?.terminalReason ?? ''),
+      notes: String(event?.notes ?? ''),
+      iteration: Number(event?.iteration) || currentIteration,
+      phase: String(event?.phase ?? ''),
+      timestamp: String(event?.timestamp ?? ''),
+      retryCount: Number.isFinite(Number(event?.retryCount)) ? Number(event.retryCount) : 0,
+      event,
+    }
+  })
+
+  const edges = nodes.slice(1).map((node, index) => ({
+    from: nodes[index].id,
+    to: node.id,
+  }))
+
+  return {
+    iteration: currentIteration,
+    nodes,
+    edges,
+  }
+}
+
+export function formatActiveLabel(activeRun, flow) {
+  const activeStepKey = flow?.activeStepKey || getStepKeyForActiveRun(activeRun)
+  if (activeStepKey !== '') {
+    const step = FLOW_STEPS.find((entry) => entry.key === activeStepKey)
+    if (step) {
+      return step.label
+    }
+  }
+
+  const status = String(activeRun?.status ?? '').trim()
+  if (status === 'idle') {
+    return 'Idle'
+  }
+  if (status === 'starting') {
+    return 'Starting'
+  }
+  if (status === 'starting_iteration') {
+    return 'Starting Iteration'
+  }
+  return status === '' ? 'Unknown' : status
+}