@zalom/plastic 1.14.0 → 2.0.0-alpha.1

package/scripts/lib/start_intent.rb

@@ -1,296 +0,0 @@
-# encoding: UTF-8
-# frozen_string_literal: true
-
-require_relative "bridge"
-require_relative "lock"
-require_relative "intent_validator"
-require_relative "spec_header"
-require_relative "outcome_guard"
-require_relative "scaffold_intent"
-
-# StartIntent - all logic for `scripts/start-intent` (intent 213, group 2). Boards a
-# session onto an intent: arm the delivery lock, then print a read-only resume-station
-# report. This is the highest-risk surface in this action set because it composes lock
-# arbitration; the rule for that surface is compose the existing primitives, add nothing
-# (spec D6).
-#
-# NEVER REIMPLEMENTS LOCK ARBITRATION. Arming is `Bridge.arm_auto` or `Bridge.arm_guided`
-# and nothing else acquires anything: no new arming logic, no retry loop, no takeover path.
-# This module NEVER calls the Lock module's release or takeover operations. That unguarded
-# read-modify-write gap is parked intent 254's territory; start-intent reports and refuses,
-# it never repairs a lock. Read-only lock inspection (`Lock.path`, `Lock.read`,
-# `Lock.fresh?`, `Lock.authorized?`) is expected and used below.
-#
-# DETERMINISM CRITERION: every value this module prints is read from already-committed
-# files or from `Bridge.arm_*`'s own return value. No model inference, no free-text
-# generation.
-#
-# Pure and dependency-injected: never calls `exit` or `abort`, never reads `ARGV` or `ENV`
-# directly. Seams: `armer:` (a lambda dispatching on mode to the two real Bridge methods),
-# plus session/harness/thread values passed in as arguments rather than read from ENV here.
-# Reading ENV for harness detection happens in the CLI (`scripts/start-intent`) and is
-# passed down.
-module StartIntent
-  module_function
-
-  EXIT_OK = 0
-  EXIT_USAGE = 1
-  EXIT_HELD = 3
-  EXIT_UNRESOLVED = 4
-
-  # --- Step 0: resolve inputs -------------------------------------------------------
-
-  # `name:` for the arm call, deterministically: the intent file frontmatter's `intent:`
-  # field, or the directory basename when the frontmatter is unreadable or blank. Never
-  # invents a name.
-  def resolve_name(intent_dir)
-    fm = IntentValidator.parse_frontmatter(Bridge.intent_file(intent_dir))
-    name = fm.is_a?(Hash) ? fm["intent"] : nil
-    Bridge.blank?(name) ? File.basename(intent_dir) : name
-  end
-
-  # Session resolution order: explicit --session, else CLAUDE_CODE_SESSION_ID (passed in
-  # as env_session, never read from ENV here), else nil. Deliberately NO fallback to the
-  # lock's own recorded owner (unlike end-intent's resolve_end_session): arming as an
-  # owner you cannot prove you are is wrong.
-  def resolve_session(explicit, env_session)
-    return explicit.to_s.strip unless Bridge.blank?(explicit)
-    return env_session.to_s.strip unless Bridge.blank?(env_session)
-    nil
-  end
-
-  # Harness/thread detection, mirroring skills/auto/SKILL.md's arm-the-lifecycle-gate
-  # snippet exactly: a non-empty CODEX_THREAD_ID means codex (thread = that id); else a
-  # non-empty CLAUDE_CODE_SESSION_ID means claude (thread = nil); else both nil. Pure:
-  # takes the raw ENV strings as arguments, never reads ENV itself.
-  def resolve_harness(codex_thread_id, claude_session_id)
-    codex = codex_thread_id.to_s.strip
-    claude = claude_session_id.to_s.strip
-    return { harness: "codex", thread: codex } unless codex.empty?
-    return { harness: "claude", thread: nil } unless claude.empty?
-    { harness: nil, thread: nil }
-  end
-
-  # --- Step 1: pre-flight lock read (read-only, before arming) ---------------------
-  #
-  # Mirrors the READ-ONLY half of scripts/end-intent's preflight_lock_verdict, minus its
-  # takeover branch (start-intent never takes over). Returns [verdict, lock_or_nil]:
-  #   :proceed    no lock, or this session already owns/delegates it
-  #   :corrupt    a lock file exists but Lock.read cannot parse it (exit 4, unconditional;
-  #               unlike end-intent, freshness is never consulted for a corrupt lock,
-  #               because there is no repair path here to reach for a stale one)
-  #   :no_session a lock file exists and no session identity resolved from any source
-  #               (exit 4)
-  #   :held       a FRESH foreign lock (exit 4... exit 3, before ever calling the armer)
-  #   :stale      a STALE foreign lock: fall through to arming, which arbitrates it (and
-  #               raises Bridge::LockHeldError with the reclaim hint) itself
-  def preflight_verdict(intent_dir, session)
-    return [:proceed, nil] unless File.exist?(Lock.path(intent_dir))
-
-    lock = Lock.read(intent_dir)
-    return [:corrupt, nil] if lock.nil?
-    return [:no_session, lock] if Bridge.blank?(session)
-    return [:proceed, lock] if Lock.authorized?(lock, session)
-    return [:held, lock] if Lock.fresh?(intent_dir)
-    [:stale, lock]
-  end
-
-  def corrupt_message(intent_dir)
-    "start-intent: the delivery lock at #{Lock.path(intent_dir)} exists but its content " \
-      "will not parse (corrupt); refusing to arm since another session may still be " \
-      "heartbeating it. Run /plastic-doctor check the lock status, or plastic-lock fix " \
-      "once it is confirmed safe."
-  end
-
-  def no_session_message(intent_dir)
-    "start-intent: a delivery lock exists at #{Lock.path(intent_dir)} but no session " \
-      "identity could be resolved (--session or CLAUDE_CODE_SESSION_ID are both blank); " \
-      "refusing rather than guessing. Pass --session explicitly."
-  end
-
-  def held_message(intent_dir, lock, harness:)
-    owner = lock.is_a?(Hash) ? lock["owner_session"] : nil
-    "start-intent: delivery lock for #{File.basename(intent_dir)} is held by a live " \
-      "session (#{owner}); run #{Bridge.skill_ref('plastic-doctor', harness: harness)} " \
-      "check the lock status"
-  end
-
-  # --- Step 2: arm -------------------------------------------------------------------
-
-  # Default arm seam: dispatches on mode to the two real Bridge methods. Nothing else
-  # acquires anything.
-  def default_armer
-    lambda do |mode, session:, intent_id:, intent_dir:, store:, name:, harness:, agent:,
-               model:, thread:|
-      case mode
-      when "auto"
-        Bridge.arm_auto(session, intent_id: intent_id, intent_dir: intent_dir, store: store,
-                        name: name, harness: harness, agent: agent, model: model, thread: thread)
-      when "guided"
-        Bridge.arm_guided(session, intent_id: intent_id, intent_dir: intent_dir, store: store,
-                          name: name, harness: harness, agent: agent, model: model, thread: thread)
-      end
-    end
-  end
-
-  # --- Step 3: the resume-station report (read-only, after arming) -----------------
-
-  # Count-only helper for the printed "actions/: <n> real action file(s)" line. The
-  # STATION gate (whether How is delivered) is decided exclusively by
-  # Bridge.has_real_action?, called separately in build_report; this exists only to render
-  # a number and must never be used for any pass/fail decision.
-  def real_action_count(intent_dir)
-    Dir.glob("#{intent_dir}/actions/*.md").count do |f|
-      File.file?(f) && File.size(f) > 0 && Bridge.stage_file_present?(f)
-    end
-  rescue StandardError
-    0
-  end
-
-  # Classify outcome.md into one of three states, per the spec's outcome.md nuance:
-  # `scaffold-intent outcome` writes a real (non-sentinel) outcome.md while leaving the
-  # frontmatter disposition at the template placeholder `delivered|abandoned`, so a naive
-  # sentinel check would misreport that as Done. Returns [state, reason]:
-  #   "not_started" the sentinel is still present (or the file is absent), reason nil
-  #   "authored"    sentinel gone AND OutcomeGuard.reason(intent_dir, disposition) is nil
-  #                 for EITHER "delivered" or "abandoned" (BLOCKING 3 fix: a fully-authored
-  #                 abandoned outcome.md is authored too; checking "delivered" only used to
-  #                 misreport it as "scaffolded, not authored" and point a resuming session
-  #                 back into Exec)
-  #   "scaffolded"  sentinel gone AND OutcomeGuard.reason(...) returns a reason string for
-  #                 BOTH dispositions
-  # OutcomeGuard.reason is the single existing definition of "is outcome.md real for this
-  # close"; this never re-derives that definition.
-  def classify_outcome(intent_dir)
-    outcome_path = File.join(intent_dir, "outcome.md")
-    return ["not_started", nil] unless Bridge.stage_file_present?(outcome_path)
-
-    delivered_reason = OutcomeGuard.reason(intent_dir, "delivered")
-    return ["authored", nil] if delivered_reason.nil?
-
-    abandoned_reason = OutcomeGuard.reason(intent_dir, "abandoned")
-    return ["authored", nil] if abandoned_reason.nil?
-
-    # Neither disposition's guard passed: report the "delivered" reason, since it is the
-    # more common close path and OutcomeGuard.reason's message already names whatever
-    # disposition is actually recorded in the frontmatter (or that the file is missing or
-    # still the scaffold placeholder), so it stays informative either way.
-    ["scaffolded", delivered_reason]
-  end
-
-  def settled_text(header)
-    return "no" unless header[:settled]
-    header[:settled_reason] ? "yes (#{header[:settled_reason]})" : "yes"
-  end
-
-  # Build the resume-station report. Every value comes from already-committed files
-  # (Bridge.stage_file_present?, Bridge.has_real_action?, SpecHeader, OutcomeGuard) or from
-  # `data`, the Hash Bridge.arm_* itself returned. No model inference, no free text beyond
-  # the fixed shape below.
-  def build_report(intent_dir:, mode:, data:)
-    spec_path = File.join(intent_dir, "spec.md")
-    plan_path = File.join(intent_dir, "plan.md")
-    checklist_path = File.join(intent_dir, "checklist.md")
-
-    spec_delivered = Bridge.stage_file_present?(spec_path)
-    plan_delivered = Bridge.stage_file_present?(plan_path)
-    checklist_delivered = Bridge.stage_file_present?(checklist_path)
-    has_action = Bridge.has_real_action?(intent_dir)
-    how_triple = plan_delivered && checklist_delivered && has_action
-
-    outcome_state, outcome_reason = classify_outcome(intent_dir)
-
-    resume_at =
-      if !spec_delivered
-        "Why"
-      elsif !how_triple
-        "How"
-      elsif outcome_state != "authored"
-        "Exec"
-      else
-        "Done"
-      end
-
-    header = SpecHeader.parse_file(spec_path)
-    tier = header[:tier] || "unknown"
-
-    worktree_code = data.dig("worktree", "code")
-    worktree_line = Bridge.blank?(worktree_code) ? "not provisioned" : worktree_code
-
-    outcome_line =
-      case outcome_state
-      when "authored" then "authored"
-      when "scaffolded" then "scaffolded, not authored (#{outcome_reason})"
-      else "not started"
-      end
-
-    lines = []
-    lines << "start-intent: #{File.basename(intent_dir)}"
-    lines << "  mode:        #{mode}"
-    lines << "  session:     #{data['session']}"
-    lines << "  lock:        held by #{data.dig('lock', 'owner_session')} (ours)"
-    lines << "  worktree:    #{worktree_line}"
-    lines << "  tier:        #{tier}"
-    lines << "  settled:     #{settled_text(header)}"
-    lines << "  spec.md:     #{spec_delivered ? 'delivered' : 'not started'}"
-    lines << "  plan.md:     #{plan_delivered ? 'delivered' : 'not started'}"
-    lines << "  checklist.md: #{checklist_delivered ? 'delivered' : 'not started'}"
-    lines << "  actions/:    #{real_action_count(intent_dir)} real action file(s)"
-    lines << "  outcome.md:  #{outcome_line}"
-    lines << "  resume at:   #{resume_at}"
-    lines.join("\n")
-  end
-
-  # --- entry point --------------------------------------------------------------------
-
-  def usage_result(message)
-    { exit_code: EXIT_USAGE, stderr: [message], stdout: [] }
-  end
-
-  def deny_result(code, message)
-    { exit_code: code, stderr: [message], stdout: [] }
-  end
-
-  def run(store:, id:, mode:, session:, env_session:, harness:, thread:, armer: default_armer)
-    return usage_result("--store is required") if Bridge.blank?(store)
-    return usage_result("--id is required") if Bridge.blank?(id)
-    return usage_result("--mode is required") if Bridge.blank?(mode)
-    unless %w[auto guided].include?(mode)
-      return usage_result("--mode must be one of auto, guided (got #{mode.inspect})")
-    end
-
-    store_abs = ScaffoldIntent.expand(store)
-    return usage_result("store dir does not exist: #{store_abs}") unless Dir.exist?(store_abs)
-
-    intent_dir, resolve_err = ScaffoldIntent.resolve_intent_dir(store_abs, id)
-    return usage_result(resolve_err) if intent_dir.nil?
-
-    name = resolve_name(intent_dir)
-    key_session = resolve_session(session, env_session)
-
-    verdict, lock = preflight_verdict(intent_dir, key_session)
-    case verdict
-    when :corrupt
-      return deny_result(EXIT_UNRESOLVED, corrupt_message(intent_dir))
-    when :no_session
-      return deny_result(EXIT_UNRESOLVED, no_session_message(intent_dir))
-    when :held
-      return deny_result(EXIT_HELD, held_message(intent_dir, lock, harness: harness))
-    end
-    # :proceed and :stale both fall through to arming; Bridge.arm_* arbitrates :stale
-    # itself (and raises Bridge::LockHeldError with the reclaim hint) via its own
-    # up-to-date Lock.acquire call.
-
-    data =
-      begin
-        armer.call(mode, session: key_session, intent_id: id, intent_dir: intent_dir,
-                   store: store_abs, name: name, harness: harness, agent: nil, model: nil,
-                   thread: thread)
-      rescue Bridge::LockHeldError => e
-        return deny_result(EXIT_HELD, e.message)
-      end
-
-    report = build_report(intent_dir: intent_dir, mode: mode, data: data)
-    { exit_code: EXIT_OK, stderr: [], stdout: [report] }
-  end
-end

