shapeup-sdlc 3.9.0 → 3.9.2

package/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "shapeup-sdlc-plugin",
   "displayName": "ShapeUp SDLC Plugin",
-  "version": "3.9.0",
+  "version": "3.9.2",
   "description": "Shape Up SDLC harness for Claude Code: shaping, intake, orient, scope-mapping, building (T0-verified, sandboxed, scope-contracted), evaluation and QA skills orchestrated by a tech-lead.",
   "author": {
     "name": "Liberty Nguyen",

package/kernel/lib/contract.mjs

@@ -263,6 +263,28 @@ function splitList(body) {
  * @returns {{meta:Object<string,*>, body:string}} Parsed scalars/lists and the remaining body
  *   ({}/whole document when there is no leading `---` block).
  */
+/**
+ * Whether a flow sequence is closed: every `[` outside a quoted run has met its `]`.
+ *
+ * Quotes are tracked because a bracket inside a quoted path is a character, not structure — and a
+ * scope substrate glob is exactly the kind of value that can carry one.
+ *
+ * @param {string} text - The accumulated text, starting at the opening bracket.
+ * @returns {boolean} True once depth returns to zero, i.e. the sequence is complete.
+ */
+function flowClosed(text) {
+  let depth = 0;
+  let quote = null;
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (quote) { if (ch === quote && text[i - 1] !== "\\") quote = null; continue; }
+    if (ch === '"' || ch === "'") { quote = ch; continue; }
+    if (ch === "[") depth++;
+    else if (ch === "]") { depth--; if (depth === 0) return true; }
+  }
+  return false;
+}
+
 export function splitFrontmatter(md) {
   const m = String(md ?? "").match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
   if (!m) return { meta: {}, body: String(md ?? "") };
@@ -275,7 +297,29 @@ export function splitFrontmatter(md) {
     const c = line.indexOf(":");
     if (c === -1) continue;
     const key = line.slice(0, c).trim();
-    const inline = line.slice(c + 1).trim();
+    let inline = line.slice(c + 1).trim();
+
+    // A FLOW SEQUENCE MAY SPAN LINES, and it used to parse as the single character "[".
+    //
+    // `field: [` followed by one quoted member per line and a closing `]` is the form a model
+    // reaches for the moment a list is too long to read on one line, and this dialect took only
+    // the text after the colon — so the value became the string "[", the members were counted as
+    // unreadable strays, and every reader downstream saw a string where an array was declared.
+    // Measured on a live run: three of five scope contracts were written this way, and each one
+    // then failed its own envelope schema at compile — the run could not dispatch those scopes at
+    // all. Accepted now: the lines are joined until the brackets balance and the whole thing is
+    // coerced as the list it is. A sequence that never closes is still reported, never guessed at.
+    if (inline.startsWith("[") && !flowClosed(inline)) {
+      let buf = inline;
+      let k = i + 1;
+      for (; k < lines.length && !flowClosed(buf); k++) buf += " " + lines[k].trim();
+      i = k - 1;
+      if (flowClosed(buf)) { meta[key] = coerce(buf); continue; }
+      meta[key] = null;
+      unreadable.push({ field: key, expected_heading: `${key}: [a, b]  (or an indented \`- item\` list)`,
+        found_under: "a flow sequence that is never closed", rows: k - (i + 1) });
+      continue;
+    }
 
     // An indented run beneath a key is a YAML BLOCK SEQUENCE, and it used to be skipped
     // entirely — so `e2e_verification_fixtures:` followed by two `- "node …"` lines parsed to

package/kernel/verify/trace.mjs

@@ -126,7 +126,9 @@ const IMPORT_RE = /(?:\bimport\b[^'"]*?from\s*|\bimport\s*|\bexport\b[^'"]*?from
  *   walk uses, plus what each widening contributed (reported, so a reader can see why it resolved).
  */
 export function sourceExtensions(profile, entryPoint) {
-  const raw = profile?.source_extensions ?? profile?.module_extensions ?? null;
+  // One spelling, the one the schema declares. A silent alias is a field nobody documented and
+  // nobody can be told to write.
+  const raw = profile?.source_extensions ?? null;
   const list = Array.isArray(raw) ? raw : typeof raw === "string" ? raw.split(/[,\s]+/) : [];
   const declared = list
     .map((e) => String(e).trim())
@@ -292,7 +294,6 @@ function sourceFilesUnder(root, exts) {
     let entries;
     try { entries = readdirSync(dir, { withFileTypes: true }); } catch { return; }
     for (const e of entries) {
-      if (e.name.startsWith(".") && e.name !== ".") { if (SKIP_DIRS.has(e.name)) continue; }
       if (SKIP_DIRS.has(e.name)) continue;
       const abs = join(dir, e.name);
       if (e.isDirectory()) walk(abs);
@@ -319,7 +320,13 @@ export function scopeReachability(contracts, reachable, sources) {
   for (const found of contracts) {
     const c = found?.contract || found || {};
     const id = c.scope_id || found?.id;
-    const globs = (c.allowed_file_substrate || []).map(globToRegExp);
+    // A CONTRACT THIS CANNOT READ IS SKIPPED, NEVER THROWN OVER. The whole oracle runs advisory, so
+    // a throw here takes out covers-closure too and the run gets no report at all — one malformed
+    // contract silencing every arm. A substrate that is not a list of globs is simply a scope this
+    // arm has nothing to say about.
+    const declared = c.allowed_file_substrate;
+    if (!Array.isArray(declared) || !declared.length) continue;
+    const globs = declared.filter((g) => typeof g === "string").map(globToRegExp);
     if (!globs.length) continue;
     const owned = sources.filter((f) => globs.some((r) => r.test(f)));
     if (!owned.length) continue;
@@ -335,8 +342,10 @@ export function scopeReachability(contracts, reachable, sources) {
  * @param {{cwd:string, gate?:boolean}} opts - cwd (root the SHARED/LOCAL paths resolve against),
  *   gate (records mode; the CLI, not this function, turns gate+red into a non-zero exit).
  * @returns {{report:object, mermaid:(string|null)}} The trace report (covers_closure, reachability,
- *   findings[], overall "green"|"red") and a Mermaid view when a wiring map exists. Each arm
- *   self-skips (checked=false) when its artifact is absent — non-regression on pre-spine specs.
+ *   scope_reachability, findings[], overall "green"|"red") and a Mermaid view when a wiring map
+ *   exists. Each arm self-skips (checked=false) when its artifact is absent — non-regression on
+ *   pre-spine specs — and reachability also self-skips when it cannot root its walk, which is what
+ *   skips the per-scope arm with it.
  */
 export function traceLint(slug, { cwd, gate = false }) {
   const shared = sharedRoot(cwd, slug);
@@ -491,7 +500,8 @@ export function traceLint(slug, { cwd, gate = false }) {
               skipped_reason: `no engine is reachable from entry_point "${entryPoint}", which reaches ${reachable.size} file(s) — with no reachable engine as a control this walk cannot tell an orphaned module from an entry point that is not the runtime root (declarative routing, a manifest, a string-loaded screen). Reachability skipped.` };
             findings.push({ severity: "warn", code: "REACH-NO-CONTROL", message:
               `reachability did not run: all ${engines.length} engine(s) are unreachable from entry_point "${entryPoint}", which reaches ${reachable.size} file(s). ` +
-              "Every engine orphaned is the one result this arm cannot distinguish from a wrong root — if this project wires its screens by name rather than by import, declare the module that does the wiring as the entry point." });
+              "Every engine orphaned is the one result this arm cannot distinguish from a wrong root. If some module does compose the app, declare that one as the entry point. " +
+              "If the screens are registered in a manifest instead — a route map, a plugin table — then no entry point roots this walk and unchecked is the correct end state for this project, not a profile to fix." });
           } else {
             for (const u of unreachable) {
               findings.push({ severity: "red", code: "UC-UNREACHABLE", uc: u.use_case,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shapeup-sdlc",
-  "version": "3.9.0",
+  "version": "3.9.2",
   "description": "Shape Up for coding agents \u2014 with gates the agent can't talk its way past. Harness for Claude Code.",
   "bin": {
     "shapeup-sdlc": "bin/init.mjs"

package/skills/tech-lead/references/gates.md

@@ -224,10 +224,12 @@ Do NOT enter MAP SCOPES until Orient is accepted.
    archetype ∈ {client-only-game|web-service|mobile|library|data-pipeline}; entry_point is the
    reachability seam (a game's main.js is NOT a service's src/server.ts). Validate the enum — a
    typo must fail, not silently disable the check. entry_point is also the root reachability walks
-   the import graph from, so pick the module the app's screens hang off, not merely the file the
-   platform starts: a framework that registers screens by name (a route map, a manifest, a
-   string-loaded page) leaves its start file importing nothing the feature touches, and the arm
-   then reports that it could not check rather than calling every engine orphaned.
+   the import graph from, so where some module does compose the app, name that one rather than the
+   file the platform happens to start. Where the screens are registered in a MANIFEST instead (a
+   route map, a plugin table, a string-loaded page), no entry point roots an import walk at all —
+   measured on a real ArkTS app, where the navigation host imports nothing and every screen arrives
+   through route_map.json. The arm then reports that it could not check, and that is the correct
+   end state for such a project rather than a profile to keep re-declaring.
    source_extensions is optional and only needed when the project's modules end in something the
    entry point does not (e.g. [".ets"] when the entry is a .ts file); leaving it out costs a
    skipped arm, never a false red. The two probes feed the round build gate (`harness verify

package/skills/tech-lead/workflows/shapeup-run.js

@@ -1800,6 +1800,13 @@ while (verdict !== "pass" && round <= maxRounds) {
         `${gate.detail ? `: ${gate.detail}` : ""}). Treated as undeclared, not as green.`);
   }
 
+  // Trace-lint runs a SECOND time here, and this is the pass that can see anything. At L1b the
+  // scopes' files do not exist yet, so per-scope reachability measures an empty set and its warning
+  // cannot fire. After the round's build gate the code is on disk, which is exactly when "this
+  // scope's fixture is green and none of its code is in the compiled set" becomes a checkable fact
+  // — the shape that once left three scopes green while their files never compiled. Advisory, like
+  // the L1b pass: it overwrites the same projection with a later and better-informed one.
+  await advisory(`verify trace --slug ${slug} --quiet`, "Build", `trace-lint:r${round}`);
   await advisory(`reduce hill --slug ${slug}`, "Build", "hill-derive");
   {
     const g = await crossGate("L2", "Build", ["proceed", "ask", "abort"],