sequant 2.10.0 → 2.12.0

package/dist/src/lib/settings.d.ts

@@ -57,6 +57,23 @@ export interface AgentSettings {
      */
     isolateParallel: boolean;
 }
+/**
+ * The Agent SDK's closed reasoning-effort enum (#914). Single source of
+ * truth — reused by `PhasePolicySchema`'s zod validation below and by
+ * `cli-flags.ts:parsePhaseSpecFlag` for the `--efforts` CLI boundary, so the
+ * two validation points cannot drift apart on which values are accepted.
+ */
+export declare const EFFORT_LEVELS: readonly ["low", "medium", "high", "xhigh", "max"];
+/**
+ * A single phase's `model`/`effort` override for the claude-code driver
+ * (#914). See `RunSettings.phases`.
+ */
+export interface PhasePolicy {
+    /** Model alias/ID, passed through unvalidated to the Agent SDK. */
+    model?: string;
+    /** Reasoning effort — validated against the SDK's closed enum. */
+    effort?: (typeof EFFORT_LEVELS)[number];
+}
 /**
  * Aider-specific settings for the aider agent driver.
  */
@@ -100,11 +117,35 @@ export interface RunSettings {
     defaultBase?: string;
     /**
      * Enable MCP servers in headless mode.
-     * When true, reads MCP config from Claude Desktop and passes to SDK.
+     * When true, injects the sequant MCP server plus any servers declared in
+     * the project's own `.mcp.json` — never a passthrough of the user's Claude
+     * Desktop config, which is a different trust domain and may carry literal
+     * secrets (#936), unless a server is explicitly named in `mcpAllowlist`
+     * below.
      * When false or --no-mcp flag is used, MCPs are disabled.
      * Default: true
      */
     mcp: boolean;
+    /**
+     * Explicit per-server opt-in to pass specific Claude Desktop MCP servers
+     * through to phase execution (#936).
+     *
+     * `mcp` above never reads Claude Desktop config by default — phase agents
+     * get the sequant server plus the project's own `.mcp.json` only. This is
+     * the deliberate escape hatch for a server that exists only in Claude
+     * Desktop config (e.g. never committed to git): list its exact
+     * `mcpServers` key here and phase agents additionally receive it. A name
+     * not present in the desktop config is silently ignored — this is a
+     * filter, not a requirement. Unset or empty (default): no desktop servers
+     * pass through, matching `mcp`'s secure-by-default behavior.
+     *
+     * ⚠️ Desktop Claude configs cannot use `${VAR}` references, so a server you
+     * allowlist here may carry a literal secret that reaches the phase
+     * process's argv (the SDK serializes `mcpServers` into `--mcp-config`).
+     * Only allowlist a server with no credential, or one whose credential you
+     * accept exposing to phase agents and to `ps`.
+     */
+    mcpAllowlist?: string[];
     /**
      * Enable automatic retry with MCP fallback.
      * When true (default), failed phases are retried with MCP disabled.
@@ -166,6 +207,30 @@ export interface RunSettings {
      * Default: true.
      */
     relay?: boolean;
+    /**
+     * Per-phase `model`/`effort` overrides for the claude-code driver (#914),
+     * keyed by phase name. Absent by default — zero behavior change until
+     * opted in. Overridable per-invocation with `--models`/`--efforts`
+     * (CLI > settings > absent, resolved by `resolvePhasePolicies` in
+     * `config-resolver.ts`).
+     */
+    phases?: Record<string, PhasePolicy>;
+    /**
+     * Evidence-based effort escalation on quality-loop retries (#915). Default
+     * `false` — raising effort raises token spend, which is the user's call.
+     * Overridable per-invocation with `--escalate-effort` (CLI > settings >
+     * default). See `effort-escalation.ts` for the resolver.
+     */
+    effortEscalation: boolean;
+    /**
+     * Whether `/fullsolve`'s Phase 5.3 merges the PR automatically once QA
+     * passes (#958). Default `false` — the workflow stops at PR creation +
+     * final summary, preserving the human merge gate kept by #817–#819.
+     * Overridable per-invocation with `--auto-merge`. Read directly by the
+     * `/fullsolve` skill prose (not by any runtime code path — `sequant run`
+     * never merges regardless of this setting).
+     */
+    autoMerge: boolean;
 }
 /**
  * Scope assessment threshold configuration
@@ -304,6 +369,25 @@ export declare const AgentSettingsSchema: z.ZodObject<{
     }>>;
     isolateParallel: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
+/**
+ * Zod schema for a single phase's model/effort override (#914).
+ *
+ * Model aliases/IDs pass through unvalidated — they churn independently of
+ * sequant releases, and the Agent SDK's `query()` call errors clearly on a
+ * bad one. Effort validates against the SDK's closed enum at settings-parse
+ * time since that set is stable and a typo here would otherwise silently
+ * fall through to the SDK default.
+ */
+export declare const PhasePolicySchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    effort: z.ZodOptional<z.ZodEnum<{
+        low: "low";
+        medium: "medium";
+        high: "high";
+        xhigh: "xhigh";
+        max: "max";
+    }>>;
+}, z.core.$strip>;
 /** Zod schema for RunSettings */
 export declare const RunSettingsSchema: z.ZodObject<{
     logJson: z.ZodDefault<z.ZodBoolean>;
@@ -322,6 +406,7 @@ export declare const RunSettingsSchema: z.ZodObject<{
     }, z.core.$strip>>;
     defaultBase: z.ZodOptional<z.ZodString>;
     mcp: z.ZodDefault<z.ZodBoolean>;
+    mcpAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
     retry: z.ZodDefault<z.ZodBoolean>;
     autoWaitMinutes: z.ZodDefault<z.ZodNumber>;
     staleBranchThreshold: z.ZodDefault<z.ZodNumber>;
@@ -335,6 +420,18 @@ export declare const RunSettingsSchema: z.ZodObject<{
         extraArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
     }, z.core.$strip>>;
     relay: z.ZodDefault<z.ZodBoolean>;
+    phases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        effort: z.ZodOptional<z.ZodEnum<{
+            low: "low";
+            medium: "medium";
+            high: "high";
+            xhigh: "xhigh";
+            max: "max";
+        }>>;
+    }, z.core.$strip>>>;
+    effortEscalation: z.ZodDefault<z.ZodBoolean>;
+    autoMerge: z.ZodDefault<z.ZodBoolean>;
 }, z.core.$strip>;
 /** Zod schema for ScopeThreshold (base — fields required, no defaults) */
 export declare const ScopeThresholdSchema: z.ZodObject<{
@@ -415,6 +512,7 @@ export declare const SettingsSchema: z.ZodObject<{
         }, z.core.$strip>>;
         defaultBase: z.ZodOptional<z.ZodString>;
         mcp: z.ZodDefault<z.ZodBoolean>;
+        mcpAllowlist: z.ZodOptional<z.ZodArray<z.ZodString>>;
         retry: z.ZodDefault<z.ZodBoolean>;
         autoWaitMinutes: z.ZodDefault<z.ZodNumber>;
         staleBranchThreshold: z.ZodDefault<z.ZodNumber>;
@@ -428,6 +526,18 @@ export declare const SettingsSchema: z.ZodObject<{
             extraArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
         }, z.core.$strip>>;
         relay: z.ZodDefault<z.ZodBoolean>;
+        phases: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                low: "low";
+                medium: "medium";
+                high: "high";
+                xhigh: "xhigh";
+                max: "max";
+            }>>;
+        }, z.core.$strip>>>;
+        effortEscalation: z.ZodDefault<z.ZodBoolean>;
+        autoMerge: z.ZodDefault<z.ZodBoolean>;
     }, z.core.$strip>>;
     agents: z.ZodDefault<z.ZodObject<{
         parallel: z.ZodDefault<z.ZodBoolean>;

package/dist/src/lib/settings.js

@@ -13,10 +13,18 @@
 import { readFile, writeFile, fileExists, ensureDir } from "./fs.js";
 import { dirname } from "path";
 import { z } from "zod";
+import { getPhaseNames } from "./workflow/phase-registry.js";
 /** Path to project-level settings file */
 export const SETTINGS_PATH = ".sequant/settings.json";
 /** Current settings schema version */
 export const SETTINGS_VERSION = "1.0";
+/**
+ * The Agent SDK's closed reasoning-effort enum (#914). Single source of
+ * truth — reused by `PhasePolicySchema`'s zod validation below and by
+ * `cli-flags.ts:parsePhaseSpecFlag` for the `--efforts` CLI boundary, so the
+ * two validation points cannot drift apart on which values are accepted.
+ */
+export const EFFORT_LEVELS = ["low", "medium", "high", "xhigh", "max"];
 // ─── Zod Schemas (AC-1, AC-5) ────────────────────────────────────────────────
 /** Zod schema for RotationSettings */
 export const RotationSettingsSchema = z.object({
@@ -36,6 +44,19 @@ export const AgentSettingsSchema = z.object({
     model: z.enum(["haiku", "sonnet", "opus"]).default("haiku"),
     isolateParallel: z.boolean().default(false),
 });
+/**
+ * Zod schema for a single phase's model/effort override (#914).
+ *
+ * Model aliases/IDs pass through unvalidated — they churn independently of
+ * sequant releases, and the Agent SDK's `query()` call errors clearly on a
+ * bad one. Effort validates against the SDK's closed enum at settings-parse
+ * time since that set is stable and a typo here would otherwise silently
+ * fall through to the SDK default.
+ */
+export const PhasePolicySchema = z.object({
+    model: z.string().optional(),
+    effort: z.enum(EFFORT_LEVELS).optional(),
+});
 /** Zod schema for RunSettings */
 export const RunSettingsSchema = z.object({
     logJson: z.boolean().default(true),
@@ -57,6 +78,7 @@ export const RunSettingsSchema = z.object({
     rotation: RotationSettingsSchema.default(() => RotationSettingsSchema.parse({})),
     defaultBase: z.string().optional(),
     mcp: z.boolean().default(true),
+    mcpAllowlist: z.array(z.string()).optional(),
     retry: z.boolean().default(true),
     autoWaitMinutes: z.number().min(0).default(0),
     staleBranchThreshold: z.number().default(5),
@@ -66,6 +88,29 @@ export const RunSettingsSchema = z.object({
     agent: z.string().optional(),
     aider: AiderSettingsSchema.optional(),
     relay: z.boolean().default(true),
+    /**
+     * Per-phase `model`/`effort` overrides for the claude-code driver (#914).
+     * Absent by default — zero behavior change until opted in. Keyed by phase
+     * name (validated against `getPhaseNames()` via `KNOWN_KEYS["run.phases"]`
+     * as a non-fatal warning, not a schema-level rejection — a typo'd phase
+     * name here should not crash a run the way an invalid `effort` enum does).
+     */
+    phases: z.record(z.string(), PhasePolicySchema).optional(),
+    /**
+     * Evidence-based effort escalation on quality-loop retries (#915). Default
+     * `false` — raising effort raises token spend, which is the user's call.
+     * When enabled, a retried phase execution (loop iteration ≥ 2, or a
+     * `sequant ready` QA-pass loop re-run) resolves one effort tier above its
+     * configured/inherited base for that execution only. See
+     * `effort-escalation.ts` for the resolver.
+     */
+    effortEscalation: z.boolean().default(false),
+    /**
+     * Whether `/fullsolve`'s Phase 5.3 merges the PR automatically once QA
+     * passes (#958). Default `false` — preserves the human merge gate kept by
+     * #817–#819. Overridable per-invocation with `--auto-merge`.
+     */
+    autoMerge: z.boolean().default(false),
 });
 /** Zod schema for ScopeThreshold (base — fields required, no defaults) */
 export const ScopeThresholdSchema = z.object({
@@ -178,6 +223,7 @@ const KNOWN_KEYS = {
         "rotation",
         "defaultBase",
         "mcp",
+        "mcpAllowlist",
         "retry",
         "staleBranchThreshold",
         "resolvedIssueTTL",
@@ -186,7 +232,13 @@ const KNOWN_KEYS = {
         "agent",
         "aider",
         "relay",
+        "phases",
     ]),
+    // #914: keyed by real phase name so a typo (`run.phases.exce`) warns
+    // instead of silently resolving to nothing. Computed from the registry
+    // rather than hardcoded so a new phase registration doesn't need a
+    // matching edit here.
+    "run.phases": new Set(getPhaseNames()),
     agents: new Set(["parallel", "model", "isolateParallel"]),
     scopeAssessment: new Set([
         "enabled",
@@ -406,6 +458,8 @@ export const DEFAULT_SETTINGS = {
         staleBranchThreshold: 5, // Block QA/test if feature is >5 commits behind main
         resolvedIssueTTL: 7, // Auto-prune resolved issues after 7 days
         relay: true, // Enable interactive relay (#383) by default
+        effortEscalation: false, // #915: off by default — raises token spend
+        autoMerge: false, // #958: off by default — preserves the human merge gate
     },
     agents: DEFAULT_AGENT_SETTINGS,
     scopeAssessment: DEFAULT_SCOPE_ASSESSMENT_SETTINGS,
@@ -536,6 +590,10 @@ export function generateSettingsJsonc(settings) {
     lines.push(`    "smartTests": ${JSON.stringify(settings.run.smartTests)},`);
     lines.push(`    // Enable MCP servers in headless mode`);
     lines.push(`    "mcp": ${JSON.stringify(settings.run.mcp)},`);
+    if (settings.run.mcpAllowlist !== undefined) {
+        lines.push(`    // Desktop MCP servers explicitly allowlisted for phases`);
+        lines.push(`    "mcpAllowlist": ${JSON.stringify(settings.run.mcpAllowlist)},`);
+    }
     lines.push(`    // Enable automatic retry with MCP fallback`);
     lines.push(`    "retry": ${JSON.stringify(settings.run.retry)},`);
     lines.push(`    // Commits behind main before warning`);
@@ -653,6 +711,7 @@ Generated by \`sequant init\`. See defaults below.
 | \`smartTests\` | boolean | \`true\` | Enable smart test detection |
 | \`defaultBase\` | string | — | Default base branch for worktree creation |
 | \`mcp\` | boolean | \`true\` | Enable MCP servers in headless mode |
+| \`mcpAllowlist\` | string[] | — | Desktop MCP server names to pass through to phases despite \`mcp\`'s default exclusion (#936) |
 | \`retry\` | boolean | \`true\` | Enable automatic retry with MCP fallback |
 | \`staleBranchThreshold\` | number | \`5\` | Commits behind main before warning |
 | \`resolvedIssueTTL\` | number | \`7\` | Days before resolved issues auto-prune (0=never, -1=immediate) |

package/dist/src/lib/system.d.ts

@@ -54,9 +54,13 @@ export interface McpServerConfig {
 /**
  * Get full MCP server configurations from Claude Desktop config
  *
- * Returns the complete mcpServers object suitable for passing to the
- * Claude Agent SDK query() options. Returns undefined if config doesn't
- * exist or is invalid (graceful degradation for AC-3).
+ * For interactive `doctor` diagnostics only — reports what's configured for
+ * the human user. Never pass this to phase execution (#936): Claude Desktop
+ * is a different trust domain (interactive, human-supervised) than an
+ * autonomous phase agent, and desktop configs carry literal secrets since
+ * they cannot use `${VAR}` references. Phase agents use
+ * `getPhaseMcpServersConfig` from `mcp-config.ts` instead, which allowlists
+ * from the project's own `.mcp.json`.
  *
  * @returns MCP server configurations or undefined
  */

package/dist/src/lib/system.js

@@ -136,9 +136,13 @@ export function getConfiguredMcpServers() {
 /**
  * Get full MCP server configurations from Claude Desktop config
  *
- * Returns the complete mcpServers object suitable for passing to the
- * Claude Agent SDK query() options. Returns undefined if config doesn't
- * exist or is invalid (graceful degradation for AC-3).
+ * For interactive `doctor` diagnostics only — reports what's configured for
+ * the human user. Never pass this to phase execution (#936): Claude Desktop
+ * is a different trust domain (interactive, human-supervised) than an
+ * autonomous phase agent, and desktop configs carry literal secrets since
+ * they cannot use `${VAR}` references. Phase agents use
+ * `getPhaseMcpServersConfig` from `mcp-config.ts` instead, which allowlists
+ * from the project's own `.mcp.json`.
  *
  * @returns MCP server configurations or undefined
  */

package/dist/src/lib/test-tautology-detector.d.ts

@@ -104,12 +104,13 @@ export declare function extractTestBlocks(content: string): Array<{
  * when it references an imported production function, directly spawns the
  * project's build output, or calls a helper that (transitively) does so.
  *
- * @param spawnHandles Names of describe/module-scope helpers that spawn the
- *   build output (see {@link collectSpawnHandles}).
+ * @param productionHandles Names of describe/module-scope helpers that reach
+ *   production — by spawning the project's executable code or by calling an
+ *   imported production function (see {@link collectProductionHandles}).
  * @param buildOutputVars Variable names bound to a build-output path (see
  *   {@link collectBuildOutputVars}).
  */
-export declare function testBlockCallsProductionCode(body: string, importedFunctions: ImportedFunction[], spawnHandles?: string[], buildOutputVars?: string[]): boolean;
+export declare function testBlockCallsProductionCode(body: string, importedFunctions: ImportedFunction[], productionHandles?: string[], buildOutputVars?: string[]): boolean;
 /**
  * Check if a file opts out of tautology detection via pragma comment.
  *

package/dist/src/lib/test-tautology-detector.js

@@ -369,20 +369,85 @@ const SPAWN_PATTERN = /(?:\b(?:execFileSync|spawnSync|execSync|execFile)\s*\(|(?
  */
 const BUILD_OUTPUT_PATTERN = /\bdist\//;
 /**
- * Collect names of variables bound to a build-output path, e.g.
+ * Non-compiled production code this project ships and executes: the hook
+ * scripts and the `scripts/` + `templates/scripts/` trees (#906).
+ *
+ * `dist/` alone was too narrow. `checkout-lock.integration.test.ts` drives the
+ * real `.claude/hooks/pre-tool.sh` as a subprocess — that hook IS the
+ * enforcement half of the feature under test — yet every block in the file
+ * read as tautological because the path is not under `dist/`.
+ */
+const PROJECT_SCRIPT_PATTERN = /\b(?:hooks\/[\w.-]+\.sh|scripts\/[\w./-]+)/;
+/**
+ * Collect names of variables bound to a path into the project's own executable
+ * code, e.g.
  *   const cliPath = resolve(projectRoot, "dist/bin/cli.js");
- * captures `cliPath`. Tests almost always spawn via such a handle rather than
- * an inline string, so these names stand in for the literal build path.
+ *   const HOOK    = join(REPO_ROOT, ".claude/hooks/pre-tool.sh");
+ * captures `cliPath` / `HOOK`. Tests almost always spawn via such a handle
+ * rather than an inline string, so these names stand in for the literal path.
  *
  * The right-hand side is statement-bounded (`[^;]`) so a match cannot bleed
- * across declarations, and must contain the `dist/` marker.
+ * across declarations, and must reach one of the two markers. Spawning a
+ * *system* binary (`git`, `bash` with a temp fixture) matches neither, which
+ * is the intended exclusion — those are not this project's code.
+ *
+ * An optional type annotation is allowed between the name and `=`, e.g.
+ *   const HOOK_COPIES: Array<[label: string, path: string]> = [...];
+ * The annotation submatch (`[^=;]*`) stops at the first `=`, so an arrow-
+ * function-typed annotation (`const f: (x: string) => void = ...`) breaks
+ * the match at its `=>` instead of reaching the real assignment — accepted
+ * as a narrow miss; typed function-value declarations are not the shape this
+ * collector targets (path-bearing table/tuple declarations are).
  */
 function collectBuildOutputVars(content) {
     const names = new Set();
-    const pattern = /(?:const|let|var)\s+(\w+)\s*=\s*[^;]*?\bdist\//g;
+    const patterns = [
+        /(?:const|let|var)\s+(\w+)\s*(?::[^=;]*)?=\s*[^;]*?\bdist\//g,
+        /(?:const|let|var)\s+(\w+)\s*(?::[^=;]*)?=\s*[^;]*?\b(?:hooks\/[\w.-]+\.sh|scripts\/[\w./-]+)/g,
+    ];
+    for (const pattern of patterns) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+            names.add(match[1]);
+        }
+    }
+    return [...names];
+}
+/**
+ * Collect callback parameter names bound to a build-output table's rows via
+ * `describe.each(X)("...", (a, b) => {...})`, when `X` is itself a
+ * build-output source: a var already collected by collectBuildOutputVars, or
+ * an inline array literal containing a build-output token directly.
+ *
+ * `describe.each` destructures each table row into positional callback
+ * params. A helper spawning `hookPath` — the param, not the table var — is
+ * exercising production code just as much as one spawning `HOOK_COPIES`
+ * directly; static analysis of the table alone misses it entirely. The
+ * string-title argument is matched by quote char (not `[^()]*`) because test
+ * titles routinely contain literal parens (e.g. `"... (#564) [%s]"`), which
+ * a paren-excluding class would truncate on.
+ *
+ * Bounded like the rest of this file's helper matchers: no nested parens in
+ * the table-var/params captures, so a callback with a destructured or
+ * default-valued param is skipped rather than mis-parsed.
+ */
+function collectDescribeEachParams(content, buildOutputVars) {
+    const names = new Set();
+    const pattern = /describe\.each\(\s*([^()]*?)\s*\)\s*\(\s*(['"`])(?:(?!\2)[\s\S])*?\2\s*,\s*(?:async\s+)?\(([^()]*)\)\s*=>/g;
     let match;
     while ((match = pattern.exec(content)) !== null) {
-        names.add(match[1]);
+        const tableArg = match[1].trim();
+        const isKnownVar = /^\w+$/.test(tableArg) && buildOutputVars.includes(tableArg);
+        const isInlineSource = BUILD_OUTPUT_PATTERN.test(tableArg) ||
+            PROJECT_SCRIPT_PATTERN.test(tableArg);
+        if (!isKnownVar && !isInlineSource)
+            continue;
+        for (const param of match[3].split(",")) {
+            const name = param.trim().split(":")[0].trim();
+            if (/^\w+$/.test(name)) {
+                names.add(name);
+            }
+        }
     }
     return [...names];
 }
@@ -391,7 +456,7 @@ function collectBuildOutputVars(content) {
  * `dist/` marker or one of the collected build-path variable names.
  */
 function referencesBuildOutput(body, buildOutputVars) {
-    if (BUILD_OUTPUT_PATTERN.test(body)) {
+    if (BUILD_OUTPUT_PATTERN.test(body) || PROJECT_SCRIPT_PATTERN.test(body)) {
         return true;
     }
     return buildOutputVars.some((name) => referenceMatcher(name).test(body));
@@ -406,45 +471,84 @@ function spawnsBuildOutput(body, buildOutputVars) {
     return (SPAWN_PATTERN.test(body) && referencesBuildOutput(body, buildOutputVars));
 }
 /**
- * Extract module/describe-scope helper definitions (named block-bodied arrow
- * consts) as { name, body } pairs.
+ * Extract module/describe-scope helper definitions as { name, body } pairs.
  *
- * Anchors on `=> {` so a return-type object annotation
- *   const run = (): { stdout: string } => { ... }
- * is not mistaken for the function body. Params are matched with `[^()]*` (no
- * nested parens) to keep the scan from running away across the file. Only
- * block-bodied arrows are collected; the subprocess integration tests this
- * targets all use them.
+ * Two shapes, because both are idiomatic and a detector that saw only one
+ * produced large-scale false positives (#906): a test calling a helper the
+ * detector cannot see reads as import-less, hence tautological. Measured on
+ * `checkout-lock.integration.test.ts` (helpers written as `function`
+ * declarations): 17 of 19 blocks flagged, every one of them real.
+ *
+ * Params are matched with `[^()]*` (no nested parens) to keep the scan from
+ * running away across the file. Expression-bodied arrows are skipped — they
+ * have no `{` body to extract.
  */
 function extractHelperDefinitions(content) {
     const helpers = [];
-    const pattern = /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^()]*\)\s*(?::[^=]*?)?=>\s*\{/g;
+    // Arrow consts anchor on `=> {`, so the body brace is unambiguous.
+    const arrowPattern = /(?:const|let|var)\s+(\w+)\s*=\s*(?:async\s+)?\([^()]*\)\s*(?::[^=]*?)?=>\s*\{/g;
     let match;
-    while ((match = pattern.exec(content)) !== null) {
-        if (isInsideString(content, match.index)) {
+    while ((match = arrowPattern.exec(content)) !== null) {
+        if (isInsideString(content, match.index))
             continue;
-        }
-        const name = match[1];
-        // The final `{` of the match is the function body's opening brace.
         const braceIndex = match.index + match[0].length - 1;
-        const body = extractBlockBody(content.substring(braceIndex));
-        helpers.push({ name, body });
+        helpers.push({
+            name: match[1],
+            body: extractBlockBody(content.substring(braceIndex)),
+        });
+    }
+    // Declarations have no `=>` marker, and the return-type annotation may open
+    // a brace group of its own:
+    //   function runHook(o): { status: number; stderr: string } { ... }
+    // so the body is NOT simply the first `{` after the parameters. Do not try
+    // to express that in the regex — a greedy annotation subpattern silently ran
+    // past the body and anchored on the NEXT declaration's brace, yielding a
+    // "helper" whose body was somebody else's code (caught by the object
+    // return-type test below). Match only to the closing paren, then walk: take
+    // the first brace group; if another `{` follows it, that group was the
+    // return type and the body is the next one.
+    const declPattern = /(?:async\s+)?function\s*\*?\s*(\w+)\s*\([^()]*\)/g;
+    while ((match = declPattern.exec(content)) !== null) {
+        if (isInsideString(content, match.index))
+            continue;
+        const rest = content.substring(match.index + match[0].length);
+        const firstBrace = rest.indexOf("{");
+        if (firstBrace === -1)
+            continue;
+        // Anything between `)` and the first `{` must be an annotation, not code.
+        if (/[;)=]/.test(rest.substring(0, firstBrace)))
+            continue;
+        let body = extractBlockBody(rest.substring(firstBrace));
+        const after = rest.substring(firstBrace + body.length);
+        if (/^\s*\{/.test(after)) {
+            body = extractBlockBody(after);
+        }
+        helpers.push({ name: match[1], body });
     }
     return helpers;
 }
 /**
- * Collect the names of helper functions that spawn the build output, resolving
- * indirection transitively: a helper that calls an already-known spawn helper
- * is itself a spawn helper. This lets a test that only calls
- * `expectFlagAccepted(...)` (which calls `runInUninitializedDir`, which spawns
- * the CLI) count as exercising production code.
+ * Collect the names of helper functions that reach production code, resolving
+ * indirection transitively: a helper that calls an already-known handle is
+ * itself a handle. This lets a test that only calls `expectFlagAccepted(...)`
+ * (which calls `runInUninitializedDir`, which spawns the CLI) count as
+ * exercising production code.
+ *
+ * A helper qualifies two ways:
+ *  - it spawns the project's own executable code (subprocess integration
+ *    tests), or
+ *  - it references an imported production function (#906). `makeLock()`
+ *    returning `new CheckoutLock({...})` is production code by any reading,
+ *    but seeding on spawns alone missed it, so every test that built its
+ *    subject through a factory read as tautological.
  */
-function collectSpawnHandles(content, buildOutputVars) {
+function collectProductionHandles(content, buildOutputVars, importedFunctions = []) {
     const helpers = extractHelperDefinitions(content);
     const handles = new Set();
-    // Seed: helpers that directly spawn the build output.
+    // Seed: helpers that directly reach production.
     for (const helper of helpers) {
-        if (spawnsBuildOutput(helper.body, buildOutputVars)) {
+        if (spawnsBuildOutput(helper.body, buildOutputVars) ||
+            importedFunctions.some((fn) => referenceMatcher(fn.name).test(helper.body))) {
             handles.add(helper.name);
         }
     }
@@ -472,12 +576,13 @@ function collectSpawnHandles(content, buildOutputVars) {
  * when it references an imported production function, directly spawns the
  * project's build output, or calls a helper that (transitively) does so.
  *
- * @param spawnHandles Names of describe/module-scope helpers that spawn the
- *   build output (see {@link collectSpawnHandles}).
+ * @param productionHandles Names of describe/module-scope helpers that reach
+ *   production — by spawning the project's executable code or by calling an
+ *   imported production function (see {@link collectProductionHandles}).
  * @param buildOutputVars Variable names bound to a build-output path (see
  *   {@link collectBuildOutputVars}).
  */
-export function testBlockCallsProductionCode(body, importedFunctions, spawnHandles = [], buildOutputVars = []) {
+export function testBlockCallsProductionCode(body, importedFunctions, productionHandles = [], buildOutputVars = []) {
     // 1. References an imported production function.
     for (const fn of importedFunctions) {
         if (referenceMatcher(fn.name).test(body)) {
@@ -490,9 +595,10 @@ export function testBlockCallsProductionCode(body, importedFunctions, spawnHandl
     if (spawnsBuildOutput(body, buildOutputVars)) {
         return true;
     }
-    // 3. Calls a describe/module-scope helper that (transitively) spawns the
-    //    build output.
-    for (const handle of spawnHandles) {
+    // 3. Calls a describe/module-scope helper that (transitively) reaches
+    //    production — spawns the project's executable code, or calls an imported
+    //    production function (#906). Covers arrow-const and `function` helpers.
+    for (const handle of productionHandles) {
         if (referenceMatcher(handle).test(body)) {
             return true;
         }
@@ -528,14 +634,15 @@ export function analyzeTestFile(content, filePath) {
     }
     try {
         const importedFunctions = extractImports(content);
-        const buildOutputVars = collectBuildOutputVars(content);
-        const spawnHandles = collectSpawnHandles(content, buildOutputVars);
+        const declaredBuildOutputVars = collectBuildOutputVars(content);
+        const buildOutputVars = declaredBuildOutputVars.concat(collectDescribeEachParams(content, declaredBuildOutputVars));
+        const productionHandles = collectProductionHandles(content, buildOutputVars, importedFunctions);
         const testBlocks = extractTestBlocks(content);
         const analyzedBlocks = testBlocks.map((block) => ({
             description: block.description,
             lineNumber: block.lineNumber,
             style: block.style,
-            isTautological: !testBlockCallsProductionCode(block.body, importedFunctions, spawnHandles, buildOutputVars),
+            isTautological: !testBlockCallsProductionCode(block.body, importedFunctions, productionHandles, buildOutputVars),
         }));
         const tautologicalCount = analyzedBlocks.filter((b) => b.isTautological).length;
         const totalTests = analyzedBlocks.length;

package/dist/src/lib/workflow/batch-executor.d.ts

@@ -8,7 +8,7 @@
  * creation).
  */
 import { LogWriter } from "./log-writer.js";
-import { ExecutionConfig, PhaseResult, IssueResult, type RunOptions, type IssueExecutionContext, type BatchExecutionContext, type ProgressCallback } from "./types.js";
+import { ExecutionConfig, PhaseResult, IssueResult, type RunOptions, type IssueExecutionContext, type BatchExecutionContext, type ProgressCallback, type QaVerdict, type QaSummary } from "./types.js";
 import { type ErrorCategory } from "./error-classifier.js";
 export type { RunOptions, ProgressCallback, IssueExecutionContext, BatchExecutionContext, } from "./types.js";
 /**
@@ -205,4 +205,23 @@ export declare function billingHaltReason(result: PhaseResult): string;
  * @internal Exported for testing
  */
 export declare function windowHaltResumeAtMs(result: PhaseResult): number | null;
+/**
+ * Build the comment body for a standard-qa-phase verdict post (#964).
+ * Includes AC coverage and any gaps/suggestions from the parsed `QaSummary`,
+ * plus a machine marker so a future dedup pass has an anchor.
+ * @internal Exported for testing.
+ */
+export declare function buildQaVerdictComment(verdict: QaVerdict, summary: QaSummary | undefined, commitHash: string | undefined, iteration: number): string;
+/**
+ * Post the qa-verdict comment for a standard (non-ready-gate) qa phase under
+ * orchestrated `sequant run` (#964). This is the channel `qa/SKILL.md` §9
+ * promises ("orchestrator handles aggregated summary") but batch-executor
+ * never backed — a re-run producing a fresh, different verdict left a stale,
+ * contradicted comment as the only externally-visible one.
+ *
+ * Best-effort: a post failure is caught and logged, never fails the run —
+ * mirrors {@link runReadyGateForIssue}'s `postReport` contract (#937 AC-4).
+ * @internal Exported for testing.
+ */
+export declare function postQaVerdictComment(issueNumber: number, verdict: QaVerdict, summary: QaSummary | undefined, commitHash: string | undefined, iteration: number, log: (msg: string) => void, postComment?: (issueNumber: number, body: string) => Promise<void>): Promise<void>;
 export declare function runIssueWithLogging(ctx: IssueExecutionContext): Promise<IssueResult>;