harnessed 3.9.26 → 4.0.1

package/dist/cli.mjs

@@ -3,22 +3,22 @@ import { spawnSync, spawn, execSync } from 'child_process';
 import { existsSync, mkdirSync, renameSync, writeFileSync, readFileSync, readdirSync } from 'fs';
 import { join, dirname, resolve, sep, relative } from 'path';
 import { homedir } from 'os';
-import { readFile, readdir, unlink, writeFile, stat, rm, cp, mkdir, access, rename } from 'fs/promises';
 import { Type } from '@sinclair/typebox';
+import { readFile, readdir, unlink, writeFile, stat, rm, cp, mkdir, access, rename } from 'fs/promises';
 import { Value } from '@sinclair/typebox/value';
-import { LineCounter, parseDocument, parse, isSeq, isScalar } from 'yaml';
 import lockfile from 'proper-lockfile';
+import { parse, LineCounter, parseDocument, isSeq, isScalar } from 'yaml';
 import * as p from '@clack/prompts';
 import { Command } from 'commander';
 import { Ajv } from 'ajv';
 import * as ajvFormatsNs from 'ajv-formats';
 import { fileURLToPath } from 'url';
 import { createHash } from 'crypto';
+import { Parser } from 'expr-eval';
 import { createPatch } from 'diff';
 import pc from 'picocolors';
 import { stdout, stdin } from 'process';
 import * as readline from 'readline/promises';
-import { Parser } from 'expr-eval';
 import { query } from '@anthropic-ai/claude-agent-sdk';
 
 var __defProp = Object.defineProperty;
@@ -119,6 +119,325 @@ var init_harnessedRoot = __esm({
   "src/installers/lib/harnessedRoot.ts"() {
   }
 });
