@renzrollon/interlock 1.2.1 → 1.3.1

package/lib/waves.mjs

@@ -102,7 +102,8 @@
 
 import { randomUUID } from 'node:crypto'
 
-import { LIMITS, EFFORT, LANE_CAPS, SOLO, clampParallel } from './limits.mjs'
+import { LIMITS, LANE_CAPS, SOLO, clampParallel } from './limits.mjs'
+import { dependsOnIds, laneEffort, laneLabel, laneModel, laneTier, laneTitle } from './lane.mjs'
 import { diffIndex, locatorPath } from './locators.mjs'
 import { canonicalizePath, isDocsPath } from './risk.mjs'
 
@@ -195,28 +196,6 @@ function unusablePaths(tasks) {
   return out
 }
 
-/**
- * One task's declared dependency edges, deduplicated, in the order written.
- *
- * THE ONLY READER of `task.dependsOn`, for the same reason `predictedPaths` is
- * the only reader of `task.paths`: validation, layering and the replan path all
- * ask the same question, and three readers each doing their own trimming is how
- * one of them ends up matching an id the others do not.
- *
- * Entries are trimmed. A whitespace-only entry is dropped here and rejected by
- * `validate`, which runs first on every path into the planner.
- */
-function dependsOnIds(task) {
-  const raw = task && Array.isArray(task.dependsOn) ? task.dependsOn : []
-  const out = []
-  for (const entry of raw) {
-    if (typeof entry !== 'string' || !entry.trim()) continue
-    const id = entry.trim()
-    if (!out.includes(id)) out.push(id)
-  }
-  return out
-}
-
 function chunk(items, size) {
   const out = []
   for (let i = 0; i < items.length; i += size) out.push(items.slice(i, i + size))
@@ -467,11 +446,6 @@ function laneCanonicalPaths(lane) {
   return out
 }
 
-/** The tier a lane dispatches on: the highest among its tasks. */
-export function laneTier(lane) {
-  return lane.reduce((m, t) => (Number.isInteger(t.tier) && t.tier > m ? t.tier : m), 0)
-}
-
 /**
  * The effective per-tier lane cap table for one plan: the published table with a
  * uniform override applied as a CEILING over every tier.
@@ -507,85 +481,10 @@ function capForTier(caps, tier) {
   return Number.isInteger(cap) && cap > 0 ? cap : 1
 }
 
-/**
- * The label a lane runs under — the name its agent, its trajectory line and its
- * briefing file all carry.
- *
- * Stable across replays, so a resumed run cache-hits the lane it already ran.
- * This derivation was written three times (the workflow script, the ACP driver,
- * and `bin/interlock`'s own trajectory logger); it is stated here once because a
- * trajectory line and the agent it describes must carry one name, not two.
- */
-export function laneLabel(lane) {
-  return lane.length === 1 ? lane[0].id : `${lane[0].id}+${lane.length - 1}`
-}
-
-/** Separates a spawn's label from the words its title adds. */
-export const TITLE_SEPARATOR = ' · '
-
-/** The longest title a lane displays under, ellipsis included. */
-const TITLE_MAX = 48
-
-/**
- * The name a lane is SHOWN under — its label, then the first words of its first
- * task's description: `1.1+5 · Add the relaunch guard to…`.
- *
- * Display only. Everything that joins on a lane — its briefing file, worktree,
- * trajectory line, record-batch fold — keys on `laneLabel`, because a key built
- * from prose would change whenever a task was reworded. It is still a pure
- * function of the lane, so a replay displays, and cache-hits, the same agent.
- */
-export function laneTitle(lane) {
-  const label = laneLabel(lane)
-  const first = lane[0] && typeof lane[0].description === 'string' ? lane[0].description : ''
-  const words = first.replace(/[`*_]/g, '').replace(/\s+/g, ' ').trim().split(' ').slice(0, 6).join(' ')
-  const gist = words.replace(/[\s.,;:—-]+$/, '')
-  if (!gist) return label
-  const full = `${label}${TITLE_SEPARATOR}${gist}`
-  return full.length <= TITLE_MAX ? full : `${full.slice(0, TITLE_MAX - 1).trimEnd()}…`
-}
-
-/**
- * The model a lane dispatches on, derived from the lane's shape and hardest tier.
- *
- * A lane of one task dispatches on that task's clamped model — haiku or sonnet,
- * or opus for a tier-5 task or a solo promotion. A lane of two or more tasks is
- * the work agent the planner chose not to split: it dispatches on opus when its
- * hardest tier is at or above `LANE_CAPS.opusMinTier`, or when every task already
- * carries opus (solo promotion of the whole change). Otherwise it runs on
- * sonnet — routine multi-task work no longer pays the flagship model by default.
- * Nothing here rewrites `task.model`: a narrowed lane of one returns to the
- * task's model.
- */
-export function laneModel(lane) {
-  if (!Array.isArray(lane) || lane.length === 0) return 'sonnet'
-  if (lane.length === 1) {
-    const only = lane[0]
-    return (only && only.model) || 'sonnet'
-  }
-  // Solo promotions rewrite every task to opus after the clamp; an all-opus
-  // multi-task lane is that decision (or a pure tier-5 pack), not the floor.
-  if (lane.every(t => t && t.model === 'opus')) return 'opus'
-  return laneTier(lane) >= LANE_CAPS.opusMinTier ? 'opus' : 'sonnet'
-}
-
-/**
- * The reasoning effort a lane dispatches at — a sibling of `laneModel`, derived
- * from the same hardest-task tier, looked up in the table published by
- * `lib/limits.mjs`. A lane is one agent, and that agent must be capable of the
- * hardest thing in the lane, so the effort is the hardest task's, never the
- * first task's — the one direction of this trade that is not survivable.
- *
- * Returns `null` (inherit the session default — do not force) for tiers 3–4 by
- * policy and for an untiered lane (`laneTier` → 0) by fallback; the plan's
- * effort report distinguishes the two. Effort is derived from tier alone. The
- * model a lane dispatches on follows shape and the opus floor, so a multi-task
- * lane of tier-1 or tier-2 tasks runs on sonnet at `low`.
- */
-export function laneEffort(lane) {
-  const tier = laneTier(lane)
-  return EFFORT.byTier[tier] ?? null
-}
+// The lane rule — tier, label, title, model, effort — lives in `lib/lane.mjs`,
+// a module the engine can load (draw-wave-plan-and-handoff-graph-from-the-cli
+// design D3). Re-exported so every importer of it from here is unchanged.
+export { laneEffort, laneLabel, laneModel, laneTier, laneTitle, TITLE_SEPARATOR } from './lane.mjs'
 
 /**
  * Group a group's tasks into lanes: connected components over canonical-path

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@renzrollon/interlock",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "description": "Autonomous spec-driven development orchestration for Claude Code, layered on OpenSpec",
   "type": "module",
   "engines": {
@@ -22,7 +22,7 @@
     "agents",
     "shared",
     ".claude-plugin/plugin.json",
-    ".claude-plugin/icon.png",
+    "assets",
     "README.md",
     "LICENSE",
     "CHANGELOG.md"

package/skills/review-artifacts/SKILL.md

@@ -19,7 +19,7 @@ Resolve the change:
 interlock validate [change-name] --json
 ```
 
-If it reports ambiguity, pick the change the user named. If they named none and several are active, review the most recently modified and **say which one you picked** — this skill runs inside automated chains where a question would stall the flow.
+An output carrying `error` and `candidates` instead of `ready` means the name did not resolve; `problems` is the list the change must clear. If the name did not resolve, pick the change the user named. If they named none and several are active, review the most recently modified and **say which one you picked** — this skill runs inside automated chains where a question would stall the flow.
 
 Read all of `proposal.md`, `specs/**/*.md`, `design.md`, `tasks.md`.
 
@@ -119,9 +119,9 @@ Write `.claude/metrics/review-artifacts-<change>-<YYYYMMDD-HHMMSS>.json` in this
 Then let the deterministic gate decide, rather than deciding in prose:
 
 ```bash
-interlock gate --findings .claude/metrics/review-artifacts-<change>-<ts>.json --metrics <change>
+interlock gate --findings .claude/metrics/review-artifacts-<change>-<ts>.json --metrics <change> --json
 ```
 
-The gate blocks if and only if at least one finding is a `blocker`. Its exit status is the verdict: non-zero means blocked. Do not re-derive the verdict in prose.
+The gate blocks if and only if at least one finding is a `blocker`. Its exit status is the verdict: non-zero means blocked. Do not re-derive the verdict in prose. In the JSON, `passed` is that same verdict; report the entries of `blockers` and `malformed`, read `metrics.written` and `metrics.reason` for whether the record landed, and hand `autonomyOutcome.blockers` on as the blocker count the spec skill passes to `interlock autonomy record`.
 
 `--metrics <change>` is not optional decoration. It writes the four counts this gate produced — raised, dismissed, dropped by the quality band, surviving — to `.claude/metrics/` in the schema `interlock report` recognizes. Drop it and this review path becomes invisible to the report forever: the review-finding indicators read `unobserved` no matter how many gates ran. It is bookkeeping only and cannot change the verdict or the exit status.

package/skills/spec/SKILL.md

@@ -189,10 +189,10 @@ What this skill owes the ledger:
 Check the file rather than trusting that you wrote it well:
 
 ```bash
-interlock ledger "<name>"
+interlock ledger "<name>" --json
 ```
 
-It exits non-zero when the ledger blocks — a `needs_human` row remains, a row is invalid, or **the ledger is missing entirely**. An absent `decisions.md` is a failure of the audit, not an empty result: "no rows" reads as "nothing needs a human", which is the one conclusion a file that was never written cannot support. The output distinguishes *missing* from *present and empty* from *unparseable*.
+It exits non-zero when the ledger blocks — a `needs_human` row remains, a row is invalid, or **the ledger is missing entirely**. An absent `decisions.md` is a failure of the audit, not an empty result: "no rows" reads as "nothing needs a human", which is the one conclusion a file that was never written cannot support. The output distinguishes *missing* from *present and empty* from *unparseable*. In the JSON, `blocking` is the verdict; report the `needs_human` entries of `rows` by `id` and `question` and the entries of `invalidRows` by `reason`, and read `missing` or `unparseable` as why a ledger with no rows still blocks.
 
 A blocking ledger with rows in it is not a failure of this skill: an honest blocking ledger is the correct output for a change that hit a real product question. It is only a failure if the questions never got written down.
 
@@ -202,10 +202,10 @@ A blocking ledger with rows in it is not a failure of this skill: an honest bloc
 
 ```bash
 openspec validate
-interlock validate "<name>"
+interlock validate "<name>" --json
 ```
 
-`openspec validate` checks schema conformance. `interlock validate` checks the flow's own preconditions — all three artifacts present and non-empty, `tasks.md` actually containing checkbox tasks — and exits non-zero when the change is not implementable. Fix anything it reports before continuing.
+`openspec validate` checks schema conformance. `interlock validate` checks the flow's own preconditions — all three artifacts present and non-empty, `tasks.md` actually containing checkbox tasks — and exits non-zero when the change is not implementable. Fix anything it reports before continuing. In the JSON, `ready` is the verdict and `problems` is the list to fix; an output carrying `error` and `candidates` instead of `ready` means the name did not resolve.
 
 ---
 
@@ -225,7 +225,7 @@ interlock autonomy clean review-artifacts explore spec
 
 A clean gate credits `explore` and `spec` too; a blocker resets them. That is what stops this skill earning autonomy by emitting shallow specs — the downstream gate blames whoever produced the bad artifact.
 
-**Keep the blocker and warning counts.** Continuity needs them, and it will not accept a review it cannot see.
+**`<n>` is `autonomyOutcome.blockers` from the gate's JSON**, carried over from the review — never a count made in prose, including the review's own `SUMMARY:` line. Continuity takes the findings file itself, so keep its path.
 
 ---