codehere 0.6.2 → 0.7.1

package/dist/infrastructure/protocols/thread-phase.js

@@ -0,0 +1,105 @@
+/**
+ * Thread phase classifier · the demo v12 lifecycle spine.
+ *
+ * A thread reads as a phased narrative (research → build → ship → audit → live).
+ * Steps don't carry phase labels, so classify by the dominant signal in the
+ * step LABEL (the output is noisy — agent names like "claude-code", file lists —
+ * and misfires the keywords).
+ *
+ * This logic used to live inline in the ui-page-v2 template string, where it was
+ * untestable — and a `\bcode\b` regex matched "claude-code" and mislabeled read
+ * steps as BUILD (caught by eye, not a test). Extracted here so it's unit-tested,
+ * and its SOURCE is injected back into the browser template via
+ * PHASE_CLASSIFIER_SRC — one source of truth, not a duplicated twin.
+ */
+export const PHASE_ORDER = ['research', 'build', 'ship', 'audit', 'live'];
+export const PHASE_META = {
+    research: { n: 1, label: 'research', done: 'research locked', verb: 'explored' },
+    build: { n: 2, label: 'build', done: 'build done', verb: 'built' },
+    ship: { n: 3, label: 'ship', done: 'shipped', verb: 'tested & shipped' },
+    audit: { n: 4, label: 'audit', done: 'audited', verb: 'reviewed' },
+    live: { n: 5, label: 'live', done: 'live', verb: 'recovered' },
+};
+// Classify on the LABEL only · keep keywords action-specific, NOT domain words.
+// "rate-limit" is a FEATURE many tasks build — it must NOT signal LIVE, or every
+// rate-limit task mislabels its build steps as live. "claude-code" must NOT
+// match \bcode\b → that was the original bug.
+export function stepPhase(step) {
+    const s = (step.label || '').toLowerCase();
+    if (/failover|crashed|recover|orphan|hydrat|checkpoint|fell back|failed over/.test(s))
+        return 'live';
+    if (/verif|audit|final report|trust grade|claim vs|w-?pass|write-pass|chain entry/.test(s))
+        return 'audit';
+    if (/\btest\b|\btests\b|\bpush\b|commit|deploy|benchmark|\bship\b|\bmerge\b/.test(s))
+        return 'ship';
+    if (/\bedit\b|\bwrite\b|writes |writing|implement|refactor|patch|\bbuild\b|dispatch/.test(s))
+        return 'build';
+    if (/pre-prompt|scan|\bread\b|grep|search|analyz|research|context|\broute|explor|\bmap\b/.test(s))
+        return 'research';
+    return null;
+}
+// Assign every step a phase · unknown steps inherit the running phase so the
+// timeline never fragments. Phases only ADVANCE, never regress — once a task has
+// shipped, a stray "read" stays in ship rather than yanking the narrative back.
+// The regress check is against the OLD running phase, THEN advance.
+export function classifySteps(steps) {
+    const out = [];
+    let cur = 'research';
+    for (let i = 0; i < steps.length; i++) {
+        let p = stepPhase(steps[i]);
+        if (!p)
+            p = cur;
+        if (PHASE_META[p].n < PHASE_META[cur].n)
+            p = cur;
+        cur = p;
+        out.push(p);
+    }
+    return out;
+}
+/**
+ * EMERGENT grouping for the unified thread timeline. A segment is a run of
+ * CONSECUTIVE steps that share a phase — so the sections are however many the
+ * actual activity produced, not a fixed pipeline. No monotonic advance, no
+ * "phase N of 5", no forced final stage: a one-read task yields one segment, a
+ * sprawling task yields several. Unknown steps inherit the running phase so a
+ * stray unclassified step doesn't fragment a run; leading unknowns (before any
+ * classified step) produce no segment.
+ *
+ * This replaces classifySteps' fixed-5 framing for the timeline. stepPhase (the
+ * per-step activity classifier) is reused unchanged.
+ */
+export function segmentSteps(steps) {
+    const segs = [];
+    let cur = null;
+    for (let i = 0; i < steps.length; i++) {
+        let p = stepPhase(steps[i]);
+        if (!p)
+            p = cur;
+        if (!p)
+            continue;
+        if (p !== cur) {
+            segs.push({ phase: p, verb: PHASE_META[p].verb, from: i, count: 1 });
+            cur = p;
+        }
+        else {
+            segs[segs.length - 1].count++;
+        }
+    }
+    return segs;
+}
+/**
+ * Browser-JS source for injection into the ui-page-v2 template literal. Emits
+ * the same PHASE_META / stepPhase / segmentSteps the tests cover, so the
+ * rendered thread uses the EXACT logic that's unit-tested. PHASE_ORDER +
+ * classifySteps are still emitted during the timeline-restructure transition
+ * (renderD's old phase-position line uses them); they go once renderD switches
+ * to segmentSteps.
+ */
+export const PHASE_CLASSIFIER_SRC = [
+    'var PHASE_ORDER=' + JSON.stringify(PHASE_ORDER) + ';',
+    'var PHASE_META=' + JSON.stringify(PHASE_META) + ';',
+    stepPhase.toString(),
+    classifySteps.toString(),
+    segmentSteps.toString(),
+].join('\n');
+//# sourceMappingURL=thread-phase.js.map