@worca/app 1.0.0 → 1.2.0-rc.1

package/agents/workspaceScanner.meta.json

@@ -1,5 +1,10 @@
 {
   "key": "workspaceScanner",
+  "metaVersion": 2,
+  "mockRole": "workspace-scan",
+  "placeable": false,
+  "inputs": [{ "id": "task", "type": "md" }],
+  "outputs": [{ "id": "workspace", "type": "md", "filename": "workspace-description.md" }],
   "domain": "shared",
   "displayName": "Workspace Scan",
   "description": "Maps how the workspace's projects relate before pipelines run. Shared APIs, schemas, queues, and build dependencies.",
@@ -7,11 +12,7 @@
   "icon": "<path d=\"M4 7h16M4 12h10M4 17h7\" stroke-linecap=\"round\"/><circle cx=\"18\" cy=\"15\" r=\"3\"/><path d=\"M20.2 17.2L22 19\" stroke-linecap=\"round\"/>",
   "agentFile": "worca-cc-workspace-scanner.md",
   "runnerType": "producer",
-  "loopSource": false,
   "fanOut": true,
-  "produces": ["workspace"],
-  "consumes": ["userPrompt"],
-  "connectsTo": [],
   "asksQuestions": false,
   "order": 0.5,
   "scope": "workspace-only"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@worca/app",
-  "version": "1.0.0",
+  "version": "1.2.0-rc.1",
   "description": "Worca — deterministic multi-agent pipeline that drives Claude Code (headless) through Plan -> Refine -> Implement -> Review, with a CLI, an installable /worca skill, and a web UI.",
   "license": "MIT",
   "author": "Sinisha Djukic",
@@ -46,10 +46,16 @@
     "smoke": "WORCA_MOCK=1 WORCA_HOME=.worca-cc-smoke node --disable-warning=ExperimentalWarning src/cli/worca-cc.mjs --project sandbox --prompt \"demo task\" --mock --yes",
     "smoke:workspace": "WORCA_MOCK=1 WORCA_HOME=.worca-cc-smoke node --disable-warning=ExperimentalWarning scripts/smoke-workspace.mjs",
     "smoke:plugin": "WORCA_MOCK=1 WORCA_HOME=.worca-cc-smoke node --disable-warning=ExperimentalWarning scripts/smoke-plugin.mjs",
-    "test": "rm -rf .worca-cc-test && WORCA_HOME=.worca-cc-test node --disable-warning=ExperimentalWarning --test test/*.mjs"
+    "ask:fixtures": "node --disable-warning=ExperimentalWarning scripts/ask-capture-fixtures.mjs",
+    "verify:composer": "node --disable-warning=ExperimentalWarning scripts/verify-composer-cdp.mjs",
+    "verify:run-monitor": "node --disable-warning=ExperimentalWarning scripts/verify-run-monitor-cdp.mjs",
+    "test": "rm -rf .worca-cc-test && PATH=\"$PWD/test/helpers/no-real-claude:$PATH\" WORCA_HOME=.worca-cc-test node --disable-warning=ExperimentalWarning --test test/*.mjs; s=$?; node test/helpers/no-real-claude/assert-none.mjs || s=1; exit $s"
   },
   "dependencies": {
+    "@highlightjs/cdn-assets": "11.12.0",
+    "dompurify": "3.4.14",
     "express": "^4.19.2",
+    "marked": "18.0.10",
     "ws": "^8.18.0"
   },
   "devDependencies": {

package/skills/worca/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: worca
-description: Run the deterministic multi-agent orchestrator (Plan -> Refine -> Implement -> Review) over a software task in the current project. Triggers on "/worca", "/worca <prompt>", "/worca --ui", and on requests to orchestrate, run the orchestration pipeline, or drive Claude Code through plan/refine/implement/review for a task.
+description: Run the node-graph multi-agent orchestrator over a software task in the current project. Triggers on "/worca", "/worca <prompt>", "/worca --ui", and on requests to orchestrate, run the orchestration pipeline, or drive plan/refine/implement/review for a task.
 ---
 
 # Orchestrate
 
-Drive the current project through the orchestrator pipeline: **Preflight -> Plan -> Refine (loop) -> Implement -> Review (loop) -> Done**. Orchestration is performed by a deterministic Node.js script; this skill just launches it. Artifacts (plans, reviews, pipeline audit logs) are written under `ai-artifacts/` in the project.
+Drive the current project through the selected pipeline template (default `wf_default`: Plan → Refine ↺ → Implement → Review ↺ → End). Orchestration is performed by a deterministic Node.js script; this skill just launches it. Artifacts (plans, reviews, pipeline audit logs) are written under `ai-artifacts/` in the project.
 
 The orchestrator repo lives wherever it was installed. `<WORCA_REPO>` below is the absolute path of that repo (the directory containing `src/cli/worca-cc.mjs`). If you installed via `scripts/install.mjs`, the installer rewrites `<WORCA_REPO>` in this file to the real path automatically; otherwise substitute it yourself (or set an `WORCA_REPO` environment variable and use `"$WORCA_REPO"`).
 
@@ -19,13 +19,13 @@ node <WORCA_REPO>/src/cli/worca-cc.mjs --project "$PWD" --prompt "<args>"
 
 - `--project "$PWD"` — operate inside the user's current project (the orchestrator does all file writes here).
 - `--prompt "<args>"` — everything the user typed after `/worca`. Quote it.
-- The CLI streams phase changes and live agent logs to the terminal. When the clarify step needs a decision it shows each question's 2–4 options plus a free-text field; when a refine/review loop hits its cap it shows the open critical/major issues and asks whether to continue or approve another cycle. Answer interactively.
+- The CLI streams every agent execution (start/done, cycle, cost) and live agent logs to the terminal. When the clarify step needs a decision it shows each question's 2–4 options plus a free-text field; when a refine/review loop hits its cap it shows the open critical/major issues and asks whether to continue or approve another cycle. Answer interactively.
 - On completion it prints the pipeline directory under `ai-artifacts/pipelines/`.
 
 Useful flags (pass through when the user asks):
 - `--file <path.md>` — use a markdown file as the prompt instead of `--prompt`.
 - `--title "<name>"` — label the pipeline.
-- `--max-refine <N>` / `--max-review <N>` — change loop caps (default 5 each).
+- `--workflow <id>` — run a saved pipeline template instead of the built-in default (`wf_default`).
 - `--model <m>` / `--permission-mode <m>` — Claude model / permission mode (default `acceptEdits`).
 - `--mock` — run the full pipeline offline with canned agents (no Claude spawn, no tokens); great for a dry run. Equivalent to setting `WORCA_MOCK=1`.
 - `--yes` / `--non-interactive` — auto-answer (clarify picks the first option; gates choose "continue"). Use for unattended runs.
@@ -39,7 +39,7 @@ node <WORCA_REPO>/src/cli/worca-cc.mjs \
 
 ## /worca --ui — launch the web UI
 
-To start the web app (new-pipeline form, step tracker, live log window, question + loop-gate panels, Stop button, run history):
+To start the web app (new-pipeline form, live pipeline graph, live log window, question + loop-gate panels, Stop button, run history):
 
 ```bash
 node <WORCA_REPO>/src/cli/worca-cc.mjs --ui

package/src/cli/render.mjs

@@ -0,0 +1,148 @@
+// src/cli/render.mjs
+//
+// The CLI's rendering of the graph engine's `exec` stream. PURE: no IO, no
+// colour codes of its own — the caller injects `color(name, text)`. Labels come
+// from the run manifest (pipelines.stepper); execution ids are NEVER printed.
+//
+// The line shapes (spec §8, literal):
+//   ▶ Implementer #2 · fix ← Reviewer      agent start (loop port from trigger.freshPorts; source = the wire's from-node)
+//     ▶ task 3/7 · Add schema              kind:'task' slice start (indented; index within its phase)
+//   ✓ Implementer #2  1m03s · $0.12        agent done (verifiers append " — blocking" / " — clean")
+//   ✓ OR · OR → Implementer                flow-node done: ONE dim line, no ordinal/duration/cost; the
+//                                          marker only for AND / OR / COMBINE (`✓ Task` is bare)
+//   ✗ Reviewer #1  12s — <error>           agent error
+//   ⏸ Implementer #1  paused               agent paused
+//   ■ End ← Reviewer.pass → plan-review.md End bound — End's ONLY line
+// Flow nodes never print a start/paused/error line; `skipped` and P8's bookend
+// executions render nothing; `token` events are never rendered.
+import { BOOKEND_EXECUTION_IDS } from '../shared/graph/constants.mjs';
+
+const nodesOf = (m) => ((m && m.graph && m.graph.nodes) || []).filter(Boolean);
+const wiresOf = (m) => ((m && m.graph && m.graph.wires) || []).filter(Boolean);
+const nodeOf = (m, id) => nodesOf(m).find((n) => n.id === id) || null;
+const labelOf = (m, id) => { const n = nodeOf(m, id); return (n && (n.label || n.id)) || id; };
+const base = (p) => String(p || '').split('/').filter(Boolean).pop() || '';
+/** Flow kinds whose done line carries a marker (` · AND`, ` · OR → X`, ` · COMBINE → X`). */
+const MARKED_FLOW = new Set(['and', 'or', 'combine']);
+
+/** `12s` / `1m03s` / `1h01m` — the CLI's compact shape (NOT the UI's `1m 3s`). */
+export function fmtDur(ms) {
+  const s = Math.max(0, Math.round((Number(ms) || 0) / 1000));
+  if (s < 60) return `${s}s`;
+  const m = Math.floor(s / 60);
+  if (m < 60) return `${m}m${String(s % 60).padStart(2, '0')}s`;
+  return `${Math.floor(m / 60)}h${String(m % 60).padStart(2, '0')}m`;
+}
+const usd = (n) => `$${(Number(n) || 0).toFixed(2)}`;
+
+/** ` · fix ← Reviewer`: the loop port that re-fired this execution
+ *  (trigger.freshPorts ∩ the node's `loop: true` inputs) and the node that
+ *  published on the wire that DELIVERED it. Through an OR valve that wire is
+ *  the valve's out-wire, so the source reads `← OR` (probe P13). */
+function loopSource(ev, node, m) {
+  const loopIns = new Set(((node && node.ports && node.ports.inputs) || []).filter((p) => p && p.loop).map((p) => p.id));
+  const trig = ev.trigger || {};
+  const port = (trig.freshPorts || []).find((p) => loopIns.has(p));
+  if (!port) return '';
+  const wire = wiresOf(m).find((w) => (trig.wireIds || []).includes(w.id) && w.to && w.to.port === port);
+  return wire ? ` · ${port} ← ${labelOf(m, wire.from.node)}` : ` · ${port}`;
+}
+
+/** The dim marker an AND/OR/COMBINE card carries: ` · AND`, ` · OR → Implementer`. */
+function flowMarker(node, m, color) {
+  const kind = String(node.kind).toUpperCase();
+  const out = wiresOf(m).find((w) => w.from && w.from.node === node.id);
+  return color('dim', out ? ` · ${kind} → ${labelOf(m, out.to.node)}` : ` · ${kind}`);
+}
+
+/** ONE `exec` event -> ONE terminal line ('' when the event renders nothing). */
+export function formatExecLine(ev, manifest, { color = (n, s) => s } = {}) {
+  if (!ev || !ev.nodeId) return '';
+  if (BOOKEND_EXECUTION_IDS.includes(ev.executionId)) return '';   // P8's preflight/done rows render nothing
+  const m = manifest || {};
+  const node = nodeOf(m, ev.nodeId);
+  const label = labelOf(m, ev.nodeId);
+  if (ev.kind === 'task') {   // a composite slice: one indented start line, nothing else
+    if (ev.status !== 'start') return '';
+    const n = ev.taskIndex, t = ev.taskTotal;
+    const which = Number.isFinite(n) && Number.isFinite(t) ? ` ${n}/${t}` : '';
+    return `  ${color('cyan', '▶')} task${which}${ev.title ? ` · ${ev.title}` : ''}`;
+  }
+  if (node && node.kind === 'end') {   // End renders ONE line: the binding
+    if (ev.status !== 'done') return '';
+    const wire = wiresOf(m).find((w) => ((ev.trigger && ev.trigger.wireIds) || []).includes(w.id));
+    const from = wire ? ` ← ${labelOf(m, wire.from.node)}.${wire.from.port}` : '';
+    const r = ev.result || {};
+    const tail = r.path ? ` → ${base(r.path)}` : (r.value != null ? ` → ${String(r.value)}` : '');
+    return `${color('bold', '■')} ${label}${from}${tail}`;
+  }
+  if (node && node.kind !== 'agent') {   // a flow card: one dim ✓ line, no ordinal / duration / cost
+    if (ev.status !== 'done') return '';
+    return `${color('green', '✓')} ${label}${MARKED_FLOW.has(node.kind) ? flowMarker(node, m, color) : ''}`;
+  }
+  const ord = ` #${ev.ordinal ?? 1}`;
+  if (ev.status === 'start') return `${color('cyan', '▶')} ${label}${ord}${loopSource(ev, node, m)}`;
+  if (ev.status === 'paused') return `${color('yellow', '⏸')} ${label}${ord}  paused`;
+  const dur = ev.durationMs != null ? `  ${fmtDur(ev.durationMs)}` : '';
+  if (ev.status === 'error') return `${color('red', '✗')} ${label}${ord}${dur} — ${ev.error || 'failed'}`;
+  if (ev.status !== 'done') return '';   // `skipped` (and anything unknown) renders nothing
+  const cost = ev.costUsd != null ? ` · ${usd(ev.costUsd)}` : '';
+  const verdict = ev.verdict ? (ev.verdict.missing ? ' — no verdict written (treated as clean)' : ev.verdict.hasBlocking ? ' — blocking' : ' — clean') : '';
+  return `${color('green', '✓')} ${label}${ord}${dur}${cost}${verdict}`;
+}
+
+/** The interactive gate prompt's header. */
+export function formatGateHeader(payload, manifest) {
+  const m = manifest || {};
+  const wire = wiresOf(m).find((w) => w.id === (payload && payload.wireId)) || null;
+  const where = wire ? ` · ${labelOf(m, wire.from.node)} → ${labelOf(m, wire.to.node)}` : '';
+  const max = wire && wire.maxCycles ? Number(wire.maxCycles) : null;
+  // The cycle comes from the PAYLOAD's `deliveryNo`, never from the id: a wire that
+  // holds more than once mints `gate-<wireId>-<deliveryNo>-h<holdNo>`, so the id's
+  // trailing number is the HOLD ordinal, not the delivery (MAJ-11). No deliveryNo
+  // (an older resume point, a hand-built payload) falls back to the budget.
+  const n = Number(payload && payload.deliveryNo);
+  const used = Number.isFinite(n) && n > 0 ? n : max;
+  const budget = max ? `  ${used || max}/${max} cycles used` : '';
+  return `? Loop gate${where}${budget}`;
+}
+
+/** The summary's result line. */
+export function formatResultLine(result) {
+  const r = result || {};
+  if (r.path) return `Result: ${r.path}`;
+  if (r.value != null && r.value !== '') return `Result: ${String(r.value)}`;
+  return 'Result: completed';
+}
+
+/** `9 executions · 12m00s active · $1.23`. */
+export function formatTotals({ executions = 0, activeMs = 0, costUsd = 0 } = {}) {
+  return `${executions} execution${executions === 1 ? '' : 's'} · ${fmtDur(activeMs)} active · ${usd(costUsd)}`;
+}
+
+/**
+ * The v2 run summary the CLI prints under `Pipeline complete.` — pure, so the
+ * quiescence arm and the executions count are testable without spawning a run.
+ * Returns [] for a v1 run. An EXECUTION row carries an executionId that is not
+ * a bookend id: today's bookends are `_recordStep('preflight'|'done', …)` rows
+ * with key 'preflight' / 'done' and NO executionId; P8's become real
+ * x:preflight:1 / x:done:1 executions (BOOKEND_EXECUTION_IDS). The active time
+ * is the SUM over execution rows — state.totalActiveMs includes preflight.
+ */
+export function formatRunSummary(state) {
+  const st = state || {};
+  if (!(st.stepper && st.stepper.version === 2)) return [];
+  const rows = (Array.isArray(st.steps) ? st.steps : [])
+    .filter((s) => s && s.executionId && !BOOKEND_EXECUTION_IDS.includes(s.executionId));
+  const lines = [];
+  // Quiescence is the reducer's rule: the run reached `done` WITHOUT the End node
+  // firing. A stopped/errored run also has endReached false and must NOT claim it.
+  if (st.endReached === false && String(st.status || '').toLowerCase() === 'done') lines.push('Finished at quiescence — End not reached');
+  else lines.push(formatResultLine(st.result));
+  lines.push(formatTotals({
+    executions: rows.length,
+    activeMs: rows.reduce((a, s) => a + (Number(s.activeMs) || 0), 0),
+    costUsd: st.totalCostUsd,
+  }));
+  return lines;
+}