package/scripts/start-intent

@@ -1,89 +0,0 @@
-#!/usr/bin/env ruby
-# encoding: UTF-8
-# frozen_string_literal: true
-
-# start-intent (intent 213, group 2) - board a session onto an intent: arm the delivery
-# lock, then print a read-only resume-station report.
-#
-# Usage:
-#   start-intent --store <path> --id <intent_id> --mode auto|guided [--session <session_id>]
-#
-# --store, --id, and --mode are required. --session is optional and defaults to
-# CLAUDE_CODE_SESSION_ID, matching end-intent's resolution order. No other flags exist.
-#
-# Steps performed:
-#   0. Resolve inputs: the intent dir, the intent name from frontmatter (falling back to
-#      the dir basename), the calling session (--session, else CLAUDE_CODE_SESSION_ID,
-#      else nil; deliberately no lock-owner fallback), and harness/thread from
-#      CODEX_THREAD_ID / CLAUDE_CODE_SESSION_ID (mirroring skills/auto/SKILL.md's arming
-#      snippet).
-#   1. Pre-flight lock read (read-only): refuse a fresh foreign lock, an unparseable
-#      lock, or a lock present with no resolvable session identity. A stale foreign lock
-#      falls through to arming, which arbitrates it itself.
-#   2. Arm: Bridge.arm_auto (--mode auto) or Bridge.arm_guided (--mode guided). Nothing
-#      else acquires anything.
-#   3. Print the resume-station report (read-only): which lifecycle files are real, and
-#      where the intent should resume (Why/How/Exec/Done).
-#
-# This script never releases and never takes over a lock: it never calls the Lock
-# module's release or takeover operations (parked intent 254's territory). A held or
-# corrupt lock is reported and refused, never repaired.
-#
-# Exit codes:
-#   0  armed and resume-station printed
-#   1  usage or path-resolution failure
-#   3  lock held by another live session (deny, mirrors end-intent's pre-flight refusal)
-#   4  unparseable lock, or no session identity with a lock present
-#
-# There is deliberately no exit 2 in this script's contract.
-
-require_relative "lib/start_intent"
-
-def parse_args(argv)
-  opts = { store: nil, id: nil, mode: nil, session: nil }
-  i = 0
-  while i < argv.length
-    arg = argv[i]
-    case arg
-    when "--store"   then opts[:store] = argv[i += 1]
-    when "--id"      then opts[:id] = argv[i += 1]
-    when "--mode"    then opts[:mode] = argv[i += 1]
-    when "--session" then opts[:session] = argv[i += 1]
-    else
-      usage_abort("unknown argument #{arg.inspect}")
-    end
-    i += 1
-  end
-  opts
-end
-
-def usage
-  "usage: start-intent --store <store_path> --id <intent_id> --mode auto|guided " \
-    "[--session <session_id>]"
-end
-
-def usage_abort(message)
-  warn "start-intent: #{message}"
-  warn usage
-  exit 1
-end
-
-def main(argv)
-  opts = parse_args(argv)
-
-  codex_thread_id = ENV["CODEX_THREAD_ID"]
-  claude_session_id = ENV["CLAUDE_CODE_SESSION_ID"]
-  detected = StartIntent.resolve_harness(codex_thread_id, claude_session_id)
-
-  result = StartIntent.run(
-    store: opts[:store], id: opts[:id], mode: opts[:mode], session: opts[:session],
-    env_session: claude_session_id, harness: detected[:harness], thread: detected[:thread]
-  )
-
-  Array(result[:stderr]).each { |line| warn line }
-  warn usage if result[:exit_code] == StartIntent::EXIT_USAGE
-  Array(result[:stdout]).each { |line| puts line }
-  exit result[:exit_code]
-end
-
-main(ARGV) if $PROGRAM_NAME == __FILE__