+function branchOnSchemaVersion(v, handlers) {
+  const isKnownVersion = Object.values(SCHEMA_VERSIONS).includes(v);
+  return isKnownVersion ? handlers.v1() : handlers.unknown();
+}
+var SCHEMA_VERSIONS;
+var init_schemaVersion = __esm({
+  "src/types/schemaVersion.ts"() {
+    SCHEMA_VERSIONS = {
+      routingSnapshot: "harnessed.routing-snapshot.v1",
+      handoffDoc: "harnessed.handoff-doc.v1",
+      phasesYaml: "harnessed.phases-yaml.v1",
+      manifestState: "harnessed.manifest-state.v1",
+      installerState: "harnessed.installer-state.v1",
+      routeDecisionLog: "harnessed.route-decision-log.v1",
+      checkpoint: "harnessed.checkpoint.v1",
+      currentWorkflow: "harnessed.current-workflow.v1",
+      // ← Phase 3.1 W1 T1.1 ADD (D-02 KARPATHY 3-state)
+      config: "harnessed.config.v1",
+      // ← Phase 3.2 W1 T1.1 ADD (D-01 PROBE gstack_prefix store)
+      governance: "harnessed.governance.v1",
+      // ← Phase 3.2 W1 T1.1 ADD (D-04 PUSH veto status)
+      aliases: "harnessed.aliases.v1",
+      // ← Phase 3.3 W1 T1.1 ADD (D-01 RICH)
+      knownGood: "harnessed.known-good.v1",
+      // ← Phase 3.3 W1 T1.1 ADD (D-03 YAML manifest)
+      capabilities: "harnessed.capabilities.v1",
+      // ← Phase v2.0-2.3 W0 ADD (R20.2 flat yaml capabilities manifest validate)
+      judgment: "harnessed.judgment.v1",
+      // ← Phase v2.0-2.3 W0 ADD (R20.4 multi-file judgments validate)
+      workflow: "harnessed.workflow.v2",
+      // ← Phase v2.0-2.4 W0 T2.4.W0.1 ADD (R20.1+R20.2+R20.9 workflow.yaml v2)
+      workflow_v3: "harnessed.workflow.v3",
+      // ← Phase v3.0-3.3 W0 T3.3.W0.11 ADD (D-09 disciplines_applied + D-05 tools_available + master delegates_to per Pattern A B.1 LOCK)
+      discipline: "harnessed.discipline.v1"
+      // ← Phase v3.0-3.3 W0 T3.3.W0.11 ADD (D-09 L0 Discipline Substrate, sister judgment.v1 multi-file pattern)
+    };
+    Type.Union([
+      Type.Literal(SCHEMA_VERSIONS.routingSnapshot),
+      Type.Literal(SCHEMA_VERSIONS.handoffDoc),
+      Type.Literal(SCHEMA_VERSIONS.phasesYaml),
+      Type.Literal(SCHEMA_VERSIONS.manifestState),
+      Type.Literal(SCHEMA_VERSIONS.installerState),
+      Type.Literal(SCHEMA_VERSIONS.routeDecisionLog),
+      Type.Literal(SCHEMA_VERSIONS.checkpoint),
+      Type.Literal(SCHEMA_VERSIONS.currentWorkflow),
+      // ← Phase 3.1 W1 T1.1 ADD
+      Type.Literal(SCHEMA_VERSIONS.config),
+      // ← Phase 3.2 W1 T1.1 ADD
+      Type.Literal(SCHEMA_VERSIONS.governance),
+      // ← Phase 3.2 W1 T1.1 ADD
+      Type.Literal(SCHEMA_VERSIONS.aliases),
+      // ← Phase 3.3 W1 T1.1 ADD
+      Type.Literal(SCHEMA_VERSIONS.knownGood),
+      // ← Phase 3.3 W1 T1.1 ADD
+      Type.Literal(SCHEMA_VERSIONS.capabilities),
+      // ← Phase v2.0-2.3 W0 ADD
+      Type.Literal(SCHEMA_VERSIONS.judgment),
+      // ← Phase v2.0-2.3 W0 ADD
+      Type.Literal(SCHEMA_VERSIONS.workflow),
+      // ← Phase v2.0-2.4 W0 T2.4.W0.1 ADD (first .v2 in union)
+      Type.Literal(SCHEMA_VERSIONS.workflow_v3),
+      // ← Phase v3.0-3.3 W0 T3.3.W0.11 ADD (first .v3 in union)
+      Type.Literal(SCHEMA_VERSIONS.discipline)
+      // ← Phase v3.0-3.3 W0 T3.3.W0.11 ADD
+    ]);
+  }
+});
+var CheckpointStatus, CheckpointV1;
+var init_checkpoint_v1 = __esm({
+  "src/checkpoint/schema/checkpoint.v1.ts"() {
+    init_schemaVersion();
+    CheckpointStatus = Type.Union([
+      Type.Literal("active"),
+      Type.Literal("paused"),
+      Type.Literal("complete")
+    ]);
+    CheckpointV1 = Type.Object(
+      {
+        schemaVersion: Type.Literal(SCHEMA_VERSIONS.checkpoint),
+        phase: Type.String({ minLength: 1 }),
+        status: CheckpointStatus,
+        last_task: Type.String(),
+        key_decisions: Type.Array(Type.String()),
+        canonical_refs: Type.Array(Type.String()),
+        /** D-04 WIRE-IN: optional SDK session_id captured via `sdkSpawn`
+         *  `onSessionId` callback (CD-4 closure-ready) for future `--resume`. */
+        session_id: Type.Optional(Type.String()),
+        /** RESEARCH § 1.3 critical constraint — SDK session resume requires cwd
+         *  match; we capture and validate at restore time. */
+        cwd: Type.String({ minLength: 1 }),
+        timestamp: Type.String({ minLength: 1 }),
+        // ISO-8601 by convention (TypeBox `format` requires Ajv-style format registry; we keep shape-check only — drift caught in writeCheckpoint path)
+        archive_path: Type.String({ minLength: 1 })
+      },
+      { additionalProperties: false }
+    );
+  }
+});
+var WorkflowStatus, CurrentWorkflowV1;
+var init_currentWorkflow_v1 = __esm({
+  "src/checkpoint/schema/currentWorkflow.v1.ts"() {
+    init_schemaVersion();
+    WorkflowStatus = Type.Union([
+      Type.Literal("active"),
+      Type.Literal("paused"),
+      Type.Literal("complete")
+    ]);
+    CurrentWorkflowV1 = Type.Object(
+      {
+        schemaVersion: Type.Literal(SCHEMA_VERSIONS.currentWorkflow),
+        phase: Type.String({ minLength: 1 }),
+        status: WorkflowStatus,
+        last_checkpoint_path: Type.Union([Type.String(), Type.Null()]),
+        // ISO-8601 by convention (TypeBox `format` requires Ajv-style registry; shape-check only here, drift surfaces in state.ts writer).
+        started_at: Type.String({ minLength: 1 }),
+        paused_at: Type.Optional(Type.String({ minLength: 1 })),
+        completed_at: Type.Optional(Type.String({ minLength: 1 }))
+      },
+      { additionalProperties: false }
+    );
+  }
+});
+
+// src/checkpoint/schema/index.ts
+var init_schema = __esm({
+  "src/checkpoint/schema/index.ts"() {
+    init_checkpoint_v1();
+    init_currentWorkflow_v1();
+  }
+});
+function statePath() {
+  return harnessedFile("current-workflow.json");
+}
+function lockTarget() {
+  return getHarnessedRoot();
+}
+function lockOpts() {
+  return {
+    stale: 1e4,
+    retries: { retries: 3, factor: 2, minTimeout: 100 },
+    lockfilePath: harnessedFile(".lock")
+  };
+}
+async function withLock(fn) {
+  const target = lockTarget();
+  await mkdir(target, { recursive: true });
+  let release;
+  try {
+    release = await lockfile.lock(target, lockOpts());
+  } catch (e) {
+    if (e.code === "ELOCKED") throw new LockHeldError();
+    throw e;
+  }
+  try {
+    return await fn();
+  } finally {
+    await release?.();
+  }
+}
+async function readCurrentWorkflow() {
+  let raw;
+  try {
+    raw = await readFile(statePath(), "utf8");
+  } catch {
+    return null;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  const v = parsed.schemaVersion ?? "";
+  return branchOnSchemaVersion(v, {
+    v1: () => Value.Check(CurrentWorkflowV1, parsed) ? parsed : null,
+    unknown: () => null
+  });
+}
+async function writeCurrentWorkflow(s) {
+  if (!Value.Check(CurrentWorkflowV1, s)) {
+    const errs = [...Value.Errors(CurrentWorkflowV1, s)].map((e) => e.message).join("; ");
+    throw new WorkflowStateError(`current-workflow schema validation failed: ${errs}`);
+  }
+  const path = statePath();
+  await mkdir(dirname(path), { recursive: true });
+  await withLock(async () => {
+    await writeFile(path, JSON.stringify(s, null, 2), "utf8");
+  });
+}
+async function activate(phase, checkpointPath = null) {
+  await writeCurrentWorkflow({
+    schemaVersion: SCHEMA_VERSIONS.currentWorkflow,
+    phase,
+    status: "active",
+    last_checkpoint_path: checkpointPath,
+    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;
+  await writeCurrentWorkflow({ ...s, status: "complete", completed_at: (/* @__PURE__ */ new Date()).toISOString() });
+}
+var WorkflowStateError, LockHeldError;
+var init_state = __esm({
+  "src/checkpoint/state.ts"() {
+    init_harnessedRoot();
+    init_schemaVersion();
+    init_schema();
+    WorkflowStateError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "WorkflowStateError";
+      }
+    };
+    LockHeldError = class _LockHeldError extends Error {
+      constructor() {
+        super(
+          `another harnessed process holds the lock at ${harnessedFile(".lock")} \u2014 wait or kill stale process (try: harnessed status)`
+        );
+        this.name = "LockHeldError";
+        Object.setPrototypeOf(this, _LockHeldError.prototype);
+      }
+    };
+  }
+});
+function estimateTokens(s) {
+  return Math.ceil(Buffer.byteLength(s, "utf8") / 4);
+}
+function enforceBudget(c, budget = BUDGET_TOKEN) {
+  let candidate = c;
+  let tokens = estimateTokens(JSON.stringify(candidate));
+  if (tokens <= budget) return candidate;
+  candidate = { ...candidate, last_task: candidate.last_task.slice(0, 200) };
+  tokens = estimateTokens(JSON.stringify(candidate));
+  if (tokens <= budget) return candidate;
+  candidate = { ...candidate, key_decisions: candidate.key_decisions.slice(0, 5) };
+  tokens = estimateTokens(JSON.stringify(candidate));
+  if (tokens <= budget) return candidate;
+  throw new CheckpointTooLargeError(
+    `Checkpoint exceeds ${budget}-token budget even after truncation (estimated ${tokens})`
+  );
+}
+function writeCheckpoint(c, customPath) {
+  if (!Value.Check(CheckpointV1, c)) {
+    const errs = [...Value.Errors(CheckpointV1, c)].map((e) => e.message).join("; ");
+    throw new CheckpointWriteError(`Schema validation failed: ${errs}`);
+  }
+  const enforced = enforceBudget(c);
+  const path = join(harnessedSubdir("checkpoints"), `${enforced.phase}.json`);
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, JSON.stringify(enforced, null, 2), "utf8");
+  return path;
+}
+var BUDGET_TOKEN, CheckpointTooLargeError, CheckpointWriteError;
+var init_template = __esm({
+  "src/checkpoint/template.ts"() {
+    init_harnessedRoot();
+    init_schema();
+    BUDGET_TOKEN = 1e3;
+    CheckpointTooLargeError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "CheckpointTooLargeError";
+      }
+    };
+    CheckpointWriteError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "CheckpointWriteError";
+      }
+    };
+  }
+});
+
+// src/checkpoint/engineHook.ts
+var engineHook_exports = {};
+__export(engineHook_exports, {
+  activatePhase: () => activatePhase,
+  completePhase: () => completePhase
+});
+async function activatePhase(phaseId) {
+  const checkpointPath = join(harnessedSubdir("checkpoints"), `${phaseId}.json`);
+  await activate(phaseId, checkpointPath);
+  return { checkpointPath };
+}
+async function completePhase(ctx) {
+  if (ctx.phaseId === "unknown") {
+    console.error(
+      `[harnessed] WARN engineHook: phaseId="unknown" \u2014 checkpoint paths fall back to ${join(harnessedSubdir("checkpoints"), "unknown.json")} (Karpathy fail-loud non-blocking; W-04 mitigation)`
+    );
+  }
+  writeCheckpoint({
+    schemaVersion: SCHEMA_VERSIONS.checkpoint,
+    phase: ctx.phaseId,
+    status: "complete",
+    last_task: ctx.lastTask ?? "engine.runRouting complete",
+    key_decisions: ctx.keyDecisions ?? [],
+    canonical_refs: ctx.canonicalRefs ?? [],
+    ...ctx.sessionId ? { session_id: ctx.sessionId } : {},
+    cwd: process.cwd(),
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    archive_path: `${join(harnessedSubdir("archive"), `phase-${ctx.phaseId}`)}/`
+  });
+  await complete();
+}
+var init_engineHook = __esm({
+  "src/checkpoint/engineHook.ts"() {
+    init_harnessedRoot();
+    init_schemaVersion();
+    init_state();
+    init_template();
+  }
+});
 function checkNodeVersion() {
   const v = process.versions.node;
   const major = Number.parseInt(v.split(".")[0] ?? "0", 10);
@@ -244,98 +563,31 @@ var init_probe_gstack = __esm({
 function checkPathSafe(input) {
   for (const re of PATH_TRAVERSAL_PATTERNS) {
     if (re.test(input)) throw new PathTraversalError();
-  }
-}
-var PATH_TRAVERSAL_PATTERNS, PathTraversalError;
-var init_path_guard = __esm({
-  "src/manifest/lib/path-guard.ts"() {
-    PATH_TRAVERSAL_PATTERNS = [
-      /\.\.\//,
-      // (1) Unix dot-dot-slash: ../../etc/passwd
-      /\.\.\\/,
-      // (2) Windows backslash: ..\windows\system32
-      // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional null-byte injection detection (R10.4 D-03 OWASP A1 vector 3)
-      /\x00/,
-      // (3) Null byte injection: path\x00attack
-      /%2[eE]%2[eE]/,
-      // (4) URL-encoded dot-dot: %2e%2e%2fetc
-      /%25[2][eE]%25[2][eE]/
-      // (5) Double-encoded: %252e%252e%252f
-    ];
-    PathTraversalError = class _PathTraversalError extends Error {
-      constructor() {
-        super("path traversal attempt detected");
-        this.name = "PathTraversalError";
-        Object.setPrototypeOf(this, _PathTraversalError.prototype);
-      }
-    };
-  }
-});
-function branchOnSchemaVersion(v, handlers) {
-  const isKnownVersion = Object.values(SCHEMA_VERSIONS).includes(v);
-  return isKnownVersion ? handlers.v1() : handlers.unknown();
-}
-var SCHEMA_VERSIONS;
-var init_schemaVersion = __esm({
-  "src/types/schemaVersion.ts"() {
-    SCHEMA_VERSIONS = {
-      routingSnapshot: "harnessed.routing-snapshot.v1",
-      handoffDoc: "harnessed.handoff-doc.v1",
-      phasesYaml: "harnessed.phases-yaml.v1",
-      manifestState: "harnessed.manifest-state.v1",
-      installerState: "harnessed.installer-state.v1",
-      routeDecisionLog: "harnessed.route-decision-log.v1",
-      checkpoint: "harnessed.checkpoint.v1",
-      currentWorkflow: "harnessed.current-workflow.v1",
-      // ← Phase 3.1 W1 T1.1 ADD (D-02 KARPATHY 3-state)
-      config: "harnessed.config.v1",
-      // ← Phase 3.2 W1 T1.1 ADD (D-01 PROBE gstack_prefix store)
-      governance: "harnessed.governance.v1",
-      // ← Phase 3.2 W1 T1.1 ADD (D-04 PUSH veto status)
-      aliases: "harnessed.aliases.v1",
-      // ← Phase 3.3 W1 T1.1 ADD (D-01 RICH)
-      knownGood: "harnessed.known-good.v1",
-      // ← Phase 3.3 W1 T1.1 ADD (D-03 YAML manifest)
-      capabilities: "harnessed.capabilities.v1",
-      // ← Phase v2.0-2.3 W0 ADD (R20.2 flat yaml capabilities manifest validate)
-      judgment: "harnessed.judgment.v1",
-      // ← Phase v2.0-2.3 W0 ADD (R20.4 multi-file judgments validate)
-      workflow: "harnessed.workflow.v2",
-      // ← Phase v2.0-2.4 W0 T2.4.W0.1 ADD (R20.1+R20.2+R20.9 workflow.yaml v2)
-      workflow_v3: "harnessed.workflow.v3",
-      // ← Phase v3.0-3.3 W0 T3.3.W0.11 ADD (D-09 disciplines_applied + D-05 tools_available + master delegates_to per Pattern A B.1 LOCK)
-      discipline: "harnessed.discipline.v1"
-      // ← Phase v3.0-3.3 W0 T3.3.W0.11 ADD (D-09 L0 Discipline Substrate, sister judgment.v1 multi-file pattern)
+  }
+}
+var PATH_TRAVERSAL_PATTERNS, PathTraversalError;
+var init_path_guard = __esm({
+  "src/manifest/lib/path-guard.ts"() {
+    PATH_TRAVERSAL_PATTERNS = [
+      /\.\.\//,
+      // (1) Unix dot-dot-slash: ../../etc/passwd
+      /\.\.\\/,
+      // (2) Windows backslash: ..\windows\system32
+      // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional null-byte injection detection (R10.4 D-03 OWASP A1 vector 3)
+      /\x00/,
+      // (3) Null byte injection: path\x00attack
+      /%2[eE]%2[eE]/,
+      // (4) URL-encoded dot-dot: %2e%2e%2fetc
+      /%25[2][eE]%25[2][eE]/
+      // (5) Double-encoded: %252e%252e%252f
+    ];
+    PathTraversalError = class _PathTraversalError extends Error {
+      constructor() {
+        super("path traversal attempt detected");
+        this.name = "PathTraversalError";
+        Object.setPrototypeOf(this, _PathTraversalError.prototype);
+      }
     };
-    Type.Union([
-      Type.Literal(SCHEMA_VERSIONS.routingSnapshot),
-      Type.Literal(SCHEMA_VERSIONS.handoffDoc),
-      Type.Literal(SCHEMA_VERSIONS.phasesYaml),
-      Type.Literal(SCHEMA_VERSIONS.manifestState),
-      Type.Literal(SCHEMA_VERSIONS.installerState),
-      Type.Literal(SCHEMA_VERSIONS.routeDecisionLog),
-      Type.Literal(SCHEMA_VERSIONS.checkpoint),
-      Type.Literal(SCHEMA_VERSIONS.currentWorkflow),
-      // ← Phase 3.1 W1 T1.1 ADD
-      Type.Literal(SCHEMA_VERSIONS.config),
-      // ← Phase 3.2 W1 T1.1 ADD
-      Type.Literal(SCHEMA_VERSIONS.governance),
-      // ← Phase 3.2 W1 T1.1 ADD
-      Type.Literal(SCHEMA_VERSIONS.aliases),
-      // ← Phase 3.3 W1 T1.1 ADD
-      Type.Literal(SCHEMA_VERSIONS.knownGood),
-      // ← Phase 3.3 W1 T1.1 ADD
-      Type.Literal(SCHEMA_VERSIONS.capabilities),
-      // ← Phase v2.0-2.3 W0 ADD
-      Type.Literal(SCHEMA_VERSIONS.judgment),
-      // ← Phase v2.0-2.3 W0 ADD
-      Type.Literal(SCHEMA_VERSIONS.workflow),
-      // ← Phase v2.0-2.4 W0 T2.4.W0.1 ADD (first .v2 in union)
-      Type.Literal(SCHEMA_VERSIONS.workflow_v3),
-      // ← Phase v3.0-3.3 W0 T3.3.W0.11 ADD (first .v3 in union)
-      Type.Literal(SCHEMA_VERSIONS.discipline)
-      // ← Phase v3.0-3.3 W0 T3.3.W0.11 ADD
-    ]);
   }
 });
 var AliasEntryV1, AliasesV1;
@@ -442,117 +694,6 @@ var init_check_deprecations = __esm({
     init_aliases();
   }
 });
-var CheckpointStatus, CheckpointV1;
-var init_checkpoint_v1 = __esm({
-  "src/checkpoint/schema/checkpoint.v1.ts"() {
-    init_schemaVersion();
-    CheckpointStatus = Type.Union([
-      Type.Literal("active"),
-      Type.Literal("paused"),
-      Type.Literal("complete")
-    ]);
-    CheckpointV1 = Type.Object(
-      {
-        schemaVersion: Type.Literal(SCHEMA_VERSIONS.checkpoint),
-        phase: Type.String({ minLength: 1 }),
-        status: CheckpointStatus,
-        last_task: Type.String(),
-        key_decisions: Type.Array(Type.String()),
-        canonical_refs: Type.Array(Type.String()),
-        /** D-04 WIRE-IN: optional SDK session_id captured via `sdkSpawn`
-         *  `onSessionId` callback (CD-4 closure-ready) for future `--resume`. */
-        session_id: Type.Optional(Type.String()),
-        /** RESEARCH § 1.3 critical constraint — SDK session resume requires cwd
-         *  match; we capture and validate at restore time. */
-        cwd: Type.String({ minLength: 1 }),
-        timestamp: Type.String({ minLength: 1 }),
-        // ISO-8601 by convention (TypeBox `format` requires Ajv-style format registry; we keep shape-check only — drift caught in writeCheckpoint path)
-        archive_path: Type.String({ minLength: 1 })
-      },
-      { additionalProperties: false }
-    );
-  }
-});
-var WorkflowStatus, CurrentWorkflowV1;
-var init_currentWorkflow_v1 = __esm({
-  "src/checkpoint/schema/currentWorkflow.v1.ts"() {
-    init_schemaVersion();
-    WorkflowStatus = Type.Union([
-      Type.Literal("active"),
-      Type.Literal("paused"),
-      Type.Literal("complete")
-    ]);
-    CurrentWorkflowV1 = Type.Object(
-      {
-        schemaVersion: Type.Literal(SCHEMA_VERSIONS.currentWorkflow),
-        phase: Type.String({ minLength: 1 }),
-        status: WorkflowStatus,
-        last_checkpoint_path: Type.Union([Type.String(), Type.Null()]),
-        // ISO-8601 by convention (TypeBox `format` requires Ajv-style registry; shape-check only here, drift surfaces in state.ts writer).
-        started_at: Type.String({ minLength: 1 }),
-        paused_at: Type.Optional(Type.String({ minLength: 1 })),
-        completed_at: Type.Optional(Type.String({ minLength: 1 }))
-      },
-      { additionalProperties: false }
-    );
-  }
-});
-
-// src/checkpoint/schema/index.ts
-var init_schema = __esm({
-  "src/checkpoint/schema/index.ts"() {
-    init_checkpoint_v1();
-    init_currentWorkflow_v1();
-  }
-});
-function estimateTokens(s) {
-  return Math.ceil(Buffer.byteLength(s, "utf8") / 4);
-}
-function enforceBudget(c, budget = BUDGET_TOKEN) {
-  let candidate = c;
-  let tokens = estimateTokens(JSON.stringify(candidate));
-  if (tokens <= budget) return candidate;
-  candidate = { ...candidate, last_task: candidate.last_task.slice(0, 200) };
-  tokens = estimateTokens(JSON.stringify(candidate));
-  if (tokens <= budget) return candidate;
-  candidate = { ...candidate, key_decisions: candidate.key_decisions.slice(0, 5) };
-  tokens = estimateTokens(JSON.stringify(candidate));
-  if (tokens <= budget) return candidate;
-  throw new CheckpointTooLargeError(
-    `Checkpoint exceeds ${budget}-token budget even after truncation (estimated ${tokens})`
-  );
-}
-function writeCheckpoint(c, customPath) {
-  if (!Value.Check(CheckpointV1, c)) {
-    const errs = [...Value.Errors(CheckpointV1, c)].map((e) => e.message).join("; ");
-    throw new CheckpointWriteError(`Schema validation failed: ${errs}`);
-  }
-  const enforced = enforceBudget(c);
-  const path = join(harnessedSubdir("checkpoints"), `${enforced.phase}.json`);
-  mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, JSON.stringify(enforced, null, 2), "utf8");
-  return path;
-}
-var BUDGET_TOKEN, CheckpointTooLargeError, CheckpointWriteError;
-var init_template = __esm({
-  "src/checkpoint/template.ts"() {
-    init_harnessedRoot();
-    init_schema();
-    BUDGET_TOKEN = 1e3;
-    CheckpointTooLargeError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "CheckpointTooLargeError";
-      }
-    };
-    CheckpointWriteError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "CheckpointWriteError";
-      }
-    };
-  }
-});
 
 // src/cli/lib/check-token-budget.ts
 var check_token_budget_exports = {};
