@zalom/plastic 1.0.0-beta.1 → 1.0.0-beta.10

package/PLASTIC.md

@@ -35,15 +35,28 @@ Identity and knowledge graph only. Nothing operational.
 ---
 id: "4a1"
 intent: "Short description of the desire"
-sources: ["4a"]        # backward links — what influenced this
-chain: ["4a1a"]        # forward links — what this spawned
+sources: ["4a"]        # direct ascendants: intents this was created from
+chain: ["4a1a"]        # forward: what this spawned and related successors
 created: 2026-05-29
 author: human          # human | agent-name
 tags: [plastic, architecture]
 ---
 ```
 
-- `sources` + `chain` form the double-linked knowledge graph (Folgezettel)
+- `sources` (formative, must-load, acyclic) and `chain` (forward + relational, lighter,
+  may cycle) form the directed knowledge graph. Reciprocity is one-directional: every
+  `sources` edge has a reciprocal `chain` entry (I1), but `chain` may carry relational
+  entries with no reciprocal `sources` (I2), so the graph is not strictly symmetric.
+- Context contract: load `sources` strongly (they are what the intent was built from);
+  traverse `chain` lightly for discovery. See
+  docs/concepts/how-plastic-sources-and-chains-intents.md for the full model.
+- `## Links` (I5) is the human-readable projection of the graph. It mirrors the
+  frontmatter exactly: every entry is `- [[id--slug|<target's full intent: text>]]`, a
+  clickable `id--slug` wikilink target with the target intent's full `intent:` text as the
+  label (cross-store targets render `- [[store:id--slug|<target's full intent: text>]]`).
+  Ordering is mandatory: all `sources` first (top), then all `chain`, frontmatter order
+  preserved within each group. Sources never appear at the end. No source/chain tags, no
+  sub-grouping. An intent with empty `sources` and `chain` carries the empty-state comment.
 - IDs use Luhmann's alternating convention: `1` → `1a` → `1a1` → `1a1a`
 - Multiple branches increment: `1a`, `1b`, `1c`
 
@@ -155,8 +168,11 @@ Format: `ID--three-to-five-words` (all stores).
 
 - **Branch (`14a`, `14b`)** — a sub-task, refinement, or direct continuation of the
   parent. It cannot stand on its own; it only makes sense as part of the parent's work.
-- **Root (`15`, `16`)** — an independent thought, even if inspired by another intent.
-  Record provenance with `sources: ["14"]`, not by branching.
+- **Root (`15`, `16`)**: an independent thought, even if inspired by another intent.
+  Reserve `sources` for true created-from provenance (intents this was built out of). An
+  independent intent merely related to or inspired by another carries NO `sources`; record
+  the relation on the PREDECESSOR's `chain` (and mirror it as a
+  `[[id--slug|<target's full intent: text>]]` wikilink in `## Links`).
 - **Rule of thumb:** if the intent could exist without its parent, it's a root.
 
 ## INDEX.md

package/agents/plastic-brainstorming.md