package/skills/_active-intent-gate.md

@@ -1,26 +0,0 @@
-## Active Intent Gate
-
-Before proceeding, resolve the active intent:
-
-1. **Detect store:**
-   - Read `~/.plastic/projects.yml`
-   - Match CWD against registered project paths
-   - If match → project store at `~/.plastic/projects/{slug}/store/`
-   - If no match → global store at `~/.plastic/store/`
-
-2. **Find active intent:**
-   - Read `INDEX.md` from the detected store
-   - Look under `## Active` for intent entries
-   - If exactly one active intent → use it
-   - If multiple active intents → ask user which one
-   - If no active intent → refuse: "No active intent. Create one first with /plastic-intent-creating"
-
-3. **Resolve paths:**
-   - Intent directory: `{store}/store/{id}--{slug}/`
-   - Spec: `{intent_dir}/spec.md`
-   - Plan: `{intent_dir}/plan.md`
-   - Checklist: `{intent_dir}/checklist.md`
-   - Resources: `{intent_dir}/resources/`
-   - Outcome: `{intent_dir}/outcome.md`
-
-All lifecycle artifacts MUST be written to the intent directory. Never write to `docs/superpowers/specs/`, `docs/superpowers/plans/`, or any other external path.

package/skills/auto/references/tiers.md

