@mmerterden/multi-agent-pipeline 8.6.1 → 10.0.6

package/pipeline/scripts/eval-intent.mjs

@@ -0,0 +1,103 @@
+#!/usr/bin/env node
+
+/**
+ * @file eval-intent.mjs  -  measured accuracy for the Phase 0 intent guard.
+ *
+ * Runs every labeled case in pipeline/eval/intent-cases.json through
+ * pipeline/lib/classify-intent.sh and reports accuracy. This turns the
+ * classifier from "a heuristic we hope works" into a number with a regression
+ * gate: a dangerous miss is a clear task read as `question` (work skipped) or a
+ * clear question read as `task` (a worktree spun up for nothing). `ambiguous`
+ * is the safe middle and is only correct when the case labels it so.
+ *
+ * Exit 0 if accuracy >= threshold (default 0.95), else 1. Override with
+ * --min <0..1>. Prints a JSON summary + the mismatches.
+ *
+ * @module pipeline/scripts/eval-intent
+ */
+
+import { readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = dirname(fileURLToPath(import.meta.url));
+const ROOT = join(HERE, "..", "..");
+const CLASSIFY = join(ROOT, "pipeline", "lib", "classify-intent.sh");
+const CASES = join(ROOT, "pipeline", "eval", "intent-cases.json");
+
+const argv = process.argv.slice(2);
+let minAccuracy = 0.95;
+for (let i = 0; i < argv.length; i++) {
+  if (argv[i] === "--min") {
+    minAccuracy = Number(argv[i + 1]);
+    // A typo'd `--min` with no/NaN value would set the threshold to NaN, and
+    // `accuracy < NaN` is always false - silently turning the gate into a
+    // no-op. Fail loudly instead.
+    if (!Number.isFinite(minAccuracy) || minAccuracy < 0 || minAccuracy > 1) {
+      console.error(`eval-intent: --min needs a number in [0,1], got: ${argv[i + 1]}`);
+      process.exit(2);
+    }
+  }
+}
+
+function classify(input) {
+  try {
+    return execFileSync("bash", [CLASSIFY, input], { encoding: "utf8" }).trim();
+  } catch {
+    return "ERROR";
+  }
+}
+
+const { cases } = JSON.parse(readFileSync(CASES, "utf8"));
+if (!Array.isArray(cases) || cases.length === 0) {
+  console.error("eval-intent: no cases found");
+  process.exit(2);
+}
+
+// Operationally-safe match: only TWO outcomes are dangerous, and they are what
+// the gate measures -
+//   - a `task` read as `question`  -> real work silently skipped
+//   - a `question` read as `task`  -> a worktree spun up for nothing
+// `ambiguous` proceeds as a task in Phase 0, so it is SAFE for a task/ambiguous
+// case but UNSAFE for a question case (ambiguous still avoids the worktree, so
+// it is acceptable for a question too - only `task` is the dangerous read).
+function isSafe(expected, got) {
+  if (got === expected) return true;
+  if (expected === "task") return got === "ambiguous"; // proceeds as task anyway
+  if (expected === "ambiguous") return got === "task"; // both proceed to dev
+  if (expected === "question") return got === "ambiguous"; // still no worktree spun up
+  return false;
+}
+
+const mismatches = [];   // operationally unsafe (gate-failing)
+const exactMisses = [];  // not exact, but operationally safe (informational)
+let safe = 0;
+let exact = 0;
+for (const c of cases) {
+  const got = classify(c.input);
+  if (got === c.expected) exact++;
+  else exactMisses.push({ input: c.input, expected: c.expected, got });
+  if (isSafe(c.expected, got)) safe++;
+  else mismatches.push({ input: c.input, expected: c.expected, got, danger: true });
+}
+
+const accuracy = safe / cases.length;
+const summary = {
+  total: cases.length,
+  safeMatches: safe,
+  safeAccuracy: Math.round(accuracy * 1000) / 1000,
+  exactMatches: exact,
+  exactAccuracy: Math.round((exact / cases.length) * 1000) / 1000,
+  minAccuracy,
+  dangerousMisclassifications: mismatches,
+  safeButInexact: exactMisses,
+};
+console.log(JSON.stringify(summary, null, 2));
+
+if (accuracy < minAccuracy) {
+  console.error(`\neval-intent: safe accuracy ${(accuracy * 100).toFixed(1)}% < required ${(minAccuracy * 100).toFixed(0)}% (${mismatches.length} dangerous misclassification(s))`);
+  process.exit(1);
+}
+console.error(`\neval-intent: safe ${(accuracy * 100).toFixed(1)}% (${safe}/${cases.length}), exact ${(exact / cases.length * 100).toFixed(1)}% - pass`);
+process.exit(0);

package/pipeline/scripts/eval-triage.mjs

@@ -1,17 +1,17 @@
 #!/usr/bin/env node
-// eval-triage.mjs — semantic regression check for Phase 4 triage.
+// eval-triage.mjs  -  semantic regression check for Phase 4 triage.
 //
 // Walks pipeline/eval/triage/<NN>-<name>/ subdirectories. For each case:
 //   1. Reads input.json (rawFindings + scope + diffSummary)
 //   2. Reads expected.json (the spec-defined triage output)
-//   3. Runs validate-triage.mjs against expected.json — must exit cleanly
+//   3. Runs validate-triage.mjs against expected.json  -  must exit cleanly
 //   4. Asserts every rawFinding in input is accounted for in expected
 //      (sum of accepted + deferred[].finding + rejected[].finding == rawFindings)
 //   5. Asserts no inventions: every classified finding traces back to a
 //      raw finding by {file, line, issue} match.
 //
 // What this catches:
-//   - Spec drift: someone changes phase-4-review.md §3 in a way that contradicts
+//   - Spec drift: someone changes phase-4-review.md section3 in a way that contradicts
 //     a fixture without updating the fixture.
 //   - Schema drift: validate-triage.mjs starts rejecting fixtures that used
 //     to pass.

package/pipeline/scripts/evidence-gate.mjs

@@ -0,0 +1,155 @@
+#!/usr/bin/env node
+// evidence-gate.mjs  -  default-FAIL gate for "it passed" claims.
+//
+// An agent recording buildStatus=passed (or test/review pass) is only trusted
+// when it can point at an evidence artifact that actually shows success. This
+// gate fails CLOSED: absent, empty, or non-confirming evidence blocks the pass
+// claim. It structurally prevents false-completion ("I built it" with no log),
+// which artifact-existence checks alone do not catch.
+//
+// Usage:
+//   node pipeline/scripts/evidence-gate.mjs --claim build --status passed --evidence build.log
+//   node pipeline/scripts/evidence-gate.mjs --claim test  --status passed --evidence test.log \
+//        --success-pattern 'All tests passed' --failure-pattern 'FAILED'
+//
+// Flags:
+//   --claim            build | test | review   (selects default success/failure markers)
+//   --status           the claimed status (only "passed" is gated; others pass through)
+//   --evidence <path>  the log / artifact that must substantiate a "passed" claim
+//   --success-pattern  override the default success regex for the claim type
+//   --failure-pattern  override the default failure regex for the claim type
+//
+// Exit codes:
+//   0  -  status is not "passed" (nothing to prove), OR evidence substantiates the pass
+//   1  -  pass claim is UNVERIFIED (no evidence / empty / shows failure / no success marker) -> caller must NOT record passed
+//   2  -  usage error
+
+import { existsSync, readFileSync, statSync } from "node:fs";
+
+// Failure markers are kept DEFINITIVE (not broad) because failure now overrides
+// success (see the decision logic): a bare "error:" or stray "FAILED" in an
+// otherwise-successful log must not flip a real pass to fail. Conversely the
+// success markers must NOT include a generic word like "SUCCESS" - a failing
+// build log that merely mentions "SUCCESS" once would otherwise sneak through.
+const DEFAULT_MARKERS = {
+  build: {
+    success: /BUILD SUCCEEDED|Build succeeded/,
+    failure: /BUILD FAILED|Build failed|fatal error:|\*\* BUILD FAILED \*\*/,
+  },
+  test: {
+    success: /\bPASS\b|0 failures|Test Suite.*passed|tests? passed|all tests passed|✓/i,
+    failure: /\bFAILED\b|✗|[1-9][0-9]*\s+failures?|[1-9][0-9]*\s+failing/i,
+  },
+  review: {
+    // Review evidence is the triage artifact; require it to exist + be non-empty.
+    success: /.*/,
+    failure: /(?!)/, // matches nothing
+  },
+};
+
+const MAX_PATTERN_LEN = 200;
+
+// Compile a caller-supplied pattern safely: cap length and catch a bad regex so
+// a malformed --success/--failure-pattern is a clean usage error, not a crash.
+function userRegExp(flagVal, fallback, which) {
+  if (!flagVal || flagVal === true) return fallback;
+  const s = String(flagVal);
+  if (s.length > MAX_PATTERN_LEN) {
+    usage(`--${which}-pattern too long (max ${MAX_PATTERN_LEN} chars)`);
+  }
+  try {
+    return new RegExp(s);
+  } catch (err) {
+    usage(`--${which}-pattern is not a valid regex: ${err.message}`);
+  }
+}
+
+function parseArgs(argv) {
+  const out = {};
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (!a.startsWith("--")) continue;
+    const body = a.slice(2);
+    // --key=value form accepts a value starting with "--" too.
+    const eq = body.indexOf("=");
+    if (eq !== -1) { out[body.slice(0, eq)] = body.slice(eq + 1); continue; }
+    const key = body;
+    const next = argv[i + 1];
+    if (next === undefined || next.startsWith("--")) {
+      out[key] = true;
+    } else {
+      out[key] = next;
+      i++;
+    }
+  }
+  return out;
+}
+
+function fail(msg) {
+  console.log(JSON.stringify({ ok: false, code: 1, reason: msg }));
+  process.exit(1);
+}
+function ok(msg) {
+  console.log(JSON.stringify({ ok: true, code: 0, reason: msg }));
+  process.exit(0);
+}
+function usage(msg) {
+  console.error(`evidence-gate: ${msg}`);
+  process.exit(2);
+}
+
+const args = parseArgs(process.argv.slice(2));
+const claim = args.claim;
+const status = args.status;
+
+if (!claim || !DEFAULT_MARKERS[claim]) {
+  usage(`--claim must be one of: ${Object.keys(DEFAULT_MARKERS).join(", ")}`);
+}
+if (typeof status !== "string") {
+  usage("--status is required");
+}
+
+// Only a "passed" claim needs proof. failed / pending / anything else is honest
+// about not succeeding, so it passes through untouched.
+if (status !== "passed") {
+  ok(`status="${status}" is not a pass claim; nothing to substantiate`);
+}
+
+const evidence = args.evidence;
+if (!evidence || evidence === true) {
+  fail(`${claim} claims passed but no --evidence artifact was provided (default-FAIL)`);
+}
+if (!existsSync(evidence)) {
+  fail(`${claim} claims passed but evidence file does not exist: ${evidence} (default-FAIL)`);
+}
+let body = "";
+try {
+  if (statSync(evidence).size === 0) {
+    fail(`${claim} claims passed but evidence file is empty: ${evidence} (default-FAIL)`);
+  }
+  body = readFileSync(evidence, "utf-8");
+} catch (err) {
+  fail(`${claim} evidence unreadable: ${err.message} (default-FAIL)`);
+}
+if (body.trim().length === 0) {
+  fail(`${claim} claims passed but evidence file is blank: ${evidence} (default-FAIL)`);
+}
+
+const successRe = userRegExp(args["success-pattern"], DEFAULT_MARKERS[claim].success, "success");
+const failureRe = userRegExp(args["failure-pattern"], DEFAULT_MARKERS[claim].failure, "failure");
+
+const showsFailure = failureRe.test(body);
+const showsSuccess = successRe.test(body);
+
+// Failure is DECISIVE. A log that shows a definitive failure marker cannot
+// substantiate a "passed" claim no matter what else it contains - this closes
+// the bypass where a failing build log that also mentioned "SUCCESS" passed.
+if (showsFailure) {
+  fail(`${claim} evidence shows a failure marker  -  pass claim contradicted by ${evidence}`);
+}
+// No failure, but also no success marker -> unproven -> default-FAIL.
+if (!showsSuccess) {
+  fail(`${claim} evidence does not contain a success marker  -  pass claim unverified by ${evidence}`);
+}
+
+ok(`${claim} pass claim substantiated by ${evidence}`);

