@azure-id/orc 1.4.1 → 1.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@azure-id/orc",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "ORC — an orchestrator skill constellation for Claude Code: intake, planning, scored parallel subagents, code-pattern matching, review, verify, ship, plus a project knowledge-base wiki.",
   "bin": {
     "orc": "bin/cli.js"

package/templates/hooks/README.md

@@ -205,12 +205,19 @@ them where you want them. One rule decides where a component may go:
 > A line may hold a component only if every line above it holds at least one.
 
 So line 1 must hold something before line 2 can, and line 2 before line 3. Each
-line holds at most five components. The panel will not let you make an illegal
+line holds at most six components. The panel will not let you make an illegal
 move, and it tells you why.
 
 Every component can be changed: its words, its colour, its shape, how wide it
 is, and when it is allowed to disappear.
 
+**The shape decides what the other settings can do.** Only these shapes print a
+short name in front of the value: `plain`, `label-value`, `bracket`, `angle`,
+`badge`, `pill` and `stack`. A bar, an icon and a bare value have no room for
+one, so the panel switches the Name box off for them and says so. The same is
+true of the number settings: a bar has a width and a colour ramp, and no number
+format at all.
+
 **Three things a terminal cannot do**, said plainly so you do not look for them:
 
 | You may want | What you get |

package/templates/hooks/orc-statusline.js

@@ -1147,16 +1147,27 @@ function custom(d, ctx) {
       if (!engine.BINDINGS[b]) return slFallback(orcDir, "statusline-layout-skew");
     }
 
-    // Rung 5. The cheap shape guard: at most three lines, at most five
+    // Rung 5. The cheap shape guard: at most three lines, at most `max_per_line`
     // components on any of them, and the dense-prefix rule —
     // A line may hold a component only if every line above it holds at least one.
+    //
+    // THE CAP AND THE COUNTING RULE ARE BOTH THE COMPILER'S (v1.4.2). This held
+    // its own `5` and counted EVERY item op, so it disagreed with the validator
+    // twice: it bounced a legal six-part line, and it bounced a legal five plus
+    // a spacer. Both fell silently back to the shipped lines with the reason
+    // only in a ledger file, which reads exactly like "my sixth part reset the
+    // bar to the default". The cap rides on the lock (already gated on
+    // `orc_version` at rung 3, so a stale copy cannot outlive its build) and
+    // the compiler marks a structural op `s` — this cannot know that on its
+    // own, because a compiled op carries an INSTANCE id and never a type.
     if (!Array.isArray(prog.lines) || prog.lines.length > 3)
       return slFallback(orcDir, "statusline-layout-invalid");
+    const cap = Number(lock.max_per_line) > 0 ? Number(lock.max_per_line) : 6;
     let seenEmpty = false;
     for (const l of prog.lines) {
-      const n = (l.ops || []).filter((o) => o.op === "item").length;
-      if (n > 5) return slFallback(orcDir, "statusline-layout-invalid");
-      if (n === 0) seenEmpty = true;
+      const ops = (l.ops || []).filter((o) => o.op === "item");
+      if (ops.filter((o) => !o.s).length > cap) return slFallback(orcDir, "statusline-layout-invalid");
+      if (ops.length === 0) seenEmpty = true;
       else if (seenEmpty) return slFallback(orcDir, "statusline-layout-invalid");
     }
 

package/templates/hooks/orc-subagent-line.js

@@ -182,10 +182,13 @@ function render(d, tasks) {
 
     // Rung 5. A subagent row is ONE line by construction — Claude Code renders
     // one row per task — so the board's three-line shape does not apply and the
-    // cheap guard is simply "one line, at most five things on it".
+    // cheap guard is simply "one line, at most `max_per_line` things on it".
     if (!Array.isArray(prog.lines) || !prog.lines.length) return null;
     const line = prog.lines[0];
-    if ((line.ops || []).filter((o) => o.op === "item").length > 5) return null;
+    // The same cap, from the same place, counted the same way (v1.4.2). A
+    // hardcoded number here is a second idea of how much one line may say.
+    const cap = Number(lock && lock.max_per_line) > 0 ? Number(lock.max_per_line) : 6;
+    if ((line.ops || []).filter((o) => o.op === "item" && !o.s).length > cap) return null;
 
     // Rung 6. One row per task, each rendered with THAT TASK bound.
     const now = Date.now();