@@ -1,100 +0,0 @@
-# Tiers — Extended Walkthrough
-
-This is the detail behind `## Tiers` in SKILL.md. The five points there (sizing rule, two
-levers, per-tier topology, never-cut list, tier record) are the authoritative contract;
-this file only expands on them with examples and rationale.
-
-## Why sizing exists
-
-Auto mode used to run every intent through the same full-ceremony team: brainstorming,
-spec-specialist, planner, executor, and an independent reviewer, each a separate agent
-booting a fresh context. For a large or novel intent that ceremony earns its cost. For a
-small intent (one file, one mechanism, an hour of real work) the ceremony dominates:
-overhead runs about 3 to 4 times the actual work time, roughly flat regardless of size, so
-it hurts small intents the most. Sizing at Why and matching the topology to that size drops
-small-intent ceremony toward about 1.5x work time, without touching structure, gates, or
-the savepoint ledger.
-
-## Sizing rule, worked examples
-
-- S: fixing one script's argument parsing, adding one skill section, a single bug fix
-  confined to one file. Hours of work.
-- M: adding a new agent role file end to end, a subsystem with a handful of touched files
-  and one clear seam. About a day.
-- L: cross-cutting prose or code that spans the skill contract plus multiple agent role
-  files (like this intent, 130), or any genuinely novel design with no established pattern
-  to follow.
-
-## S/M collapsed topology, in detail
-
-One thinker agent boots ONCE and stays in a single context for two stations:
-
-1. Station 1 — writes `spec.md` (collapsed sections allowed, one line each is valid).
-2. Station 2 — writes `plan.md` + `checklist.md` + at least one real action file in the
-   SAME context (no reboot). At S/M the thinker consolidates the whole delivery into one
-   `actions/ACTION_1.md` (rather than one file per task); `actions/` is populated at every
-   tier, and a `.gitkeep`-only or empty `actions/` fails the How gate.
-
-Then a sonnet executor (a fresh dispatch, this is the one topology split that always
-happens) implements from plan.md + checklist.md, checks off items, appends `## Insights`,
-and drives the suite green. At S/M that is ONE executor dispatch for the whole consolidated
-action: no per-task implementer, and no per-task spec review or quality review. L keeps the
-per-task loop. The gate lives in `plastic-intent-executing`'s Subagent-Driven workflow,
-which reads the `Tier:` line stamped at the top of spec.md, the authoritative record. The
-arithmetic: an S plan with N tasks costs 3N plus 1 agent boots under the L shape, and 2
-boots under this one.
-
-The independent reviewer still runs at the final gate for S/M, in its own fresh context,
-never the maker. This is on the never-cut list; it does not collapse.
-
-S sends ONE mid-flight owner briefing instead of four. Only the How briefing fires, at the
-point the plan is ready and before any code is written, and it folds in what the What and
-Why briefings would have said; the Exec briefing folds into the final owner report at End.
-M and L send all four. The briefing calls live in `plastic-auto`'s stage sections, and the
-depth note lives in `references/human-report-contract.md`.
-
-S may skip the QMD discovery deposit (normally a `plastic-intent-discovery` pass before
-Why) when the intent's `chain` and `sources` are both empty in frontmatter. With no graph
-edges there is nothing to discover, so the deposit is pure overhead; a one-line context
-note ("no chain/sources, discovery skipped") takes its place, written to
-`resources/discovery--<slug>.md`. Three places implement the skip: the dispatch site in
-`plastic-intent-starting` step 4, the precondition in `plastic-intent-discovering`, and the
-same precondition in the `plastic-intent-discovery` agent file. The skip needs a size already
-on record (a stamped `Tier: S` line in spec.md), and sizing happens at Why, so a first
-activation usually runs the full pass.
-
-## L topology, unchanged
-
-L keeps today's full multi-agent team as described in `## Team Spin-Up`: brainstorming,
-spec-specialist, planner, executor, each a separate agent in its own fresh context, plus
-the independent reviewer at the final gate. Cross-cutting or novel work benefits from the
-separate perspectives and the handoff discipline; the ceremony is not waste at this size.
-
-## Same-structure invariant, why it is non-negotiable
-
-The file set, stage order, gates, and savepoint ledger never change by tier. Renaming or
-skipping files to save time would require new gate logic per tier and would break state
-derivability (the gates and the savepoint rebuild depend on a fixed file set at fixed
-paths). So the only two levers are content depth and agent topology; structure is the
-constant that keeps every tier auditable the same way.
-
-## Tier record, mechanics
-
-The tier is recorded as a `Tier: S|M|L` line at the very top of spec.md, above the `#
-Spec:` heading. It is convention-only: the orchestrator reads it to pick topology, and
-nothing else depends on it. No frontmatter schema change, no new file, no doctor rule, no
-gate check. If a later intent wants doctor or a gate to validate the line, that is a
-separate, explicit follow-up; this system deliberately adds no new operational surface.
-
-Settledness is a separate line, `Settled: yes (<reason>)`, directly beneath the `Tier:` line
-and above the `# Spec:` heading. It records that a design has already done its thinking. An
-absent line means not settled; there is no `Settled: no` form. Settledness and scope are
-independent, so a large intent can be settled without becoming a smaller tier.
-`scripts/lib/spec_header.rb` is the only parser of both lines.
-
-## Never-cut list, the safety floor
-
-At any tier or mode: the independent reviewer (separate agent, fresh context, never the
-maker), `outcome.md` as the truth of delivery, the delivery lock, worktree isolation,
-intent creation via skill, INDEX as status truth, the QMD reindex at End. These are
-predictability and safety guarantees, not ceremony, and lightness never touches them.