package/pipeline/scripts/fixtures/install-layout.tsv

@@ -1,16 +1,16 @@
 .claude/CLAUDE.md	1
 .claude/agents	8
-.claude/commands	78
-.claude/lib	18
+.claude/commands	87
+.claude/lib	23
 .claude/multi-agent-preferences.json	1
 .claude/rules	12
-.claude/schemas	20
-.claude/scripts	143
+.claude/schemas	23
+.claude/scripts	173
 .claude/settings.json	1
-.claude/skills	414
+.claude/skills	555
 .copilot/agents	8
 .copilot/copilot-instructions.md	1
-.copilot/lib	18
-.copilot/schemas	20
-.copilot/scripts	143
-.copilot/skills	444
+.copilot/lib	23
+.copilot/schemas	23
+.copilot/scripts	173
+.copilot/skills	590

package/pipeline/scripts/gc-tmp.sh

@@ -0,0 +1,102 @@
+#!/usr/bin/env bash
+# gc-tmp.sh  -  remove leftover /tmp scratch files from past pipeline runs.
+#
+# Each run writes ephemeral scratch under /tmp: picker state, PR/review diffs,
+# channel payloads, external-context bundles, and analysis drafts. These are
+# never cleaned up automatically (review.md traps its own, the rest linger), so
+# a long-lived machine accumulates them. This sweeps the known prefixes.
+#
+# SAFE BY DEFAULT: dry-run. It lists what WOULD be removed and the space it
+# would free, and deletes nothing until you pass --yes.
+#
+# Usage:
+#   gc-tmp.sh                      # dry-run: list matches + total size
+#   gc-tmp.sh --yes                # actually delete
+#   gc-tmp.sh --older-than=60      # only match items older than 60 minutes
+#   gc-tmp.sh --older-than=60 --yes
+#
+# Env:
+#   GC_TMP_ROOT   override the scratch root (default /tmp; tests set this)
+#
+# Exit: 0 on success, 2 on usage error. Always exits 0 when nothing matches.
+
+set -uo pipefail
+
+ROOT="${GC_TMP_ROOT:-/tmp}"
+DELETE=0
+OLDER_MIN=0
+
+usage() {
+  grep -E '^#( |$)' "$0" | sed -E 's/^# ?//'
+}
+
+for arg in "$@"; do
+  case "$arg" in
+    --yes | --force) DELETE=1 ;;
+    --older-than=*)
+      OLDER_MIN="${arg#*=}"
+      if ! printf '%s' "$OLDER_MIN" | grep -qE '^[0-9]+$'; then
+        echo "gc-tmp: --older-than needs a whole number of minutes, got: $OLDER_MIN" >&2
+        exit 2
+      fi
+      ;;
+    -h | --help)
+      usage
+      exit 0
+      ;;
+    *)
+      echo "gc-tmp: unknown argument: $arg" >&2
+      exit 2
+      ;;
+  esac
+done
+
+# Scratch prefixes the pipeline writes under $ROOT (see jira.md, review.md,
+# update-issue-progress.sh, channels/*.md, external-context-injection.md,
+# analysis.md). maxdepth 1 so we never descend into unrelated trees.
+NAME_ARGS=(
+  -name 'multi-agent-*'
+  -o -name 'issue-progress-*'
+  -o -name 'channels-*'
+  -o -name 'context-links-*'
+  -o -name 'context-by-type-*'
+  -o -name 'analysis-*'
+)
+
+MTIME_ARGS=()
+if [ "$OLDER_MIN" -gt 0 ]; then
+  MTIME_ARGS=(-mmin "+$OLDER_MIN")
+fi
+
+matches=()
+while IFS= read -r -d '' p; do
+  matches+=("$p")
+done < <(find "$ROOT" -maxdepth 1 \( "${NAME_ARGS[@]}" \) ${MTIME_ARGS[@]+"${MTIME_ARGS[@]}"} -print0 2>/dev/null)
+
+if [ "${#matches[@]}" -eq 0 ]; then
+  echo "gc-tmp: no leftover scratch under $ROOT  -  nothing to do"
+  exit 0
+fi
+
+# Total size (KB), portable across BSD/GNU du.
+total_kb=0
+for p in "${matches[@]}"; do
+  kb=$(du -sk "$p" 2>/dev/null | awk '{print $1}')
+  total_kb=$((total_kb + ${kb:-0}))
+done
+human="${total_kb} KB"
+[ "$total_kb" -ge 1024 ] && human="$((total_kb / 1024)) MB"
+
+if [ "$DELETE" -eq 0 ]; then
+  echo "DRY-RUN  -  would remove ${#matches[@]} item(s) under $ROOT (frees ~${human}):"
+  for p in "${matches[@]}"; do echo "  $p"; done
+  echo "Re-run with --yes to delete."
+  exit 0
+fi
+
+removed=0
+for p in "${matches[@]}"; do
+  rm -rf "$p" 2>/dev/null && removed=$((removed + 1))
+done
+echo "══ garbage-collect: removed ${removed}/${#matches[@]} item(s), freed ~${human} ══"
+exit 0

