@litfamily/litopencode 1.0.0

package/skills/autoconference/references/upstream-family-contract.md

@@ -0,0 +1,130 @@
+---
+name: autoconference-skill
+description: |
+  Multi-agent research conference that spawns parallel autoresearchers with
+  symposium sharing, adversarial peer review, and insight synthesis.
+  Reads a conference.md, orchestrates N researchers in structured rounds,
+  and produces a synthesized result combining the best findings.
+  TRIGGER when: user mentions "autoconference" or "conference" with research context;
+  user wants multiple researchers competing or collaborating; user wants parallel
+  autoresearch with peer review; user mentions "conference.md"; user wants
+  research synthesis from multiple approaches; user wants adversarial evaluation
+  of research results.
+  DO NOT TRIGGER when: user wants a single autoresearch loop (use autoresearch-skill);
+  user wants a simple one-shot answer; user wants to read a single paper.
+allowed-tools:
+  - Read
+  - Glob
+  - Grep
+---
+
+# Autoconference Source-Family Coverage
+
+## OpenCode authority envelope
+
+This reference is inert compatibility guidance. `lit-plan` must approve the finite root-owned
+objective, budget, roots, packet schema, and review contract before any mutation or delegation,
+including interactive runs. Only explicit `/start-work` may consume that approval. Children remain
+depth-one and packet-only; children must not write or mutate root-owned state, select models, or
+invoke routes.
+
+This retained reference is inert coverage material. The installed `skills/autoconference/SKILL.md`,
+read-only `lit-plan`, explicit `/start-work`, live root OpenCode task probe, and depth-one packet
+contract are authoritative. Historical tool/model assumptions grant no capability.
+
+## Mandatory Start Gate
+
+Before dispatching `/autoconference`, require a pre-flight confirmation gate:
+
+1. If the user has exactly specified researcher count, iterations/budget, Success Metric or Success Criteria, and Critic/Devil's Advocate inclusion, calculate the run conditions and produce an approval packet.
+2. If any of those values are missing or vague, ask the user for exact values first; then calculate conditions and ask for final confirmation.
+3. Do not write, evaluate, dispatch, or begin the conference loop from planning. After explicit
+   confirmation, hand the packet to `/start-work`.
+
+The adversarial Reviewer is part of the protocol every round; the gate's Critic/Devil's Advocate choice controls whether an additional researcher is assigned a contrarian role.
+
+## Conference Persistence Directive
+
+Once the bounded conference begins through `/start-work`:
+
+1. Complete a round only while task capability, approved authority, and budget remain.
+2. Stop on cancellation, stale state, a new boundary, malformed packets, or missing review.
+3. Continue after a valid round receipt without seeking redundant approval inside the same grant.
+4. **The conference runs until one of these conditions is met:**
+   - Target metric achieved (convergence)
+   - `max_rounds` or `max_total_iterations` exhausted (budget spent — this is normal, not failure)
+   - All researchers simultaneously stalled at Level 2+ (early synthesis)
+   - The user manually interrupts
+5. **If none of these conditions are true, begin the next round immediately.**
+
+Think of `max_rounds` as a budget to *spend*, not a limit to *fear*.
+
+## Commands
+
+| Command | Description | Skill Path |
+|---------|-------------|------------|
+| `/autoconference` | Core conference loop — N researchers, 4-phase rounds, synthesis | `skills/autoconference/SKILL.md` |
+| `/autoconference-plan` | Planning-only proposal and approval packet | `skills/autoconference/modes/plan.md` |
+| `/autoconference-resume` | Resume interrupted conference from checkpoint | `skills/autoconference/modes/resume.md` |
+| `/autoconference-analyze` | Post-conference insight analysis | `skills/autoconference/modes/analyze.md` |
+| `/autoconference-debate` | Adversarial 2-researcher debate mode | `skills/autoconference/modes/debate.md` |
+| `/autoconference-survey` | Systematic multi-database literature survey | `skills/autoconference/modes/survey.md` |
+| `/autoconference-ship` | Convert results to a local readiness packet | `skills/autoconference/modes/ship.md` |
+
+## Dispatch Logic
+
+- **Core command** (`/autoconference`) → load `skills/autoconference/SKILL.md` and `skills/autoconference/modes/core.md`.
+- **Hyphen-native mode command** → load the exact enrolled `skills/autoconference/modes/<name>.md` contract.
+- Unknown and near-miss modes remain inert; never fall back from a miss to an unintended execution route.
+
+## How It Works
+
+```
+┌─────────────────────────────────────────────────────────┐
+│                    CONFERENCE ROUND                       │
+│                                                           │
+│  Phase 1: INDEPENDENT RESEARCH (parallel)                │
+│  ┌──────────┐ ┌──────────┐ ┌──────────┐                 │
+│  │Researcher│ │Researcher│ │Researcher│  Each runs N     │
+│  │    A     │ │    B     │ │    C     │  autoresearch    │
+│  │ (iter×N) │ │ (iter×N) │ │ (iter×N) │  iterations     │
+│  └────┬─────┘ └────┬─────┘ └────┬─────┘                 │
+│       │             │            │                        │
+│  Phase 2: POSTER SESSION (packet-only comparison)         │
+│  Phase 3: PEER REVIEW (independent review packet)         │
+│  Phase 4: KNOWLEDGE TRANSFER (validated → shared)        │
+└─────────────────────────────────────────────────────────┘
+          │
+          ▼  Convergence check → next round or final synthesis
+```
+
+## Agent Roles
+
+| Role | Model | Count | Responsibility |
+|------|-------|-------|----------------|
+| **Root coordinator** | Current root-primary route | 1 | Owns capability probe, phase receipts, and terminal verdict |
+| **Researcher** | OpenCode depth-one task | N | Runs bounded autoresearch within one partition and returns a packet |
+| **Session Chair** | OpenCode depth-one task | 1/round | Produces the poster packet from accepted researcher packets |
+| **Reviewer** | OpenCode depth-one task | 1/round | Challenges claims and returns verdict evidence |
+| **Synthesizer** | Root or approved review task | 1 | Combines only independently validated findings |
+
+## Dependencies
+
+- **Required:** live root OpenCode task capability and the installed `autoresearch` managed family
+- **Extends:** `skills/autoresearch/SKILL.md` — each researcher runs the bounded core loop
+- **Python 3.8+** required only for `scripts/init_conference.py` (scaffolding helper)
+
+## Relationship to Other Skills
+
+| Skill | Relationship |
+|-------|-------------|
+| `autoresearch` | Required managed dependency for each researcher packet. |
+| `lit-plan` | Read-only proposal and approval-packet route. |
+| `/start-work` | Explicit bounded write/evaluator/task execution handoff after approval. |
+| `/review-work` | Completed-work evidence review before a DoneClaim. |
+
+## OpenCode Port Boundary
+
+This file does not dispatch, write, or execute standalone. The package installer recursively installs
+the family, and doctor verifies the exact tree. See `skills/autoconference/SKILL.md` and
+`skills/autoconference/references/conference-protocol.md` for the current orchestration and isolation contracts.

