@erclx/canon 4.23.1 → 4.24.1

package/claude/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "canon",
   "description": "Automated governance, versioning, and discovery tools for Claude Code.",
-  "version": "4.23.1",
+  "version": "4.24.1",
   "author": {
     "name": "Eric Le",
     "url": "https://github.com/erclx"

package/claude/skills/claude-orchestrate/REQUIREMENT.md

@@ -94,6 +94,7 @@ The session also records nothing of what it learns. Both other callers of memory
 - Merge. Recommend merge or changes and leave the gate to the human.
 - Spawn a worker with the Agent tool, since an in-process subagent shares this session's context and cannot be steered or reached independently. A dispatched `claude --bg` process is not this: it is a separate session with its own worktree and its own PR, gated by the collision check and the file-set disjointness test.
 - Hand a worker anything but a plan, because scope lives there
+- Name a count of the defect's extent or the mechanism behind it while filing a row, since this seat measures a defect from where it stands and the planner is the reader who commits to that scope. A blocker re-test, a collision check, and a file set decide whether a row can start rather than how big it is, and they stay.
 - Run a second orchestrator against the same board
 - Promote a task to fill the queue when nothing qualifies. A thin queue is a real answer.
 - Promote a parked row on how long it has waited, since age is not a measurement of the blocker

package/claude/skills/claude-orchestrate/SKILL.md

@@ -149,6 +149,14 @@ The tracked-file boundary collides with `CLAUDE.md`, which says to handle a smal
 
 Record a change identified while orchestrating against the task that owns it, fold one no task owns into the next task touching the same surface, and file a task only when no such task exists or is expected. Run `claude-review` when the boundary is crossed anyway, since a branch-diff pass is not independent and is the only check a self-authored change can get.
 
+Filing a row states the defect and the surface it was seen on, and stops there. The extent and the cause belong to whoever plans it, so a row names neither a count of how far the defect reaches nor the mechanism behind it. Say in a plain sentence in the task file that the count was not taken, where the row's shape invites one, rather than in a marker of any prescribed form. The board's own cell has no room for it, since `${CLAUDE_SKILL_DIR}/../../standards/tasks.md` caps a `Waiting on` cell at two clauses.
+
+A finding placed into another task's `## Findings` is filing under a second name and takes the same rule. An unverified cause costs more than an unverified count, since a count fails loudly at the first re-measurement while a mechanism nobody opened the module to check sends real work in the wrong direction.
+
+What the measurement decides is the test, rather than whether one was taken. A measurement that decides whether a row can start stays in this seat, which covers the blocker re-test in `${CLAUDE_SKILL_DIR}/references/orchestrator-parked.md`, the collision check before a dispatch, and the file set refill step 6 lists against every track in flight. One that decides how big the row is goes to the planner.
+
+Both kinds read the same tree, and only a sizing count commits a plan to a scope this seat cannot see the whole of. A row filed under `## Needs a plan` carries no `Touches` column either, so filing it unmeasured owes no file set and the disjointness machinery is untouched. A position claim in that group's cell is in scope as well: name the row it outranks or the class it belongs to, each a judgment about order, and never reach for a count of the defect's extent to justify the rank, which is the untested number this boundary keeps off the row wearing a ranking argument.
+
 ## Refilling the ready queue
 
 Keep enough planned, non-conflicting tasks available that a free worker never waits, and place the findings the last merge produced before promoting anything new. Run this after every merge, whenever the ready list thins, and whenever a wave is in flight with fewer unclaimed plans than there are workers building. `${CLAUDE_SKILL_DIR}/references/orchestrator-sweep.md` wraps this procedure for a batch of merges and adds the plan re-verification that a merge invalidates.

package/claude/skills/claude-orchestrate/references/orchestrator-parked.md

@@ -29,6 +29,8 @@ The blocker cell states what the row waits on, and each kind is tested different
 - Waiting on a plan: nothing external holds the row, so the pass writes the plan rather than testing anything. See The plan half below.
 - Waiting on an operator action, such as a run that happens from a shell: record it as untestable this pass and name what the operator has to do. A session cannot clear it, and re-measuring it every pass is waste.
 
+Every measurement this pass takes is a blocker re-test on a row already filed, and it decides whether that row can start rather than how big it is. Sizing a row is the filing boundary `claude-orchestrate` states under `## Boundaries`, which leaves the extent and the cause to whoever plans the row.
+
 Write the result into the row. A re-test reported in chat is lost at the next compaction and the next pass measures the same thing again. Rewrite a blocker cell whose test no longer holds, move the row to the group its new state puts it in, and record the measurement in that task's `## Findings` with the date it was taken. `### Writing the board` in `claude-orchestrate` owns the method, and `canon tasks validate` runs once the board is rewritten and before the report.
 
 ## Two ways a re-test goes wrong

package/docs/agents/key-changes.md

@@ -58,7 +58,7 @@ A span anywhere in the bullet has to survive all of these:
 | No whitespace, `<`, `>`, `$`, `*`, `\|`, `?`, `^` | A backticked command, a placeholder, a glob, a pattern |
 | No `://` and no leading `/`, `~`, `@`, `#`, `!`   | A URL, an absolute path, a module alias                |
 | Contains `/`                                      | A bare filename with no folder around it               |
-| Extension starts with a letter, or ends with `/`  | A dotted number such as an address                     |
+| Not a dotted-decimal segment, or ends with `/`    | A dotted number such as an address                     |
 | Not a single top-level folder                     | `src/`, which nobody claims to have rewritten whole    |
 | A `file:line` span leads its bullet               | A citation into a file the bullet is describing        |
 | The region carries no no-change marker            | A bullet recording a file it deliberately left alone   |

package/docs/workflow/operating-model.md

@@ -65,6 +65,14 @@ goes to the task that owns the surface, or folds into the next task touching it,
 because a session that writes a change cannot review it independently afterwards
 and no later session recovers that vantage.
 
+Filing that row stops at the defect and the surface it was seen on. How far the
+defect reaches and what causes it belong to whoever plans the row, so it arrives
+carrying neither a count nor an asserted mechanism, and the seat that found it
+says as much in a plain sentence rather than supplying either. What separates the
+two is what a measurement decides: the blocker re-test, the collision check, and
+the file set compared against every track in flight all decide whether a row can
+start, and only a count of the defect's extent decides how big it is.
+
 ## The loop
 
 One feature travels this path end to end.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@erclx/canon",
   "type": "module",
-  "version": "4.23.1",
+  "version": "4.24.1",
   "description": "Infrastructure and quality tooling for developer workflows",
   "license": "MIT",
   "bin": {

package/src/pr/paths.ts

@@ -94,15 +94,18 @@ function isNotRepositoryPath(span: string): boolean {
 }
 
 /**
- * Whether the span's last segment carries a file extension.
+ * Whether the span's last segment is a bare dotted-decimal number, such as
+ * an address (`127.0.0.1`) or an unprefixed version number (`1.2.3`).
  *
- * The extension has to start with a letter, which is what keeps `127.0.0.1`
- * out. A bare dotted number reaching the comparison is the shape that put
- * `src/serve/127.0.0.1` in a report over a body that was correct.
+ * This is the one exclusion `resolveSpan` still applies to a non-directory
+ * span. A bare dotted number reaching the comparison is the shape that put
+ * `src/serve/127.0.0.1` in a report over a body that was correct, and every
+ * other segment carrying no extension, such as `.husky/post-merge`, now
+ * resolves.
  */
-function hasExtension(span: string): boolean {
+function isDottedNumber(span: string): boolean {
   const segment = span.slice(span.lastIndexOf('/') + 1)
-  return /\.[A-Za-z][A-Za-z0-9]*$/.test(segment)
+  return /^\d+(?:\.\d+)+$/.test(segment)
 }
 
 /** Blanks every backticked span so a cue search never fires inside one. */
@@ -285,7 +288,7 @@ function resolveSpan(span: string): ResolvedSpan | undefined {
       : { path: span, directory: true }
   }
 
-  return hasExtension(span) ? { path: span, directory: false } : undefined
+  return isDottedNumber(span) ? undefined : { path: span, directory: false }
 }
 
 /**