package/pipeline/scripts/gen-mode-dispatch.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * gen-mode-dispatch.mjs — emit the canonical Phase Tracker Contract block
+ * gen-mode-dispatch.mjs  -  emit the canonical Phase Tracker Contract block
  * for a given mode dispatch file (dev / dev-local / autopilot / local / etc).
  *
  * v8.0.0 introduced this generator as the single source of truth for the
@@ -10,7 +10,7 @@
  * call, anti-pattern warning, and ref link are identical.
  *
  * Usage:
- *   node pipeline/scripts/gen-mode-dispatch.mjs --mode=dev          # 0/3/5/6/7 (User Test kept — autopilot/local variants skip 5)
+ *   node pipeline/scripts/gen-mode-dispatch.mjs --mode=dev          # 0/3/5/6/7 (Phase 5 User Test runs only in dev + full; autopilot/local variants drop it)
  *   node pipeline/scripts/gen-mode-dispatch.mjs --mode=full         # 0..7
  *   node pipeline/scripts/gen-mode-dispatch.mjs --mode=full-local   # 0..7
  *   node pipeline/scripts/gen-mode-dispatch.mjs --mode=dev-local    # 0/3/6/7 + local-mode caveat
@@ -39,6 +39,12 @@ const PHASE_NAMES = [
   "7:Report",
 ];
 
