dev-loops 0.6.0 → 0.7.1

package/skills/docs/workflow-handoff-contract.md

@@ -17,6 +17,35 @@ template.
 | Gate state (detectors) + strategy defaults | `currentGate`, `worktreeRequired` |
 | Settings (`.devloops` at repo root + `defaults.yaml`) | `gateConfig`, `stopRules`, `asyncStartMode`, `requireDraftFirst`, `maxCopilotRounds` |
 | Gate state (detectors) | `currentHeadSha`, `ciStatus`, `unresolvedThreadCount`, `copilotRoundCount` |
+| Canonical sanctioned-command map (`scripts/loop/sanctioned-commands.mjs`) | `sanctionedCommands` |
+
+## Sanctioned commands (MANDATORY DEFAULT — issue #1081)
+
+`sanctionedCommands` is a **mandatory default** element of every handoff
+envelope. It is the operation → wrapper command map (which wrapper performs
+which GitHub/loop operation), plus the forbidden and orchestrator-owned lists.
+The `loop build-envelope` CLI injects it into every emitted envelope, so a
+spawned dev-loop subagent receives it verbatim without the briefer adding it —
+no re-deriving which wrapper does `gh pr ready` etc.
+
+The **single source of truth** is `scripts/loop/sanctioned-commands.mjs` (a
+frozen data module). `@dev-loops/core` stays consumer-agnostic: it defines the
+envelope SHAPE and carries whatever `sanctionedCommands` object the consumer
+supplies; the repo-specific `scripts/...` paths live only in the consumer
+module. Do not duplicate the map into prose — reference the module.
+
+```typescript
+sanctionedCommands?: {
+  reads: Record<string, string>;         // operation → wrapper path (some also accept `loop info`)
+  edits: Record<string, string>;
+  lifecycle: Record<string, string>;
+  forbidden: string[];                   // raw `gh pr view/checks/edit`, `node -e`, `python -c`, transcript tailing, sleep-poll loops
+  orchestratorOwned: string[];           // `gh pr merge`, board status transitions — never done by a subagent
+};
+```
+
+A contract test (`test/contracts/sanctioned-commands-exist.test.mjs`) asserts
+every mapped wrapper exists on disk and fails closed if one is renamed/removed.
 
 ## Acceptance templates
 
@@ -111,6 +140,15 @@ interface HandoffEnvelope {
     scopeConstraint?: string;
     customStopAt?: string;
   };