@@ -955,122 +1096,21 @@ function loadKnownGood(harnessedVer) {
       `${path} schema invalid: ${errs.map((e) => `${e.path} ${e.message}`).join("; ")}`
     );
   }
-  _cache.set(harnessedVer, parsed);
-  return parsed;
-}
-function getPinnedVersion(upstreamName, harnessedVer) {
-  const kg = loadKnownGood(harnessedVer);
-  if (!kg) return null;
-  const entry = kg.upstreams.find((u) => u.name === upstreamName);
-  return entry?.version ?? null;
-}
-var versionsDir, _cache;
-var init_knownGood = __esm({
-  "src/manifest/knownGood.ts"() {
-    init_known_good_v1();
-    versionsDir = () => join(process.cwd(), "versions");
-    _cache = /* @__PURE__ */ new Map();
-  }
-});
-function statePath2() {
-  return harnessedFile("current-workflow.json");
-}
-function lockTarget() {
-  return getHarnessedRoot();
-}
-function lockOpts() {
-  return {
-    stale: 1e4,
-    retries: { retries: 3, factor: 2, minTimeout: 100 },
-    lockfilePath: harnessedFile(".lock")
-  };
-}
-async function withLock(fn) {
-  const target = lockTarget();
-  await mkdir(target, { recursive: true });
-  let release;
-  try {
-    release = await lockfile.lock(target, lockOpts());
-  } catch (e) {
-    if (e.code === "ELOCKED") throw new LockHeldError();
-    throw e;
-  }
-  try {
-    return await fn();
-  } finally {
-    await release?.();
-  }
-}
-async function readCurrentWorkflow() {
-  let raw;
-  try {
-    raw = await readFile(statePath2(), "utf8");
-  } catch {
-    return null;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return null;
-  }
-  const v = parsed.schemaVersion ?? "";
-  return branchOnSchemaVersion(v, {
-    v1: () => Value.Check(CurrentWorkflowV1, parsed) ? parsed : null,
-    unknown: () => null
-  });
-}
-async function writeCurrentWorkflow(s) {
-  if (!Value.Check(CurrentWorkflowV1, s)) {
-    const errs = [...Value.Errors(CurrentWorkflowV1, s)].map((e) => e.message).join("; ");
-    throw new WorkflowStateError(`current-workflow schema validation failed: ${errs}`);
-  }
-  const path = statePath2();
-  await mkdir(dirname(path), { recursive: true });
-  await withLock(async () => {
-    await writeFile(path, JSON.stringify(s, null, 2), "utf8");
-  });
-}
-async function activate(phase, checkpointPath = null) {
-  await writeCurrentWorkflow({
-    schemaVersion: SCHEMA_VERSIONS.currentWorkflow,
-    phase,
-    status: "active",
-    last_checkpoint_path: checkpointPath,
-    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;
-  await writeCurrentWorkflow({ ...s, status: "complete", completed_at: (/* @__PURE__ */ new Date()).toISOString() });
+  _cache.set(harnessedVer, parsed);
+  return parsed;
 }
-var WorkflowStateError, LockHeldError;
-var init_state = __esm({
-  "src/checkpoint/state.ts"() {
-    init_harnessedRoot();
-    init_schemaVersion();
-    init_schema();
-    WorkflowStateError = class extends Error {
-      constructor(message) {
-        super(message);
-        this.name = "WorkflowStateError";
-      }
-    };
-    LockHeldError = class _LockHeldError extends Error {
-      constructor() {
-        super(
-          `another harnessed process holds the lock at ${harnessedFile(".lock")} \u2014 wait or kill stale process (try: harnessed status)`
-        );
-        this.name = "LockHeldError";
-        Object.setPrototypeOf(this, _LockHeldError.prototype);
-      }
-    };
+function getPinnedVersion(upstreamName, harnessedVer) {
+  const kg = loadKnownGood(harnessedVer);
+  if (!kg) return null;
+  const entry = kg.upstreams.find((u) => u.name === upstreamName);
+  return entry?.version ?? null;
+}
+var versionsDir, _cache;
+var init_knownGood = __esm({
+  "src/manifest/knownGood.ts"() {
+    init_known_good_v1();
+    versionsDir = () => join(process.cwd(), "versions");
+    _cache = /* @__PURE__ */ new Map();
   }
 });
 
@@ -1231,7 +1271,7 @@ var init_auto_install = __esm({
 
 // package.json
 var package_default = {
-  version: "3.9.26"};
+  version: "4.0.1"};
 
 // src/manifest/errors.ts
 function instancePathToKeyPath(instancePath) {
@@ -2082,7 +2122,7 @@ function renderHumanTable(records) {
   }
 }
 function pipeToJq(filterExpr, lines) {
-  return new Promise((resolve14, reject) => {
+  return new Promise((resolve16, reject) => {
     const child = spawn("jq", [filterExpr], {
       stdio: ["pipe", "inherit", "inherit"],
       windowsHide: true
@@ -2091,12 +2131,12 @@ function pipeToJq(filterExpr, lines) {
       const e = err2;
       if (e.code === "ENOENT") {
         console.error(t("audit_log.jq_missing"));
-        resolve14(1);
+        resolve16(1);
       } else {
         reject(err2);
       }
     });
-    child.on("close", (code) => resolve14(code ?? 0));
+    child.on("close", (code) => resolve16(code ?? 0));
     child.stdin.write(lines.join("\n"));
     child.stdin.end();
   });
@@ -2304,6 +2344,51 @@ function registerBackupList(program2) {
   });
 }
 
+// src/cli/checkpoint.ts
+var ACTIONS = ["start", "complete", "fail"];
+function isAction(a) {
+  return ACTIONS.includes(a);
+}
+function registerCheckpoint(program2) {
+  program2.command("checkpoint <action> <sub>").description(
+    "Record workflow progress: start | complete | fail <sub-workflow> (writes to ~/.claude/harnessed/checkpoints/)"
+  ).option("--summary <text>", "short summary stored as the checkpoint lastTask").action(async (action, sub, opts) => {
+    if (!isAction(action)) {
+      console.error(
+        `[harnessed] checkpoint: unknown action "${action}" \u2014 expected one of ${ACTIONS.join(", ")}`
+      );
+      process.exit(1);
+      return;
+    }
+    const { activatePhase: activatePhase2, completePhase: completePhase2 } = await Promise.resolve().then(() => (init_engineHook(), engineHook_exports));
+    if (action === "start") {
+      const { checkpointPath } = await activatePhase2(sub);
+      console.log(`[harnessed] checkpoint started: ${sub} \u2192 ${checkpointPath}`);
+      process.exit(0);
+      return;
+    }
+    if (action === "complete") {
+      await completePhase2({
+        phaseId: sub,
+        status: "complete",
+        lastTask: opts.summary ?? `phase ${sub} complete`
+      });
+      console.log(`[harnessed] checkpoint complete: ${sub}`);
+      process.exit(0);
+      return;
+    }
+    await completePhase2({
+      phaseId: sub,
+      status: "complete",
+      lastTask: `FAILED: ${opts.summary ?? ""}`
+    });
+    console.error(
+      `[harnessed] checkpoint FAILED recorded: ${sub}${opts.summary ? ` \u2014 ${opts.summary}` : ""}`
+    );
+    process.exit(1);
+  });
+}
+
 // src/cli/doctor.ts
 init_doctor_registry();
 function registerDoctor(program2) {
@@ -2327,13 +2412,329 @@ function registerDoctor(program2) {
         console.log(`${mark} ${r.name} \u2014 ${r.message}`);
         if (r.status !== "pass" && r.fix) console.log(`    fix: ${r.fix}`);
       }
-      console.log(
-        hasFail ? t("doctor.summary.fail") : hasWarn ? t("doctor.summary.warn") : t("doctor.summary.pass")
-      );
+      console.log(
+        hasFail ? t("doctor.summary.fail") : hasWarn ? t("doctor.summary.warn") : t("doctor.summary.pass")
+      );
+    }
+    process.exit(hasFail ? 1 : 0);
+  });
+}
+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]);
+var UserOverrideEntry = Type.Object(
+  {
+    id: Type.String({ minLength: 1 }),
+    // kebab-case (e.g. 'brainstorm', 'arch-review')
+    keywords: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
+    triggers: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 })
+  },
+  { additionalProperties: false }
+);
+var UserOverridesFile = Type.Object(
+  {
+    schema_version: Type.Literal("harnessed.user-overrides.v1"),
+    overrides: Type.Array(UserOverrideEntry, { minItems: 1 })
+  },
+  { additionalProperties: false }
+);
+
+// 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 userOverrides = context.user_overrides;
+  if (Array.isArray(userOverrides) && userOverrides.includes(gateRef)) {
+    return true;
+  }
+  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);
+}
+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/gates.ts
+var VALID_MASTERS = /* @__PURE__ */ new Set(["auto", "discuss", "plan", "task", "verify"]);
+var PARALLELISM_GATE = "judgments.parallelism-gate.agent-teams-upgrade.fires";
+function defaultContext(task, stage) {
+  return {
+    task,
+    user_understanding_unclear: false,
+    phase: {
+      stage,
+      is_critical_module: true,
+      is_final_step: true,
+      is_major_release: false,
+      has_auth_or_secrets: false,
+      has_design_changes: false,
+      has_ui_changes: false,
+      requires_creative_polish: false,
+      is_complex_architecture: true,
+      has_cross_phase_data_flow: true,
+      open_decisions: 2,
+      scope_days: 2,
+      scope_locked_in_history: false,
+      single_task: false,
+      type: "general"
+    },
+    subtask: {
+      approaches: 2,
+      core_algorithm: true,
+      has_api_contract: true,
+      error_cost: "high",
+      lines: 50,
+      type: "general",
+      is_core_business_logic: true,
+      is_algorithm: true,
+      is_data_processing: true,
+      regression_risk: "high",
+      reliability_required: true,
+      communication_needed: false,
+      needs_lib_docs: false,
+      needs_web_search: false,
+      parallel_count: 1,
+      search_type: "general",
+      test_type: "general"
+    }
+  };
+}
+function resolveMasterYamlPath(master, packageRoot) {
+  return master === "auto" ? resolve(packageRoot, "workflows", "auto", "workflow.yaml") : resolve(packageRoot, "workflows", master, "auto", "workflow.yaml");
+}
+function registerGates(program2) {
+  program2.command("gates").description(
+    "Evaluate which sub-workflows fire for a master orchestrator (JSON plan, no spawn)."
+  ).argument("<master>", "master name: auto | discuss | plan | task | verify").option("--task <text>", "task description (injected as gateContext.task)").option("--skip-sub <names>", "comma-separated sub names to skip without gate eval").option("--context <json>", "JSON object merged over the default gate context").action(async (master, raw) => {
+    if (!VALID_MASTERS.has(master)) {
+      console.error(
+        `error: unknown master '${master}'. Expected one of: auto, discuss, plan, task, verify.`
+      );
+      process.exit(1);
+      return;
+    }
+    const packageRoot = getPackageRoot();
+    const yamlPath = resolveMasterYamlPath(master, packageRoot);
+    let raw_yaml;
+    try {
+      raw_yaml = await readFile(yamlPath, "utf8");
+    } catch (err2) {
+      console.error(
+        `error: failed to read master workflow.yaml at ${yamlPath} \u2014 ${err2.message}`
+      );
+      process.exit(1);
+      return;
+    }
+    let parsed;
+    try {
+      parsed = parse(raw_yaml);
+    } catch (err2) {
+      console.error(`error: failed to parse ${yamlPath} \u2014 ${err2.message}`);
+      process.exit(1);
+      return;
+    }
+    const delegates = parsed?.delegates_to;
+    if (!Array.isArray(delegates) || delegates.length === 0) {
+      console.error(`error: master '${master}' workflow.yaml missing delegates_to[]`);
+      process.exit(1);
+      return;
+    }
+    const clauses = delegates;
+    const task = typeof raw.task === "string" ? raw.task : "";
+    const stage = master;
+    const ctx = defaultContext(task, stage);
+    if (typeof raw.context === "string" && raw.context.length > 0) {
+      let extra;
+      try {
+        extra = JSON.parse(raw.context);
+      } catch (err2) {
+        console.error(`error: --context is not valid JSON \u2014 ${err2.message}`);
+        process.exit(1);
+        return;
+      }
+      if (extra && typeof extra === "object") {
+        Object.assign(ctx, extra);
+      }
     }
-    process.exit(hasFail ? 1 : 0);
+    const skipSubs = new Set(
+      typeof raw.skipSub === "string" && raw.skipSub.length > 0 ? raw.skipSub.split(",").map((s) => s.trim()).filter((s) => s.length > 0) : []
+    );
+    ctx.skip_subs = [...skipSubs];
+    ctx.task = task;
+    const fire = [];
+    const skip = [];
+    for (const clause of clauses) {
+      if (skipSubs.has(clause.sub)) {
+        skip.push({
+          sub: clause.sub,
+          reason: "skipped via skip_subs (done interactively in main session)"
+        });
+        continue;
+      }
+      if (!clause.gate) {
+        fire.push(fireEntry(clause));
+        continue;
+      }
+      try {
+        const passes = await resolveJudgmentGate(clause.gate, ctx, packageRoot);
+        if (passes) {
+          fire.push(fireEntry(clause));
+        } else {
+          skip.push({ sub: clause.sub, reason: `gate ${clause.gate} = false` });
+        }
+      } catch (e) {
+        console.warn(
+          `\u26A0\uFE0F master ${master} sub ${clause.sub} gate ${clause.gate} eval failed (${e.message}); firing sub as if gate=true (ADR 0029 fail-soft).`
+        );
+        fire.push(fireEntry(clause));
+      }
+    }
+    let parallelism = { escalate_to_teams: false, reason: null };
+    try {
+      const escalate = await resolveJudgmentGate(PARALLELISM_GATE, ctx, packageRoot);
+      parallelism = escalate ? { escalate_to_teams: true, reason: "agent-teams-upgrade gate fired" } : { escalate_to_teams: false, reason: null };
+    } catch {
+      parallelism = { escalate_to_teams: false, reason: null };
+    }
+    const result = { master, fire, skip, parallelism };
+    console.log(JSON.stringify(result, null, 2));
+    process.exit(0);
   });
 }
