harnessed 3.4.3 → 3.5.0

package/dist/cli.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { execSync, spawnSync, spawn } from 'child_process';
-import { existsSync, mkdirSync, renameSync, writeFileSync, readFileSync, readdirSync, appendFileSync } from 'fs';
-import { join, resolve, dirname, relative } from 'path';
+import { existsSync, mkdirSync, renameSync, writeFileSync, readFileSync, readdirSync } from 'fs';
+import { join, dirname, resolve, relative } from 'path';
 import { homedir } from 'os';
 import { Type } from '@sinclair/typebox';
 import { Value } from '@sinclair/typebox/value';
@@ -13,6 +13,7 @@ import { Ajv } from 'ajv';
 import * as ajvFormatsNs from 'ajv-formats';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
+import { Parser } from 'expr-eval';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import * as p from '@clack/prompts';
 import { createPatch } from 'diff';
@@ -688,6 +689,11 @@ async function activate(phase, checkpointPath = null) {
     started_at: (/* @__PURE__ */ new Date()).toISOString()
   });
 }
+async function pause() {
+  const s = await readCurrentWorkflow();
+  if (!s) return;
+  await writeCurrentWorkflow({ ...s, status: "paused", paused_at: (/* @__PURE__ */ new Date()).toISOString() });
+}
 async function complete() {
   const s = await readCurrentWorkflow();
   if (!s) return;
@@ -847,7 +853,7 @@ var init_resume = __esm({
 
 // package.json
 var package_default = {
-  version: "3.4.3"};
+  version: "3.5.0"};
 
 // src/manifest/errors.ts
 function instancePathToKeyPath(instancePath) {
@@ -1698,7 +1704,7 @@ function renderHumanTable(records) {
   }
 }
 function pipeToJq(filterExpr, lines) {
-  return new Promise((resolve12, reject) => {
+  return new Promise((resolve14, reject) => {
     const child = spawn("jq", [filterExpr], {
       stdio: ["pipe", "inherit", "inherit"],
       windowsHide: true
@@ -1707,12 +1713,12 @@ function pipeToJq(filterExpr, lines) {
       const e = err2;
       if (e.code === "ENOENT") {
         console.error(t("audit_log.jq_missing"));
-        resolve12(1);
+        resolve14(1);
       } else {
         reject(err2);
       }
     });
-    child.on("close", (code) => resolve12(code ?? 0));
+    child.on("close", (code) => resolve14(code ?? 0));
     child.stdin.write(lines.join("\n"));
     child.stdin.end();
   });
@@ -2137,6 +2143,14 @@ var Discipline = Type.Object(
 );
 
 // src/workflow/disciplineLoader.ts
+var DEFAULT_APPLIED = [
+  "karpathy",
+  "output-style",
+  "language",
+  "operational",
+  "priority",
+  "protocols"
+];
 var _cache = /* @__PURE__ */ new Map();
 async function loadDiscipline(basename2, packageRoot) {
   const cached = _cache.get(basename2);
@@ -2152,12 +2166,20 @@ async function loadDiscipline(basename2, packageRoot) {
   _cache.set(basename2, parsed);
   return parsed;
 }
+async function loadAllApplied(disciplines_applied, packageRoot) {
+  const applied = disciplines_applied && disciplines_applied.length > 0 ? disciplines_applied : DEFAULT_APPLIED;
+  const out = /* @__PURE__ */ new Map();
+  for (const basename2 of applied) {
+    out.set(basename2, await loadDiscipline(basename2, packageRoot));
+  }
+  return out;
+}
 
 // src/discipline/enforcement/before-commit.ts
 var TS_JS_RE = /\.(ts|tsx|js|mjs)$/;
 async function runBeforeCommitHook(ctx) {
   const d = await loadDiscipline("operational", ctx.packageRoot);
-  if (ctx.changedFiles.some((f) => TS_JS_RE.test(f))) {
+  if (ctx.cmdType === "git-commit" && ctx.changedFiles.some((f) => TS_JS_RE.test(f))) {
     const rule = d.rules.find((r) => r.id === "biome-preempt");
     if (rule?.auto_fix_cmd) {
       console.warn("\u26A0\uFE0F biome preempt \u2014 running auto-fix before commit");
@@ -2168,341 +2190,10 @@ async function runBeforeCommitHook(ctx) {
     console.error("\u274C no-skip-hooks violated: --no-verify forbidden");
     process.exit(2);
   }
-}
-
-// src/routing/completionSchema.ts
-var COMPLETION_SCHEMA = {
-  type: "object",
-  properties: {
-    status: { type: "string", enum: ["COMPLETE", "PARTIAL", "BLOCKED"] },
-    phase: { type: "string", enum: ["01-clarify", "02-code", "03-test", "04-deliver"] },
-    summary: { type: "string" },
-    blockers: { type: "array", items: { type: "string" } }
-  },
-  required: ["status", "phase"]
-};
-
-// src/routing/systemPrompt.ts
-`## RULE: subagent COMPLETE marker
-When you spawn a subagent and it returns a final message:
-1. **DO NOT summarize, paraphrase, or interpret the subagent's final message**
-2. **DO NOT skip or omit the COMPLETE marker**
-3. The subagent will emit \`<promise>COMPLETE</promise>\` (exact verbatim XML wrapper) when done
-4. You MUST verbatim grep \`<promise>COMPLETE</promise>\` from final message \u2192 if present, treat task as done
-5. If \`<promise>COMPLETE</promise>\` absent \u2192 re-spawn subagent (max 20 iterations); after max, throw VerbatimCompleteFailError
-
-## skills fail-fast handling
-- SkillNotInstalledError \u2192 print user-friendly fix command (e.g., "Run: harnessed install <name>")
-- RestartRequiredError \u2192 print "\u8BF7 exit + restart Claude Code \u8BA9 plugin \u751F\u6548"
-
-## \u515C\u5E95 max-iterations
-- max-iterations 20 (external ralph-loop) \xD7 maxTurns 50 (internal AgentDefinition) = 1000 round-trips worst case
-
-## Completion signal (dual-signal \u2014 emit BOTH)
-If \`outputFormat: { type: 'json_schema' }\` is set on this query, emit a final-turn output conforming to the schema (status/phase/summary/blockers \u2014 keys: ${Object.keys(COMPLETION_SCHEMA.properties).join(", ")}).
-AND emit \`<promise>COMPLETE</promise>\` (FALLBACK signal \u2014 required regardless of structured output presence, for inner-layer subagent completion detection per RESEARCH \xA7 1.3).
-`;
-var COMPLETE_INSTRUCTION = `## CRITICAL RULE: COMPLETE marker
-When your task is done, emit the exact verbatim XML wrapper
-\`<promise>COMPLETE</promise>\` on its own line and nothing else after it. Do
-NOT emit any other variant \u2014 not "completed", not "DONE", not bare \`COMPLETE\`,
-not "\u2705". The parent agent will verbatim grep \`<promise>COMPLETE</promise>\` \u2014
-any deviation fails the round-trip and forces a re-spawn (max 20 iterations).
-`;
-
-// src/routing/agentDefinition.ts
-var SkillNotInstalledError = class extends Error {
-  constructor(skill) {
-    super(`Skill not installed: ${skill}. Run: harnessed install ${skill} --apply`);
-    this.skill = skill;
-    this.name = "SkillNotInstalledError";
-  }
-  skill;
-};
-var InvalidDecisionError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InvalidDecisionError";
-  }
-};
-var MissingSkillsError = class extends Error {
-  constructor(missing) {
-    super(`Required skills missing: ${missing.join(", ")}`);
-    this.missing = missing;
-    this.name = "MissingSkillsError";
-  }
-  missing;
-};
-var RestartRequiredError = class extends Error {
-  constructor(hint) {
-    super(hint);
-    this.hint = hint;
-    this.name = "RestartRequiredError";
-  }
-  hint;
-};
-var KARPATHY_BASELINE = `## \u5FC3\u6CD5 (always-on baseline)
-- Think Before Coding: read, plan, then write \u2014 never write before understanding.
-- Simplicity First: minimum effective code; avoid unnecessary abstraction.
-- Surgical Changes: small atomic edits; keep history clean.
-- Goal-Driven Execution: each step earns its place by satisfying a goal.
-`;
-async function createAgent(task, decision, opts = {}) {
-  if (!decision.primary_expert) {
-    throw new InvalidDecisionError("decision.primary_expert is required (got null)");
-  }
-  const skillsRoot = opts.skillsRoot ?? join(homedir(), ".claude", "skills");
-  const requested = decision.required_skills ?? (decision.primary_expert ? [decision.primary_expert] : []);
-  const isInstalled2 = (name) => existsSync(join(skillsRoot, name, "SKILL.md"));
-  const missing = requested.filter((s) => !isInstalled2(s));
-  if (missing.length === requested.length && requested.length > 0) {
-    throw new MissingSkillsError(missing);
-  }
-  if (missing.length > 0) {
-    throw new SkillNotInstalledError(missing[0]);
-  }
-  const promptBody = `${KARPATHY_BASELINE}
-## \u4EFB\u52A1
-${task.task}
-
-${COMPLETE_INSTRUCTION}`;
-  return {
-    description: `Routing-engine spawned subagent (${decision.category}) \u2014 primary: ${decision.primary_expert}`,
-    prompt: promptBody,
-    tools: ["Read", "Grep", "Glob", "Bash", "Edit", "Write"],
-    disallowedTools: decision.forbidden_skills?.map((s) => `Skill(${s})`),
-    model: opts.modelOverride ?? process.env.HARNESSED_AGENT_MODEL ?? "inherit",
-    skills: requested,
-    mcpServers: void 0,
-    memory: "project",
-    maxTurns: opts.maxTurnsOverride ?? 50,
-    background: false,
-    effort: opts.effortOverride ?? "medium",
-    permissionMode: opts.permissionModeOverride ?? "default",
-    // v1.1 errata (ADR 0009 § Decision Errata 1) — `initialPrompt` carries the
-    // task body for the plugin-main-thread upgrade path;
-    // `criticalSystemReminder_EXPERIMENTAL` re-asserts the verbatim
-    // <promise>COMPLETE</promise> contract at the system-prompt layer.
-    initialPrompt: task.task,
-    criticalSystemReminder_EXPERIMENTAL: COMPLETE_INSTRUCTION
-  };
-}
-
-// src/routing/dag.ts
-function resolveDag(nodes) {
-  const ids = new Set(nodes.map((n) => n.id));
-  const adj = /* @__PURE__ */ new Map();
-  const indegree = /* @__PURE__ */ new Map();
-  for (const id of ids) {
-    adj.set(id, []);
-    indegree.set(id, 0);
-  }
-  for (const node of nodes) {
-    for (const dep of node.deps) {
-      if (!ids.has(dep)) continue;
-      adj.get(dep)?.push(node.id);
-      indegree.set(node.id, (indegree.get(node.id) ?? 0) + 1);
-    }
-  }
-  const queue = [];
-  for (const [id, deg] of indegree) {
-    if (deg === 0) queue.push(id);
-  }
-  queue.sort();
-  const order = [];
-  while (queue.length > 0) {
-    const id = queue.shift();
-    order.push(id);
-    let exposed = false;
-    for (const dependent of adj.get(id) ?? []) {
-      const next = (indegree.get(dependent) ?? 0) - 1;
-      indegree.set(dependent, next);
-      if (next === 0) {
-        queue.push(dependent);
-        exposed = true;
-      }
-    }
-    if (exposed) queue.sort();
-  }
-  if (order.length !== ids.size) {
-    const cycle = [];
-    for (const [id, deg] of indegree) {
-      if (deg > 0) cycle.push(id);
-    }
-    cycle.sort();
-    return { ok: false, cycle };
-  }
-  return { ok: true, order };
-}
-var Domain = Type.Union([
-  Type.Literal("meta"),
-  Type.Literal("engineering"),
-  Type.Literal("design"),
-  Type.Literal("content"),
-  Type.Literal("testing"),
-  Type.Literal("search")
-]);
-var HitPolicy = Type.Union([Type.Literal("P"), Type.Literal("F"), Type.Literal("U")]);
-var Str1 = Type.String({ minLength: 1 });
-var ObjStrict = (p4) => Type.Object(p4, { additionalProperties: false });
-var RuleSchema = ObjStrict({
-  id: Str1,
-  priority: Type.Integer({ minimum: 0 }),
-  domain: Domain,
-  when: Type.Record(Type.String(), Type.Unknown()),
-  decision: Type.Record(Type.String(), Type.Unknown())
-});
-var PhaseEntrySchema = ObjStrict({
-  skills: Type.Array(Str1, { minItems: 1 }),
-  triggers: Type.Array(Str1, { minItems: 1 })
-});
-var MattpocockPhasesSchema = ObjStrict({
-  discuss: PhaseEntrySchema,
-  plan: PhaseEntrySchema,
-  execute: PhaseEntrySchema,
-  verify: PhaseEntrySchema
-});
-var DecisionRulesFileSchema = ObjStrict({
-  // v2 additive (D1.5-10): accept v1 OR v2 — schema stays backward compatible.
-  version: Type.Union([Type.Literal(1), Type.Literal(2)]),
-  hit_policy: HitPolicy,
-  rules: Type.Array(RuleSchema, { minItems: 1 }),
-  // v2 — optional mattpocock_phases map; absent in v1 files.
-  mattpocock_phases: Type.Optional(MattpocockPhasesSchema),
-  fallback_supervisor: Type.Optional(ObjStrict({ trigger: Str1, llm: Str1 })),
-  deprecated: Type.Optional(Type.Array(ObjStrict({ id: Str1, reason: Str1, fallback: Str1 })))
-});
-var ajv2 = new Ajv({ strict: true, allErrors: true, allowUnionTypes: false });
-var _compiled2 = null;
-function getValidator2() {
-  if (!_compiled2) _compiled2 = ajv2.compile(DecisionRulesFileSchema);
-  return _compiled2;
-}
-function scanShellInjection(node, path = "") {
-  if (typeof node === "string") {
-    const hit = checkCmdString(node);
-    return hit ? `${path || "<root>"}: ${hit.label} (${hit.hint})` : null;
-  }
-  if (Array.isArray(node)) {
-    for (let i = 0; i < node.length; i++) {
-      const v = scanShellInjection(node[i], `${path}[${i}]`);
-      if (v) return v;
-    }
-    return null;
-  }
-  if (node && typeof node === "object") {
-    for (const [k, v] of Object.entries(node)) {
-      const hit = scanShellInjection(v, path ? `${path}.${k}` : k);
-      if (hit) return hit;
-    }
-  }
-  return null;
-}
-function loadDecisionRules(yamlPath) {
-  const doc = parseDocument(readFileSync(yamlPath, "utf8"));
-  if (doc.errors.length > 0) {
-    throw new Error(`decision_rules yaml parse error: ${doc.errors[0]?.message}`);
-  }
-  const data = doc.toJS();
-  const validate = getValidator2();
-  if (!validate(data)) {
-    const e = validate.errors?.[0];
-    throw new Error(`decision_rules schema invalid: ${e?.instancePath || "/"} ${e?.message}`);
-  }
-  const inj = scanShellInjection(data);
-  if (inj) throw new Error(`decision_rules security violation: ${inj}`);
-  return data;
-}
-function arbitrate(rules, task) {
-  const matches = rules.filter((r) => matchesWhen(r.when, task));
-  const [top, second] = [...matches].sort((a, b) => b.priority - a.priority);
-  if (!top) return null;
-  if (second && second.priority === top.priority) return null;
-  return top;
-}
-var ARRAY_TRIGGER_FIELDS = /* @__PURE__ */ new Set(["keywords", "signals", "override_keywords"]);
-function taskHas(task, needle, extraKey) {
-  const n = needle.toLowerCase();
-  const prompt = typeof task.prompt === "string" ? task.prompt.toLowerCase() : "";
-  if (prompt.includes(n)) return true;
-  const sources = [];
-  if (Array.isArray(task.signals)) sources.push(...task.signals);
-  if (extraKey && extraKey !== "signals" && Array.isArray(task[extraKey])) {
-    sources.push(...task[extraKey]);
-  }
-  return sources.some((s) => typeof s === "string" && s.toLowerCase().includes(n));
-}
-function matchesWhen(when, task) {
-  for (const [k, v] of Object.entries(when)) {
-    if (ARRAY_TRIGGER_FIELDS.has(k) && Array.isArray(v)) {
-      if (!v.some((kw) => typeof kw === "string" && taskHas(task, kw, k))) return false;
-      continue;
-    }
-    if (Array.isArray(v)) {
-      if (!v.includes(task[k])) return false;
-      continue;
-    }
-    if (task[k] !== v) return false;
+  if (ctx.cmdType === "git-push" && !ctx.hasUserApproval) {
+    console.error("\u274C no-push-without-approval: user explicit approval required");
+    process.exit(2);
   }
-  return true;
-}
-
-// src/audit/log.ts
-init_harnessedRoot();
-function auditPath2() {
-  return harnessedFile("audit.log");
-}
-Type.Object(
-  {
-    ts: Type.String(),
-    phase: Type.String(),
-    task_excerpt: Type.String(),
-    task_sha1: Type.String(),
-    matched_rule_id: Type.Union([Type.String(), Type.Null()]),
-    primary_expert: Type.Union([Type.String(), Type.Null()]),
-    secondary_expert: Type.Union([Type.String(), Type.Null()]),
-    category: Type.String(),
-    route_layer: Type.String(),
-    outcome: Type.String(),
-    session_id: Type.Union([Type.String(), Type.Null()]),
-    iter_count: Type.Union([Type.Number(), Type.Null()])
-  },
-  { additionalProperties: false }
-);
-function buildAuditRecord(task, decision, matched, ctx) {
-  return {
-    ts: (/* @__PURE__ */ new Date()).toISOString(),
-    phase: task.phaseId ?? "unknown",
-    task_excerpt: task.task.slice(0, 200),
-    task_sha1: createHash("sha1").update(task.task).digest("hex"),
-    matched_rule_id: matched?.id ?? null,
-    primary_expert: decision.primary_expert ?? null,
-    secondary_expert: decision.secondary_expert ?? null,
-    category: decision.category,
-    route_layer: ctx.routeLayer,
-    outcome: ctx.outcome,
-    session_id: ctx.sessionId ?? null,
-    iter_count: ctx.iterCount
-  };
-}
-function emitAuditRecord(record) {
-  const path = auditPath2();
-  mkdirSync(dirname(path), { recursive: true });
-  appendFileSync(path, `${JSON.stringify(record)}
-`);
-}
-
-// src/audit/hook.ts
-function emitAudit(task, decision, matched, outcome, sessionId) {
-  emitAuditRecord(
-    buildAuditRecord(task, decision, matched, {
-      outcome,
-      routeLayer: matched ? "L1-keyword" : "L3-fallback",
-      sessionId,
-      iterCount: null
-      // Phase 4.3 YAGNI (ralphLoopWrap returns string only; defer v0.5+ per RESEARCH § 7 Q2)
-    })
-  );
 }
 
 // src/checkpoint/engineHook.ts
@@ -2536,7 +2227,363 @@ async function completePhase(ctx) {
   await complete();
 }
 
-// src/routing/lib/fallbackHandlers.ts
+// src/workflow/run.ts
+init_state();
+async function loadRolePrompts(workflowsDir) {
+  const path = join(workflowsDir, "role-prompts.yaml");
+  let raw;
+  try {
+    raw = await readFile(path, "utf8");
+  } catch {
+    return {};
+  }
+  const doc = parse(raw);
+  return doc?.prompts ?? {};
+}
+function generateCommandFile(name, prompt, _capabilities, _installedPlugins, _installedUserSkills) {
+  const isMaster = prompt.is_master === true;
+  const argHint = isMaster ? "[task description]" : "[requirement text or omit]";
+  const stagedNote = name === "auto" ? "\n- For stage-by-stage review, append `--staged` (pauses between stages for user review)." : "";
+  const body = [
+    `# /${name}`,
+    ``,
+    prompt.description,
+    ``,
+    `## How to invoke`,
+    ``,
+    `Use the Bash tool to run:`,
+    ``,
+    "```bash",
+    `echo "$ARGUMENTS" | harnessed run ${name} --task-stdin`,
+    "```",
+    ``,
+    `If \`$ARGUMENTS\` is empty (slash command invoked with no args), run \`harnessed run ${name}\` (no stdin pipe).`,
+    ``,
+    `After completion, the Bash output prints a \`Next:\` hint on stderr suggesting the next stage. Decide whether to invoke based on conversation context \u2014 the hint is informational, not prescriptive.`,
+    ``,
+    `## Notes`,
+    ``,
+    `- This file is generated by \`harnessed setup\` v3.4.4+. Re-run \`harnessed setup\` after a harnessed upgrade to refresh.`,
+    `- The sister \`~/.claude/skills/${name}/SKILL.md\` is the Skill-tool entry point (Claude loads it when triggers match \`trigger_phrases:\`). Both files invoke the same \`harnessed run ${name}\` Bash command.${stagedNote}`,
+    `- Workflow runtime: \`src/workflow/run.ts\` walks \`workflows/${nameToYamlHintPath(name)}\` with disciplines + judgments + master orchestration applied per the yaml \`delegates_to[]\` + \`gate\` clauses.`,
+    ``,
+    `<!-- harnessed-generated:v3.4.4 -->`,
+    ``
+  ].join("\n");
+  const warnings = [];
+  const frontmatter = [
+    "---",
+    `description: ${JSON.stringify(prompt.description)}`,
+    `argument-hint: ${JSON.stringify(argHint)}`,
+    "---",
+    ""
+  ].join("\n");
+  return { content: frontmatter + body, warnings };
+}
+function nameToYamlHintPath(name) {
+  if (["auto", "research", "retro"].includes(name)) return `${name}/workflow.yaml`;
+  if (["discuss", "plan", "task", "verify"].includes(name)) return `${name}/auto/workflow.yaml`;
+  const dashIdx = name.indexOf("-");
+  if (dashIdx > 0) {
+    return `${name.slice(0, dashIdx)}/${name.slice(dashIdx + 1)}/workflow.yaml`;
+  }
+  return `${name}/workflow.yaml`;
+}
+var HARNESSED_MARKER_RX = /<!--\s*harnessed-generated:v3\.4\.\d+\s*-->/;
+var V3_4_3_SIGNATURE_SUB_RX = /\*\*Preferred path\*\*[\s\S]*use the SlashCommand tool[\s\S]*\*\*Fallback path\*\*[\s\S]*use the Task tool to spawn/;
+var V3_4_3_SIGNATURE_MASTER_RX = /\*\*Preferred path\*\*[\s\S]*dispatch to the per-sub-workflow/;
+function shouldOverwriteFile(content) {
+  return HARNESSED_MARKER_RX.test(content) || V3_4_3_SIGNATURE_SUB_RX.test(content) || V3_4_3_SIGNATURE_MASTER_RX.test(content);
+}
+async function writeAllCommands(slashNames, commandsDir, rolePrompts, capabilities, installedPlugins, installedUserSkills, writer, fileExists2 = existsSync, readFileSync9 = (p4) => readFileSync(p4, "utf8")) {
+  const results = [];
+  const aggregatedWarnings = /* @__PURE__ */ new Set();
+  for (const name of slashNames) {
+    const path = join(commandsDir, `${name}.md`);
+    const prompt = rolePrompts[name];
+    if (!prompt) {
+      results.push({
+        name,
+        path,
+        written: false,
+        warning: `no role-prompts.yaml entry for '${name}' \u2014 skipping commands/${name}.md generation`
+      });
+      aggregatedWarnings.add(`role-prompts.yaml missing entry for '${name}'`);
+      continue;
+    }
+    if (fileExists2(path)) {
+      let existing = "";
+      try {
+        existing = readFileSync9(path);
+      } catch {
+        existing = "";
+      }
+      if (!shouldOverwriteFile(existing)) {
+        results.push({
+          name,
+          path,
+          written: false,
+          warning: `commands/${name}.md is user-authored (no harnessed marker) \u2014 leaving unchanged. Delete the file to force regenerate.`
+        });
+        continue;
+      }
+    }
+    const { content, warnings } = generateCommandFile(
+      name,
+      prompt);
+    try {
+      await writer(path, content);
+      results.push({ name, path, written: true });
+    } catch (e) {
+      results.push({
+        name,
+        path,
+        written: false,
+        warning: `write failed for commands/${name}.md: ${e.message}`
+      });
+    }
+    for (const w of warnings) aggregatedWarnings.add(w);
+  }
+  return { results, warnings: [...aggregatedWarnings] };
+}
+
+// src/discipline/enforcement/after-output.ts
+var EM_DASH_RE = /——|—/;
+var EMOJI_RE = new RegExp("\\p{Emoji_Presentation}", "u");
+var SYCOPHANTIC_RE = /(好问题|太棒了|完美|希望对你有帮助|还需要别的吗|要不要我帮你)/;
+var END_RECAP_RE = /## 总结|## Summary|综上所述|In summary/;
+async function runAfterOutputHook(ctx) {
+  const warns = [];
+  await Promise.all([
+    loadDiscipline("output-style", ctx.packageRoot),
+    loadDiscipline("language", ctx.packageRoot)
+  ]);
+  const firstSentence = ctx.responseText.split(/[。.!?\n]/)[0] ?? "";
+  if (firstSentence.length > 100) warns.push("BLUF missing: first sentence > 100 char");
+  if (EM_DASH_RE.test(ctx.responseText)) warns.push("em-dash detected (auto-fix recommended)");
+  if (EMOJI_RE.test(ctx.responseText)) {
+    warns.push("emoji used without explicit user request");
+  }
+  if (SYCOPHANTIC_RE.test(ctx.responseText)) warns.push("sycophantic phrase detected");
+  const lastChunk = ctx.responseText.slice(-200);
+  if (END_RECAP_RE.test(lastChunk)) warns.push("redundant end recap detected");
+  for (const w of warns) console.warn(`\u26A0\uFE0F output-style: ${w}`);
+  return warns;
+}
+
+// src/discipline/enforcement/before-phase-execute.ts
+async function loadDisciplinesForPhase(disciplines_applied, packageRoot) {
+  return loadAllApplied(disciplines_applied, packageRoot);
+}
+
+// src/discipline/enforcement/before-spawn.ts
+async function arbitrateBeforeSpawn(fired, packageRoot) {
+  if (fired.length <= 1) return fired;
+  const d = await loadDiscipline("priority", packageRoot);
+  const hierarchy = d.priority_hierarchy ?? [];
+  const rank = (tier) => {
+    const i = hierarchy.indexOf(tier);
+    return i === -1 ? Number.MAX_SAFE_INTEGER : i;
+  };
+  return [...fired].sort((a, b) => rank(a.tier) - rank(b.tier));
+}
+
+// src/workflow/governance.ts
+init_harnessedRoot();
+init_schemaVersion();
+
+// src/workflow/schema/governance.ts
+init_schemaVersion();
+var GovernanceStatus = Type.Union([Type.Literal("active"), Type.Literal("vetoed")]);
+var GovernanceV1 = Type.Object(
+  {
+    schemaVersion: Type.Literal(SCHEMA_VERSIONS.governance),
+    // 'harnessed.governance.v1'
+    status: GovernanceStatus,
+    reason: Type.Optional(Type.String({ maxLength: 500 })),
+    // DOS cap per RESEARCH § 11.4
+    // ISO-8601 date-time regex (Phase 3.2 W2 Rule 1 fix — TypeBox `format: 'date-time'`
+    // requires FormatRegistry.Set which is not registered project-wide; using
+    // `pattern` is zero-config equivalent. Sister checkpoint.v1 uses ISO pattern too.).
+    vetoed_at: Type.Optional(
+      Type.String({
+        pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(\\.\\d+)?(Z|[+-]\\d{2}:\\d{2})$"
+      })
+    ),
+    vetoed_by: Type.Optional(Type.String({ maxLength: 100 }))
+    // e.g. 'CEO' (gstack role)
+  },
+  { additionalProperties: false }
+);
+
+// src/workflow/governance.ts
+function govPath() {
+  return harnessedFile("governance.json");
+}
+async function readGovernance() {
+  let raw;
+  try {
+    raw = await readFile(govPath(), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const v = parsed.schemaVersion ?? "";
+  return branchOnSchemaVersion(v, {
+    v1: () => Value.Check(GovernanceV1, parsed) ? parsed : null,
+    unknown: () => null
+  });
+}
+async function isVetoed() {
+  return (await readGovernance())?.status === "vetoed";
+}
+var PARSER_OPTIONS = {
+  operators: {
+    add: false,
+    subtract: false,
+    multiply: false,
+    divide: false,
+    logical: true,
+    comparison: true,
+    in: true,
+    assignment: false
+  }
+};
+var _parserSingleton = new Parser(PARSER_OPTIONS);
+var GateEvalError = class extends Error {
+  constructor(message, expression) {
+    super(message);
+    this.expression = expression;
+    this.name = "GateEvalError";
+  }
+  expression;
+};
+function evalGate(expression, context) {
+  try {
+    const parsed = _parserSingleton.parse(expression);
+    const result = parsed.evaluate(context);
+    if (typeof result !== "boolean") {
+      throw new GateEvalError(
+        `Expression must evaluate to boolean, got ${typeof result}`,
+        expression
+      );
+    }
+    return result;
+  } catch (err2) {
+    if (err2 instanceof GateEvalError) throw err2;
+    throw new GateEvalError(`Gate eval failed: ${err2.message}`, expression);
+  }
+}
+
+// src/workflow/schema/judgment.ts
+init_schemaVersion();
+var TriggerInvocation = Type.Object(
+  {
+    capability: Type.String()
+  },
+  { additionalProperties: false }
+);
+var RequiresCapabilities = Type.Object(
+  {
+    capabilities: Type.Array(Type.String())
+  },
+  { additionalProperties: false }
+);
+var JudgmentTrigger = Type.Object(
+  {
+    description: Type.Optional(Type.String()),
+    fires_when: Type.Optional(Type.String()),
+    skips_when: Type.Optional(Type.String()),
+    invokes: Type.Optional(Type.Array(TriggerInvocation)),
+    requires: Type.Optional(RequiresCapabilities),
+    wraps: Type.Optional(Type.Array(Type.String()))
+  },
+  { additionalProperties: false }
+);
+var FallbackRule = Type.Object(
+  {
+    description: Type.Optional(Type.String()),
+    fallback_action: Type.Optional(Type.String()),
+    message_template: Type.Optional(Type.String()),
+    override_signal: Type.Optional(Type.Array(Type.String())),
+    chain_isolation: Type.Optional(Type.Boolean())
+  },
+  { additionalProperties: false }
+);
+var JudgmentTriggersFile = Type.Object(
+  {
+    schema_version: Type.Literal(SCHEMA_VERSIONS.judgment),
+    triggers: Type.Record(Type.String(), JudgmentTrigger)
+  },
+  { additionalProperties: false }
+);
+var JudgmentRulesFile = Type.Object(
+  {
+    schema_version: Type.Literal(SCHEMA_VERSIONS.judgment),
+    rules: Type.Record(Type.String(), FallbackRule)
+  },
+  { additionalProperties: false }
+);
+Type.Union([JudgmentTriggersFile, JudgmentRulesFile]);
+
+// src/workflow/judgmentResolver.ts
+var TriggerNotFoundError = class extends Error {
+  constructor(trigger, fileName) {
+    super(`Trigger '${trigger}' not found in judgments/${fileName}.yaml`);
+    this.trigger = trigger;
+    this.fileName = fileName;
+    this.name = "TriggerNotFoundError";
+  }
+  trigger;
+  fileName;
+};
+var _fileCache = /* @__PURE__ */ new Map();
+async function resolveJudgmentGate(gateRef, context, packageRoot) {
+  const parts = gateRef.split(".");
+  if (parts.length !== 4 || parts[0] !== "judgments") {
+    throw new Error(`Invalid gate ref: ${gateRef}`);
+  }
+  const [, fileName, triggerName, fieldName] = parts;
+  let parsed = _fileCache.get(fileName);
+  if (!parsed) {
+    const yamlPath = resolve(packageRoot, "workflows", "judgments", `${fileName}.yaml`);
+    const raw = await readFile(yamlPath, "utf8");
+    const parsedRaw = parse(raw);
+    const schema = fileName === "fallback" ? JudgmentRulesFile : JudgmentTriggersFile;
+    if (!Value.Check(schema, parsedRaw)) {
+      const errors = [...Value.Errors(schema, parsedRaw)].slice(0, 3).map((e) => `${e.path} ${e.message}`).join("; ");
+      throw new Error(`Invalid judgment file ${fileName}.yaml: ${errors}`);
+    }
+    parsed = parsedRaw;
+    _fileCache.set(fileName, parsed);
+  }
+  const entries = "triggers" in parsed ? parsed.triggers : parsed.rules;
+  const trigger = entries[triggerName];
+  if (!trigger) {
+    throw new TriggerNotFoundError(triggerName, fileName);
+  }
+  const expr = fieldName === "fires" ? trigger.fires_when : fieldName === "skips" ? trigger.skips_when : void 0;
+  if (!expr) {
+    throw new Error(
+      `Field '${fieldName}' has no expression in trigger '${triggerName}' of ${fileName}.yaml`
+    );
+  }
+  return evalGate(expr, context);
+}
+
+// src/workflow/lib/promiseExtract.ts
+var PROMISE_PATTERN = /<promise>([^<]+)<\/promise>/;
+function extractPromise(text) {
+  const match = text.match(PROMISE_PATTERN);
+  return match ? match[1] : null;
+}
+
+// src/workflow/lib/fallbackHandlers.ts
 function handleMaxIterationsExceeded(err2, fallback, ctx) {
   const yamlShort = fallback.message.replace(
     /\{\{\s*args\.max_iterations\s*\}\}/g,
@@ -2562,33 +2609,8 @@ ${yamlShort}`;
   process.exit(fallback.exit_code);
   throw new Error("unreachable");
 }
-function handleVerbatimCompleteFail(err2, fallback, ctx) {
-  const truncated = err2.lastMessage.slice(0, 500);
-  const uxText = `\u274C ralph-loop verbatim COMPLETE signal missing (F33 P1).
-Sub-task: ${ctx.subtaskSummary}
-Workflow: ${ctx.workflowName} / phase ${ctx.phaseId}
-Last subagent output (truncated): ${truncated}
-The subagent's final message lacked verbatim "<promise>COMPLETE</promise>" tag.
-This indicates one of:
-  1. Subagent skipped the completion-promise contract (review system prompt)
-  2. Output format misconfigured (check outputFormat schema)
-Manual options:
-  A) Re-run with explicit COMPLETE instruction in subagent prompt
-  B) Abort cleanly: exit ${fallback.exit_code}
-Exit code: ${fallback.exit_code}`;
-  console.error(uxText);
-  process.exit(fallback.exit_code);
-  throw new Error("unreachable");
-}
-
-// src/routing/lib/promiseExtract.ts
-var PROMISE_PATTERN = /<promise>([^<]+)<\/promise>/;
-function extractPromise(text) {
-  const match2 = text.match(PROMISE_PATTERN);
-  return match2 ? match2[1] : null;
-}
 
-// src/routing/lib/ralphLoop.ts
+// src/workflow/lib/ralphLoop.ts
 function isComplete(output) {
   try {
     const env = JSON.parse(output);
@@ -2607,14 +2629,6 @@ var MaxIterationsExceededError = class extends Error {
   }
   iterations;
 };
-var VerbatimCompleteFailError = class extends Error {
-  constructor(lastMessage) {
-    super("subagent final message lacked verbatim <promise>COMPLETE</promise> (F33 P1 mitigation)");
-    this.lastMessage = lastMessage;
-    this.name = "VerbatimCompleteFailError";
-  }
-  lastMessage;
-};
 async function ralphLoopWrap(spawn6, maxIter) {
   let last = "";
   let sessionId;
@@ -2627,7 +2641,26 @@ async function ralphLoopWrap(spawn6, maxIter) {
   throw new MaxIterationsExceededError(maxIter);
 }
 
-// src/routing/lib/sdkReconcile.ts
+// src/workflow/lib/completionSchema.ts
+var COMPLETION_SCHEMA = {
+  type: "object",
+  properties: {
+    status: { type: "string", enum: ["COMPLETE", "PARTIAL", "BLOCKED"] },
+    phase: { type: "string", enum: ["01-clarify", "02-code", "03-test", "04-deliver"] },
+    summary: { type: "string" },
+    blockers: { type: "array", items: { type: "string" } },
+    // v3.5.0 Phase 2 — Option 1-Lite signal-driven Agent Teams escalation.
+    // spawned subagent SHOULD set this when any of parallelism-gate.yaml 5
+    // upgrade triggers fire. harnessed runtime propagates to stderr hint;
+    // user opens team in main Claude Code session (TeamCreate not exposed to
+    // spawned subagents via SDK v0.3.142 — see PHASE-2-SPEC.md § Why).
+    needs_teams_escalation: { type: "boolean" },
+    escalation_reason: { type: "string" }
+  },
+  required: ["status", "phase"]
+};
+
+// src/workflow/lib/sdkReconcile.ts
 function toSdkAgentDefinition(def) {
   return {
     description: def.description,
@@ -2664,7 +2697,7 @@ ${def.criticalSystemReminder_EXPERIMENTAL}`);
   return parts.join("\n\n");
 }
 
-// src/routing/lib/sdkSpawn.ts
+// src/workflow/lib/sdkSpawn.ts
 var SpawnFailError = class extends Error {
   constructor(lastMessage) {
     super("sdkSpawn produced no result message");
@@ -2704,146 +2737,30 @@ async function sdkSpawn(def, opts) {
   };
   return JSON.stringify(envelope);
 }
-function isInstalled(skill, root) {
-  return existsSync(join(root, skill, "SKILL.md"));
-}
-var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
-async function ensureSkillsInstalled(required, skillsRoot) {
-  for (const name of required) {
-    if (isInstalled(name, skillsRoot)) continue;
-    await sleep(500);
-    let retries = 3;
-    while (retries-- > 0 && !isInstalled(name, skillsRoot)) await sleep(300);
-    if (!isInstalled(name, skillsRoot)) {
-      throw new RestartRequiredError(
-        `Skill ${name} still missing after retry \u2014 please exit + restart Claude Code so the plugin takes effect.`
-      );
-    }
-  }
-}
-
-// src/routing/semanticRouter.ts
-var DEFAULT_SEMANTIC_THRESHOLD = 0.85;
-async function match(prompt, threshold = DEFAULT_SEMANTIC_THRESHOLD) {
-  return { matched: false, rule: null, confidence: 0 };
-}
 
-// src/routing/engine.ts
-var defaultSpawn = (def, ctx) => sdkSpawn(def, ctx);
-function buildDecision(matched) {
-  if (!matched) {
-    return {
-      matched_rule_id: null,
-      primary_expert: null,
-      secondary_expert: null,
-      category: "meta"
-    };
+// src/workflow/interpolate.ts
+var InterpolationError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InterpolationError";
   }
-  return {
-    matched_rule_id: matched.id,
-    primary_expert: matched.decision.primary_expert ?? null,
-    secondary_expert: matched.decision.secondary_expert ?? null,
-    category: matched.domain,
-    forbidden_skills: matched.decision.forbidden,
-    required_skills: matched.decision.required_skills
-  };
-}
-async function runRouting(task, opts = {}) {
-  const rulesPath = opts.rulesPath ?? join("routing", "decision_rules.yaml");
-  const skillsRoot = opts.skillsRoot ?? join(homedir(), ".claude", "skills");
-  const maxIter = opts.maxIterations ?? 20;
-  const userSpawn = opts.spawn;
-  if (opts.dagNodes && opts.dagNodes.length > 0) {
-    const dag = resolveDag(opts.dagNodes);
-    if (!dag.ok) {
-      const error = new InvalidDecisionError(
-        `skill dependency cycle: ${dag.cycle.join(" \u2192 ")} (see ADR 0009 \xA7 DAG resolver)`
+};
+var STRICT = /\{\{\s*(\w+)\s*\}\}/g;
+var ANY_TEMPLATE = /\{\{[^}]*\}\}/;
+function interpolate(template, vars) {
+  const out = template.replace(STRICT, (_m, name) => {
+    const v = vars[name];
+    if (v === void 0) {
+      throw new InterpolationError(
+        `undefined template variable '${name}' (template excerpt: ${template.slice(0, 80)})`
       );
-      return { ok: false, phase: "arbitrate", error };
-    }
-  }
-  let rules;
-  try {
-    rules = loadDecisionRules(rulesPath).rules;
-  } catch (error) {
-    return { ok: false, phase: "arbitrate", error };
-  }
-  const taskCtx = {
-    task_type: task.task_type,
-    ...task.override_keywords ? { override_keywords: task.override_keywords } : {}
-  };
-  const matched = arbitrate(rules, taskCtx);
-  const decision = buildDecision(matched);
-  if (!matched) {
-    const semantic = await match(task.task, opts.semanticThreshold);
-    void semantic.rule;
-    if (opts.fallbackSupervisor) {
-      const result = await opts.fallbackSupervisor(task);
-      return { ok: true, result, matchedRule: null };
-    }
-    return {
-      ok: false,
-      phase: "arbitrate",
-      error: new InvalidDecisionError("no rule matched and no fallbackSupervisor provided")
-    };
-  }
-  try {
-    await ensureSkillsInstalled(decision.required_skills ?? [], skillsRoot);
-  } catch (error) {
-    return { ok: false, phase: "install", error };
-  }
-  let agentDef;
-  try {
-    agentDef = await createAgent(task, decision, { ...opts.agentOpts, skillsRoot });
-  } catch (error) {
-    if (error instanceof SkillNotInstalledError || error instanceof MissingSkillsError) {
-      return { ok: false, phase: "install", error };
-    }
-    if (error instanceof InvalidDecisionError) {
-      return { ok: false, phase: "arbitrate", error };
-    }
-    return { ok: false, phase: "spawn", error };
-  }
-  const phaseId = task.phaseId ?? "unknown";
-  await activatePhase(phaseId);
-  const expertName = matched.decision.primary_expert ?? "unknown";
-  let capturedSessionId;
-  const wrappedSpawn = async (resumeSessionId, onSessionIdInner) => userSpawn ? userSpawn(agentDef) : defaultSpawn(agentDef, {
-    expertName,
-    ...resumeSessionId ? { resumeSessionId } : {},
-    onSessionId: (id) => {
-      capturedSessionId = id;
-      onSessionIdInner?.(id);
     }
+    return v;
   });
-  const fbCtx = {
-    subtaskSummary: task.task,
-    workflowName: task.task_type ?? "unknown",
-    phaseId: opts.fallbackPhaseId ?? task.phaseId ?? "unknown"
-  };
-  try {
-    const result = await ralphLoopWrap(wrappedSpawn, maxIter);
-    await completePhase({ phaseId, sessionId: capturedSessionId, status: "complete" });
-    emitAudit(task, decision, matched, "complete", capturedSessionId);
-    return { ok: true, result, matchedRule: matched };
-  } catch (error) {
-    if (error instanceof MaxIterationsExceededError) {
-      emitAudit(task, decision, matched, "max-iter", capturedSessionId);
-      if (opts.fallbackConfig)
-        handleMaxIterationsExceeded(error, opts.fallbackConfig, {
-          ...fbCtx,
-          maxIterations: maxIter
-        });
-      return { aborted: true, reason: error.message };
-    }
-    if (error instanceof VerbatimCompleteFailError) {
-      emitAudit(task, decision, matched, "verbatim-fail", capturedSessionId);
-      if (opts.fallbackConfig) handleVerbatimCompleteFail(error, opts.fallbackConfig, fbCtx);
-      return { ok: false, phase: "verbatim", error };
-    }
-    emitAudit(task, decision, matched, "spawn-err", capturedSessionId);
-    return { ok: false, phase: "spawn", error };
+  if (ANY_TEMPLATE.test(out)) {
+    throw new InterpolationError(`unsupported template syntax in: ${out.slice(0, 80)}`);
   }
+  return out;
 }
 var ModelTier = Type.Union([
   Type.Literal("haiku"),
@@ -3020,7 +2937,7 @@ var WorkflowPhaseV3 = Type.Object(
   },
   { additionalProperties: false }
 );
-Type.Object(
+var WorkflowSchemaV3 = Type.Object(
   {
     schema_version: Type.Literal(SCHEMA_VERSIONS.workflow_v3),
     workflow: Type.String({ minLength: 1 }),
@@ -3044,26 +2961,638 @@ var PhasesValidationError = class extends Error {
     this.errors = errors;
     this.name = "PhasesValidationError";
   }
-  errors;
+  errors;
+};
+function loadPhases(yamlPath, vars) {
+  const raw = readFileSync(yamlPath, "utf8");
+  const parsed = parse(raw);
+  const version = parsed?.schema_version;
+  if (version === "harnessed.workflow.v3") {
+    if (!Value.Check(WorkflowSchemaV3, parsed)) {
+      throw new PhasesValidationError([...Value.Errors(WorkflowSchemaV3, parsed)]);
+    }
+  } else if (version === "harnessed.workflow.v2") {
+    if (!Value.Check(WorkflowSchemaV2, parsed)) {
+      throw new PhasesValidationError([...Value.Errors(WorkflowSchemaV2, parsed)]);
+    }
+  } else {
+    if (!Value.Check(PhasesSchema, parsed)) {
+      throw new PhasesValidationError([...Value.Errors(PhasesSchema, parsed)]);
+    }
+  }
+  const validated = parsed;
+  if (vars && validated.phases) {
+    for (const ph of validated.phases) {
+      if (ph.invokes) ph.invokes = interpolate(ph.invokes, vars);
+    }
+  }
+  return validated;
+}
+function resolveMasterYamlPath(masterName, packageRoot) {
+  return masterName === "auto" ? resolve(packageRoot, "workflows", "auto", "workflow.yaml") : resolve(packageRoot, "workflows", masterName, "auto", "workflow.yaml");
+}
+function resolveSubYamlPath(masterName, subName, packageRoot) {
+  if (masterName === "auto") {
+    if (subName === "research" || subName === "retro") {
+      return resolve(packageRoot, "workflows", subName, "workflow.yaml");
+    }
+    return resolve(packageRoot, "workflows", subName, "auto", "workflow.yaml");
+  }
+  return resolve(packageRoot, "workflows", masterName, subName, "workflow.yaml");
+}
+var defaultSpawnDriver = async (masterName, subName, _context, packageRoot) => {
+  const subYamlPath = resolveSubYamlPath(masterName, subName, packageRoot);
+  try {
+    await runWorkflow(subYamlPath, {}, { packageRoot, gateContext: _context });
+  } catch (err2) {
+    console.warn(
+      `\u26A0\uFE0F master spawnSubWorkflow Path A failed for ${masterName}/${subName} (${err2.message});Path B sub-shell fallback deferred T3.5.W2.1.`
+    );
+  }
+};
+var defaultPauseFn = async (stageName) => {
+  const readline2 = await import('readline/promises');
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    await rl.question(
+      `
+[--staged] Stage '${stageName}' complete. Press Enter to continue (Ctrl+C to abort)... `
+    );
+  } finally {
+    rl.close();
+  }
+};
+var defaultAssessComplexity = async (_taskDescription) => {
+  return "medium";
+};
+var defaultPromptUserUnderstanding = async (prompter = defaultPrompter) => {
+  const answer = await prompter(
+    "\n[Phase 0.5] \u5BF9\u9700\u6C42\u6709\u6E05\u6670\u8BA4\u77E5\u5417? [Y/n] (n = \u5148\u8DD1 /research \u591A\u6E90\u8C03\u7814): "
+  );
+  const a = answer.trim().toLowerCase();
+  return !(a === "n" || a === "no");
+};
+var defaultPrompter = async (question) => {
+  const readline2 = await import('readline/promises');
+  const rl = readline2.createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await rl.question(question);
+  } finally {
+    rl.close();
+  }
+};
+async function runAutoPreFlight(ctx, opts) {
+  const assess = opts.assessComplexity ?? defaultAssessComplexity;
+  const prompter = opts.prompter ?? defaultPrompter;
+  const taskDesc = typeof ctx.task_description === "string" ? ctx.task_description : "";
+  const size = await assess(taskDesc);
+  console.log(`[/auto Phase 0] Complexity assessment: ${size}`);
+  let nextOpts = opts;
+  if (size === "large") {
+    const a = (await prompter(
+      "\n[Phase 0] \u9700\u6C42\u590D\u6742\u5EA6\u8F83\u5927,\u5168\u7A0B auto \u53EF\u80FD\u65F6\u95F4\u8FC7\u957F / \u4E0A\u4E0B\u6587\u8D85\u9650\u3002\u5EFA\u8BAE `--staged` \u6A21\u5F0F (\u6BCF stage \u5B8C\u505C review)\u3002\u662F\u5426\u5207\u6362? [Y/n]: "
+    )).trim().toLowerCase();
+    if (a === "n" || a === "no") {
+      console.log(
+        "\n[/auto Phase 0] User declined --staged. Aborting auto mode \u2014 \u5EFA\u8BAE\u624B\u52A8 `/discuss` \u542F\u52A8\u3002"
+      );
+      return { proceed: false, opts };
+    }
+    console.log("[/auto Phase 0] Switching to --staged mode.");
+    nextOpts = { ...opts, pauseBetweenStages: true };
+  }
+  const promptUnderstanding = opts.promptUserUnderstanding ?? defaultPromptUserUnderstanding;
+  const isClear = await promptUnderstanding(prompter);
+  ctx.user_understanding_unclear = !isClear;
+  console.log(
+    `[/auto Phase 0.5] user_understanding_unclear=${!isClear} (research will ${isClear ? "skip" : "fire"})`
+  );
+  return { proceed: true, opts: nextOpts };
+}
+function emitGateTransparency(masterName, totalGates, gateEvalled) {
+  console.log(`[${masterName} master] Evaluating ${totalGates} sub-workflow gates:`);
+  for (const g of gateEvalled) {
+    const mark = g.passes ? "\u2713" : "\u2298";
+    const tail = g.passes ? g.clause.gate ? ` (${g.clause.gate} == true)` : " (unconditional)" : ` skipped \u2014 ${g.reason}`;
+    console.log(`  ${mark} ${g.clause.sub}${tail}`);
+  }
+}
+async function maybeArbitrate(firedClauses, packageRoot) {
+  if (firedClauses.length <= 1) return;
+  const firedCaps = firedClauses.map((c) => ({ name: c.sub, tier: c.sub }));
+  try {
+    await arbitrateBeforeSpawn(firedCaps, packageRoot);
+    console.warn(
+      `\u26A0\uFE0F multi-capability fires (${firedClauses.length} sub), arbitrating by priority hierarchy (K14 warn-not-halt; v3.0 sub-as-tier placeholder, real cross-tier sort defer v3.x)`
+    );
+  } catch (e) {
+    console.warn(`\u26A0\uFE0F arbitrate failed (${e.message}) \u2014 proceeding default order`);
+  }
+}
+
+// src/workflow/masterOrchestrator.ts
+async function runMasterOrchestrator(masterName, context, packageRoot, spawnDriver = defaultSpawnDriver, opts = {}) {
+  const yamlPath = resolveMasterYamlPath(masterName, packageRoot);
+  const raw = await readFile(yamlPath, "utf8");
+  const parsed = parse(raw);
+  if (!Value.Check(WorkflowSchemaV3, parsed)) {
+    const errors = [...Value.Errors(WorkflowSchemaV3, parsed)].slice(0, 3).map((e) => `${e.path} ${e.message}`).join("; ");
+    throw new Error(`Invalid master workflow.yaml at ${yamlPath}: ${errors}`);
+  }
+  const master = parsed;
+  if (!master.delegates_to || master.delegates_to.length === 0) {
+    throw new Error(`Master workflow ${masterName} missing delegates_to`);
+  }
+  let effectiveOpts = opts;
+  const preflightActive = masterName === "auto" && (opts.assessComplexity !== void 0 || opts.prompter !== void 0 || opts.promptUserUnderstanding !== void 0);
+  if (preflightActive) {
+    const pre = await runAutoPreFlight(context, opts);
+    if (!pre.proceed) {
+      console.log(`[${masterName} master] Aborted by user (complexity gate decline).`);
+      return { master: masterName, fired: [], skipped: master.delegates_to.map((c) => c.sub) };
+    }
+    effectiveOpts = pre.opts;
+  }
+  const gateEvalled = [];
+  for (const clause of master.delegates_to) {
+    if (!clause.gate) {
+      gateEvalled.push({ clause, passes: true });
+      continue;
+    }
+    try {
+      const passes = await resolveJudgmentGate(clause.gate, context, packageRoot);
+      gateEvalled.push({
+        clause,
+        passes,
+        reason: passes ? void 0 : `gate ${clause.gate} = false`
+      });
+    } catch (e) {
+      gateEvalled.push({
+        clause,
+        passes: false,
+        reason: `gate eval error: ${e.message}`
+      });
+    }
+  }
+  emitGateTransparency(masterName, master.delegates_to.length, gateEvalled);
+  const PARALLEL_MID_ANCHOR = 50;
+  const firedClauses = gateEvalled.filter((g) => g.passes).map((g) => g.clause);
+  const serialLeading = firedClauses.filter((c) => c.mode === "serial" && (c.order ?? 0) < PARALLEL_MID_ANCHOR).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  const serialTrailing = firedClauses.filter((c) => c.mode === "serial" && (c.order ?? 0) >= PARALLEL_MID_ANCHOR).sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  const parallelClauses = firedClauses.filter((c) => (c.mode ?? "parallel") === "parallel");
+  const serialN = serialLeading.length + serialTrailing.length;
+  const parallelN = parallelClauses.length;
+  await maybeArbitrate(firedClauses, packageRoot);
+  const modeLabel = serialN > 0 && parallelN > 0 ? "serial+parallel" : serialN > 0 ? "serial" : "parallel";
+  console.log(`Firing ${firedClauses.length} sub in ${modeLabel}:`);
+  const fired = [];
+  const pauseHook = effectiveOpts.pauseBetweenStages ? effectiveOpts.pauseFn ?? defaultPauseFn : void 0;
+  for (const clause of serialLeading) {
+    console.log(`  \u2192 ${clause.sub} (serial order=${clause.order ?? 0})`);
+    await spawnDriver(masterName, clause.sub, context, packageRoot);
+    fired.push(clause.sub);
+    if (pauseHook) await pauseHook(clause.sub);
+  }
+  const parallelResults = await Promise.allSettled(
+    parallelClauses.map(async (clause) => {
+      console.log(`  \u2192 ${clause.sub} (parallel)`);
+      await spawnDriver(masterName, clause.sub, context, packageRoot);
+      return clause.sub;
+    })
+  );
+  for (const r of parallelResults) {
+    if (r.status === "fulfilled") fired.push(r.value);
+  }
+  for (const clause of serialTrailing) {
+    console.log(`  \u2192 ${clause.sub} (serial order=${clause.order ?? 0})`);
+    await spawnDriver(masterName, clause.sub, context, packageRoot);
+    fired.push(clause.sub);
+    if (pauseHook) await pauseHook(clause.sub);
+  }
+  const skipped = gateEvalled.filter((g) => !g.passes).map((g) => g.clause.sub);
+  console.log(`[${masterName} master] Complete: ${fired.length} fired, ${skipped.length} skipped.`);
+  return { master: masterName, fired, skipped };
+}
+
+// src/workflow/run.ts
+var MASTER_NAMES = ["discuss", "plan", "task", "verify", "auto"];
+var RALPH_DEFAULT_MAX_ITER = 20;
+var RALPH_HARD_UPPER_LIMIT = 100;
+var ESCALATION_RULES = `If during this task you detect ANY of the following 5 conditions, set \`needs_teams_escalation: true\` in your structured output and fill \`escalation_reason\` with the trigger name + one-sentence specifics. These are signals to the human user in the main Claude Code session \u2014 do NOT attempt to call TeamCreate/SendMessage/TeamDelete yourself (those tools are not available to you).
+
+Five triggers (any one suffices):
+
+1. **teammate_send_message_needed** \u2014 the task requires two or more subagents to exchange messages mid-task (e.g., reconciling API contract proposals across frontend and backend), not just fan-out + report.
+
+2. **subagent_context_overflow** \u2014 your context budget is filling and a separate subagent is needed to take over a portion of the work.
+
+3. **shared_task_list** \u2014 multiple subagents need to coordinate self-assignment from a shared task list (not pre-partitioned work).
+
+4. **opposing_hypothesis_debate** \u2014 the task requires two subagents to defend opposing hypotheses to a lead arbiter (e.g., root-cause debugging where two competing theories need separate evidence-gathering).
+
+5. **fullstack_three_way** \u2014 the task is a synchronized fullstack push (frontend + backend + tests) requiring API contract alignment across three roles simultaneously.
+
+If none of the five apply, omit \`needs_teams_escalation\` (defaults to false) and proceed normally.`;
+function buildAgentDef(skillName, rolePrompts, workflowName, modelTierOverride) {
+  const rp = rolePrompts?.[skillName] ?? (workflowName ? rolePrompts?.[workflowName] : void 0);
+  if (!rp) {
+    return {
+      description: `harnessed workflow phase: ${skillName}`,
+      prompt: `You are executing the '${skillName}' workflow phase. Follow the phase intent and emit a structured COMPLETE signal when done.`,
+      criticalSystemReminder_EXPERIMENTAL: ESCALATION_RULES,
+      ...modelTierOverride ? { model: modelTierOverride } : {}
+    };
+  }
+  const checklist = rp.checklist.length ? `
+
+Checklist:
+${rp.checklist.map((c, i) => `  ${i + 1}. ${c}`).join("\n")}` : "";
+  const prompt = [
+    `You are a ${rp.specialist}.`,
+    ``,
+    rp.responsibility.trim(),
+    checklist,
+    ``,
+    `Severity scale: ${rp.severity}`,
+    ``,
+    `Emit a structured COMPLETE signal when done.`
+  ].join("\n");
+  return {
+    description: rp.description,
+    prompt,
+    criticalSystemReminder_EXPERIMENTAL: ESCALATION_RULES,
+    ...modelTierOverride ? { model: modelTierOverride } : {}
+  };
+}
+function isRalphLoopOptIn(phase) {
+  if (!phase || typeof phase !== "object") return false;
+  const p4 = phase;
+  if (p4.max_iterations !== void 0 && p4.max_iterations !== null) return true;
+  if (p4.upstream === "ralph-loop") return true;
+  const fb = p4.fallback;
+  if (fb?.max_iterations_exceeded !== void 0) return true;
+  return false;
+}
+function resolveMaxIterations(phase, gateContext) {
+  const fromCli = typeof gateContext.maxIterations === "number" ? gateContext.maxIterations : void 0;
+  let fromYaml;
+  if (phase && typeof phase === "object") {
+    const raw = phase.max_iterations;
+    if (typeof raw === "number") fromYaml = raw;
+    else if (typeof raw === "string") {
+      const n = Number.parseInt(raw, 10);
+      if (Number.isFinite(n) && n > 0) fromYaml = n;
+    }
+  }
+  const chosen = fromCli ?? fromYaml ?? RALPH_DEFAULT_MAX_ITER;
+  return Math.min(Math.max(1, chosen), RALPH_HARD_UPPER_LIMIT);
+}
+var _dispatchSkillStub = {
+  fn: async (skillName, phase, opts) => {
+    const optIn = isRalphLoopOptIn(phase);
+    const spawnOnce = async (resumeSessionId, onSessionId) => sdkSpawn(
+      buildAgentDef(skillName, opts?.rolePrompts, opts?.workflowName, opts?.modelTierOverride),
+      {
+        expertName: skillName,
+        ...resumeSessionId ? { resumeSessionId } : {},
+        ...onSessionId ? { onSessionId } : {}
+      }
+    );
+    let envelopeJson;
+    try {
+      if (optIn) {
+        const maxIter = opts?.maxIter ?? RALPH_DEFAULT_MAX_ITER;
+        envelopeJson = await ralphLoopWrap(spawnOnce, maxIter);
+      } else {
+        envelopeJson = await spawnOnce();
+      }
+    } catch (err2) {
+      if (err2 instanceof MaxIterationsExceededError && opts?.fallback) {
+        handleMaxIterationsExceeded(err2, opts.fallback, {
+          subtaskSummary: `phase ${skillName}`,
+          // Phase 4 — plumbed actual workflow name (was hardcoded 'harnessed-run'
+          // pre-Phase 4); falls back to literal when opts.workflowName absent
+          // (preserves Phase 3 behavior for callers that don't pass workflowName).
+          workflowName: opts.workflowName ?? "harnessed-run",
+          phaseId: skillName,
+          maxIterations: opts?.maxIter ?? RALPH_DEFAULT_MAX_ITER
+        });
+      }
+      return {
+        status: "fail",
+        output: err2 instanceof MaxIterationsExceededError ? `ralph-loop max-iterations exceeded (${err2.iterations}) for ${skillName}` : `sdkSpawn failed for ${skillName}: ${err2.message}`
+      };
+    }
+    const env = JSON.parse(envelopeJson);
+    const status = env.structured_output?.status === "COMPLETE" || env.subtype === "success" ? "ok" : "fail";
+    const escalation = env.structured_output?.needs_teams_escalation === true;
+    return {
+      status,
+      output: env.text ?? env.result ?? "",
+      ...env.structured_output?.status ? { decision: env.structured_output.status } : {},
+      ...escalation ? {
+        needsTeamsEscalation: true,
+        ...env.structured_output?.escalation_reason ? { escalationReason: env.structured_output.escalation_reason } : {}
+      } : {}
+    };
+  }
 };
-function loadPhases(yamlPath, vars) {
-  const raw = readFileSync(yamlPath, "utf8");
-  const parsed = parse(raw);
-  const isV2 = parsed?.schema_version === "harnessed.workflow.v2";
-  if (isV2) {
-    if (!Value.Check(WorkflowSchemaV2, parsed)) {
-      throw new PhasesValidationError([...Value.Errors(WorkflowSchemaV2, parsed)]);
+async function runWorkflow(yamlPath, vars, opts = {}) {
+  const parsed = loadPhases(yamlPath, vars);
+  const yamlDir = dirname(resolve(yamlPath));
+  const inferredRoot = resolve(yamlDir, "..", "..");
+  const packageRoot = opts.packageRoot ?? inferredRoot;
+  const gateContext = { ...opts.gateContext ?? {} };
+  let rolePrompts = {};
+  try {
+    rolePrompts = await loadRolePrompts(join(packageRoot, "workflows"));
+  } catch (err2) {
+    console.warn(
+      `\u26A0\uFE0F loadRolePrompts failed (${err2.message}); proceeding without role-prompt enrichment (ADR 0029 fail-soft).`
+    );
+  }
+  const workflowName = parsed.workflow;
+  const isMaster = "delegates_to" in parsed && Array.isArray(parsed.delegates_to) && parsed.delegates_to.length > 0 && MASTER_NAMES.includes(workflowName);
+  if (isMaster) {
+    const r = await runMasterOrchestrator(workflowName, gateContext, packageRoot);
+    return {
+      status: "complete",
+      phasesRun: r.fired.length,
+      ...r.skipped.length > 0 ? { skippedPhases: r.skipped } : {}
+    };
+  }
+  const disciplinesApplied = "disciplines_applied" in parsed && Array.isArray(parsed.disciplines_applied) ? parsed.disciplines_applied : void 0;
+  try {
+    const disciplines = await loadDisciplinesForPhase(disciplinesApplied, packageRoot);
+    gateContext.disciplines = disciplines;
+  } catch (err2) {
+    console.warn(
+      `\u26A0\uFE0F loadDisciplinesForPhase failed (${err2.message}); proceeding without disciplines map (sister ADR 0029 fail-soft).`
+    );
+  }
+  const skippedPhases = [];
+  const phases = parsed.phases ?? [];
+  for (let i = 0; i < phases.length; i++) {
+    const ph = phases[i];
+    if (!ph) continue;
+    await activatePhase(ph.id);
+    const invokesTools = "invokes_tools" in ph && Array.isArray(ph.invokes_tools) ? ph.invokes_tools : void 0;
+    if (invokesTools && invokesTools.length > 1) {
+      try {
+        const firedCaps = invokesTools.map((c) => ({ name: c.tool, tier: c.tool }));
+        await arbitrateBeforeSpawn(firedCaps, packageRoot);
+      } catch (err2) {
+        console.warn(
+          `\u26A0\uFE0F phase ${ph.id} before-spawn arbitrate failed (${err2.message}); proceeding default tool order (K14 warn-not-halt).`
+        );
+      }
     }
-  } else {
-    if (!Value.Check(PhasesSchema, parsed)) {
-      throw new PhasesValidationError([...Value.Errors(PhasesSchema, parsed)]);
+    if (await isVetoed()) {
+      await pause();
+      return { status: "paused-veto", phasesRun: i, lastPhaseId: ph.id };
+    }
+    if ("gate" in ph && ph.gate) {
+      let fires = true;
+      try {
+        fires = await resolveJudgmentGate(ph.gate, gateContext, packageRoot);
+      } catch (err2) {
+        console.warn(
+          `\u26A0\uFE0F phase ${ph.id} gate ${ph.gate} eval failed (${err2.message}); proceeding with phase as if gate fired=true (ADR 0029 fail-soft).`
+        );
+      }
+      if (!fires) {
+        skippedPhases.push(ph.id);
+        await completePhase({
+          phaseId: ph.id,
+          lastTask: `phase ${ph.id} skipped: gate ${ph.gate} evaluated false`
+        });
+        continue;
+      }
+    }
+    const skillName = "skills" in ph && ph.skills?.[0] || ph.id;
+    const maxIter = resolveMaxIterations(ph, gateContext);
+    const fallback = "fallback" in ph && ph.fallback?.max_iterations_exceeded ? ph.fallback.max_iterations_exceeded : void 0;
+    const r = await _dispatchSkillStub.fn(skillName, ph, {
+      maxIter,
+      ...fallback ? { fallback } : {},
+      workflowName,
+      rolePrompts,
+      ...typeof gateContext.modelTierOverride === "string" ? { modelTierOverride: gateContext.modelTierOverride } : {}
+    });
+    if (r.status !== "ok") {
+      return { status: "failed", phasesRun: i, lastPhaseId: ph.id };
+    }
+    if (r.needsTeamsEscalation === true) {
+      const reason = r.escalationReason ?? "unspecified trigger";
+      console.error(
+        `\u26A0\uFE0F phase ${ph.id} suggests Agent Teams escalation \u2014 ${reason}. Consider opening a team in your main Claude Code session (TeamCreate) if continuing this work benefits from teammate coordination. See workflows/judgments/parallelism-gate.yaml for the 5 upgrade triggers.`
+      );
+    }
+    if (r.target === "chat") {
+      try {
+        await runAfterOutputHook({
+          responseText: r.output,
+          responseTarget: "chat",
+          userRequestedEmoji: false,
+          packageRoot
+        });
+      } catch (err2) {
+        console.warn(
+          `\u26A0\uFE0F phase ${ph.id} after-output hook failed (${err2.message}); proceeding (ADR 0029 fail-soft).`
+        );
+      }
+    }
+    if (r.triggers_commit === true) {
+      try {
+        await runBeforeCommitHook({
+          changedFiles: [],
+          cmdArgs: [],
+          packageRoot,
+          cmdType: "git-commit",
+          hasUserApproval: false
+        });
+      } catch (err2) {
+        console.warn(
+          `\u26A0\uFE0F phase ${ph.id} before-commit hook failed (${err2.message}); proceeding (ADR 0029 fail-soft).`
+        );
+      }
     }
+    await completePhase({
+      phaseId: ph.id,
+      lastTask: `phase ${ph.id} complete: ${r.output}`
+    });
   }
-  const validated = parsed;
-  return validated;
+  return {
+    status: "complete",
+    phasesRun: phases.length,
+    ...skippedPhases.length > 0 ? { skippedPhases } : {}
+  };
+}
+function getPackageRoot() {
+  const thisFile = fileURLToPath(import.meta.url);
+  const thisDir = dirname(thisFile);
+  if (thisDir.endsWith("dist") || thisDir.replace(/\\/g, "/").endsWith("/dist")) {
+    return resolve(thisDir, "..");
+  }
+  return resolve(thisDir, "..", "..", "..");
+}
+var PACKAGE_ROOT = getPackageRoot();
+var WORKFLOWS_DIR = join(PACKAGE_ROOT, "workflows");
+var _autoChainCache = null;
+var _autoChainLoadFailed = false;
+function registerRun(program2) {
+  program2.command("run").description(
+    "Run a harnessed workflow (master orchestrator or sub-workflow). Slash commands invoke via this subcommand."
+  ).argument("[name]", "workflow name (e.g. discuss, verify-paranoid, research, auto)").option("--task <text>", "task description (passed as workflow gateContext.task)").option("--task-stdin", "read task description from stdin until EOF (avoids shell-escape)").option(
+    "--max-iterations <n>",
+    "ralph-loop max iter (default 20; honored Phase 3 onward)",
+    (v) => parseInt(v, 10)
+  ).option("--model <model>", "subagent model: 'haiku' | 'sonnet' | 'opus'").option(
+    "--dry-run",
+    "validate yaml load + walk runtime without spawning (Phase 1 default for verification)"
+  ).option("--staged", "/auto super-master: pause between stages for user review").option("--list", "print all known workflow names and exit").action(async (name, raw) => {
+    if (raw.list) {
+      const names = await listWorkflowNames(WORKFLOWS_DIR);
+      for (const n of names) console.log(n);
+      process.exit(0);
+    }
+    if (!name) {
+      console.error("error: workflow name required (or pass --list to enumerate)");
+      process.exit(2);
+    }
+    let task = "";
+    if (typeof raw.task === "string") {
+      task = raw.task;
+    } else if (raw.taskStdin) {
+      task = await readStdinToEnd();
+    }
+    const yamlPath = await resolveWorkflowYaml(name, WORKFLOWS_DIR);
+    if (!yamlPath) {
+      console.error(
+        `error: workflow '${name}' not found under workflows/. Run \`harnessed run --list\` to enumerate.`
+      );
+      process.exit(2);
+    }
+    const gateContext = {
+      task,
+      ...raw.model ? { modelOverride: raw.model } : {},
+      ...raw.maxIterations ? { maxIterations: raw.maxIterations } : {},
+      ...raw.staged ? { staged: true } : {}
+    };
+    if (raw.dryRun) {
+      console.log(JSON.stringify({ workflow: name, yamlPath, gateContext }, null, 2));
+      process.exit(0);
+    }
+    let result;
+    try {
+      result = await runWorkflow(yamlPath, {}, { packageRoot: PACKAGE_ROOT, gateContext });
+    } catch (err2) {
+      console.error(`error: workflow runtime failed \u2014 ${err2.message}`);
+      process.exit(1);
+      return;
+    }
+    const hint = await getNextHint(name);
+    process.stderr.write(`[stage ${name} ${result.status}]
+`);
+    if (hint) {
+      process.stderr.write(`Next stage: harnessed run ${hint}
+(In Claude Code: /${hint})
+`);
+    }
+    process.exit(result.status === "failed" ? 1 : 0);
+  });
+}
+async function resolveWorkflowYaml(name, workflowsDir) {
+  const tier1 = join(workflowsDir, name, "workflow.yaml");
+  if (existsSync(tier1)) return tier1;
+  const tier2 = join(workflowsDir, name, "auto", "workflow.yaml");
+  if (existsSync(tier2)) return tier2;
+  const dashIdx = name.indexOf("-");
+  if (dashIdx > 0) {
+    const stage = name.slice(0, dashIdx);
+    const sub = name.slice(dashIdx + 1);
+    const tier3 = join(workflowsDir, stage, sub, "workflow.yaml");
+    if (existsSync(tier3)) return tier3;
+  }
+  return null;
+}
+async function listWorkflowNames(workflowsDir) {
+  const names = [];
+  const entries = await readdir(workflowsDir);
+  for (const e of entries.sort()) {
+    const p4 = join(workflowsDir, e);
+    const s = await stat(p4).catch(() => null);
+    if (!s?.isDirectory()) continue;
+    if (await fileExists(join(p4, "workflow.yaml"))) {
+      names.push(e);
+      continue;
+    }
+    if (await fileExists(join(p4, "auto", "workflow.yaml"))) {
+      names.push(e);
+      const subs = await readdir(p4).catch(() => []);
+      for (const sub of subs.sort()) {
+        if (sub === "auto") continue;
+        if (await fileExists(join(p4, sub, "workflow.yaml"))) {
+          names.push(`${e}-${sub}`);
+        }
+      }
+    }
+  }
+  return names;
+}
+async function fileExists(path) {
+  return stat(path).then(() => true).catch(() => false);
+}
+async function readStdinToEnd() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+  }
+  return Buffer.concat(chunks).toString("utf8").trim();
+}
+function loadAutoChain() {
+  if (_autoChainCache !== null) return _autoChainCache;
+  if (_autoChainLoadFailed) return [];
+  try {
+    const yamlPath = join(WORKFLOWS_DIR, "auto", "workflow.yaml");
+    const parsed = loadPhases(yamlPath);
+    const delegates = "delegates_to" in parsed && Array.isArray(parsed.delegates_to) ? parsed.delegates_to : [];
+    const sorted = [...delegates].sort((a, b) => {
+      const ao = typeof a.order === "number" ? a.order : Number.MAX_SAFE_INTEGER;
+      const bo = typeof b.order === "number" ? b.order : Number.MAX_SAFE_INTEGER;
+      return ao - bo;
+    });
+    _autoChainCache = sorted.map((d) => d.sub).filter((s) => typeof s === "string");
+    return _autoChainCache;
+  } catch (err2) {
+    _autoChainLoadFailed = true;
+    process.stderr.write(`\u26A0\uFE0F getNextHint failed (${err2.message}); skipping hint.
+`);
+    return [];
+  }
+}
+async function getNextHint(workflowName) {
+  if (workflowName === "auto") return null;
+  const chain = loadAutoChain();
+  if (chain.length === 0) return null;
+  const directIdx = chain.indexOf(workflowName);
+  if (directIdx >= 0) {
+    return directIdx + 1 < chain.length ? chain[directIdx + 1] ?? null : null;
+  }
+  const dashIdx = workflowName.indexOf("-");
+  if (dashIdx > 0) {
+    const parentStage = workflowName.slice(0, dashIdx);
+    const parentIdx = chain.indexOf(parentStage);
+    if (parentIdx >= 0) {
+      return parentIdx + 1 < chain.length ? chain[parentIdx + 1] ?? null : null;
+    }
+  }
+  return null;
 }
 
 // src/cli/execute-task.ts
+var PACKAGE_ROOT2 = getPackageRoot();
+var WORKFLOWS_DIR2 = join(PACKAGE_ROOT2, "workflows");
 function registerExecuteTask(program2) {
   program2.command("execute-task").description(
     "Run execute-task workflow (4-phase chain \u2192 ralph-loop COMPLETE; immediate by default \u2014 use --dry-run for preview)"
@@ -3073,40 +3602,27 @@ function registerExecuteTask(program2) {
       process.exit(2);
     }
     const workflowName = raw.workflow ?? "execute-task";
-    let phases;
-    try {
-      phases = loadPhases(`workflows/${workflowName}/phases.yaml`);
-    } catch (error) {
+    const yamlPath = await resolveWorkflowYaml(workflowName, WORKFLOWS_DIR2);
+    if (!yamlPath) {
       console.error(
         t("execute_task.load_phases_failed", {
           workflow: workflowName,
-          message: error.message
+          message: "workflow.yaml not found"
         })
       );
       process.exit(2);
+      return;
     }
-    if (raw.modelTier === "inherit") {
-      phases = {
-        ...phases,
-        phases: phases.phases.map((p4) => ({ ...p4, model: "inherit" }))
-      };
-    }
-    const taskCtx = { task: raw.task, task_type: "execute-task" };
-    const isDryRun = raw.dryRun === true;
-    if (isDryRun) {
-      console.log(
-        JSON.stringify({ workflow: phases.workflow, phases: phases.phases, taskCtx }, null, 2)
-      );
+    const gateContext = {
+      task: raw.task,
+      ...raw.model ? { modelOverride: raw.model } : {},
+      ...raw.modelTier ? { modelTierOverride: raw.modelTier } : {},
+      ...raw.maxIterations ? { maxIterations: raw.maxIterations } : {}
+    };
+    if (raw.dryRun === true) {
+      console.log(JSON.stringify({ workflow: workflowName, yamlPath, gateContext }, null, 2));
       process.exit(0);
-    }
-    let fallbackConfig;
-    let fallbackPhaseId;
-    for (const ph of phases.phases) {
-      if ("fallback" in ph && ph.fallback?.max_iterations_exceeded) {
-        fallbackConfig = ph.fallback.max_iterations_exceeded;
-        fallbackPhaseId = ph.id;
-        break;
-      }
+      return;
     }
     try {
       const stagedOut = execSync("git status --porcelain", { encoding: "utf8" });
@@ -3122,22 +3638,15 @@ function registerExecuteTask(program2) {
     } catch (err2) {
       console.warn(t("execute_task.precommit_skipped", { message: err2.message }));
     }
-    const result = await runRouting(taskCtx, {
-      maxIterations: raw.maxIterations ?? 20,
-      ...raw.model ? { agentOpts: { modelOverride: raw.model } } : {},
-      ...fallbackConfig ? { fallbackConfig } : {},
-      ...fallbackPhaseId ? { fallbackPhaseId } : {}
-    });
-    if ("aborted" in result) {
-      console.error(t("install.aborted", { reason: result.reason }));
-      process.exit(2);
-    }
-    if ("ok" in result && result.ok === false) {
-      console.error(`error: ${result.phase} \u2014 ${result.error.message}`);
+    let result;
+    try {
+      result = await runWorkflow(yamlPath, {}, { packageRoot: PACKAGE_ROOT2, gateContext });
+    } catch (err2) {
+      console.error(`error: workflow runtime failed \u2014 ${err2.message}`);
       process.exit(1);
+      return;
     }
-    console.log(result.result);
-    process.exit(0);
+    process.exit(result.status === "failed" ? 1 : 0);
   });
 }
 var DURATION_RE = /^(\d+)([dhmw])$/;
@@ -3543,7 +4052,7 @@ async function isPluginRegistered(pluginName) {
   return Object.keys(plugins).some((k) => k.split("@")[0] === pluginName);
 }
 function runArgs(claudeArgs, cwd, timeoutMs = 15e3) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     const isWin = process.platform === "win32";
     const child = isWin ? spawn("cmd.exe", ["/c", "claude", ...claudeArgs], { cwd, windowsHide: true }) : spawn("claude", claudeArgs, { cwd, shell: false });
     let stderr = "";
@@ -3552,15 +4061,15 @@ function runArgs(claudeArgs, cwd, timeoutMs = 15e3) {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve12({ exitCode: -1, stderr: `${stderr}[timeout after ${timeoutMs}ms]` });
+      resolve14({ exitCode: -1, stderr: `${stderr}[timeout after ${timeoutMs}ms]` });
     }, timeoutMs);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve12({ exitCode: -1, stderr: `${stderr}${e.message}` });
+      resolve14({ exitCode: -1, stderr: `${stderr}${e.message}` });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve12({ exitCode: code ?? -1, stderr });
+      resolve14({ exitCode: code ?? -1, stderr });
     });
   });
 }
@@ -3739,10 +4248,10 @@ async function spawnCmd(ctx, cmd, args, timeoutMs) {
   child.stderr?.setEncoding("utf8").on("data", (chunk) => {
     stderr += chunk;
   });
-  return await new Promise((resolve12) => {
+  return await new Promise((resolve14) => {
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve12({
+      resolve14({
         ok: false,
         phase: "spawn",
         error: {
@@ -3757,7 +4266,7 @@ async function spawnCmd(ctx, cmd, args, timeoutMs) {
     }, effectiveTimeoutMs);
     child.on("error", (err2) => {
       clearTimeout(timer);
-      resolve12({
+      resolve14({
         ok: false,
         phase: "spawn",
         error: {
@@ -3772,14 +4281,14 @@ async function spawnCmd(ctx, cmd, args, timeoutMs) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve12({ ok: true, exitCode: code ?? -1, stdout: stdout2, stderr });
+      resolve14({ ok: true, exitCode: code ?? -1, stdout: stdout2, stderr });
     });
   });
 }
 
 // src/installers/gitCloneWithSetup.ts
 function gitRevParseHead(cwd, timeoutMs = 1e4) {
-  return new Promise((resolve12) => {
+  return new Promise((resolve14) => {
     const isWin = process.platform === "win32";
     const child = isWin ? spawn("cmd.exe", ["/c", "git", "rev-parse", "HEAD"], { cwd, windowsHide: true }) : spawn("git", ["rev-parse", "HEAD"], { cwd, shell: false });
     let stdout2 = "";
@@ -3788,15 +4297,15 @@ function gitRevParseHead(cwd, timeoutMs = 1e4) {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve12({ sha: "", exit: -1 });
+      resolve14({ sha: "", exit: -1 });
     }, timeoutMs);
     child.on("error", () => {
       clearTimeout(timer);
-      resolve12({ sha: "", exit: -1 });
+      resolve14({ sha: "", exit: -1 });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve12({ sha: stdout2.trim(), exit: code ?? -1 });
+      resolve14({ sha: stdout2.trim(), exit: code ?? -1 });
     });
   });
 }
@@ -3967,16 +4476,16 @@ var installGitCloneWithSetup = async (ctx) => {
 function resolveEnvVars(value) {
   const pattern = /\$\{([A-Z_][A-Z0-9_]*)\}/g;
   let resolved = value;
-  let match2;
+  let match;
   pattern.lastIndex = 0;
-  while ((match2 = pattern.exec(value)) !== null) {
-    const name = match2[1];
+  while ((match = pattern.exec(value)) !== null) {
+    const name = match[1];
     if (name === void 0) continue;
     const v = process.env[name];
     if (v === void 0 || v === "") {
       return { ok: false, missing: name };
     }
-    resolved = resolved.replace(match2[0], v);
+    resolved = resolved.replace(match[0], v);
   }
   return { ok: true, resolved };
 }
@@ -4508,16 +5017,6 @@ async function runInstall(manifest, opts) {
 
 // src/cli/install.ts
 init_path_guard();
-function getPackageRoot() {
-  const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = dirname(thisFile);
-  if (thisDir.endsWith("dist") || thisDir.replace(/\\/g, "/").endsWith("/dist")) {
-    return resolve(thisDir, "..");
-  }
-  return resolve(thisDir, "..", "..", "..");
-}
-
-// src/cli/install.ts
 function formatError(e) {
   const head = `error: ${e.message}`;
   const where = e.path && e.path !== "/" ? `
@@ -4715,8 +5214,8 @@ function registerManifestAdd(program2) {
     process.exit(0);
   });
 }
-
-// src/cli/research.ts
+var PACKAGE_ROOT3 = getPackageRoot();
+var WORKFLOWS_DIR3 = join(PACKAGE_ROOT3, "workflows");
 function registerResearch(program2) {
   program2.command("research").description(
     "Run research workflow (search category sub-routing \u2192 spawn \u2192 verbatim COMPLETE; immediate by default \u2014 use --dry-run for preview)"
@@ -4725,48 +5224,30 @@ function registerResearch(program2) {
       console.error(t("research.require_query"));
       process.exit(2);
     }
-    const taskCtx = { task: raw.query, task_type: "search" };
+    const yamlPath = await resolveWorkflowYaml("research", WORKFLOWS_DIR3);
+    if (!yamlPath) {
+      console.error(`error: workflows/research/workflow.yaml not found under ${WORKFLOWS_DIR3}`);
+      process.exit(2);
+      return;
+    }
+    const gateContext = {
+      task: raw.query,
+      ...raw.model ? { modelOverride: raw.model } : {}
+    };
     if (raw.dryRun === true) {
-      const preview = await runRouting(taskCtx, {
-        skillsRoot: void 0,
-        // Stub spawn — dry-run never reaches it; explicit COMPLETE keeps shape happy.
-        spawn: async () => "dry-run preview\nCOMPLETE",
-        maxIterations: 1,
-        ...raw.model ? { agentOpts: { modelOverride: raw.model } } : {}
-      });
-      if ("aborted" in preview) {
-        console.error(t("install.aborted", { reason: preview.reason }));
-        process.exit(2);
-      }
-      if ("ok" in preview && preview.ok === false) {
-        console.error(`error: ${preview.phase} \u2014 ${preview.error.message}`);
-        process.exit(1);
-      }
-      console.log(
-        t("research.dry_run.matched_rule", {
-          rule: preview.matchedRule?.id ?? "(fallback supervisor)"
-        })
-      );
-      console.log(t("research.dry_run.query", { query: raw.query }));
-      console.log(t("research.dry_run.run_hint"));
+      console.log(JSON.stringify({ workflow: "research", yamlPath, gateContext }, null, 2));
       process.exit(0);
+      return;
     }
-    const result = await runRouting(taskCtx, {
-      ...raw.model ? { agentOpts: { modelOverride: raw.model } } : {}
-    });
-    if ("aborted" in result) {
-      console.error(t("install.aborted", { reason: result.reason }));
-      process.exit(2);
-    }
-    if ("ok" in result && result.ok === false) {
-      console.error(`error: ${result.phase} \u2014 ${result.error.message}`);
-      if (result.phase === "install") {
-        console.error(t("research.install_fix_hint"));
-      }
+    let result;
+    try {
+      result = await runWorkflow(yamlPath, {}, { packageRoot: PACKAGE_ROOT3, gateContext });
+    } catch (err2) {
+      console.error(`error: workflow runtime failed \u2014 ${err2.message}`);
       process.exit(1);
+      return;
     }
-    console.log(result.result);
-    process.exit(0);
+    process.exit(result.status === "failed" ? 1 : 0);
   });
 }
 
@@ -4939,13 +5420,13 @@ function resolveCapabilityCmd(capability, installedPlugins, installedUserSkills)
 var CAPABILITY_CMD_TEMPLATE = /\{\{\s*capabilities\.([a-zA-Z0-9_-]+)\.cmd\s*\}\}/g;
 function renderSkillBody(body, capabilities, installedPlugins, installedUserSkills) {
   const warningsSet = /* @__PURE__ */ new Set();
-  const out = body.replace(CAPABILITY_CMD_TEMPLATE, (match2, name) => {
+  const out = body.replace(CAPABILITY_CMD_TEMPLATE, (match, name) => {
     const cap = capabilities[name];
     if (!cap) {
       warningsSet.add(
         `capability '${name}' referenced in SKILL.md but not defined in capabilities.yaml`
       );
-      return match2;
+      return match;
     }
     const { renderedCmd, warning } = resolveCapabilityCmd(
       cap,
@@ -5123,114 +5604,6 @@ async function atomicWrite2(path, content) {
     return `write ${path} failed: ${err2.message}`;
   }
 }
-async function loadRolePrompts(workflowsDir) {
-  const path = join(workflowsDir, "role-prompts.yaml");
-  let raw;
-  try {
-    raw = await readFile(path, "utf8");
-  } catch {
-    return {};
-  }
-  const doc = parse(raw);
-  return doc?.prompts ?? {};
-}
-function generateCommandFile(name, prompt, capabilities, installedPlugins, installedUserSkills) {
-  const isMaster = prompt.is_master === true;
-  const primaryCmdLine = prompt.primary_cap && capabilities[prompt.primary_cap] ? `{{ capabilities.${prompt.primary_cap}.cmd }}` : "";
-  const checklistBlock = prompt.checklist.length ? prompt.checklist.map((item, i) => `> ${i + 1}. ${item}`).join("\n>\n") : "> (Master orchestrator \u2014 dispatches to per-sub-workflow slash commands listed below.)";
-  const fallbackPath = isMaster ? `**Fallback path** (when no slash command from the sub-list resolves): run each missing sub-workflow inline using its own role prompt (see \`~/.claude/skills/<sub-name>/SKILL.md\` for the per-sub fallback prompt). Do NOT skip stages silently \u2014 each sub either runs or is logged as "skipped: <reason>".` : [
-    `**Fallback path** (when the upstream isn't installed or returns no result): use the Task tool to spawn a general-purpose subagent with this prompt:`,
-    ``,
-    `> You are a **${prompt.specialist}**.`,
-    `>`,
-    `> **Mission**: ${prompt.responsibility.trim().replace(/\n/g, " ")}`,
-    `>`,
-    `> **Default-suspect mode**: assume the change is broken / risky / incomplete until proven otherwise. Cite \`file:line\` for every finding; do not generalize.`,
-    `>`,
-    `> **Review checklist**:`,
-    checklistBlock,
-    `>`,
-    `> **Output format**: structured report with severity-classified findings (${prompt.severity}). One finding per line: \`[severity] file:line \u2014 problem (one sentence); fix: suggested change\`. If no findings, say so explicitly. No preamble, no end-of-report summary.`,
-    ``,
-    `(The role prompt is self-contained \u2014 works even when the upstream \`${prompt.primary_cap || "specialist"}\` user-skill / plugin isn't installed.)`
-  ].join("\n");
-  const preferredPath = primaryCmdLine ? `**Preferred path** (when the upstream specialist is installed): use the SlashCommand tool to run \`${primaryCmdLine}\` \u2014 the upstream specialist takes over.` : `**Preferred path** (master orchestrator): dispatch to the per-sub-workflow slash commands in the order this stage prescribes. Each sub command is its own \`~/.claude/commands/<sub-name>.md\` and has its own dual-path fallback.`;
-  const rawBody = [
-    `# /${name}`,
-    ``,
-    prompt.description,
-    ``,
-    `## How to invoke`,
-    ``,
-    preferredPath,
-    ``,
-    fallbackPath,
-    ``,
-    `## Notes`,
-    ``,
-    `- This file (\`~/.claude/commands/${name}.md\`) is generated by \`harnessed setup\` from \`workflows/role-prompts.yaml\` + \`workflows/<stage>/<sub>/SKILL.md\`. To regenerate after a harnessed upgrade, re-run \`harnessed setup\`.`,
-    `- The companion \`~/.claude/skills/${name}/SKILL.md\` is the Skill-tool entry point (Claude loads it when triggers match \`trigger_phrases:\`). Both files carry the same dual-path instruction.`,
-    `- If your shell shows a \`\u26A0\uFE0F ... not installed\` warning from \`harnessed setup\` for this command, the upstream is missing on disk \u2014 install per the warning, OR rely on the fallback Task-spawn role prompt above (it does not require the upstream).`,
-    ``
-  ].join("\n");
-  const { body, warnings } = renderSkillBody(
-    rawBody,
-    capabilities,
-    installedPlugins,
-    installedUserSkills
-  );
-  const frontmatter = ["---", `description: ${JSON.stringify(prompt.description)}`, "---", ""].join(
-    "\n"
-  );
-  return { content: frontmatter + body, warnings };
-}
-async function writeAllCommands(slashNames, commandsDir, rolePrompts, capabilities, installedPlugins, installedUserSkills, writer, fileExists = existsSync) {
-  const results = [];
-  const aggregatedWarnings = /* @__PURE__ */ new Set();
-  for (const name of slashNames) {
-    const path = join(commandsDir, `${name}.md`);
-    const prompt = rolePrompts[name];
-    if (!prompt) {
-      results.push({
-        name,
-        path,
-        written: false,
-        warning: `no role-prompts.yaml entry for '${name}' \u2014 skipping commands/${name}.md generation`
-      });
-      aggregatedWarnings.add(`role-prompts.yaml missing entry for '${name}'`);
-      continue;
-    }
-    if (fileExists(path)) {
-      results.push({
-        name,
-        path,
-        written: false,
-        warning: `commands/${name}.md already exists \u2014 leaving user file unchanged`
-      });
-      continue;
-    }
-    const { content, warnings } = generateCommandFile(
-      name,
-      prompt,
-      capabilities,
-      installedPlugins,
-      installedUserSkills
-    );
-    try {
-      await writer(path, content);
-      results.push({ name, path, written: true });
-    } catch (e) {
-      results.push({
-        name,
-        path,
-        written: false,
-        warning: `write failed for commands/${name}.md: ${e.message}`
-      });
-    }
-    for (const w of warnings) aggregatedWarnings.add(w);
-  }
-  return { results, warnings: [...aggregatedWarnings] };
-}
 async function loadCapabilities(workflowsDir) {
   const path = join(workflowsDir, "capabilities.yaml");
   const raw = await readFile(path, "utf8");
@@ -5865,7 +6238,7 @@ var uninstallNpmCli = async (ctx) => {
   const m = install.cmd.match(/npm\s+(?:install|i)\s+(?:-g\s+)?(\S+)/);
   const pkg = m?.[1] ?? ctx.manifest.metadata.upstream.source;
   const isWin = process.platform === "win32";
-  const result = await new Promise((resolve12) => {
+  const result = await new Promise((resolve14) => {
     const child = isWin ? spawn("cmd.exe", ["/c", "npm", "uninstall", "-g", pkg], { windowsHide: true }) : spawn("npm", ["uninstall", "-g", pkg], { shell: false });
     let stderr = "";
     child.stderr?.setEncoding("utf8").on("data", (c) => {
@@ -5873,15 +6246,15 @@ var uninstallNpmCli = async (ctx) => {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve12({ exitCode: -1, stderr: `${stderr}[timeout]` });
+      resolve14({ exitCode: -1, stderr: `${stderr}[timeout]` });
     }, 3e4);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve12({ exitCode: -1, stderr: e.message });
+      resolve14({ exitCode: -1, stderr: e.message });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve12({ exitCode: code ?? -1, stderr });
+      resolve14({ exitCode: code ?? -1, stderr });
     });
   });
   if (result.exitCode !== 0) {
@@ -6030,6 +6403,7 @@ registerGc(program);
 registerResume(program);
 registerUninstall(program);
 registerSetup(program);
+registerRun(program);
 program.parse(process.argv);
 //# sourceMappingURL=cli.mjs.map
 //# sourceMappingURL=cli.mjs.map