+
+  // Mandatory default (issue #1081). Source: scripts/loop/sanctioned-commands.mjs
+  sanctionedCommands?: {
+    reads: Record<string, string>;
+    edits: Record<string, string>;
+    lifecycle: Record<string, string>;
+    forbidden: string[];
+    orchestratorOwned: string[];
+  };
 }
 ```
 
@@ -121,6 +159,7 @@ interface HandoffEnvelope {
 3. Execute `nextAction`.
 4. Respect `stopRules` — do not proceed past a gated stop point without authorization.
 5. Use `acceptance` to self-validate before declaring completion.
+6. Use `sanctionedCommands` as the authoritative operation → wrapper map: never call a raw `gh`/`node -e`/`python -c` for an operation the map covers, and never perform an `orchestratorOwned` action.
 
 ## Backward compatibility
 

package/skills/local-implementation/SKILL.md

@@ -43,11 +43,17 @@ Treat missing optional files as normal bootstrap conditions, not errors.
 
 ### Tracker-backed local implementation
 
-Local implementation supports two durable spec inputs:
+Local implementation supports these spec-of-record inputs. The first two are durable/committed artifacts; the third is a spec-of-record that is NOT a durable committed artifact:
+
+Durable/committed spec artifacts:
 
 - phase-doc-backed local sessions ([Phase Plan](../../docs/phases/phase-x.md) is canonical)
 - tracker-backed local sessions (the tracker issue is canonical)
 
+Non-durable spec-of-record (no committed plan artifact):
+
+- lightweight PR-body-as-spec sessions (`--lightweight`; the PR description is the canonical spec-of-record but NOT a durable committed artifact — the resolver output carries `canonicalSpecSource: pr_body` and the derived handoff envelope carries `specSource: pr_body`; no phase/plan doc minted or committed). Same gate sequence as the phase-doc path; only the backing artifact differs. See [Artifact Authority Contract](../docs/artifact-authority-contract.md) "Lightweight (PR-body-as-spec)".
+
 Tracker-backed local implementation stays inside the existing `local_implementation` path. For sub-issue tree decomposition, see [Sub-Issue Tree Contract](../../docs/sub-issue-tree-contract.md) (this is a source-repo reference; it is not part of the bundled `../docs/` runtime contract surface for installed skill copies). It does not introduce a new routing mode.
 
 When the local spec already lives in a tracker issue:
@@ -130,33 +136,33 @@ Follow [Anti-patterns](../docs/anti-patterns.md) for the general tooling-interna
 
 Apply [Structural Quality](../docs/structural-quality.md) from the `deep` review angle.
 
-## Light mode (small changes) — config-only
+## Light mode (small changes)
+
+Light mode is wired into gate dispatch. A PR that is **under threshold** (≤ `maxLines` lines changed AND ≤ `maxFiles` files, per `.devloops` field `localImplementation.lightMode` — this repo sets `maxLines: 20`, `maxFiles: 2`; the shipped built-in default has light mode disabled (`enabled: false`); if enabled without explicit values it falls back to `maxFiles: 3` / `maxLines: 200`) AND carries no `gate:full` label collapses BOTH `draft_gate` and `pre_approval_gate` to a single inline single-agent correctness + no-op check. The Copilot review request and its polling are skipped.
 
-Light mode is currently **config-only**: the schema, resolver, and scope detector are implemented, but no functional wiring exists yet in the local-implementation flow. When scope is small enough, the intent is to skip fan-out/fan-in and use a single review pass instead. Light mode will still require validation and pre-approval gate once wired.
+**Escalation:**
+1. Auto-escalate — if the inline check surfaces any finding whose severity is in the gate's `blockCleanOnFindingSeverities` (i.e. ≥ `worth-fixing-now`), dispatch escalates to full fan-out.
+2. Label override — the `gate:full` label forces full fan-out regardless of PR size.
 
-**Eligibility:** ≤3 files AND ≤200 lines changed (configurable via `.devloops` field `localImplementation.lightMode`).
+The `draft_gate` boundary (draft → ready) is still recorded because `requireDraftFirst` is honored: light mode only changes HOW the gate runs (inline vs fan-out), not WHETHER the draft boundary exists.
 
-Use `scripts/loop/detect-change-scope.mjs` to determine eligibility:
+Dispatch is resolved deterministically via `resolveGateDispatchMode(config, gate, { scope, hasFullLabel, inlineFindingSeverities })` from `@dev-loops/core/config`. `scripts/loop/resolve-gate-dispatch.mjs` is the CLI wrapper the orchestrator calls, combining `detect-change-scope.mjs` output with the `gate:full` label fact.
+
+Use `scripts/loop/detect-change-scope.mjs` to determine scope:
 ```sh
 node scripts/loop/detect-change-scope.mjs
 ```
 
-**Planned light mode path (not yet wired):**
-1. Validation (`npm run verify`)
-2. Single review pass (not multi-angle fan-out)
-3. Pre-approval gate
-4. Finalization
-
 **Override threshold:**
 ```yaml
 localImplementation:
   lightMode:
     enabled: true