@@ -27,7 +27,15 @@ When dispatched in auto mode you receive the standard Plastic spawn preamble (fr
 2. Read the intent file, its `## Links`, and related code or docs
 3. Research with the adaptive budget the enforcer set (simple 2-3, medium 5-8, complex 10-15 steps)
 4. Produce (output handoff): an enriched `## Context` plus `### Decisions` with rationale
-5. Log autonomous calls in `## Insights` with the `(autonomous)` marker, then report for gating
+5. Log autonomous calls in `## Insights` with the `(autonomous)` marker, then report for gating (see `## Completion Report`)
+
+## Completion Report
+
+END your turn with a structured completion report as your final message, per the spawn preamble's `REPORT_CONTRACT` and `skills/auto/references/agent-report-contract.md`. Do not finish silently. Carry the common envelope (role, intent id, stage, status, artifacts written, verification, checklist deltas, deviations, blockers) plus the brainstorming payload:
+
+- Decisions recorded in `### Decisions`, each with its one-line rationale
+- Context enriched: what was researched and the key findings
+- Open questions resolved, and any deliberately left for the spec
 
 ## Constraints
 

package/agents/plastic-executor.md

@@ -28,6 +28,16 @@ When dispatched in auto mode you receive the standard Plastic spawn preamble (fr
 3. Edit project code (the gate is open now that plan and checklist exist)
 4. Run the full suite, iterate to zero failures and zero errors
 5. Produce (output handoff): the code changes, a checked-off `checklist.md`, and `## Insights`
+6. Report for gating (see `## Completion Report`); the enforcer reviews the work at the final gate
+
+## Completion Report
+
+END your turn with a structured completion report as your final message, per the spawn preamble's `REPORT_CONTRACT` and `skills/auto/references/agent-report-contract.md`. Do not finish silently. Carry the common envelope (role, intent id, stage, status, artifacts written, verification, checklist deltas, deviations, blockers) plus the executor payload:
+
+- Actions implemented this turn, mapped to checklist items checked off (checked / total)
+- A summary of the code changed (files and the shape of the change)
+- Test result: the full-suite command and its pass / fail counts
+- Insights appended, with the `(autonomous)` marker
 
 ## Constraints
 

package/agents/plastic-intent-curator.md

@@ -18,23 +18,25 @@ You are the Plastic Intent Curator. Your role is to maintain the health and navi
 
 ## Your Responsibilities
 
-1. **Intent lifecycle management** — move intents between Active/Future/Completed in INDEX.md, fill in `## Outcome` sections
-2. **INDEX.md maintenance** — keep Active/Future/Clusters/Completed sections accurate and well-organized
+1. **Intent lifecycle management** — move intents between Active/Future/Completed/Abandoned in INDEX.md, fill in `## Outcome` sections (including the abandonment rationale when an intent is abandoned)
+2. **INDEX.md maintenance** — keep Active/Future/Clusters/Completed/Abandoned sections accurate and well-organized
 3. **Link discovery** — suggest connections between intents that share topics but aren't linked
 4. **Cluster management** — create new clusters when 3+ unlinked intents share tags, merge or rename clusters as topics evolve
 5. **Orphan detection** — flag intents with no links and no cluster membership
 
 ## How You Work
 
+0. QMD-first (when available): when you need to locate a specific intent (to reclassify, link, or cluster it) rather than rebuild the whole landscape, before scanning the store with grep/Read run `ruby ~/.plastic/scripts/qmd-sync search "<terms>"` to surface candidate or related intents, then open the authoritative intent file for any hit you act on. The command is a no-op when QMD is absent, so fall back to the full scan below. (This is discovery; the reindex step at a terminal-state transition is separate.)
 1. Scan `~/.plastic/store/*/ID--slug.md` (or project store) to understand the full intent landscape
 2. Read `~/.plastic/INDEX.md` (or project INDEX.md) to understand current organization
-3. Compare: are there intents not in any cluster? Missing from Active/Completed? Status mismatches?
+3. Compare: are there intents not in any cluster? Missing from Active/Completed/Abandoned? Status mismatches?
 4. Make targeted edits to INDEX.md and intent frontmatter/links
-5. Report what you changed
+5. On a terminal-state transition: whenever you move an intent to Completed OR Abandoned, refresh the QMD index for that store so the new outcome (or abandonment rationale) is searchable. This is mandatory on any terminal-state move and a no-op when QMD is absent, and it runs in the background so it never blocks: `ruby ~/.plastic/scripts/qmd-sync reindex --store <store-root> --async`
+6. Report what you changed
 
 ## Constraints
 
 - You only edit `~/.plastic/INDEX.md` (or project INDEX.md) and `~/.plastic/store/*/ID--slug.md` (or project store) files
 - You never create new intents — that's the creating-intent skill's job
 - You never modify `## Insights`, `## Context`, or `## Outcome` content sections — those belong to the worker
-- You use Read and grep/find for discovery, Edit for targeted changes
+- For discovery, put QMD first when available (`qmd-sync search`), then fall back to Read and grep/find; use Edit for targeted changes

package/agents/plastic-planner.md

@@ -27,7 +27,17 @@ When dispatched in auto mode you receive the standard Plastic spawn preamble (fr
 2. Read `spec.md` and the plan/checklist templates; match their FORM
 3. Write `plan.md`, the `actions/` directory, and `checklist.md` into the intent directory
 4. Produce (output handoff): `plan.md` plus `actions/` plus `checklist.md`
-5. Report for gating; the enforcer verifies plan and checklist exist before Exec is allowed
+5. Report for gating (see `## Completion Report`); the enforcer verifies plan and checklist exist before Exec is allowed
+
+## Completion Report
+
+END your turn with a structured completion report as your final message, per the spawn preamble's `REPORT_CONTRACT` and `skills/auto/references/agent-report-contract.md`. Do not finish silently. Carry the common envelope (role, intent id, stage, status, artifacts written, verification, checklist deltas, deviations, blockers) plus the planner payload, which EXPLAINS THE PLAN BACK TO THE ORCHESTRATOR:
+
+- The ordered actions, one line each: what the action does and how it is verified
+- Decomposition rationale: why this order, and why the actions are independent
+- Checklist coverage: the item count, and that every action plus suite-green is covered
+
+The plan is an argument; the orchestrator gates on whether that argument is sound before any code is written, so make the report make that case.
 
 ## Constraints
 

package/agents/plastic-spec-specialist.md

@@ -27,7 +27,15 @@ When dispatched in auto mode you receive the standard Plastic spawn preamble (fr
 2. Read the spec template (`templates/spec.md`) and match its FORM exactly
 3. Write `spec.md` into the intent directory, resolving the decisions into a coherent approach
 4. Produce (output handoff): a complete `spec.md`
-5. Report for gating; the enforcer checks the spec against its exit criteria before How begins
+5. Report for gating (see `## Completion Report`); the enforcer checks the spec against its exit criteria before How begins
+
+## Completion Report
+
+END your turn with a structured completion report as your final message, per the spawn preamble's `REPORT_CONTRACT` and `skills/auto/references/agent-report-contract.md`. Do not finish silently. Carry the common envelope (role, intent id, stage, status, artifacts written, verification, checklist deltas, deviations, blockers) plus the spec payload:
+
+- The spec sections produced (Problem, Goals, Non-Goals, Approach, Decisions, Acceptance Criteria)
+- How the recorded decisions resolved into the chosen approach
+- The acceptance-criteria count, so the planner knows the surface to cover
 
 ## Constraints
 

package/hooks/statusline

@@ -1,56 +1,165 @@
 #!/bin/bash
-# plastic-hook-version: 2.0.0
-# StatusLine hook — chains user's original statusline, adds Plastic info
+# plastic-hook-version: 3.0.0
+# StatusLine hook - Plastic owns the full statusline (no chaining).
+# Renders: {model} - Plastic {version}[ -> {next}] - {path} - [{project}: {id} {title}]
+# Pure bash (macOS 3.2 compatible). No ruby, no jq. Reads stdin once; small file reads only.
 
 INPUT=$(cat)
 
-# --- Chain original statusline ---
-ORIGINAL_CONFIG="$HOME/.plastic/.cache/original-statusline.json"
-ORIGINAL_OUTPUT=""
-if [ -f "$ORIGINAL_CONFIG" ]; then
-  ORIGINAL_CMD=$(grep -o '"command":"[^"]*"' "$ORIGINAL_CONFIG" 2>/dev/null | head -1 | cut -d'"' -f4)
-  if [ -z "$ORIGINAL_CMD" ]; then
-    ORIGINAL_CMD=$(grep -o '"command": "[^"]*"' "$ORIGINAL_CONFIG" 2>/dev/null | head -1 | sed 's/.*"command": "//;s/".*//')
-  fi
-  if [ -n "$ORIGINAL_CMD" ] && [ -x "$ORIGINAL_CMD" ]; then
-    ORIGINAL_OUTPUT=$(echo "$INPUT" | "$ORIGINAL_CMD" 2>/dev/null)
+# --- Colors (ANSI-C quoting; bash 3.2 supports $'\033') ---
+C_MODEL=$'\033[38;2;90;140;220m'   # navy blue - model (lightened for legibility)
+C_VER=$'\033[37m'                  # white     - "Plastic {version}" and update arrow
+C_NEXT=$'\033[33m'                 # yellow    - next version
+C_PATH=$'\033[38;2;128;134;144m'   # gray      - path (matches dim UI text)
+C_BRACK=$'\033[33m'                # yellow    - work-unit brackets
+C_PROJ=$'\033[38;2;249;140;30m'    # orange    - project name
+C_ID=$'\033[38;2;45;212;191m'      # teal      - intent id (accent between orange + yellow)
+C_INTENT=$'\033[33m'               # yellow    - intent title
+C_SEP=$'\033[38;2;128;134;144m'    # gray      - separators
+RST=$'\033[0m'
+SEP="${C_SEP} "$'\302\267'" ${RST}"   # " . " middot, dim
+
+# --- Extract a flat JSON string field from stdin: json_str <key> ---
+json_str() {
+  printf '%s' "$INPUT" \
+    | grep -o "\"$1\"[[:space:]]*:[[:space:]]*\"[^\"]*\"" \
+    | head -1 \
+    | sed "s/.*\"$1\"[[:space:]]*:[[:space:]]*\"//;s/\"$//"
+}
+
+# --- Model (model.display_name) ---
+MODEL=$(json_str "display_name")
+
+# --- Path (workspace.current_dir, fallback top-level cwd) ---
+REAL_CWD=$(json_str "current_dir")
+[ -z "$REAL_CWD" ] && REAL_CWD=$(json_str "cwd")
+# Abbreviate $HOME -> ~
+CWD="$REAL_CWD"
+case "$CWD" in
+  "$HOME") CWD="~" ;;
+  "$HOME"/*) CWD="~${CWD#"$HOME"}" ;;
+esac
+
+# --- Plastic version ---
+VERSION=""
+[ -f "$HOME/.plastic/VERSION" ] && VERSION=$(tr -d ' \t\n' < "$HOME/.plastic/VERSION")
+
+# --- Update (next version when one is available) ---
+NEXT=""
+CACHE_FILE="$HOME/.plastic/.cache/update-check.json"
+if [ -f "$CACHE_FILE" ]; then
+  if grep -q '"updateAvailable"[[:space:]]*:[[:space:]]*true' "$CACHE_FILE" 2>/dev/null; then
+    LATEST=$(grep -o '"latest"[[:space:]]*:[[:space:]]*"[^"]*"' "$CACHE_FILE" 2>/dev/null \
+      | head -1 | sed 's/.*"latest"[[:space:]]*:[[:space:]]*"//;s/"$//')
+    if [ -n "$LATEST" ]; then
+      case "$LATEST" in
+        *-*) NEXT="${LATEST##*-}" ;;   # 1.0.0-beta.3 -> beta.3
+        *)   NEXT="$LATEST" ;;
+      esac
+    fi
   fi
 fi
 
-# --- Plastic status ---
-PLASTIC_PARTS=""
+# --- Scope resolution: cwd -> registered project store, else global ---
+# Match the longest registered project path that prefixes the real cwd.
+PROJECTS_YML="$HOME/.plastic/projects.yml"
+SLUG=""
+if [ -n "$REAL_CWD" ] && [ -f "$PROJECTS_YML" ]; then
+  SLUG=$(awk -v cwd="$REAL_CWD" '
+    /^  [A-Za-z0-9_.-]+:[[:space:]]*$/ { s=$1; sub(/:$/,"",s); next }
+    /^    path:/ {
+      p=$0; sub(/^[[:space:]]*path:[[:space:]]*/,"",p); gsub(/"/,"",p);
+      if (length(p)>0 && (cwd==p || index(cwd, p"/")==1) && length(p)>best) { best=length(p); win=s }
+    }
+    END { if (win!="") print win }
+  ' "$PROJECTS_YML")
+fi
 
-# Active intent from INDEX.md
-INDEX="$HOME/.plastic/INDEX.md"
-if [ -f "$INDEX" ]; then
-  ACTIVE=$(sed -n '/^## Active$/,/^## /{/^- \[/p;}' "$INDEX" | head -1)
-  if [ -n "$ACTIVE" ]; then
-    INTENT=$(echo "$ACTIVE" | sed 's/^- \[\([^]]*\)\].*/\1/')
-    PLASTIC_PARTS="plastic: ${INTENT}"
-  fi
+if [ -n "$SLUG" ]; then
+  INDEX="$HOME/.plastic/projects/$SLUG/INDEX.md"
+  PROJ_LABEL="$SLUG"
+else
+  INDEX="$HOME/.plastic/INDEX.md"
+  PROJ_LABEL="global"
 fi
+INDEX_DIR=$(dirname "$INDEX")
 
-# Update notification
-CACHE_FILE="$HOME/.plastic/.cache/update-check.json"
-if [ -f "$CACHE_FILE" ]; then
-  UPDATE_AVAILABLE=$(grep -o '"updateAvailable":true' "$CACHE_FILE" 2>/dev/null)
-  if [ -n "$UPDATE_AVAILABLE" ]; then
-    LATEST=$(grep -o '"latest":"[^"]*"' "$CACHE_FILE" 2>/dev/null | head -1 | cut -d'"' -f4)
-    CURRENT=$(grep -o '"current":"[^"]*"' "$CACHE_FILE" 2>/dev/null | head -1 | cut -d'"' -f4)
-    UPDATE_MSG="plastic update: $CURRENT -> $LATEST"
-    if [ -n "$PLASTIC_PARTS" ]; then
-      PLASTIC_PARTS="$PLASTIC_PARTS | $UPDATE_MSG"
-    else
-      PLASTIC_PARTS="$UPDATE_MSG"
+# --- Current-session work-unit: the live bridge wins over savepoint recency ---
+# The statusline receives the real session_id on stdin; the session's bridge
+# (plastic-{session_id}.json) is the authoritative "what THIS session is driving".
+# This beats the shared, savepoint-recency heuristic so parallel sessions on one
+# store no longer overwrite each other's line. grep/sed only - no jq, no ruby.
+WORK=""
+SID=$(json_str "session_id")
+if [ -n "$SID" ]; then
+  BRIDGE="${PLASTIC_TMP:-/tmp}/plastic-${SID}.json"
+  if [ -f "$BRIDGE" ]; then
+    # Bridge JSON is pretty-printed (one field per line). Scope extraction to the
+    # "intent" object so a sibling top-level "id"/"name" can never win (the intent
+    # object holds only string fields, so the first "}" closes it). grep/sed only.
+    INTENT_BLOCK=$(sed -n '/"intent"[[:space:]]*:[[:space:]]*{/,/}/p' "$BRIDGE" 2>/dev/null)
+    B_ID=$(printf '%s\n' "$INTENT_BLOCK" | grep -o '"id"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+      | sed 's/.*"id"[[:space:]]*:[[:space:]]*"//;s/"$//')
+    B_NAME=$(printf '%s\n' "$INTENT_BLOCK" | grep -o '"name"[[:space:]]*:[[:space:]]*"[^"]*"' | head -1 \
+      | sed 's/.*"name"[[:space:]]*:[[:space:]]*"//;s/"$//')
+    if [ -n "$B_ID" ] && [ -n "$B_NAME" ]; then
+      EMDASH=$'\342\200\224'
+      WORK="${B_ID} ${EMDASH} ${B_NAME}"
     fi
   fi
 fi
 
-# --- Combine output ---
-if [ -n "$ORIGINAL_OUTPUT" ] && [ -n "$PLASTIC_PARTS" ]; then
-  echo "$ORIGINAL_OUTPUT | $PLASTIC_PARTS"
-elif [ -n "$ORIGINAL_OUTPUT" ]; then
-  echo "$ORIGINAL_OUTPUT"
-elif [ -n "$PLASTIC_PARTS" ]; then
-  echo "$PLASTIC_PARTS"
+# --- Most-recently-accessed active intent (mirror dashboard: last savepoint ts) ---
+# Fallback only: runs when no session bridge resolved a work-unit above.
+if [ -z "$WORK" ] && [ -f "$INDEX" ]; then
+  BEST_TS=""
+  while IFS= read -r line; do
+    [ -z "$line" ] && continue
+    inside=${line#*[}; inside=${inside%%]*}             # "{id} - {title}"
+    dir=${line#*](store/}; dir=${dir%%/*}              # intent directory name
+    [ -z "$dir" ] && continue
+    sp="$INDEX_DIR/store/$dir/savepoint.md"
+    ts=""
+    if [ -f "$sp" ]; then
+      ts=$(grep -oE '[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}Z' "$sp" 2>/dev/null | tail -1)
+    fi
+    # ISO8601 sorts lexicographically; keep the newest. Empty ts sorts lowest.
+    if [ -z "$BEST_TS" ] || { [ -n "$ts" ] && [ "$ts" \> "$BEST_TS" ]; }; then
+      BEST_TS="$ts"
+      WORK="$inside"
+    fi
+  done <<EOF
+$(sed -n '/^## Active$/,/^## /{/^- \[/p;}' "$INDEX")
+EOF
+fi
+
+# --- Build the work-unit "[{project}: {id} {title}]" with title truncation ---
+WORK_SEG=""
+if [ -n "$WORK" ]; then
+  # Split "{id} - {title}" on the em-dash (U+2014).
+  EMDASH=$'\342\200\224'
+  id=${WORK%% $EMDASH *}
+  title=${WORK#* $EMDASH }
+  # Fallback if the em-dash form is absent: split on first space.
+  if [ "$id" = "$WORK" ]; then id=${WORK%% *}; title=${WORK#* }; fi
+  # Truncate long titles (~40 chars).
+  if [ ${#title} -gt 40 ]; then title="$(printf '%.40s' "$title")..."; fi
+  WORK_SEG="${C_BRACK}[${RST}${C_PROJ}${PROJ_LABEL}${RST}${C_INTENT}: ${RST}${C_ID}${id}${RST}${C_INTENT} ${title}${RST}${C_BRACK}]${RST}"
 fi
+
+# --- Assemble segments in order, joined by " . " ---
+PARTS=""
+add() { [ -z "$1" ] && return; if [ -z "$PARTS" ]; then PARTS="$1"; else PARTS="$PARTS$SEP$1"; fi; }
+
+# Order: stable values first (model, work-unit), then the volatile-length
+# values last (version, path) so the line does not visually jump as they change.
+[ -n "$MODEL" ] && add "${C_MODEL}${MODEL}${RST}"
+[ -n "$WORK_SEG" ] && add "$WORK_SEG"
+if [ -n "$VERSION" ]; then
+  vseg="${C_VER}Plastic ${VERSION}${RST}"
+  [ -n "$NEXT" ] && vseg="${vseg}${C_VER} "$'\342\206\222'" ${RST}${C_NEXT}${NEXT}${RST}"
+  add "$vseg"
+fi
+[ -n "$CWD" ] && add "${C_PATH}${CWD}${RST}"
+
+printf '%s\n' "$PARTS"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zalom/plastic",
-  "version": "1.0.0-beta.1",
+  "version": "1.0.0-beta.10",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {

package/scripts/agent-report

@@ -0,0 +1,142 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+# frozen_string_literal: true
+
+# agent-report - deterministic filesystem-derived completion report (intent 74).
+#
+# The auto-mode report contract is decision-shaped (the spawn preamble's
+# REPORT_CONTRACT plus the role prompts ask every dispatched agent to END with a
+# structured completion report). Because child-agent honor is best-effort across
+# harnesses (Tier B/C, docs/reference/harness-adapters.md), the contract is never a
+# hard block. This script is the always-a-report fallback: when a dispatched agent
+# returns no usable report, the enforcer runs it to synthesize one from the intent
+# directory, so the handoff account always exists.
+#
+# Like scripts/spawn-preamble, it is a PURE function of the intent dir: no network,
+# no randomness, no wall-clock reads. Two runs over the same on-disk state produce
+# byte-identical output.
+#
+# Usage:
+#   agent-report <intent_dir> [--role ROLE]
+#
+# Exit codes: 0 (report emitted), 2 (usage).
+
+require_relative "lib/bridge"
+
+def parse_args(argv)
+  role = nil
+  positional = []
+  i = 0
+  while i < argv.length
+    case argv[i]
+    when "--role"
+      role = argv[i + 1]
+      i += 2
+    else
+      positional << argv[i]
+      i += 1
+    end
+  end
+  [positional.first, role]
+end
+
+# Read the intent file frontmatter via the same path spawn-preamble uses, so the
+# id/intent we report match what the rest of Plastic sees. Never raises.
+def frontmatter_for(intent_dir)
+  ifile = Bridge.intent_file(intent_dir)
+  return {} unless File.exist?(ifile)
+
+  content = File.read(ifile)
+  return {} unless content.start_with?("---")
+
+  parts = content.split("---", 3)
+  return {} if parts.length < 3
+
+  require "yaml"
+  require "date"
+  require "time"
+  YAML.safe_load(parts[1], permitted_classes: [Date, Time]) || {}
+rescue StandardError
+  {}
+end
+
+# Current stage: prefer the last non-empty savepoint line (the ledger encodes the
+# furthest-reached milestone), else the file-derived stage. Same logic as
+# spawn-preamble's current_stage.
+STAGE_LABELS = {
+  "what" => "What", "why" => "Why", "how" => "How",
+  "exec" => "Exec", "done" => "Done"
+}.freeze
+
+def current_stage(intent_dir)
+  ledger = File.join(intent_dir, Bridge::SAVEPOINT_FILE)
+  if File.exist?(ledger)
+    last = File.read(ledger).each_line.map(&:strip).reject(&:empty?).last
+    return last if last
+  end
+  STAGE_LABELS.fetch(Bridge.derive_stage(intent_dir), Bridge.derive_stage(intent_dir))
+end
+
+# checklist.md checked/total: count GFM task-list items. Returns "n/a" when there
+# is no checklist (a checklist is only meaningful from How onward).
+def checklist_progress(intent_dir)
+  path = File.join(intent_dir, "checklist.md")
+  return "n/a" unless Bridge.stage_file_present?(path)
+
+  lines = File.readlines(path)
+  total = lines.count { |l| l =~ /^\s*- \[[ xX]\]/ }
+  checked = lines.count { |l| l =~ /^\s*- \[[xX]\]/ }
+  return "n/a" if total.zero?
+
+  "#{checked}/#{total}"
+end
+
+# The outcome line: first content line under outcome.md's "## Summary" (or the first
+# non-heading content line), else a placeholder. Pure read of the intent dir.
+def outcome_line(intent_dir)
+  path = File.join(intent_dir, "outcome.md")
+  return "(no outcome yet)" unless Bridge.stage_file_present?(path)
+
+  lines = File.readlines(path).map(&:rstrip)
+  start = lines.index { |l| l.strip.downcase == "## summary" }
+  scan = start ? lines[(start + 1)..] : lines
+  (scan || []).each do |l|
+    s = l.strip
+    next if s.empty? || s.start_with?("#") || s.start_with?("<!--")
+    return s
+  end
+  "(no outcome yet)"
+end
+
+intent_dir_arg, role = parse_args(ARGV)
+
+if intent_dir_arg.nil? || intent_dir_arg.empty?
+  warn "usage: agent-report <intent_dir> [--role ROLE]"
+  exit 2
+end
+
+intent_dir = File.expand_path(intent_dir_arg)
+
+fm = frontmatter_for(intent_dir)
+id = fm["id"].to_s.strip
+intent_name = fm["intent"].to_s.strip
+id = "(unknown)" if id.empty?
+intent_name = "(unknown)" if intent_name.empty?
+
+stage = current_stage(intent_dir)
+role_label = (role && !role.empty?) ? role : stage
+artifacts = Bridge.has_files(intent_dir)
+artifacts_str = artifacts.empty? ? "(none)" : artifacts.join(", ")
+
+lines = []
+lines << "=== Plastic agent report (synthesized) ==="
+lines << "Intent: #{id} - #{intent_name}"
+lines << "Stage: #{stage}"
+lines << "Role: #{role_label}"
+lines << "Status: synthesized (filesystem-derived; no agent-authored report)"
+lines << "Artifacts present: #{artifacts_str}"
+lines << "Checklist: #{checklist_progress(intent_dir)}"
+lines << "Outcome: #{outcome_line(intent_dir)}"
+lines << "=== end report ==="
+
+puts lines.join("\n")

package/scripts/dashboard.rb

@@ -223,15 +223,17 @@ def effort_of(rec, type)
 end
 
 # Value -> :high | :low (explicit frontmatter field wins).
-# High is deliberately rare: an explicit stamp, or a human-authored root idea that has
-# already spawned follow-on work (chain non-empty) — i.e. a strategic theme the user owns.
+# High is deliberately rare: an explicit stamp, a human-authored root idea, or an intent
+# that has SPAWNED follow-on work, i.e. a strategic theme the user owns. "Has spawned work"
+# means a reciprocal (I1) edge: another intent lists this one in its `sources`, captured by
+# `referenced`. A purely relational `chain` entry (D2, no reciprocal `sources`) does NOT
+# count as spawned, so bare `chain` membership is not a high-value signal (intent 68).
 def value_of(rec, referenced = {})
   case rec[:value_field]
   when "high" then return :high
   when "low"  then return :low
   end
   return :high if rec[:author] == "human" && root_intent?(rec[:id])
-  return :high unless rec[:chain].empty?
   return :high if referenced[[rec[:scope], rec[:id]]]
   :low
 end