package/skills/continuing/SKILL.md

@@ -1,34 +0,0 @@
----
-name: plastic-continuing
-description: >-
-  Use when the user says "continue", "resume", or "pick up where we left off", starts a new
-  session and wants to keep going, asks "what should I work on", or asks a where-was-I question
-  that never says "continue" (for example "where was I"). This is the front door for resuming
-  work: it dispatches to plastic-intent-continuing (a specific intent named to resume),
-  plastic-project-continuing (the default, general board landing), or
-  plastic-roadmap-continuing (a roadmap or delivery batch named to resume).
-user-invocable: true
----
-
-# Continuing - the front door
-
-`plastic-continuing` is the front door for resuming work (ruling 96: continuing routes,
-starting does the lock plus resume plus work). It routes to exactly one of three skills and
-does nothing else: no ledger-resume, no dashboard render, no roadmap read happens here.
-
-## Route
-
-| Args / context | Route to |
-|---|---|
-| `--intent {id}`, or the user names one specific intent (by id or description) to resume | `plastic-intent-continuing` (intent route) |
-| `--roadmap {slug}`, or the user asks to continue/resume a roadmap or delivery batch | `plastic-roadmap-continuing` (roadmap route) |
-| bare "continue" / "resume" / no further target (default) | `plastic-project-continuing` (project route) |
-
-## Announce, then hand off
-
-State the chosen route in one line before delegating (this is the router's own "present state
-before any ask" - the router asks nothing itself). Example: "Routing to the project board (no
-specific intent or roadmap named)."
-
-Then hand off to the chosen skill. Do not inline any of the routed skill's own work here -
-that belongs to the routes.

package/skills/continuing/evals/evals.json

@@ -1,91 +0,0 @@
-{
-  "skill_name": "plastic-continuing",
-  "notes": "Intent 158a1. New bare front-door router restored per intent 96 (D8). Scopes: description triggering (1-5) and routing behavior (6-9), the latter checked as convention against SKILL.md's routing table.",
-  "results": {
-    "triggering": { "cases": 5, "passed": 5, "run": "2026-07-10, one subagent per case" },
-    "behavior": { "cases": 4, "passed": 4, "evidence": "convention checks against skills/continuing/SKILL.md's routing table" }
-  },
-  "evals": [
-    {
-      "id": 1, "scope": "triggering", "set": "train",
-      "prompt": "continue",
-      "expected_output": "Activates plastic-continuing (the bare 'continue' keyword is the router's documented trigger).",
-      "files": [],
-      "assertions": [
-        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
-      ]
-    },
-    {
-      "id": 2, "scope": "triggering", "set": "train",
-      "prompt": "resume where we left off",
-      "expected_output": "Activates plastic-continuing.",
-      "files": [],
-      "assertions": [
-        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
-      ]
-    },
-    {
-      "id": 3, "scope": "triggering", "set": "validation",
-      "prompt": "pick up where we left off",
-      "expected_output": "Activates plastic-continuing.",
-      "files": [],
-      "assertions": [
-        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
-      ]
-    },
-    {
-      "id": 4, "scope": "triggering", "set": "validation",
-      "prompt": "where was I",
-      "expected_output": "Activates plastic-continuing (indirect trigger: a continue request that never says 'continue').",
-      "files": [],
-      "assertions": [
-        { "type": "code", "check": "router CHOICE == plastic-continuing", "observed": "plastic-continuing", "result": "pass" }
-      ]
-    },
-    {
-      "id": 5, "scope": "triggering", "set": "validation",
-      "prompt": "continue the for-loop in this function",
-      "expected_output": "Does NOT activate plastic-continuing. Near-miss: shares 'continue' but is a code-editing task.",
-      "files": [],
-      "assertions": [
-        { "type": "code", "check": "router CHOICE != plastic-continuing", "observed": "none", "result": "pass" }
-      ]
-    },
-    {
-      "id": 6, "scope": "behavior", "set": "train",
-      "prompt": "continue",
-      "expected_output": "Bare 'continue' with no further target dispatches to the project route (plastic-project-continuing), the routing table's default.",
-      "files": ["skills/continuing/SKILL.md"],
-      "assertions": [
-        { "type": "convention", "check": "routing table's default row maps bare continue/resume/no target to plastic-project-continuing", "observed": "present", "result": "pass" }
-      ]
-    },
-    {
-      "id": 7, "scope": "behavior", "set": "train",
-      "prompt": "continue --intent 4a",
-      "expected_output": "Dispatches to the intent route (plastic-intent-continuing).",
-      "files": ["skills/continuing/SKILL.md"],
-      "assertions": [
-        { "type": "convention", "check": "routing table maps --intent {id} to plastic-intent-continuing", "observed": "present", "result": "pass" }
-      ]
-    },
-    {
-      "id": 8, "scope": "behavior", "set": "validation",
-      "prompt": "resume the statusline-coloring intent",
-      "expected_output": "Dispatches to the intent route (plastic-intent-continuing): a specific intent named by description.",
-      "files": ["skills/continuing/SKILL.md"],
-      "assertions": [
-        { "type": "convention", "check": "routing table maps a named specific intent (by id or description) to plastic-intent-continuing", "observed": "present", "result": "pass" }
-      ]
-    },
-    {
-      "id": 9, "scope": "behavior", "set": "validation",
-      "prompt": "continue the consistency-dividend roadmap",
-      "expected_output": "Dispatches to the roadmap route (plastic-roadmap-continuing).",
-      "files": ["skills/continuing/SKILL.md"],
-      "assertions": [
-        { "type": "convention", "check": "routing table maps a named roadmap/delivery batch to plastic-roadmap-continuing", "observed": "present", "result": "pass" }
-      ]
-    }
-  ]
-}