-    maxFiles: 5
-    maxLines: 300
+    maxFiles: 2
+    maxLines: 20
 ```
 
-Disabled by default (opt-in). Scope above threshold falls back to full fan-out/fan-in path.
+Scope above threshold falls back to the full fan-out/fan-in path.
 
 ## Deterministic logging structure
 
@@ -264,6 +270,10 @@ For the **current phase only**, run this loop before implementation.
 
 ### 1. Create or update the durable phase doc and tmp scaffold
 
+**Lightweight (PR-body-as-spec) exception:** when the session is lightweight — the resolver output carries `canonicalSpecSource: pr_body` and the derived handoff envelope carries `specSource: pr_body` (started via `resolve-dev-loop-startup.mjs --issue <n> --lightweight`) — SKIP the durable phase-doc mint entirely. The PR description is the spec-of-record; do NOT create or commit any `docs/phases/*.md` for this session. The ephemeral `tmp/phases/` scaffold may still be used for local execution state. All other steps (read prior learning, plan, implement) proceed unchanged, and the gate sequence (draft → pre-approval fanout → detect-evidence → human merge) is identical. See [Artifact Authority Contract](../docs/artifact-authority-contract.md) "Lightweight (PR-body-as-spec)".
+
+Otherwise (default phase-doc path), create or update the durable phase doc.
+
 Use paths like:
 - `docs/phases/phase-0.md`
 - `tmp/phases/phase-0/`
@@ -643,6 +653,7 @@ See [Stop Conditions](../docs/stop-conditions.md). Local-specific stops: phase c
 - PR creation always goes through `dev-loops pr create`, which is ALWAYS draft and always assigned — self-assigned by default (`--assignee @me` when none is given; honors an explicit `--assignee <login>` / `-a <login>`), never via raw `gh pr create`, and the PR body must contain `Closes #N` (or `Fixes #N`) for the linked issue so GitHub auto-closes it on merge. When `.devloops` sets `workflow.requireDraftFirst` to true, use `dev-loops pr create --assignee @me ...`. Do not create a fresh PR directly in ready-for-review state unless the user explicitly overrides that policy for the current PR scope. The draft gate inspection is a real workflow boundary, so a new PR must exist in draft before `gh pr ready` is eligible.
 - When authorization is pending, record the phase as `awaiting-finalization` and describe the exact missing step.
 - For phase-doc-backed sessions, merge the fully reviewed, locally validated branch back into local `main` when authorized.
+- Behind-branch integration before merge (for example a sibling PR merged first and both touch shared files): prefer a merge commit (`git merge origin/main`) over rebase + force-push. Since dev-loop PRs are squash-merged, intermediate branch history is discarded at merge time, so a merge commit lands an identical result on `main` while avoiding a non-fast-forward push to the remote. Force-push (`--force-with-lease` only, never bare `--force`) remains acceptable only for a branch the loop solely owns and where no integration alternative exists (rare); document that carve-out rather than leaving it implicit. After any integration that changes the head SHA, re-verify gate evidence at the new head (existing behavior — see [Merge Preconditions](../docs/merge-preconditions.md#required-before-merge)).
 
 ## Commit policy
 

package/skills/loop-grill/SKILL.md

@@ -0,0 +1,165 @@
+---
+name: loop-grill
+description: >-
+  Standalone pre-loop Socratic Q&A grill for issues (tracker-first) or local
+  plan files (local-planning). Detects spec gaps, asks clarifying questions
+  (interactive) or self-answers them from codebase context (--auto), then
+  writes a ## Grill findings section back to the source artifact.
+allowed-tools: read bash edit write
+user-invocable: false
+---
+# Loop-grill skill
+
+A standalone, on-demand pre-loop grilling skill. Run it against an issue or a local plan file **before** the dev loop starts to surface underspecified acceptance criteria, fuzzy scope boundaries, unresolved primary actors, and undocumented hard-to-reverse decisions.
+
+It is entirely separate from the in-loop docs-grill (`docs/docs-grill-step.md`), which audits code/doc drift while the loop runs. This skill operates on the *spec* before any implementation begins.
+
+## Interface
+
+```
+/loop-grill <issue-number>             # tracker-first, interactive
+/loop-grill <issue-number> --auto      # tracker-first, auto-answer
+/loop-grill <path/to/plan.md>          # local-planning, interactive
+/loop-grill <path/to/plan.md> --auto   # local-planning, auto-answer
+```
+
+## Argument validation (fail-closed)
+
+Before doing anything else:
+
+1. Confirm exactly one positional argument is present (issue number or path). No argument → error, stop.
+2. Confirm the only optional flag is `--auto`. Any other flag → error, stop.
+3. **Tracker-first:** verify the issue exists. Non-existent issue → `Error: issue #<n> not found.`, stop.
+4. **Local-planning:** verify the file exists. Missing file → `Error: plan file not found: <path>`, stop.
+5. Never mutate any artifact when argument validation fails.
+
+## Step 1 — Load the target
+
+- **Tracker-first:** fetch the issue body (title + description + any existing `## Grill findings` section).
+- **Local-planning:** read the plan file from disk.
+
+## Step 1b — Surface external resources
+
+Before detecting gaps, scan the loaded content for external resource references: links, other repo URLs, API endpoints, doc URLs, screenshots, or Playwright navigation descriptors.
+
+- **Interactive mode:** if external resources are present, ask the operator to confirm they are accessible or to provide them before the Q&A starts.
+- **`--auto` mode:** attempt to fetch each resource using bounded wrapper commands (e.g. `gh`, API wrapper scripts under `scripts/`). Do not fetch resources inline with raw `curl` or token-heavy calls. Flag any inaccessible resource as `unresolved` in the findings rather than silently skipping it.
+- When no external resources are present, skip this step silently.
+
+## Step 2 — Detect gaps
+
+Scan the loaded content and identify each gap. The minimum required gap detectors are:
+
+| Gap kind | Detection signal |
+|---|---|
+| Missing acceptance criteria | No `## Acceptance criteria` section, or section is empty / stub |
+| Missing scope boundary | No explicit in-scope / out-of-scope statement or non-goals section |
+| Unresolved primary actor | No named user, system, or role that is the main beneficiary of the feature |
+| Undocumented hard-to-reverse decision | Destructive or irreversible operations described without a rationale or rollback note |
+
+Additional gaps discovered through semantic reading of the spec are also recorded.
+
+For each gap, classify it as either:
+- **Bounded choice** — the answer is one of a small discrete set (e.g. yes/no, A/B/C).
+- **Open-ended** — the answer requires free-form elaboration.
+
+## Step 3 — Fill gaps
+
+### Interactive mode (default)
+
+For each gap, in order:
+
+- **Bounded choice gap:** use `AskUserQuestion` with the question text and the choice options, plus an "Other / free text" option. Block until the user answers.
+- **Open-ended gap:** present the question as a plain text turn. Block until the user answers.
+
+Record each answer with its source: `human`.
+
+> `AskUserQuestion` is a Claude Code–native construct. If you are running outside Claude Code, use `--auto` mode instead.
+
+### Auto mode (`--auto`)
+
+Answer every grilling question yourself without prompting the user. Source answers from (in priority order):
+
+1. **`codebase`** — inspectable source files, tests, scripts, config in the repository.
+2. **`docs`** — markdown files under `docs/`, `skills/docs/`, and adjacent contract docs.
+3. **`context`** — `CONTEXT.md` at the repo root, if present. When absent, skip silently — do not crash, no warning required.
+4. **`inferred`** — reasoning from the issue/plan text alone, with no external citation.
+
+Record the evidence source for every answer. Flag a question as **`unresolved`** when:
+- The only available source is `inferred`, **and**
+- No codebase path, doc section, or issue/plan text can be cited as the basis for the answer.
+
+Do not silently guess an `inferred` answer when no evidence can be cited — flag it `unresolved` instead.
+
+## Step 4 — Write back (replace-section semantics)
+
+Write a `## Grill findings` section back to the source artifact using **replace-section** semantics:
+
+- **Find** the existing `## Grill findings` section: the range from the `## Grill findings` heading through the next `##`-level heading (exclusive) or end of file.
+- **Replace** that range in place with the new section content.
+- If no `## Grill findings` section exists, **append** it.
+- This makes re-runs idempotent — no accumulated noise, no duplicate sections.
+- If parsing the section boundary fails, **abort with an error** rather than silently truncating.
+
+**Tracker-first write-back:** update the GitHub issue body using:
+
+```
+gh issue edit <n> --repo <owner/repo> --body-file <tmp-path>
+```
+
+The `## Grill findings` section lives in the issue body, not as a comment. Do not use `comment-issue.mjs` here — that creates a comment, not a body update.
+
+**GitHub body size guard:** issue bodies are capped at 65,536 characters. Before writing back, check whether the updated body would exceed this limit. If so, warn: `Warning: updated body would exceed GitHub's 65,536-character limit — write-back skipped. Truncate the findings or the issue body manually.` Do not silently truncate.
+
+**Local-planning write-back:** update the plan file in place using the edit tool.
+
+## Output artifact format
+
+The `## Grill findings` section written to the artifact:
+
+```markdown
+## Grill findings
+
+<!-- loop-grill: <timestamp> mode:<interactive|auto> -->
+
+### Resolved gaps
+
+| # | Gap | Question | Answer | Source |
+|---|-----|----------|--------|--------|
+| 1 | Missing AC | <question text> | <answer text> | codebase \| docs \| context \| inferred \| human |
+
+### Unresolved gaps
+
+| # | Gap | Question | Reason unresolved |
+|---|-----|----------|-------------------|
+| 1 | Unresolved primary actor | <question text> | No citable evidence found |
+
+### Verdict
+
+grill-clean
+```
+
+Replace `grill-clean` with `N unresolved items` when unresolved gaps remain.
+
+## Step 5 — Emit verdict
+
+After write-back, emit the verdict line to stdout:
+
+- `grill-clean` when no unresolved gaps remain.
+- `N unresolved items` (e.g. `3 unresolved items`) when gaps remain after all questions are answered.
+
+## CONTEXT.md degradation rule
+
+When `CONTEXT.md` is absent from the repo root, skip the context-source check silently. Do not crash. Do not emit a warning. The grill continues with the remaining sources (`codebase`, `docs`, `inferred`).
+
+## Idempotency guarantee
+
+Running `/loop-grill` twice on the same target must produce a single `## Grill findings` section, not two. The replace-section logic handles the already-present-section case. On the second run, if the gap set is identical to the first run, the section content is replaced with an equivalent section (same questions, same answers, updated timestamp).
+
+## Non-goals
+
+- Auto-triggering from `issue_intake` — this is on-demand only.
+- Replacing or modifying the in-loop docs-grill (`docs/docs-grill-step.md`, `scripts/loop/docs-grill-contract.mjs`) — different concern, different firing surface.
+- Full DDD `CONTEXT.md` management.
+- Scheduling or storing grill runs — stateless and on-demand.
+- Any CI/CD integration.

package/.claude/commands/continue.md

@@ -1,15 +0,0 @@
----
-description: "Continue the dev loop — the current in-progress board item, or a given issue/PR."
-argument-hint: "[issue|pr]"
----
-<!-- GENERATED from commands/continue.command.md by scripts/claude/generate-claude-assets.mjs — do not edit; edit the source and regenerate. -->
-
-Continue a dev loop. Two forms, both handed to the `dev-loop` skill — do NOT pick an internal strategy yourself.
-
-- With an argument (`$ARGUMENTS` is an issue or PR — `123`, `#123`, or a GitHub URL): run the `dev-loop` skill with the public intent `continue dev loop on $ARGUMENTS`. Resolve that artifact's authoritative state first, then route; ignore board position.
-
-- Bare (no `$ARGUMENTS`): pick up the single in-progress board item. Resolve the board's repo and project the same way the queue commands do, then run `node scripts/projects/resolve-active-board-item.mjs --repo <owner/name> --project <number>`.
-  - It returns `{ ok: true, target: { kind, number } }` for exactly one in-progress item → run the `dev-loop` skill with the public intent `continue dev loop on #<number>` (the resolved `target.number`), so the intent carries the concrete target instead of re-resolving board state.
-  - It returns `{ ok: false, reason }` when there are zero or more than one in-progress items → FAIL CLOSED: print the reason verbatim (it lists the items) and instruct the user to run `/continue #N` explicitly. Do NOT guess.
-
-Resolve authoritative state before routing. All paths terminate in the dev-loop skill's `loop startup` → build-envelope → route, stopping at the human-approval checkpoint as usual. No new routing logic here.

package/scripts/loop/conductor.mjs

@@ -1,233 +0,0 @@
-#!/usr/bin/env node
-import { runConductorCycle } from "./run-conductor-cycle.mjs";
-import { runConductorMonitor } from "./conductor-monitor.mjs";
-import { requireTokenValue } from "../_cli-primitives.mjs";
-import { buildParseError, formatCliError, isDirectCliRun } from "../_core-helpers.mjs";
-import { parseRepoSlug } from "@dev-loops/core/github/repo-slug";
-import {
-  loadDevLoopConfig,
-  resolveWorkflowConfig,
-  resolveAutonomyStopAt,
-  resolveGateConfig,
-} from "@dev-loops/core/config";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { parseArgs } from "node:util";
-const USAGE = `Usage: conductor.mjs --repo <owner/name> [--auto-resume] [--cycle-only] [--monitor-only] [--require-retrospective]
-Unified conductor entrypoint for dev-loop lifecycle orchestration.`.trim();
-const parseError = buildParseError(USAGE);
-function checkRetrospectiveGate(cwd, requireRetrospective) {
-  if (!requireRetrospective) return { blocked: false };
-  try {
-    const checkpointPath = path.join(cwd, ".pi", "dev-loop-retrospective-checkpoint.json");
-    const checkpointText = readFileSync(checkpointPath, "utf8");
-    const checkpoint = JSON.parse(checkpointText);
-    const state = typeof checkpoint?.state === "string" ? checkpoint.state.trim().toLowerCase() : null;
-    if (state === "none" || state === "complete" || state === "skipped") {
-      return { blocked: false };
-    }
-    if (state === "required" || state === "missing" || state === null || state === "") {
-      return {
-        blocked: true,
-        reason: state === "required" || state === "missing"
-          ? `Retrospective checkpoint pending (state: ${state}). Complete the retrospective before running the conductor.`
-          : "Retrospective checkpoint file exists but has an unrecognized or empty state; cannot determine retrospective status safely.",
-      };
-    }
-    return {
-      blocked: true,
-      reason: `Retrospective checkpoint has an unrecognized state: "${state}".`,
-    };
-  } catch (err) {
-    if (err?.code === "ENOENT") return { blocked: false };
-    return { blocked: true, reason: `Cannot read retrospective checkpoint: ${err.message}` };
-  }
-}
-function parseCliArgs(argv) {
-  const options = {
-    help: false,
-    repo: undefined,
-    autoResume: false,
-    cycleOnly: false,
-    monitorOnly: false,
-    requireRetrospective: false,
-  };
-  const { tokens } = parseArgs({
-    args: [...argv],
-    options: {
-      help: { type: "boolean", short: "h" },
-      repo: { type: "string" },
-      "auto-resume": { type: "boolean" },
-      "cycle-only": { type: "boolean" },
-      "monitor-only": { type: "boolean" },
-      "require-retrospective": { type: "boolean" },
-    },
-    allowPositionals: true,
-    strict: false,
-    tokens: true,
-  });
-  for (const token of tokens) {
-    if (token.kind === "positional") {
-      throw parseError(`Unknown argument: ${token.value}`);
-    }
-    if (token.kind !== "option") {
-      continue;
-    }
-    if (token.name === "help") {
-      options.help = true;
-      return options;
-    }
-    if (token.name === "repo") {
-      options.repo = requireTokenValue(token, parseError).trim();
-      continue;
-    }
-    if (token.name === "auto-resume") {
-      options.autoResume = true;
-      continue;
-    }
-    if (token.name === "cycle-only") {
-      options.cycleOnly = true;
-      continue;
-    }
-    if (token.name === "monitor-only") {
-      options.monitorOnly = true;
-      continue;
-    }
-    if (token.name === "require-retrospective") {
-      options.requireRetrospective = true;
-      continue;
-    }
-    throw parseError(`Unknown argument: ${token.rawName}`);
-  }
-  if (options.repo === undefined) {
-    throw parseError("conductor requires --repo <owner/name>");
-  }
-  if (options.cycleOnly && options.monitorOnly) {
-    throw parseError("--cycle-only and --monitor-only are mutually exclusive");
-  }
-  try {
-    parseRepoSlug(options.repo);
-  } catch (error) {
-    throw parseError(error instanceof Error ? error.message : String(error));
-  }
-  return options;
-}
-export async function runConductor(options, runtime = {}) {
-  const { cycleOnly = false, monitorOnly = false, autoResume = false, requireRetrospective: forceRetrospective = false } = options;
-  const cwd = runtime.repoRoot || process.cwd();
-  const loadConfig = runtime.loadConfigImpl || loadDevLoopConfig;
-  let configLoadResult;
-  let requireRetrospective = false;
-  let autonomyStopAt = ["merge"];
-  let gateConfig = { draft: { requireCi: true }, preApproval: { requireCi: true } };
-  try {
-    configLoadResult = await loadConfig({ repoRoot: cwd });
-    const hasErrors = Array.isArray(configLoadResult.errors) && configLoadResult.errors.length > 0;
-    if (hasErrors) {
-      configLoadResult = { ...configLoadResult };
-    } else {
-      const cfg = configLoadResult.config ?? {};
-      requireRetrospective = resolveWorkflowConfig(cfg, "requireRetrospective");
-      autonomyStopAt = resolveAutonomyStopAt(cfg);
-      const draftCfg = resolveGateConfig(cfg, "draft");
-      const preApprovalCfg = resolveGateConfig(cfg, "preApproval");
-      gateConfig = {
-        draft: { requireCi: draftCfg.requireCi },
-        preApproval: { requireCi: preApprovalCfg.requireCi },
-      };
-    }
-  } catch (error) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    configLoadResult = { config: null, warnings: [], errors: [{ path: "<config>", message: `Failed to load config: ${errorMessage}`, layer: "merged" }] };
-  }
-  const effectiveRequireRetrospective = forceRetrospective || requireRetrospective;
-  const retroGate = checkRetrospectiveGate(cwd, effectiveRequireRetrospective);
-  if (retroGate.blocked) {
-    return {
-      ok: false,
-      error: retroGate.reason,
-      repo: options.repo,
-      blockedByRetrospective: true,
-      checkedAt: new Date().toISOString(),
-    };
-  }
-  const runCycle = !monitorOnly;
-  const runMonitor = !cycleOnly;
-  const cycleResult = runCycle
-    ? await runConductorCycle({ repo: options.repo, autonomyStopAt, gateConfig }, runtime).catch((error) => ({
-        ok: false,
-        error: error instanceof Error ? error.message : String(error),
-      }))
-    : null;
-  const monitorResult = runMonitor
-    ? await runConductorMonitor({ repo: options.repo, autoResume }, runtime).catch((error) => ({
-        ok: false,
-        error: error instanceof Error ? error.message : String(error),
-      }))
-    : null;
-  const cycleOk = cycleResult?.ok === true;
-  const monitorOk = monitorResult?.ok === true;
-  return {
-    ok: (runCycle ? cycleOk : true) && (runMonitor ? monitorOk : true),
-    repo: options.repo,
-    checkedAt: new Date().toISOString(),
-    cycle: cycleResult ?? null,
-    monitor: monitorResult ?? null,
-    cycleOk,
-    monitorOk,
-    config: {
-      requireRetrospective: effectiveRequireRetrospective,
-      configRequireRetrospective: requireRetrospective,
-      autonomyStopAt,
-      gateConfig,
-      configErrors: configLoadResult?.errors?.length ?? 0,
-    },
-    summary: {
-      totalPrs: (cycleResult?.prCount ?? 0) || (monitorResult?.prCount ?? 0),
-      cycleActions: cycleResult?.actions?.length ?? 0,
-      needsSubagent: cycleResult?.summary?.needsSubagent ?? 0,
-      readyToMerge: cycleResult?.summary?.readyToMerge ?? 0,
-      waiting: cycleResult?.summary?.waiting ?? 0,
-      blocked: cycleResult?.summary?.blocked ?? 0,
-      done: cycleResult?.summary?.done ?? 0,
-      errors: cycleResult?.summary?.errors ?? 0,
-      queueStatus: monitorResult?.queueStatus ?? "unknown",
-      needsAttentionCount: monitorResult?.needsAttentionCount ?? 0,
-      orphanedPrCount: monitorResult?.orphanedPrCount ?? 0,
-      resumePlanCount: monitorResult?.resumePlanCount ?? 0,
-      manualAttentionCount: monitorResult?.manualAttentionCount ?? 0,
-    },
-  };
-}
-export async function runCli(
-  argv = process.argv.slice(2),
-  {
-    stdout = process.stdout,
-    env = process.env,
-    ghCommand = "gh",
-    cwd = process.cwd(),
-  } = {},
-) {
-  const options = parseCliArgs(argv);
-  if (options.help) {
-    stdout.write(`${USAGE}\n`);
-    return;
-  }
-  const result = await runConductor(options, {
-    env,
-    ghCommand,
-    repoRoot: cwd,
-  });
-  if (result.ok === false) {
-    process.stderr.write(`${JSON.stringify(result)}\n`);
-    process.exitCode = 1;
-    return;
-  }
-  stdout.write(`${JSON.stringify(result)}\n`);
-}
-if (isDirectCliRun(import.meta.url)) {
-  runCli().catch((error) => {
-    process.stderr.write(`${formatCliError(error)}\n`);
-    process.exitCode = 1;
-  });
-}