package/skills/autoconference/references/visualization-guide.md

@@ -0,0 +1,105 @@
+# Visualization Guide
+
+## OpenCode authority envelope
+
+This reference is inert rendering guidance. `lit-plan` must approve the finite root-owned figure
+objective, budget, source roots, output roots, and review contract before any mutation or delegation,
+including interactive runs. Only explicit `/start-work` may consume that approval. Children remain
+depth-one and packet-only; children must not write or mutate root-owned state, select models, or
+invoke routes.
+
+Mandatory rules for all `results.png` figures generated by autoresearch-skill. Based on the `/lit-scientific-visualization` skill standards.
+
+## Setup
+
+Every `visualize.py` MUST start with:
+
+```python
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', 'scripts'))
+from style_presets import rcparams
+rcparams()  # MUST be called before plt.subplots()
+```
+
+This loads `scripts/style_presets.py` which sets Pretendard/Arial fonts, inward ticks, Okabe-Ito colors, white background, and DPI 600.
+
+## 7 Mandatory Rules
+
+### 1. Axis endpoints must show numbers
+First and last tick on both axes must be visible. Use `ax.set_xlim()` and `ax.set_ylim()` explicitly.
+
+### 2. Subplots must maintain spacing
+Use `fig.tight_layout(pad=1.5)` or `constrained_layout=True`. No overlapping labels.
+
+### 3. Legend must never obscure data
+Place legend where it doesn't cover data points. Use `loc='upper right'` or `bbox_to_anchor` if needed.
+
+### 4. No titles
+Journal figures use captions, not titles. Do NOT call `ax.set_title()` or `fig.suptitle()`.
+
+### 5. Legend text color must match data color
+Each legend entry's text color matches its data series color:
+```python
+leg = ax.legend()
+colors = ['#0072B2', '#D55E00', '#009E73']
+for i, text in enumerate(leg.get_texts()):
+    text.set_color(colors[i])
+```
+
+### 6. Legend border: black, framealpha=1
+```python
+ax.legend(frameon=True, edgecolor='black', framealpha=1)
+```
+
+### 7. DPI > 500
+Save at 600 DPI. Export both PNG and PDF:
+```python
+fig.savefig('results.png', dpi=600, bbox_inches='tight')
+fig.savefig('results.pdf', dpi=600, bbox_inches='tight')
+```
+
+## Figure Structure for Autoresearch
+
+Two-panel layout with panel labels:
+
+```python
+fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
+
+# Panel labels
+ax1.text(-0.08, 1.08, 'A', transform=ax1.transAxes, fontsize=16, fontweight='bold', va='top')
+ax2.text(-0.08, 1.08, 'B', transform=ax2.transAxes, fontsize=16, fontweight='bold', va='top')
+```
+
+**Panel A — Metric Convergence:**
+- Scatter: kept iterations (blue `#0072B2`) vs reverted (vermillion `#D55E00`)
+- Line: best-so-far envelope (green `#009E73`)
+- Dashed: target threshold (orange `#E69F00`)
+- Annotate baseline and best values
+
+**Panel B — Domain-specific result:**
+- Code optimization: bar chart of execution times
+- Function fitting: prediction curve vs data scatter
+- Literature review: category coverage
+- Skill elaboration: component breakdown
+
+## Okabe-Ito Palette Reference
+
+| Color | Hex | Use |
+|-------|-----|-----|
+| Orange | `#E69F00` | Target line, warnings |
+| Sky Blue | `#56B4E9` | Train data, secondary |
+| Bluish Green | `#009E73` | Best-so-far, success |
+| Yellow | `#F0E442` | Highlights |
+| Blue | `#0072B2` | Kept iterations, primary |
+| Vermillion | `#D55E00` | Reverted, errors |
+| Reddish Purple | `#CC79A7` | Prediction curves |
+| Black | `#000000` | Baselines, text |
+
+## Conference-Specific Panels
+
+For autoconference visualizations, use multi-panel layouts:
+
+**Panel A:** Per-researcher metric convergence (one line per researcher, different colors)
+**Panel B:** Best-of-conference envelope (across all researchers)
+**Panel C:** Peer review verdict distribution (validated/challenged/overturned per round)
+**Panel D (optional):** Researcher strategy heatmap or cross-pollination graph