+// Phase 5 (User Test) checks out the change from the git worktree and hands it
+// to the user interactively. It therefore only runs when the mode is BOTH
+// interactive (not autopilot) AND worktree-backed (not local). So only `dev`
+// and `full` keep it; every autopilot or local variant drops it.
+const PHASE_NAMES_NO_TEST = PHASE_NAMES.filter((p) => p !== "5:Test");
+
 /**
  * Mode → phases + flag descriptor. The descriptor controls the autopilot /
  * local caveat banners. Each mode dispatch file under
@@ -51,11 +57,11 @@ const MODES = {
   "dev-autopilot":        { phases: ["0:Init", "3:Dev", "6:Commit", "7:Report"], local: false, autopilot: true  },
   "dev-local":            { phases: ["0:Init", "3:Dev", "6:Commit", "7:Report"], local: true,  autopilot: false },
   "dev-local-autopilot":  { phases: ["0:Init", "3:Dev", "6:Commit", "7:Report"], local: true,  autopilot: true  },
-  autopilot:              { phases: PHASE_NAMES, local: false, autopilot: true  },
+  autopilot:              { phases: PHASE_NAMES_NO_TEST, local: false, autopilot: true  },
   full:                   { phases: PHASE_NAMES, local: false, autopilot: false },
-  local:                  { phases: PHASE_NAMES, local: true,  autopilot: false },
-  "local-autopilot":      { phases: PHASE_NAMES, local: true,  autopilot: true  },
-  "full-local":           { phases: PHASE_NAMES, local: true,  autopilot: false },
+  local:                  { phases: PHASE_NAMES_NO_TEST, local: true,  autopilot: false },
+  "local-autopilot":      { phases: PHASE_NAMES_NO_TEST, local: true,  autopilot: true  },
+  "full-local":           { phases: PHASE_NAMES_NO_TEST, local: true,  autopilot: false },
 };
 
 const spec = MODES[MODE];
@@ -72,7 +78,7 @@ const activeIds = spec.phases.map((p) => p.split(":")[0]);
 const skippedIds = ALL_PHASE_IDS.filter((id) => !activeIds.includes(id));
 const phaseSequence = activeIds.map((id) => `Phase ${id}`).join(" → ");
 
-// Mode label for prose — how to refer to the mode in the TaskCreate paragraph.
+// Mode label for prose  -  how to refer to the mode in the TaskCreate paragraph.
 const MODE_LABELS = {
   "dev":                  "`--dev`",
   "dev-autopilot":        "`--dev autopilot`",
@@ -88,22 +94,22 @@ const modeLabel = MODE_LABELS[MODE] ?? `\`${MODE}\``;
 
 // Prose for the skip-set + ordering paragraphs.
 const skipNote = skippedIds.length > 0
-  ? `${modeLabel} mode does NOT TaskCreate phases ${skippedIds.join("/")} — those are not part of the ${modeLabel} phase set (\`${spec.phases.join(" ")}\`). Only register tiles for the active set.`
+  ? `${modeLabel} mode does NOT TaskCreate phases ${skippedIds.join("/")}  -  those are not part of the ${modeLabel} phase set (\`${spec.phases.join(" ")}\`). Only register tiles for the active set.`
   : `${modeLabel} mode TaskCreates all 8 phases (no phase is skipped).`;
 
-const orderingNote = `**All TaskCreate calls fire in strict phase-number order BEFORE any TaskUpdate is applied.** For ${modeLabel} that means: ${phaseSequence}. The native widget renders by creation order, not by phase number — out-of-order calls produce visually scrambled tile stacks. Full ordering contract in \`refs/tracker-contract.md\` § "TaskCreate ordering (strict)".`;
+const orderingNote = `**All TaskCreate calls fire in strict phase-number order BEFORE any TaskUpdate is applied.** For ${modeLabel} that means: ${phaseSequence}. The native widget renders by creation order, not by phase number  -  out-of-order calls produce visually scrambled tile stacks. Full ordering contract in \`refs/tracker-contract.md\` section "TaskCreate ordering (strict)".`;
 
 const localCaveat = spec.local
-  ? `\n> **Local mode:** no worktree is created, work happens on the current branch. Phase 0 Init still calls \`init\` — the \`--local\` flag is stored in tracker-state.json, and \`:resume\` restores the correct CWD.\n`
+  ? `\n> **Local mode:** no worktree is created, work happens on the current branch. Phase 0 Init still calls \`init\`  -  the \`--local\` flag is stored in tracker-state.json, and \`:resume\` restores the correct CWD.\n`
   : "";
 
 const banner = spec.autopilot
-  ? `\n> **Autopilot mode:** user confirmations are skipped. The tracker is still mandatory — autopilot agent calls cannot skip it; skipping breaks \`smoke-tracker-contract.sh\`.\n`
+  ? `\n> **Autopilot mode:** user confirmations are skipped. The tracker is still mandatory  -  autopilot agent calls cannot skip it; skipping breaks \`smoke-tracker-contract.sh\`.\n`
   : "";
 
 const out = `## Required: Phase Tracker Contract
 
-**The phase tracker is mandatory** — the agent cannot skip it. Full spec: [\`refs/tracker-contract.md\`](./refs/tracker-contract.md).
+**The phase tracker is mandatory**  -  the agent cannot skip it. Full spec: [\`refs/tracker-contract.md\`](./refs/tracker-contract.md).
 ${banner}${localCaveat}
 Two channels run in parallel at every phase boundary:
 
@@ -125,27 +131,27 @@ bash $HOME/.claude/scripts/phase-tracker.sh update <N> in_progress|completed|fai
 bash $HOME/.claude/scripts/phase-tracker.sh tokens <N> <in> <out>
 \`\`\`
 
-### Visual channel — Claude Code (native TaskList widget, required)
+### Visual channel  -  Claude Code (native TaskList widget, required)
 
-In Claude Code the agent MUST also drive the native TaskList widget so the user sees a sticky phase tile stack — this is the only progress signal Claude Code surfaces. Skipping these calls is the #1 source of "I don't see any phases" complaints.
+In Claude Code the agent MUST also drive the native TaskList widget so the user sees a sticky phase tile stack  -  this is the only progress signal Claude Code surfaces. Skipping these calls is the #1 source of "I don't see any phases" complaints.
 
-**TaskCreate ordering (strict)**: All TaskCreate calls fire in strict phase-number order BEFORE any TaskUpdate is applied. The native widget renders by creation order, not by phase number — out-of-order calls produce visually scrambled tile stacks (e.g. \`1 ✓ · 2 ✓ · 4 ✓ · 0 ▶ · 3 ☐\`) even when the underlying state is correct. Pre-marking phases as completed/skipped before Phase 0 starts is FORBIDDEN — register the tile in order, then flip status via TaskUpdate when the phase actually short-circuits. Full contract in \`refs/tracker-contract.md\` § "TaskCreate ordering (strict)".
+**TaskCreate ordering (strict)**: All TaskCreate calls fire in strict phase-number order BEFORE any TaskUpdate is applied. The native widget renders by creation order, not by phase number  -  out-of-order calls produce visually scrambled tile stacks (e.g. \`1 ✓ · 2 ✓ · 4 ✓ · 0 ▶ · 3 ☐\`) even when the underlying state is correct. Pre-marking phases as completed/skipped before Phase 0 starts is FORBIDDEN  -  register the tile in order, then flip status via TaskUpdate when the phase actually short-circuits. Full contract in \`refs/tracker-contract.md\` section "TaskCreate ordering (strict)".
 
 \`\`\`text
-# Phase 0 startup — register one tile per phase (0..N), capture the taskId, persist it:
+# Phase 0 startup  -  register one tile per phase (0..N), capture the taskId, persist it:
 for each phase in ${spec.phases.join(", ")}:
   TaskCreate({ subject: "Phase <N>: <Name>", activeForm: "<doing-form>" })
     -> returns taskId
   bash $HOME/.claude/scripts/phase-tracker.sh meta <N> tasklist_id "<taskId>"
 
-# Phase entry — flip the tile to in_progress alongside the state update:
+# Phase entry  -  flip the tile to in_progress alongside the state update:
 TaskUpdate({ taskId: <saved>, status: "in_progress" })
 bash $HOME/.claude/scripts/phase-tracker.sh update <N> in_progress
 
-# Active sub-step inside a phase — update activeForm so the spinner header reflects what's happening now:
+# Active sub-step inside a phase  -  update activeForm so the spinner header reflects what's happening now:
 TaskUpdate({ taskId: <saved>, activeForm: "Editing TopBarView.swift" })
 
-# Phase exit — flip to completed/failed/skipped on both channels:
+# Phase exit  -  flip to completed/failed/skipped on both channels:
 TaskUpdate({ taskId: <saved>, status: "completed" })
 bash $HOME/.claude/scripts/phase-tracker.sh update <N> completed
 \`\`\`
@@ -156,7 +162,7 @@ ${skipNote}
 
 ${orderingNote}
 
-### Visual channel — Copilot CLI / Cursor / Windsurf / plain shell
+### Visual channel  -  Copilot CLI / Cursor / Windsurf / plain shell
 
 These CLIs have no TaskList widget. After every state change the agent calls render, which prints a bordered ANSI card as the last tool result so the user sees an updated phase table:
 
@@ -164,7 +170,7 @@ These CLIs have no TaskList widget. After every state change the agent calls ren
 bash $HOME/.claude/scripts/phase-tracker.sh render
 \`\`\`
 
-Do NOT call TaskCreate on these CLIs — the tool does not exist and the call fails.
+Do NOT call TaskCreate on these CLIs  -  the tool does not exist and the call fails.
 `;
 
 process.stdout.write(out);

package/pipeline/scripts/gen-skills-index.mjs

@@ -63,15 +63,15 @@ const breakdown = GROUPS.map((g) => `${counts[g]} ${g}`).join(" + ");
 
 let md = `# Shared Skills Index\n\n`;
 md += `Single source of truth for skills delivered to both Claude Code (\`~/.claude/skills/\`) and Copilot CLI (\`~/.copilot/skills/\`) by the installer.\n\n`;
-md += `**Total:** ${total} skills (${breakdown}). Auto-generated by \`scripts/gen-skills-index.mjs\` — do not edit by hand.\n\n`;
+md += `**Total:** ${total} skills (${breakdown}). Auto-generated by \`scripts/gen-skills-index.mjs\`  -  do not edit by hand.\n\n`;
 md += `## Directory layout\n\n`;
-md += `- **\`core/\`** — ${counts.core} \`multi-agent*\` orchestration skills that are pipeline-critical. Edits here are core-code changes.\n`;
-md += `- **\`external/\`** — ${counts.external} iOS / Android / generic skills imported from the upstream skill library. Mirrors of third-party guidance.\n`;
+md += `- **\`core/\`**  -  ${counts.core} \`multi-agent*\` orchestration skills that are pipeline-critical. Edits here are core-code changes.\n`;
+md += `- **\`external/\`**  -  ${counts.external} iOS / Android / generic skills imported from the upstream skill library. Mirrors of third-party guidance.\n`;
 md += `- Install destination stays flat: both trees flatten into \`~/.claude/skills/\` and \`~/.copilot/skills/\`. See ADR-0006 for the rationale.\n\n`;
-md += `Source layout is logical grouping only — skill discovery at runtime is unchanged.\n\n`;
+md += `Source layout is logical grouping only  -  skill discovery at runtime is unchanged.\n\n`;
 md += `## Categories\n\n`;
 for (const k of order) {
-  md += `- [${titles[k]}](#${titles[k].toLowerCase().replace(/[^a-z0-9]+/g, "-")}) — ${buckets[k].length}\n`;
+  md += `- [${titles[k]}](#${titles[k].toLowerCase().replace(/[^a-z0-9]+/g, "-")})  -  ${buckets[k].length}\n`;
 }
 md += `\n`;
 for (const k of order) {
@@ -80,7 +80,7 @@ for (const k of order) {
   md += `| Skill | Group | Description |\n|-------|-------|-------------|\n`;
   for (const { name, group, desc } of buckets[k]) {
     const safeDesc = desc.replace(/\|/g, "\\|").replace(/\n/g, " ");
-    md += `| [\`${name}\`](./${group}/${name}/) | \`${group}\` | ${safeDesc || "—"} |\n`;
+    md += `| [\`${name}\`](./${group}/${name}/) | \`${group}\` | ${safeDesc || " - "} |\n`;
   }
   md += `\n`;
 }

package/pipeline/scripts/github-ssh-setup.sh

@@ -80,7 +80,7 @@ elif command -v xclip >/dev/null 2>&1; then
   xclip -selection clipboard < "${KEY_PATH}.pub"
   echo "[Otomatik olarak panoya kopyalandı! (xclip)]"
 else
-  echo "[Panoya kopyalanamadı — yukarıdaki anahtarı manuel kopyalayın]"
+  echo "[Panoya kopyalanamadı  -  yukarıdaki anahtarı manuel kopyalayın]"
 fi
 
 echo ""

package/pipeline/scripts/keychain-save.sh

@@ -6,7 +6,7 @@ set -uo pipefail
 # Örnek:    ./keychain-save.sh github-pat
 #           ./keychain-save.sh firebase-sa
 
-SERVICE_NAME="$1"
+SERVICE_NAME="${1:-}"
 
 if [ -z "$SERVICE_NAME" ]; then
     echo "Kullanım: $0 <service-adı>"

package/pipeline/scripts/keychain.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 """
-keychain.py — deterministic Keychain helper, Python counterpart to credential-store.sh.
+keychain.py  -  deterministic Keychain helper, Python counterpart to credential-store.sh.
 
 Purpose
 -------
@@ -102,7 +102,7 @@ def doctor() -> dict:
         return {
             "platform": pf,
             "backend_ok": ok,
-            "remediation": None if ok else "macOS Keychain CLI missing — /usr/bin/security should ship with macOS; reinstall Command Line Tools.",
+            "remediation": None if ok else "macOS Keychain CLI missing  -  /usr/bin/security should ship with macOS; reinstall Command Line Tools.",
         }
     if pf == "linux":
         ok = shutil.which("secret-tool") is not None
@@ -142,7 +142,7 @@ def get(label: str, account: Optional[str] = None) -> Optional[str]:
         rc, out, _ = _run(["/usr/bin/security", "find-generic-password", "-a", acct, "-s", label, "-w"])
         if rc == 0:
             return out.decode("utf-8", errors="replace").rstrip("\n")
-        # account-agnostic last resort — some entries were written without -a
+        # account-agnostic last resort  -  some entries were written without -a
         rc, out, _ = _run(["/usr/bin/security", "find-generic-password", "-l", label, "-w"])
         if rc == 0:
             return out.decode("utf-8", errors="replace").rstrip("\n")
@@ -150,7 +150,7 @@ def get(label: str, account: Optional[str] = None) -> Optional[str]:
         if rc == 0:
             return out.decode("utf-8", errors="replace").rstrip("\n")
         return None
-    # linux / secret-tool — store under both `label` and `service` schema attrs
+    # linux / secret-tool  -  store under both `label` and `service` schema attrs
     rc, out, _ = _run(["secret-tool", "lookup", "label", label, "account", acct])
     if rc == 0:
         return out.decode("utf-8", errors="replace").rstrip("\n")
@@ -181,7 +181,7 @@ def set_(label: str, value: str, account: Optional[str] = None) -> None:
             sys.stderr.write(err.decode("utf-8", errors="replace"))
             sys.exit(4)
         return
-    # linux / secret-tool — store reads the secret from stdin; tag both schema attrs
+    # linux / secret-tool  -  store reads the secret from stdin; tag both schema attrs
     rc, _, err = _run(
         ["secret-tool", "store", "--label", label, "label", label, "service", label, "account", acct],
         input_value=value.encode("utf-8"),
@@ -253,7 +253,7 @@ def main(argv: list[str]) -> int:
 
     s = sub.add_parser("set")
     s.add_argument("label")
-    s.add_argument("value", help="Use '-' to read from stdin (preferred — keeps secrets out of shell history).")
+    s.add_argument("value", help="Use '-' to read from stdin (preferred  -  keeps secrets out of shell history).")
     s.add_argument("--account")
 
     d = sub.add_parser("delete")