@zalom/plastic 1.0.0-beta.2 → 1.0.0-beta.20

package/PLASTIC.md

@@ -50,6 +50,31 @@ tags: [plastic, architecture]
 - 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.
+- `## Links` is a DERIVED view, not a place to author links (Convention over Configuration).
+  It equals the projection of `sources` (first) then `chain`. Never hand-write or hand-edit a
+  `## Links` line, and never auto-delete one. The edge lives in the frontmatter graph; the
+  section is regenerated from it (doctor `graph_links_projection` enforces this identity). To
+  add a link, add the frontmatter edge, then reproject.
+- Links are decided by CONTEXT INFLUENCE, not by shared files, shared symbols, or a topic
+  similarity score. The question is whether one intent's context actually informed another.
+  Three tiers:
+  - **sources:** the foundational context that shaped this intent's creation (a split, an idea
+    born during development, a merge). Earns an edge.
+  - **chain:** the context that materially helps DELIVER this intent. This is a HIGH bar: only
+    the genuinely delivery-moving intents, not everything in the same area. Earns an edge,
+    reflected in `## Links`.
+  - **tags:** a loose theme grouping for search. NOT a link. A shared tag is a door INTO the
+    store (filtered discovery), not a pathway BETWEEN two notes.
+  Judging influence is an agent's call, made by reading the candidate's Intent and Context. A
+  script cannot grade it, so `scripts/link-suggest` only gathers candidates with that evidence,
+  records a confirmed edge with a rating and reason, and flags drift.
 - IDs use Luhmann's alternating convention: `1` → `1a` → `1a1` → `1a1a`
 - Multiple branches increment: `1a`, `1b`, `1c`
 
@@ -72,10 +97,29 @@ The connection: an intent's `## Insights` feeds the Coordinator's Observe phase.
 | **How** | Planning | `plan.md` + `actions/` + `checklist.md` | `plastic-writing-plans` |
 | **Exec** | Execution | `outcome.md` | `plastic-executing-plan` |
 