package/skills/autoconference/scripts/check_conference.sh

@@ -0,0 +1,371 @@
+#!/usr/bin/env bash
+# check_conference.sh - Lightweight progress monitor for autoconference runs
+# Usage: check_conference.sh [conference_dir]
+
+CONF_DIR="${1:-.}"
+CONF_DIR="${CONF_DIR%/}"  # strip trailing slash
+
+CONF_MD="$CONF_DIR/conference.md"
+RESULTS_TSV="$CONF_DIR/conference_results.tsv"
+EVENTS_JSONL="$CONF_DIR/conference_events.jsonl"
+SYNTHESIS_MD="$CONF_DIR/synthesis.md"
+FINAL_REPORT_MD="$CONF_DIR/final_report.md"
+
+if [[ ! -d "$CONF_DIR" || ! -f "$CONF_MD" ]]; then
+    printf 'Status:     not initialized\n'
+    exit 2
+fi
+
+NODE_BINARY="${NODE_BINARY:-node}"
+if ! command -v "$NODE_BINARY" >/dev/null 2>&1; then
+    printf 'Status:     BLOCKED_NODE_UNAVAILABLE\n'
+    exit 3
+fi
+
+# ── Parse conference.md ───────────────────────────────────────────────────────
+
+if [[ -f "$CONF_MD" ]]; then
+    # First non-empty line after "## Goal"
+    goal=$(awk '/^## Goal/{found=1; next} found && /[^[:space:]]/{print; exit}' \
+           "$CONF_MD")
+    # max_rounds: line matching "max_rounds", "Rounds:", or scaffolded "Max rounds:"
+    max_rounds=$(grep -m1 -iE 'max_rounds|Rounds:' "$CONF_MD" \
+                  | grep -oE '[0-9]+' \
+                  | head -1)
+    # Researcher count: prefer scaffolded "Count", fall back to named researcher entries
+    researcher_count=$(grep -m1 -iE '\*\*Count:\*\*|^count:' "$CONF_MD" \
+                       | grep -oE '[0-9]+' \
+                       | head -1)
+    if [[ -z "$researcher_count" ]]; then
+        researcher_count=$(grep -cE '^\s*-\s+\*\*Name\*\*:|^\s*-\s+name:' "$CONF_MD" 2>/dev/null) || researcher_count=0
+    fi
+    # Direction
+    direction=$(grep -m1 -i '\*\*Direction:\*\*' "$CONF_MD" \
+                | sed 's/.*\*\*Direction:\*\*[[:space:]]*//' \
+                | sed 's/[[:space:]]*$//' \
+                | tr '[:upper:]' '[:lower:]')
+    # Target
+    target=$(grep -m1 -i '\*\*Target:\*\*' "$CONF_MD" \
+              | sed 's/.*\*\*Target:\*\*[[:space:]]*//' \
+              | sed 's/[[:space:]]*$//')
+else
+    goal="?"; max_rounds="?"; researcher_count="?"; direction="maximize"; target="?"
+fi
+
+[[ -z "$goal"              ]] && goal="?"
+[[ -z "$max_rounds"        ]] && max_rounds="?"
+[[ -z "$researcher_count"  ]] && researcher_count="?"
+[[ -z "$direction"          ]] && direction="maximize"
+[[ -z "$target"            ]] && target="?"
+
+# ── Parse conference_results.tsv ──────────────────────────────────────────────
+
+best_metric="?"; best_researcher="?"; result_count="0"
+
+if [[ -f "$RESULTS_TSV" ]]; then
+    # Expect conference-level columns:
+    # round, researcher, iteration, metric_value, delta, delta_pct, status, description,
+    # evaluator_source, peer_review_verdict, timestamp
+    # Track best metric value and which researcher achieved it
+    best_val=""
+    while IFS=$'\t' read -r f_round f_researcher f_iteration f_metric f_rest; do
+        [[ -z "$f_researcher" ]] && continue
+        result_count=$(( result_count + 1 ))
+        val="$f_metric"
+        if [[ "$val" =~ ^-?[0-9]+(\.[0-9]+)?$ ]]; then
+            if [[ -z "$best_val" ]]; then
+                best_val="$val"
+                best_researcher="$f_researcher"
+            else
+                if [[ "$direction" == "minimize" ]]; then
+                    better=$(awk -v a="$val" -v b="$best_val" 'BEGIN{print (a<b)?1:0}')
+                else
+                    better=$(awk -v a="$val" -v b="$best_val" 'BEGIN{print (a>b)?1:0}')
+                fi
+                if [[ "$better" == "1" ]]; then
+                    best_val="$val"
+                    best_researcher="$f_researcher"
+                fi
+            fi
+        fi
+    done < <(tail -n +2 "$RESULTS_TSV" | grep -v '^[[:space:]]*$')
+
+    if [[ -n "$best_val" ]]; then
+        best_metric="$best_val"
+    fi
+    [[ -z "$best_researcher" ]] && best_researcher="?"
+fi
+
+# ── Parse conference_events.jsonl ─────────────────────────────────────────────
+
+current_round="0"; last_event_type="?"; last_event_ts="?"; stuck_count="0"; terminal_event_state="none"
+
+if [[ -f "$EVENTS_JSONL" ]]; then
+    # Count current and legacy round completion event names.
+    completed_rounds=$(grep -Ec '"round\.completed"|"round\.[0-9]+\.completed"' "$EVENTS_JSONL" 2>/dev/null) || completed_rounds=0
+    current_round="$completed_rounds"
+
+    # Count "researcher.stuck" events
+    stuck_count=$(grep -c '"researcher\.stuck"' "$EVENTS_JSONL" 2>/dev/null) || stuck_count=0
+    if ! terminal_event_state=$("$NODE_BINARY" - "$EVENTS_JSONL" "$RESULTS_TSV" "$researcher_count" "$max_rounds" "$direction" <<'NODE'
+const fs = require("node:fs");
+
+const [eventsPath, resultsPath, researcherCountRaw, maxRoundsRaw, direction] = process.argv.slice(2);
+const researcherCount = Number(researcherCountRaw);
+const maxRounds = Number(maxRoundsRaw);
+const allowedVerdicts = new Set([
+  "TARGET_MET", "CONVERGED", "BUDGET_EXHAUSTED", "STALLED", "CANCELLED", "BLOCKED"
+]);
+const allowedStatuses = new Set(["baseline", "kept", "reverted", "failed"]);
+const allowedPeerVerdicts = new Set(["validated", "challenged", "overturned", "-"]);
+const expectedHeader = ["round", "researcher", "iteration", "metric_value", "delta", "delta_pct", "status", "description", "evaluator_source", "peer_review_verdict", "timestamp"];
+
+function validTimestamp(value) {
+  if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/u.test(value)) return false;
+  const parsed = new Date(value);
+  if (!Number.isFinite(parsed.getTime())) return false;
+  const normalized = value.includes(".") ? value : value.replace(/Z$/u, ".000Z");
+  return parsed.toISOString() === normalized;
+}
+
+function finiteNumber(value) {
+  return typeof value === "string"
+    && /^-?(?:\d+(?:\.\d+)?|\.\d+)(?:[eE][+-]?\d+)?$/u.test(value)
+    && Number.isFinite(Number(value));
+}
+
+function parseResults() {
+  if (!Number.isInteger(researcherCount) || researcherCount < 1 || researcherCount > 26
+    || !Number.isInteger(maxRounds) || maxRounds < 1 || !new Set(["maximize", "minimize"]).has(direction)
+    || !fs.existsSync(resultsPath)) return { valid: false, rows: [] };
+  const configuredResearchers = new Set(Array.from({ length: researcherCount }, (_, index) => String.fromCharCode(65 + index)));
+  const lines = fs.readFileSync(resultsPath, "utf8").split(/\r?\n/u);
+  if (lines.at(-1) === "") lines.pop();
+  if (lines.length === 0 || lines[0] !== expectedHeader.join("\t")) return { valid: false, rows: [] };
+  const keys = new Set();
+  const rows = [];
+  let experimentCount = 0;
+  for (const line of lines.slice(1)) {
+    if (line === "") return { valid: false, rows };
+    const fields = line.split("\t");
+    if (fields.length !== expectedHeader.length) return { valid: false, rows };
+    const [roundRaw, researcher, iterationRaw, metricRaw, delta, deltaPct, status, description, evaluator, peerVerdict, timestamp] = fields;
+    if (!/^\d+$/u.test(roundRaw) || !/^\d+$/u.test(iterationRaw) || !configuredResearchers.has(researcher)
+      || !finiteNumber(metricRaw) || !(delta === "-" || finiteNumber(delta))
+      || !(deltaPct === "-" || /^-?(?:\d+(?:\.\d+)?|\.\d+)%$/u.test(deltaPct))
+      || !allowedStatuses.has(status) || description.trim() === "" || evaluator.trim() === ""
+      || !allowedPeerVerdicts.has(peerVerdict) || !validTimestamp(timestamp)) return { valid: false, rows };
+    const round = Number(roundRaw);
+    const iteration = Number(iterationRaw);
+    const key = `${round}:${researcher}:${iteration}`;
+    if (!Number.isSafeInteger(round) || round < 1 || round > maxRounds || !Number.isSafeInteger(iteration)
+      || keys.has(key)) return { valid: false, rows };
+    if (iteration === 0) {
+      if (status !== "baseline" || delta !== "-" || deltaPct !== "-" || peerVerdict !== "-") {
+        return { valid: false, rows };
+      }
+    } else {
+      if (status === "baseline") return { valid: false, rows };
+      experimentCount += 1;
+    }
+    keys.add(key);
+    rows.push({ round, researcher, iteration, metric: Number(metricRaw), status });
+  }
+  return { valid: true, rows, configuredResearchers, experimentCount };
+}
+
+const results = parseResults();
+if (!results.valid) {
+  process.stdout.write("invalid");
+  process.exit(0);
+}
+const resultCount = results.experimentCount;
+
+let latest;
+const completedRounds = new Map();
+let invalidRoundReceipt = false;
+for (const line of fs.readFileSync(eventsPath, "utf8").split(/\r?\n/u)) {
+  if (line.trim() === "") continue;
+  let event;
+  try {
+    event = JSON.parse(line);
+  } catch {
+    continue;
+  }
+  if (event !== null && typeof event === "object" && !Array.isArray(event)) {
+    if (event.event === "round.completed") {
+      const payload = event.payload;
+      const validPayload = payload !== null && typeof payload === "object" && !Array.isArray(payload)
+        && Number.isInteger(payload.round) && payload.round >= 1 && payload.round <= maxRounds
+        && typeof payload.best_metric === "number" && Number.isFinite(payload.best_metric)
+        && results.configuredResearchers.has(payload.best_researcher) && typeof payload.converged === "boolean";
+      if (!validTimestamp(event.timestamp) || !validPayload || completedRounds.has(payload?.round)) {
+        invalidRoundReceipt = true;
+        continue;
+      }
+      const candidates = results.rows.filter((row) => row.round === payload.round && row.status !== "failed");
+      const bestMetric = candidates.reduce((best, row) => direction === "minimize"
+        ? Math.min(best, row.metric) : Math.max(best, row.metric), direction === "minimize" ? Infinity : -Infinity);
+      const reconciled = candidates.length > 0 && payload.best_metric === bestMetric
+        && candidates.some((row) => row.researcher === payload.best_researcher && row.metric === bestMetric);
+      if (!reconciled) invalidRoundReceipt = true;
+      else completedRounds.set(payload.round, payload);
+    }
+    if (event.event === "conference.completed") latest = event;
+  }
+}
+
+if (latest === undefined) {
+  process.stdout.write("none");
+  process.exit(0);
+}
+
+const payload = latest.payload;
+const roundCount = completedRounds.size;
+const roundsAreSequential = Array.from({ length: roundCount }, (_, index) => index + 1)
+  .every((round) => completedRounds.has(round));
+const resultRounds = new Set(results.rows.map((row) => row.round));
+const rowsReconciled = resultRounds.size === roundCount && [...resultRounds].every((round) => completedRounds.has(round));
+const baselinesReconciled = [...completedRounds.keys()].every((round) =>
+  [...results.configuredResearchers].every((researcher) =>
+    results.rows.some((row) => row.round === round && row.researcher === researcher
+      && row.iteration === 0 && row.status === "baseline")));
+const validPayload = payload !== null
+  && typeof payload === "object"
+  && !Array.isArray(payload)
+  && payload.synthesis_path === "synthesis.md"
+  && payload.final_report_path === "final_report.md"
+  && Number.isInteger(payload.total_iterations)
+  && payload.total_iterations >= 0
+  && payload.total_iterations === resultCount
+  && Number.isInteger(payload.total_rounds)
+  && payload.total_rounds >= 0
+  && payload.total_rounds === roundCount
+  && roundsAreSequential
+  && Number.isInteger(payload.researcher_count)
+  && payload.researcher_count >= 1
+  && payload.researcher_count === researcherCount
+  && rowsReconciled
+  && baselinesReconciled;
+const valid = validTimestamp(latest.timestamp)
+  && allowedVerdicts.has(latest.terminal_verdict)
+  && validPayload
+  && !invalidRoundReceipt;
+process.stdout.write(valid ? "valid" : "invalid");
+NODE
+    ); then
+        printf 'Status:     BLOCKED_NODE_RUNTIME_ERROR\n'
+        exit 3
+    fi
+
+    # Last event: extract type and timestamp from the last non-empty line
+    last_line=$(grep -v '^[[:space:]]*$' "$EVENTS_JSONL" | tail -1)
+    if [[ -n "$last_line" ]]; then
+        # Extract event type — value of "event" or "type" key
+        last_event_type=$(printf '%s' "$last_line" \
+                          | grep -oE '"(event|type)"\s*:\s*"[^"]+"' \
+                          | head -1 \
+                          | grep -oE '"[^"]+"\s*$' \
+                          | tr -d '"' \
+                          | sed 's/^[[:space:]]*//')
+        # Extract timestamp — value of "ts", "timestamp", or "time" key
+        last_event_ts=$(printf '%s' "$last_line" \
+                        | grep -oE '"(ts|timestamp|time)"\s*:\s*"[^"]+"' \
+                        | head -1 \
+                        | grep -oE '"[^"]+"\s*$' \
+                        | tr -d '"' \
+                        | sed 's/^[[:space:]]*//')
+    fi
+fi
+
+[[ -z "$last_event_type" ]] && last_event_type="?"
+[[ -z "$last_event_ts"   ]] && last_event_ts=""
+
+# ── Determine run status ──────────────────────────────────────────────────────
+
+if [[ -f "$CONF_MD" ]] && grep -q 'Scaffold status:[[:space:]]*INCOMPLETE' "$CONF_MD"; then
+    run_status="incomplete scaffold"
+elif [[ "$terminal_event_state" == "invalid" ]]; then
+    run_status="terminal invalid"
+elif [[ "$terminal_event_state" == "valid" ]] && [[ -s "$SYNTHESIS_MD" ]] && [[ -s "$FINAL_REPORT_MD" ]] && [[ "$result_count" -gt 0 ]]; then
+    run_status="COMPLETE"
+elif [[ "$terminal_event_state" == "valid" ]]; then
+    run_status="terminal incomplete"
+elif [[ "$current_round" -gt 0 || "$result_count" -gt 0 || "$last_event_type" != "?" ]]; then
+    run_status="progress recorded"
+else
+    run_status="ready; no progress recorded"
+fi
+
+# ── Build display strings ─────────────────────────────────────────────────────
+
+round_display="${current_round} / ${max_rounds}"
+
+# Format last event with timestamp if available
+if [[ -n "$last_event_ts" ]]; then
+    last_event_display="${last_event_type} @ ${last_event_ts}"
+else
+    last_event_display="$last_event_type"
+fi
+
+# Add stuck researcher info if any
+if [[ "$stuck_count" -gt 0 ]]; then
+    researcher_display="${researcher_count} (${stuck_count} stuck)"
+else
+    researcher_display="$researcher_count"
+fi
+
+# Truncate long strings to keep box tidy (max ~44 chars for value column)
+_trunc() {
+    local s="$1" max="${2:-44}"
+    if [[ ${#s} -gt $max ]]; then
+        printf '%s' "${s:0:$((max-1))}…"
+    else
+        printf '%s' "$s"
+    fi
+}
+
+val_w=44
+
+conf_val=$(_trunc "${CONF_DIR}/" $val_w)
+goal_val=$(_trunc "$goal" $val_w)
+round_val=$(_trunc "$round_display" $val_w)
+researcher_val=$(_trunc "$researcher_display" $val_w)
+metric_val=$(_trunc "${best_metric} (${best_researcher})" $val_w)
+target_val=$(_trunc "$target" $val_w)
+status_val=$(_trunc "$run_status" $val_w)
+last_val=$(_trunc "$last_event_display" $val_w)
+
+# ── Box drawing ───────────────────────────────────────────────────────────────
+
+inner_w=54  # fixed inner width for clean alignment
+border=$(printf '─%.0s' $(seq 1 $inner_w))
+
+_pad_row() {
+    local label="$1" value="$2"
+    local content="  ${label}${value}"
+    local pad=$(( inner_w - ${#content} ))
+    if [[ $pad -lt 0 ]]; then
+        local max_val=$(( inner_w - ${#label} - 2 ))
+        value="${value:0:$((max_val-1))}…"
+        content="  ${label}${value}"
+        pad=0
+    fi
+    printf '│%s%*s│\n' "$content" "$pad" ""
+}
+
+printf '┌─ autoconference progress ─%s┐\n' "$(printf '─%.0s' $(seq 1 $((inner_w - 28))))"
+_pad_row "Conference:   " "$conf_val"
+_pad_row "Goal:         " "$goal_val"
+_pad_row "Round:        " "$round_val"
+_pad_row "Researchers:  " "$researcher_val"
+_pad_row "Best metric:  " "$metric_val"
+_pad_row "Target:       " "$target_val"
+_pad_row "Status:       " "$status_val"
+_pad_row "Last event:   " "$last_val"
+printf '└%s┘\n' "$border"
+
+if [[ "$run_status" == "terminal invalid" ]]; then
+    exit 4
+fi
+exit 0