+function fireEntry(clause) {
+  const entry = { sub: clause.sub };
+  if (clause.order !== void 0) entry.order = clause.order;
+  if (clause.mode !== void 0) entry.mode = clause.mode;
+  if (clause.gate !== void 0) entry.gate = clause.gate;
+  return entry;
+}
 var DURATION_RE = /^(\d+)([dhmw])$/;
 function parseDuration(s) {
   const m = DURATION_RE.exec(s);
@@ -2561,11 +2962,11 @@ function preflight(ctx) {
 // src/installers/lib/state.ts
 init_harnessedRoot();
 var DEFAULT_STATE = { version: "1", installed: {} };
-function statePath(_cwd) {
+function statePath2(_cwd) {
   return harnessedFile("state.json");
 }
 async function readState(cwd) {
-  const path = statePath();
+  const path = statePath2();
   let raw;
   try {
     raw = await readFile(path, "utf8");
@@ -2586,7 +2987,7 @@ async function readState(cwd) {
   }
 }
 async function writeState(cwd, state) {
-  const path = statePath();
+  const path = statePath2();
   const tmp = `${path}.tmp`;
   await mkdir(dirname(path), { recursive: true });
   await writeFile(tmp, `${JSON.stringify(state, null, 2)}
@@ -2753,10 +3154,10 @@ async function spawnCmd(ctx, cmd, args, timeoutMs) {
   child.stderr?.setEncoding("utf8").on("data", (chunk) => {
     stderr += chunk;
   });
-  return await new Promise((resolve14) => {
+  return await new Promise((resolve16) => {
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve14({
+      resolve16({
         ok: false,
         phase: "spawn",
         error: {
@@ -2771,7 +3172,7 @@ async function spawnCmd(ctx, cmd, args, timeoutMs) {
     }, effectiveTimeoutMs);
     child.on("error", (err2) => {
       clearTimeout(timer);
-      resolve14({
+      resolve16({
         ok: false,
         phase: "spawn",
         error: {
@@ -2786,7 +3187,7 @@ async function spawnCmd(ctx, cmd, args, timeoutMs) {
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve14({ ok: true, exitCode: code ?? -1, stdout: stdout2, stderr });
+      resolve16({ ok: true, exitCode: code ?? -1, stdout: stdout2, stderr });
     });
   });
 }
@@ -2899,7 +3300,7 @@ async function isAlreadyInstalled(ctx, opts = {}) {
 // src/installers/ccPluginMarketplace.ts
 init_readClaudeConfig();
 function runArgs(claudeArgs, cwd, timeoutMs = 15e3) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve16) => {
     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 = "";
@@ -2908,15 +3309,15 @@ function runArgs(claudeArgs, cwd, timeoutMs = 15e3) {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve14({ exitCode: -1, stderr: `${stderr}[timeout after ${timeoutMs}ms]` });
+      resolve16({ exitCode: -1, stderr: `${stderr}[timeout after ${timeoutMs}ms]` });
     }, timeoutMs);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve14({ exitCode: -1, stderr: `${stderr}${e.message}` });
+      resolve16({ exitCode: -1, stderr: `${stderr}${e.message}` });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve14({ exitCode: code ?? -1, stderr });
+      resolve16({ exitCode: code ?? -1, stderr });
     });
   });
 }
@@ -3062,7 +3463,7 @@ ${newEntry}
   return { ok: true, backupId: bk.backupId, appliedFiles: [settingsFile] };
 };
 function gitRevParseHead(cwd, timeoutMs = 1e4) {
-  return new Promise((resolve14) => {
+  return new Promise((resolve16) => {
     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 = "";
@@ -3071,15 +3472,15 @@ function gitRevParseHead(cwd, timeoutMs = 1e4) {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve14({ sha: "", exit: -1 });
+      resolve16({ sha: "", exit: -1 });
     }, timeoutMs);
     child.on("error", () => {
       clearTimeout(timer);
-      resolve14({ sha: "", exit: -1 });
+      resolve16({ sha: "", exit: -1 });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve14({ sha: stdout2.trim(), exit: code ?? -1 });
+      resolve16({ sha: stdout2.trim(), exit: code ?? -1 });
     });
   });
 }
@@ -3786,16 +4187,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 !== "/" ? `
@@ -3983,38 +4374,8 @@ function registerManifestAdd(program2) {
   });
 }
 
-// src/checkpoint/engineHook.ts
-init_harnessedRoot();
-init_schemaVersion();
-init_state();
-init_template();
-async function activatePhase(phaseId) {
-  const checkpointPath = join(harnessedSubdir("checkpoints"), `${phaseId}.json`);
-  await activate(phaseId, checkpointPath);
-  return { checkpointPath };
-}
-async function completePhase(ctx) {
-  if (ctx.phaseId === "unknown") {
-    console.error(
-      `[harnessed] WARN engineHook: phaseId="unknown" \u2014 checkpoint paths fall back to ${join(harnessedSubdir("checkpoints"), "unknown.json")} (Karpathy fail-loud non-blocking; W-04 mitigation)`
-    );
-  }
-  writeCheckpoint({
-    schemaVersion: SCHEMA_VERSIONS.checkpoint,
-    phase: ctx.phaseId,
-    status: "complete",
-    last_task: ctx.lastTask ?? "engine.runRouting complete",
-    key_decisions: ctx.keyDecisions ?? [],
-    canonical_refs: ctx.canonicalRefs ?? [],
-    ...ctx.sessionId ? { session_id: ctx.sessionId } : {},
-    cwd: process.cwd(),
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    archive_path: `${join(harnessedSubdir("archive"), `phase-${ctx.phaseId}`)}/`
-  });
-  await complete();
-}
-
 // src/workflow/run.ts
+init_engineHook();
 init_state();
 async function loadRolePrompts(workflowsDir) {
   const path = join(workflowsDir, "role-prompts.yaml");
@@ -4034,17 +4395,31 @@ var INTERACTIVE_COMMANDS = /* @__PURE__ */ new Set([
   "discuss-subtask",
   "task-clarify"
 ]);
-var HYBRID_COMMANDS = /* @__PURE__ */ new Set(["auto", "task"]);
+var ORCHESTRATOR_COMMANDS = /* @__PURE__ */ new Set(["auto", "plan", "task", "verify"]);
 var MARKER = `<!-- harnessed-generated:v3.4.4 -->`;
+var LANG_DIRECTIVE = `> **Language**: respond to the user in the language set by \`env.HARNESSED_USER_LANG\` (e.g. \`zh-Hans\` \u2192 \u7B80\u4F53\u4E2D\u6587, \`en\` \u2192 English). If unset, mirror the user's input language. Keep code / commands / identifiers / error messages / URLs verbatim.`;
+function spawnLoopSteps(indent) {
+  const i = indent;
+  return [
+    `${i}a. Bash: \`harnessed prompt <sub> --task "<spec>" --json\` \u2192 parse \`{prompt, max_iterations, model}\`.`,
+    `${i}b. Spawn a CC-native subagent (Task / Agent tool) with that \`prompt\` and \`model\`. Wrap in the ralph-loop plugin for completion-promise enforcement:`,
+    `${i}   \`/ralph-loop "<prompt>" --max-iterations <max_iterations> --completion-promise "COMPLETE"\``,
+    `${i}   If the ralph-loop plugin is not installed, self-loop: spawn \u2192 check output for \`<promise>COMPLETE</promise>\` \u2192 if absent, re-spawn with the prior output appended (up to max_iterations).`,
+    `${i}c. If the subagent output contains \`STATUS: NEEDS_CLARIFICATION\` + a question list: STOP. Use AskUserQuestion to relay those exact questions to the user. Append the user's answers to the spec, then re-spawn the same sub. (This is the round-trip headless spawn cannot do.)`,
+    `${i}d. On \`<promise>COMPLETE</promise>\`: Bash \`harnessed checkpoint complete <sub> --summary "<one-line>"\`.`
+  ];
+}
 function buildInteractiveBody(name, prompt) {
   return [
     `# /${name}`,
     ``,
     prompt.description,
     ``,
+    LANG_DIRECTIVE,
+    ``,
     `## How to run (interactive \u2014 in THIS session)`,
     ``,
-    `Clarification requires real user dialogue. Spawned subagents cannot ask the user questions, so run this stage directly in this session \u2014 do NOT spawn \`harnessed run ${name}\`.`,
+    `Clarification requires real user dialogue. Spawned subagents cannot ask the user questions, so run this stage directly in this session \u2014 do NOT spawn it.`,
     ``,
     `1. Evaluate the clarification criteria for "$ARGUMENTS":`,
     `   - Strategic layer: new feature / new milestone / unclear business scope \u2192 run gstack \`/office-hours\` + \`/plan-ceo-review\``,
@@ -4054,85 +4429,73 @@ function buildInteractiveBody(name, prompt) {
     `3. Skip layers that don't fire \u2014 state which were skipped and why (transparent skip).`,
     `4. Persist locked decisions to \`.planning/\` via planning-with-files (\`findings.md\` / \`task_plan.md\`).`,
     ``,
-    `Output: a locked spec the execution stages can consume without further user input.`,
+    `Output: a locked spec the execution stages can consume without further user input. Then run \`/plan\` \u2192 \`/task\` \u2192 \`/verify\` with that spec.`,
     ``,
     `## Notes`,
     ``,
-    `- This file is generated by \`harnessed setup\`. Re-run \`harnessed setup\` after a harnessed upgrade to refresh.`,
-    `- The downstream execution command (\`/plan\` \u2192 \`/task\` \u2192 \`/verify\`) embeds the locked spec in its task text.`,
+    `- Generated by \`harnessed setup\`. Re-run after a harnessed upgrade to refresh.`,
     ``,
     MARKER,
     ``
   ].join("\n");
 }
-function buildHybridBody(name, prompt) {
-  const chain = name === "auto" ? [
-    `3. Then run the execution stages in order via the Bash tool (each stage's output informs the next):`,
-    ``,
-    "```bash",
-    `echo "<locked spec + $ARGUMENTS>" | harnessed run plan --task-stdin`,
-    `echo "<locked spec + plan output>" | harnessed run task --task-stdin --skip-sub clarify`,
-    `echo "<locked spec + task output>" | harnessed run verify --task-stdin`,
-    `echo "<summary of all stages>" | harnessed run retro --task-stdin`,
-    "```",
-    ``,
-    `   Do NOT run \`harnessed run auto\` \u2014 that would re-spawn the discuss stage headlessly, defeating the interactive clarification you just did.`,
-    `   \`--skip-sub clarify\` tells the task master that clarification is already done.`
+function buildOrchestratorBody(name, prompt) {
+  const autoDiscussStep = name === "auto" ? [
+    `1. FIRST run the discuss stage interactively in THIS session (spawned subagents cannot ask the user questions). Evaluate strategic / phase / subtask clarification criteria for "$ARGUMENTS"; for each that fires, dialogue with the user (AskUserQuestion) and lock decisions; transparent-skip the rest. Produce a locked spec.`
   ] : [
-    `3. Then spawn the execution subs via the Bash tool:`,
-    ``,
-    "```bash",
-    `echo "<locked spec + $ARGUMENTS>" | harnessed run task --task-stdin --skip-sub clarify`,
-    "```",
-    ``,
-    `   \`--skip-sub clarify\` tells the task master that clarification is already done in this session.`
+    `1. If the clarification criteria fire for "$ARGUMENTS" (\u22652 approaches / core algorithm / API contract / high error cost), clarify interactively in THIS session first (AskUserQuestion) and lock decisions. Otherwise transparent-skip. Produce a locked spec.`
   ];
   return [
     `# /${name}`,
     ``,
     prompt.description,
     ``,
-    `## How to run (hybrid \u2014 clarify in THIS session, then spawn execution)`,
+    LANG_DIRECTIVE,
+    ``,
+    `## How to run (orchestrator \u2014 clarify in THIS session, then drive native subagent spawns)`,
+    ``,
+    `harnessed is the orchestration brain: \`harnessed gates\` tells you which subs fire, \`harnessed prompt\` gives you each sub's spawn-ready prompt. YOU (the main session) do the spawning with CC-native Task / Agent tools \u2014 keeping the session responsive, enabling Agent Teams, and letting clarification round-trips reach the user.`,
     ``,
-    `1. FIRST clarify interactively in this session (spawned subagents cannot ask the user questions):`,
-    `   - Evaluate the subtask clarification criteria for "$ARGUMENTS": \u22652 distinct approaches / core algorithm / API contract design / high error cost \u2192 brainstorm with the user (AskUserQuestion for option-style decisions) and lock every open decision.`,
-    `   - If criteria don't fire (CRUD / known pattern / single obvious implementation), skip with a one-line transparent declaration.`,
-    `2. Embed the locked decisions into the task text passed downstream.`,
-    ...chain,
+    ...autoDiscussStep,
+    `2. Bash: \`harnessed gates ${name} --task "<locked spec>" --skip-sub clarify\` \u2192 parse the JSON \`{fire: [{sub, order, mode}], skip, parallelism: {escalate_to_teams}}\`.`,
+    `3. If \`parallelism.escalate_to_teams === true\`: this stage needs multiple subagents to coordinate (SendMessage / shared contract). Read \`~/.claude/rules/agent-teams.md\`, then \`TeamCreate\` \u2192 \`Agent(name, team_name, ...)\` per fired sub (prompt from \`harnessed prompt <sub>\`) \u2192 coordinate via SendMessage \u2192 \`SendMessage shutdown_request\` + \`TeamDelete\`.`,
+    `4. Otherwise, for each fired sub in \`order\` (serial subs sequentially, parallel subs concurrently via parallel Task calls):`,
+    ...spawnLoopSteps("   "),
+    `5. Report a per-sub fired/skipped summary to the user. ${name === "auto" ? "Then run the `retro` stage to capture lessons." : ""}`,
+    ``,
+    `Do NOT pipe to \`harnessed run ${name}\` \u2014 that is the CI/headless path (SDK spawn, blocks the session, no Agent Teams, no clarification round-trip).`,
     ``,
     `## Notes`,
     ``,
-    `- This file is generated by \`harnessed setup\`. Re-run \`harnessed setup\` after a harnessed upgrade to refresh.`,
-    `- Execution stages (code / test / deliver / verify) spawn headless subagents \u2014 appropriate since they need no user dialogue.`,
+    `- Generated by \`harnessed setup\`. Re-run after a harnessed upgrade to refresh.`,
+    `- gate/discipline SoT: \`workflows/${nameToYamlHintPath(name)}\` + \`workflows/judgments/\` \u2014 consumed by \`harnessed gates\` + \`harnessed prompt\`.`,
     ``,
     MARKER,
     ``
   ].join("\n");
 }
-function buildSpawnBody(name, prompt) {
-  const stagedNote = name === "auto" ? "\n- For stage-by-stage review, append `--staged` (pauses between stages for user review)." : "";
+function buildExecutionBody(name, prompt) {
   return [
     `# /${name}`,
     ``,
     prompt.description,
     ``,
-    `## How to invoke`,
+    LANG_DIRECTIVE,
     ``,
-    `Use the Bash tool to run:`,
+    `## How to run (execution \u2014 native subagent spawn)`,
     ``,
-    "```bash",
-    `echo "$ARGUMENTS" | harnessed run ${name} --task-stdin`,
-    "```",
+    `harnessed gives you the spawn-ready prompt; YOU spawn the subagent with a CC-native Task / Agent tool (keeps the session responsive + lets clarification round-trips reach the user).`,
     ``,
-    `If \`$ARGUMENTS\` is empty (slash command invoked with no args), run \`harnessed run ${name}\` (no stdin pipe).`,
+    ...spawnLoopSteps("").map(
+      (s) => s.replace("<sub>", name).replace('--task "<spec>"', '--task "$ARGUMENTS"')
+    ),
     ``,
-    `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.`,
+    `Do NOT pipe to \`harnessed run ${name}\` \u2014 that is the CI/headless path (SDK spawn).`,
     ``,
     `## 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.`,
+    `- Generated by \`harnessed setup\`. Re-run 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). gate/discipline SoT: \`workflows/${nameToYamlHintPath(name)}\`.`,
     ``,
     MARKER,
     ``
@@ -4144,10 +4507,10 @@ function generateCommandFile(name, prompt, _capabilities, _installedPlugins, _in
   let body;
   if (INTERACTIVE_COMMANDS.has(name)) {
     body = buildInteractiveBody(name, prompt);
-  } else if (HYBRID_COMMANDS.has(name)) {
-    body = buildHybridBody(name, prompt);
+  } else if (ORCHESTRATOR_COMMANDS.has(name)) {
+    body = buildOrchestratorBody(name, prompt);
   } else {
-    body = buildSpawnBody(name, prompt);
+    body = buildExecutionBody(name, prompt);
   }
   const warnings = [];
   const frontmatter = [
@@ -4436,159 +4799,6 @@ async function readGovernance() {
 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]);
-var UserOverrideEntry = Type.Object(
-  {
-    id: Type.String({ minLength: 1 }),
-    // kebab-case (e.g. 'brainstorm', 'arch-review')
-    keywords: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 }),
-    triggers: Type.Array(Type.String({ minLength: 1 }), { minItems: 1 })
-  },
-  { additionalProperties: false }
-);
-var UserOverridesFile = Type.Object(
-  {
-    schema_version: Type.Literal("harnessed.user-overrides.v1"),
-    overrides: Type.Array(UserOverrideEntry, { minItems: 1 })
-  },
-  { additionalProperties: false }
-);
-
-// 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 userOverrides = context.user_overrides;
-  if (Array.isArray(userOverrides) && userOverrides.includes(gateRef)) {
-    return true;
-  }
-  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>/;
@@ -5009,7 +5219,7 @@ function loadPhases(yamlPath, vars) {
   }
   return validated;
 }
-function resolveMasterYamlPath(masterName, packageRoot) {
+function resolveMasterYamlPath2(masterName, packageRoot) {
   return masterName === "auto" ? resolve(packageRoot, "workflows", "auto", "workflow.yaml") : resolve(packageRoot, "workflows", masterName, "auto", "workflow.yaml");
 }
 function resolveSubYamlPath(masterName, subName, packageRoot) {
@@ -5113,7 +5323,7 @@ async function maybeArbitrate(firedClauses, packageRoot) {
 
 // src/workflow/masterOrchestrator.ts
 async function runMasterOrchestrator(masterName, context, packageRoot, spawnDriver = defaultSpawnDriver, opts = {}) {
-  const yamlPath = resolveMasterYamlPath(masterName, packageRoot);
+  const yamlPath = resolveMasterYamlPath2(masterName, packageRoot);
   const raw = await readFile(yamlPath, "utf8");
   const parsed = parse(raw);
   if (!Value.Check(WorkflowSchemaV3, parsed)) {
@@ -5496,6 +5706,94 @@ async function runWorkflow(yamlPath, vars, opts = {}) {
     ...skippedPhases.length > 0 ? { skippedPhases } : {}
   };
 }
+
+// src/cli/prompt.ts
+var DEFAULT_MAX_ITERATIONS = 20;
+var DEFAULT_MODEL = "sonnet";
+var DEFAULT_SPECIALIST = "Implementation Engineer";
+var LANG_NAMES = {
+  en: "English",
+  "zh-Hans": "\u7B80\u4F53\u4E2D\u6587 (Simplified Chinese)",
+  "zh-CN": "\u7B80\u4F53\u4E2D\u6587 (Simplified Chinese)",
+  "zh-Hant": "\u7E41\u9AD4\u4E2D\u6587 (Traditional Chinese)",
+  "zh-TW": "\u7E41\u9AD4\u4E2D\u6587 (Traditional Chinese)"
+};
+function buildLanguageSection() {
+  const code = process.env.HARNESSED_USER_LANG;
+  if (!code) return "";
+  const name = LANG_NAMES[code] ?? code;
+  return `
+## Language
+Respond in ${name}. Keep code, commands, file/identifier/API names, error messages, stack traces, URLs, commit hashes, and version numbers in their original form (do not translate or transliterate them).
+`;
+}
+var PROTOCOLS = `
+## Completion protocol
+When done emit: <promise>COMPLETE</promise>
+
+## Clarification protocol
+If you hit a gray area you cannot decide (\u22652 reasonable options, missing key context, ambiguous requirement), do NOT self-decide. Emit:
+STATUS: NEEDS_CLARIFICATION
+1. <question>
+2. <question>
+The main session will relay these to the user and re-spawn you with answers.
+`;
+async function resolveMaxIterations2(sub, packageRoot) {
+  try {
+    const path = resolve(packageRoot, "workflows", "defaults.yaml");
+    const raw = await readFile(path, "utf8");
+    const doc = parse(raw);
+    const entry = doc?.ralph_max_iterations?.[sub];
+    if (typeof entry === "number" && Number.isFinite(entry)) {
+      return entry;
+    }
+    if (entry && typeof entry === "object") {
+      for (const v of Object.values(entry)) {
+        if (typeof v === "number" && Number.isFinite(v)) {
+          return v;
+        }
+      }
+    }
+    return DEFAULT_MAX_ITERATIONS;
+  } catch {
+    return DEFAULT_MAX_ITERATIONS;
+  }
+}
+function registerPrompt(program2) {
+  program2.command("prompt").description(
+    "Print a spawn-ready prompt for a sub-workflow (role + checklist + protocols, no spawn)."
+  ).argument("<sub>", "sub-workflow name (e.g. task-code, verify-paranoid)").option("--task <text>", "task description prepended as a ## Task section").option("--json", "emit JSON {prompt, max_iterations, model, specialist} instead of text").action(async (sub, raw) => {
+    const packageRoot = getPackageRoot();
+    const workflowsDir = resolve(packageRoot, "workflows");
+    const rolePrompts = await loadRolePrompts(workflowsDir);
+    const def = buildAgentDef(sub, rolePrompts, void 0, void 0, void 0);
+    const body = def.prompt;
+    const taskSection = typeof raw.task === "string" && raw.task.length > 0 ? `## Task
+${raw.task}
+
+` : "";
+    const fullPrompt = `${taskSection}${body}
+${PROTOCOLS}${buildLanguageSection()}`;
+    if (raw.json) {
+      const maxIterations = await resolveMaxIterations2(sub, packageRoot);
+      const rp = rolePrompts[sub];
+      const model = def.model ?? DEFAULT_MODEL;
+      const specialist = rp?.specialist ?? DEFAULT_SPECIALIST;
+      console.log(
+        JSON.stringify({
+          prompt: fullPrompt,
+          max_iterations: maxIterations,
+          model,
+          specialist
+        })
+      );
+      process.exit(0);
+      return;
+    }
+    console.log(fullPrompt);
+    process.exit(0);
+  });
+}
 async function loadUserOverrides(packageRoot) {
   const yamlPath = resolve(packageRoot, "workflows", "judgments", "user-overrides.yaml");
   let raw;
@@ -5542,7 +5840,7 @@ 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."
+    "Run a harnessed workflow via in-process SDK spawn (CI/headless mode \u2014 blocks, no Agent Teams, no clarification round-trip). Slash commands use CC-native spawn via gates/prompt/checkpoint instead."
   ).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)",
@@ -6789,7 +7087,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((resolve14) => {
+  const result = await new Promise((resolve16) => {
     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) => {
@@ -6797,15 +7095,15 @@ var uninstallNpmCli = async (ctx) => {
     });
     const timer = setTimeout(() => {
       child.kill("SIGKILL");
-      resolve14({ exitCode: -1, stderr: `${stderr}[timeout]` });
+      resolve16({ exitCode: -1, stderr: `${stderr}[timeout]` });
     }, 3e4);
     child.on("error", (e) => {
       clearTimeout(timer);
-      resolve14({ exitCode: -1, stderr: e.message });
+      resolve16({ exitCode: -1, stderr: e.message });
     });
     child.on("close", (code) => {
       clearTimeout(timer);
-      resolve14({ exitCode: code ?? -1, stderr });
+      resolve16({ exitCode: code ?? -1, stderr });
     });
   });
   if (result.exitCode !== 0) {
@@ -7104,6 +7402,9 @@ registerResume(program);
 registerUninstall(program);
 registerSetup(program);
 registerRun(program);
+registerGates(program);
+registerPrompt(program);
+registerCheckpoint(program);
 program.parse(process.argv);
 //# sourceMappingURL=cli.mjs.map
 //# sourceMappingURL=cli.mjs.map