-`## Insights` — append-only work log captured throughout ALL stages. **Append-only means
-newest entry at the bottom; never prepend.** This ordering is a hard convention: Insights
-are the semantic trace of an intent, and a consistent newest-last order keeps that trace
-readable across every intent.
+`## Insights` is the append-only log of durable discoveries captured throughout ALL stages.
+An insight is a discovery worth keeping for later reads: novel, or old but newly relevant,
+surfaced at any stage (What, Why, How, Exec). It is the most interesting residue of an
+intent, the part a future reader most wants. **Append-only means newest entry at the bottom;
+never prepend.** This ordering is a hard convention: Insights are the semantic trace of an
+intent, and a consistent newest-last order keeps that trace readable across every intent.
+
+Every entry leads with a fixed, machine-parseable prefix `{utc-iso8601} · {stage} · {author}`,
+for example `2026-06-24T08:13:05Z · Why · plastic-brainstorming (autonomous)`. The UTC ISO8601
+timestamp (to the second, trailing `Z`) is the same convention the savepoint ledger uses, so
+the store has one timestamp convention. This per-entry prefix is not prepending the entry:
+entries stay append-only, newest at the bottom; the prefix only stamps each line with when,
+which stage, and who.
+
+The blessed write path is the `insight-append` helper
+(`scripts/insight-append <intent_dir> <text> --stage S --author A`), which formats the prefix,
+validates it, and appends at the bottom. Hand-editing `## Insights` is an escape hatch; the
+helper is the default so the format cannot drift.
+
+Background sessions and dispatched sub-agents do not write the insight themselves. They carry
+each nugget home in the completion report's `insights:` field, and the orchestrator (or any
+agent that can write the file) persists it via the helper. A session that cannot write the
+intent file still returns its report, so the insight survives.
 For full lifecycle detail, the skills in the Detail column have references/.
 
 `savepoint.md` — a deterministic, append-only ledger of cycle-step milestones (one line per
@@ -164,8 +208,8 @@ Format: `ID--three-to-five-words` (all stores).
 - **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]]` wikilink in
-  `## Links`).
+  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
@@ -176,6 +220,10 @@ Sections: `## Active`, `## Future`, `## Clusters`, `## Abandoned`, `## Completed
 
 For index maintenance, use `plastic-managing-index`.
 
+One-line entry convention. Each index entry is ONE line: `- [<id> <terse title>](<dir>) <tags>`.
+The title is the title, not a summary: aim for about 80 characters, no multi-sentence
+descriptions. This is a self-check, not a gate.
+
 ## Rules for Skills
 
 ALL work flows through intents.
@@ -187,6 +235,62 @@ ALL work flows through intents.
 5. Researches are intents. No separate folder.
 6. Intents are created only via `plastic-creating-intent`. Never hand-author an intent file. The skill self-verifies the written intent with `scripts/validate-intent` before announcing or committing, so every intent is born complete.
 
+## House Style (self-check)
+
+The agent is the heaviest contributor to the transcript, so terseness pays every turn. These
+are pre-send self-checks the agent applies to its own output. They are not gated.
+
+- Answer or decision first. Lead with the result, then support it.
+- Bullets over paragraphs.
+- No preamble, no end-recap. Do not restate the question or summarize what you just said.
+- One question-cluster at a time when asking the human.
+- Reasoning goes in the thinking channel, not duplicated into the visible reply. This keeps
+  the human's visibility into your reasoning without paying for it twice in the transcript.
+
+Active-intent cache rule. For the intent under active development you already hold its
+delivered artifacts in your own context: prefer revisiting that in-context memory (hit the
+cache) over re-reading them from disk, which only widens context. QMD is for OTHER or indexed
+intents, not for re-reading what you just wrote. Pairs with `/clear` plus savepoint-resume
+hygiene after each intent. Advisory self-check, not hard-verifiable.
+
+## Retrieval Gate
+
+A single capability-aware PreToolUse gate enforces retrieval-first routing on the agent's own
+Bash/Read/Grep/Glob calls (and on subagents, since PreToolUse binds them). The gate is
+OPERATION-based: it separates searching from reading, and it never stands between you and
+reading something you have already located.
+
+- Only CONTENT SEARCH over a Plastic store is gated. The Grep tool and bash `grep`/`rg`/`ag`
+  whose target is at or under a store route to QMD when QMD is present and the index is fresh:
+  the raw scan is blocked and you use `qmd search`/`qmd query` (or `scripts/qmd-sync search`)
+  instead. When QMD is present but stale, the search is allowed this turn and a background
+  reindex is fired so the next turn enforces against a fresh index; reindex is never
+  synchronous. When QMD is absent, the search is allowed.
+- Reading a known target (the Read tool, bash `cat`/`head`/`tail`) and structural discovery
+  (the Glob tool, bash `find`/`ls`) are always allowed, including over the store. QMD cannot
+  list directories or hand back one specific file, so these are never gated.
+- Code is never hard-gated here. Symbolic code navigation via Serena is a soft prompt mandate
+  (the UserPromptSubmit power-tools hook), not a block: content grep over code is allowed,
+  because Serena navigates symbols and cannot grep arbitrary strings.
+- QMD failure model. Absent or stale degrades to allow (stale also fires the background
+  reindex). A broken QMD, where the freshness probe errors or times out, also fails open, and
+  the hook emits a one-line warning so a degraded QMD is visible rather than silent.
+- Bypass: append a trailing `# qmd-ok` shell comment to a Bash command when you attempted
+  discovery and it did not serve you (no hits, or results that do not answer your need by your
+  reading of the snippets, not their score). A quoted or echoed occurrence does not bypass.
+  Bypasses are logged. The gate enforces that discovery was attempted, never that it succeeded.
+- Scope: only the agent's tool calls. Ruby `File.read` inside a script is invisible to the gate
+  and is out of scope by design.
+
+## Context-economy measurement buckets (84a)
+
+Intent 84 defines three buckets for sibling 84a to audit against; 84 does not run the audit.
+
+- (a) gate-hook prose tokens: the per-transition narration emitted by the gate hook.
+- (b) main-loop store-read tokens: tokens the main agent spends reading or grepping the store
+  in the transcript.
+- (c) authored-section sizes: sizes of authored artifacts (INDEX entries and the like).
+
 ## Transition Gates
 
 | Transition | Trigger | Gate |
@@ -198,6 +302,26 @@ ALL work flows through intents.
 
 Hard blocking — hooks exit code 2 on gate failure.
 
+## Delivery Isolation and the Single-Owner Lock
+
+Exactly one session or agent develops an intent's delivery at a time. Ownership is the armed
+session bridge, which doubles as the delivery lock: arming records the owning session, the
+owner pid, an acquired-at timestamp, and the host. Another session that finds an armed bridge
+for the same intent with a live owner backs off; if the owner pid is dead the lock is
+reclaimable. This is mandatory, not a convention.
+
+Every code-touching intent gets its own git worktree named `{id}--{slug}`, and all code edits
+for that intent happen only inside it. Plastic provisions the worktree deterministically: it
+resolves the project repo from `projects.yml` and runs `git -C <repo> worktree add`, so
+isolation never depends on the current working directory. There are two worktrees per project
+intent: a code worktree at `<repo>/.claude/worktrees/{id}--{slug}` (branch `plastic/{id}--{slug}`)
+and a store worktree at `<plastic_home>/.worktrees/{id}--{slug}` (branch
+`plastic-store/{id}--{slug}`), so lifecycle-doc commits and code commits move as one unit.
+
+Provisioning fails open for intents that touch no project code (pure research or decision
+intents in the global store, or a non-git repo): those get the lock only, and the worktree
+block stays unprovisioned. The fail-open path is always logged, never silent.
+
 ## Deprecation Process
 
 Deprecations live in `deprecations.yml` and are shown at SessionStart. While Plastic is
@@ -224,5 +348,5 @@ Detailed conventions live inside the skills that use them, not in this file.
 | Index maintenance | `plastic-managing-index` | — |
 | Releases, deprecations | `plastic-releasing` | deprecation process |
 | Health diagnostics | `plastic-doctor` | three scopes: `--core` (binary install-integrity check, runs on SessionStart), `--store [global\|<slug>]` (per-store check, runs on dashboard load), no flag = full check (runs after every update); gate enforcement, stuck detection |
-| Writing agent instructions | `plastic-writing-instructions` | agentskills.io spec |
+| Authoring skills, agents, hooks | `plastic-creating-skills` | progressive disclosure, agentskills.io spec |
 | Evaluating skills, evals | `plastic-evaluating-skills` | eval methodology, convention checks |

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, insights) 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-enforcer.md

@@ -30,7 +30,7 @@ You are the Plastic Enforcer. You ARE the auto orchestrator, spanning the whole
 
 ## Constraints
 
-- Enforce gates manually; do not rely on hooks, because `CLAUDE_SESSION_ID` may be unset in headless or background runs
+- Enforce gates manually; do not rely on hooks, because the session id may be unset in headless or background runs
 - You never delegate gate ownership; the orchestrator is always the gate-keeper
 - Roles are thin handoff contracts, not an execution engine; dispatch through `plastic-executing-plan` by default, and through the superpowers skills only when they are available or the user prefers them
 - Fall back by case: if the harness supports subagents but superpowers is absent, use the native `plastic-executing-plan` engine; if the harness has no subagent dispatch at all, fall back to a single agent walking the full cycle

package/agents/plastic-executor.md

@@ -18,7 +18,7 @@ When dispatched in auto mode you receive the standard Plastic spawn preamble (fr
 
 1. **Implement the actions** — make the code changes for each action in order
 2. **Track progress** — check off `checklist.md` items as they complete
-3. **Record insights** — append observations to `## Insights` with the `(autonomous)` marker
+3. **Record insights** — capture durable discoveries and report them in the `insights:` field; persist each to `## Insights` via the `insight-append` helper (`scripts/insight-append <intent_dir> <text> --stage Exec --author "plastic-executor (autonomous)"`), the blessed write path that stamps the `{utc-iso8601} · {stage} · {author}` prefix
 4. **Prove it green** — run the full test suite and reach zero failures before reporting done
 
 ## How You Work
@@ -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, insights) 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, insights) 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, insights) 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/hooks.json

@@ -40,6 +40,16 @@
           }
         ]
       },
+      {
+        "matcher": "Write|Edit",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" savepoint-pre",
+            "statusMessage": "Recording stage start..."
+          }
+        ]
+      },
       {
         "matcher": "Write",
         "hooks": [
@@ -59,6 +69,16 @@
             "statusMessage": "Checking lifecycle gate..."
           }
         ]
+      },
+      {
+        "matcher": "Bash|Read|Grep|Glob",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "\"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook\" retrieval-gate",
+            "statusMessage": "Checking retrieval gate..."
+          }
+        ]
       }
     ],
     "PostToolUse": [

package/hooks/retrieval-gate

@@ -0,0 +1,10 @@
+#!/bin/bash
+# Retrieval-gate hook launcher (intent 84, Lever 2). No-op when there is no
+# global store. Passes the PreToolUse JSON through on stdin (exec inherits it)
+# and the plastic_home as ARGV[0], mirroring the qmd-search launcher.
+GLOBAL_INDEX="$HOME/.plastic/INDEX.md"
+if [ ! -f "$GLOBAL_INDEX" ]; then
+  exit 0
+fi
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+exec ruby "$SCRIPT_DIR/../scripts/hook-retrieval-gate" "$HOME/.plastic"

package/hooks/savepoint-pre

@@ -0,0 +1,10 @@
+#!/bin/bash
+INPUT=$(cat)
+FILE_PATH=$(echo "$INPUT" | ruby -rjson -e 'data = JSON.parse(STDIN.read); puts data.dig("tool_params", "file_path") || data.dig("tool_input", "file_path") || ""' 2>/dev/null)
+
+if [ -z "$FILE_PATH" ]; then
+  exit 0
+fi
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+ruby "$SCRIPT_DIR/../scripts/hook-savepoint-pre" "$FILE_PATH"

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.2",
+  "version": "1.0.0-beta.20",
   "description": "Intent-driven idea development system for AI coding agents",
   "type": "module",
   "bin": {