sequant 2.10.0 → 2.12.0

package/dist/src/lib/workflow/qa-gaps-marker.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Parseable structured gap-finding markers for `/qa` (#937).
+ *
+ * `parseQaSummary`'s prose scrape (`parseListSection` against a
+ * `**Issues:**`/`**Gaps**` header) is lossy — it misses AC-table NOT_MET
+ * rows, §6d Adversarial Re-Read findings, and §5 Risk Assessment. QA output
+ * templates now end with a structured marker:
+ *
+ * ```
+ * <!-- SEQUANT_QA_GAPS: {"findings":[{"category":"test_gap","evidence":"...",
+ * "description":"...","recommendedAction":"fix_now"}]} -->
+ * ```
+ *
+ * Same durable-marker idiom as `SEQUANT_SPEC` (spec-recommendation.ts),
+ * `SEQUANT_PHASE` (phase-detection.ts), and `SEQUANT_MUTATION`
+ * (mutation-marker.ts) — but unlike those three, this marker's payload is
+ * an array of objects, not a flat record, so it cannot reuse their
+ * `{[^}]+}` regex (that stops at the FIRST `}`, truncating mid-JSON on any
+ * nested object). Instead this matches lazily up to the closing `-->`,
+ * which the emitting template guarantees appears on the same line as the
+ * marker (single-line JSON, no `-->` inside string values).
+ */
+import { type GapFinding } from "./run-log-schema.js";
+/**
+ * Parse every `SEQUANT_QA_GAPS` marker from a QA comment/output and return
+ * the findings from the last valid one (latest-wins, matching
+ * `resolveSpecRecommendation`'s idiom for `SEQUANT_SPEC`).
+ *
+ * Markers inside fenced code blocks or inline code (e.g. a doc example
+ * showing the marker format) are ignored. Malformed JSON or a
+ * schema-invalid payload is skipped rather than thrown — an unparseable
+ * marker degrades to "no marker found", not a crash.
+ *
+ * @param output - QA comment body or agent output text
+ * @returns The findings array from the last valid marker, or `null` if no
+ *   valid marker was found
+ */
+export declare function parseQaGapsMarker(output: string): GapFinding[] | null;

package/dist/src/lib/workflow/qa-gaps-marker.js

@@ -0,0 +1,66 @@
+/**
+ * Parseable structured gap-finding markers for `/qa` (#937).
+ *
+ * `parseQaSummary`'s prose scrape (`parseListSection` against a
+ * `**Issues:**`/`**Gaps**` header) is lossy — it misses AC-table NOT_MET
+ * rows, §6d Adversarial Re-Read findings, and §5 Risk Assessment. QA output
+ * templates now end with a structured marker:
+ *
+ * ```
+ * <!-- SEQUANT_QA_GAPS: {"findings":[{"category":"test_gap","evidence":"...",
+ * "description":"...","recommendedAction":"fix_now"}]} -->
+ * ```
+ *
+ * Same durable-marker idiom as `SEQUANT_SPEC` (spec-recommendation.ts),
+ * `SEQUANT_PHASE` (phase-detection.ts), and `SEQUANT_MUTATION`
+ * (mutation-marker.ts) — but unlike those three, this marker's payload is
+ * an array of objects, not a flat record, so it cannot reuse their
+ * `{[^}]+}` regex (that stops at the FIRST `}`, truncating mid-JSON on any
+ * nested object). Instead this matches lazily up to the closing `-->`,
+ * which the emitting template guarantees appears on the same line as the
+ * marker (single-line JSON, no `-->` inside string values).
+ */
+import { z } from "zod";
+import { GapFindingSchema } from "./run-log-schema.js";
+import { stripMarkdownCode } from "./phase-detection.js";
+/** Regex to extract the SEQUANT_QA_GAPS marker JSON from an HTML comment. */
+const QA_GAPS_MARKER_REGEX = /<!-- SEQUANT_QA_GAPS: (\{[\s\S]*?\}) -->/g;
+const QaGapsMarkerPayloadSchema = z.object({
+    findings: z.array(GapFindingSchema),
+});
+/**
+ * Parse every `SEQUANT_QA_GAPS` marker from a QA comment/output and return
+ * the findings from the last valid one (latest-wins, matching
+ * `resolveSpecRecommendation`'s idiom for `SEQUANT_SPEC`).
+ *
+ * Markers inside fenced code blocks or inline code (e.g. a doc example
+ * showing the marker format) are ignored. Malformed JSON or a
+ * schema-invalid payload is skipped rather than thrown — an unparseable
+ * marker degrades to "no marker found", not a crash.
+ *
+ * @param output - QA comment body or agent output text
+ * @returns The findings array from the last valid marker, or `null` if no
+ *   valid marker was found
+ */
+export function parseQaGapsMarker(output) {
+    if (!output)
+        return null;
+    const stripped = stripMarkdownCode(output);
+    QA_GAPS_MARKER_REGEX.lastIndex = 0;
+    let latest = null;
+    let match;
+    while ((match = QA_GAPS_MARKER_REGEX.exec(stripped)) !== null) {
+        let parsed;
+        try {
+            parsed = JSON.parse(match[1]);
+        }
+        catch {
+            continue;
+        }
+        const result = QaGapsMarkerPayloadSchema.safeParse(parsed);
+        if (result.success) {
+            latest = result.data.findings;
+        }
+    }
+    return latest;
+}

package/dist/src/lib/workflow/ready-gate.d.ts

@@ -22,7 +22,8 @@
  * lives in `src/commands/ready.ts`.
  */
 import type { ExecutionConfig, PhaseResult, ProgressCallback } from "./types.js";
-import type { QaVerdict } from "./run-log-schema.js";
+import { type EscalationRecord } from "./effort-escalation.js";
+import type { QaVerdict, GapCategory, GapAction } from "./run-log-schema.js";
 import type { ReadyPolicy } from "../settings.js";
 import type { IssueStatus } from "./state-schema.js";
 import { type LoopProgressSnapshot } from "./qa-stagnation.js";
@@ -68,6 +69,15 @@ export interface ReadyGapItem {
      * mode these are explicitly report-only (never fed to the fix loop).
      */
     nonGoal: boolean;
+    /**
+     * Structured taxonomy fields from the `SEQUANT_QA_GAPS` marker (#937),
+     * present only when this gap's description matched a marker finding.
+     * A gap surfaced only via the legacy prose scrape carries none of these.
+     */
+    category?: GapCategory;
+    evidence?: string;
+    recommendedAction?: GapAction;
+    affectedAcs?: string[];
 }
 /** Structured outcome of a ready-gate run. */
 export interface ReadyResult {
@@ -90,6 +100,12 @@ export interface ReadyResult {
     tokensUsed: number;
     /** Human-readable markdown gap report (AC-4). */
     report: string;
+    /**
+     * Effort escalations applied during this gate's QA-pass loop (#915),
+     * base+escalated tier per escalated `qa`/`loop` dispatch. Empty when
+     * `effortEscalation` is off or no dispatch escalated.
+     */
+    effortEscalations: EscalationRecord[];
 }
 /**
  * Thin phase-runner abstraction so the engine can be unit-tested without the
@@ -110,6 +126,13 @@ export interface RunReadyGateOptions {
     phaseTimeout: number;
     /** Whether MCP servers are enabled for phase execution. */
     mcp: boolean;
+    /**
+     * Claude Desktop MCP server names explicitly opted in (#936). Callers
+     * (`commands/ready.ts`) resolve this from `settings.run.mcpAllowlist` —
+     * see the doc comment on `ExecutionConfig.mcpAllowlist` for why this
+     * producer cannot drift from `buildExecutionConfig`'s own assignment.
+     */
+    mcpAllowlist?: string[];
     verbose?: boolean;
     /** Injectable phase runner — defaults to the real executePhaseWithRetry wrapper. */
     runPhase: ReadyPhaseRunner;
@@ -127,6 +150,35 @@ export interface RunReadyGateOptions {
     classifyChangesFn?: (cwd: string) => ExecChangeState;
     /** Injectable loop-progress snapshot — defaults to {@link snapshotLoopProgress}. */
     snapshotFn?: (cwd: string) => LoopProgressSnapshot;
+    /**
+     * Resolved per-phase `model`/`effort` overrides (#914), keyed by phase
+     * name. Callers (e.g. `commands/ready.ts`) resolve this via
+     * `resolvePhasePolicies` — the same shared resolver `buildExecutionConfig`
+     * uses — so this producer cannot drift from that one (#833 class).
+     * `buildPhaseConfig` spreads it onto every `ExecutionConfig` it builds;
+     * `phase-executor.ts` applies the entry for the phase actually running.
+     */
+    phasePolicies?: Record<string, {
+        model?: string;
+        effort?: string;
+    }>;
+    /**
+     * Evidence-based effort escalation on quality-loop retries (#915). Callers
+     * (e.g. `commands/ready.ts`) resolve this CLI > settings > `false`, the same
+     * precedence `buildExecutionConfig` uses for the `run` path (#833 class).
+     * `buildPhaseConfig` spreads it onto every `ExecutionConfig` it builds;
+     * `withEscalatedEffort` (`effort-escalation.ts`) reads it at each QA-pass
+     * dispatch to decide whether that specific `qa`/`loop` call escalates.
+     */
+    effortEscalation?: boolean;
+    /**
+     * Persist the final gap report as an issue comment when the gate reaches
+     * a terminal state with a QA verdict (#937 AC-4) — callers wire this to
+     * `GitHubProvider.postComment`. Best-effort: a failure here is caught and
+     * swallowed, never failing the gate itself — `result.report` (returned to
+     * the caller either way) is the primary channel.
+     */
+    postReport?: (body: string) => Promise<void>;
 }
 /**
  * Pure exit predicate. Given a policy and a QA verdict, has the loop reached

package/dist/src/lib/workflow/ready-gate.js

@@ -21,6 +21,7 @@
  * (out of scope for #683) can reuse `runReadyGate` directly. The command shell
  * lives in `src/commands/ready.ts`.
  */
+import { withEscalatedEffort, } from "./effort-escalation.js";
 import { snapshotLoopProgress, compareLoopProgress, } from "./qa-stagnation.js";
 import { classifyExecChanges } from "./phase-executor.js";
 import { readTokenUsageFiles, aggregateTokenUsage, TOKEN_USAGE_DIR, } from "./token-utils.js";
@@ -137,11 +138,28 @@ export function parseNonGoals(issueBody) {
     }
     return items;
 }
-function classifyGaps(gaps, nonGoals) {
-    return gaps.map((g) => ({
-        description: g,
-        nonGoal: gapTouchesNonGoals(g, nonGoals),
-    }));
+/**
+ * Classify each gap description for the report, enriching with structured
+ * taxonomy fields (#937) when the gap matches a `SEQUANT_QA_GAPS` marker
+ * finding. `findings` are matched to `gaps` by description (trimmed,
+ * case-folded) since `parseQaSummary` already unions marker findings into
+ * `gaps` in document order — every marker finding's description is present.
+ */
+function classifyGaps(gaps, nonGoals, findings) {
+    const byDescription = new Map((findings ?? []).map((f) => [f.description.trim().toLowerCase(), f]));
+    return gaps.map((g) => {
+        const finding = byDescription.get(g.trim().toLowerCase());
+        return {
+            description: g,
+            nonGoal: finding?.nonGoal ?? gapTouchesNonGoals(g, nonGoals),
+            ...(finding && {
+                category: finding.category,
+                evidence: finding.evidence,
+                recommendedAction: finding.recommendedAction,
+                ...(finding.affectedAcs && { affectedAcs: finding.affectedAcs }),
+            }),
+        };
+    });
 }
 function defaultReadTokensUsed(worktreePath) {
     const dir = path.join(worktreePath, TOKEN_USAGE_DIR);
@@ -166,7 +184,13 @@ function buildPhaseConfig(opts, extra) {
         noSmartTests: false,
         dryRun: false,
         mcp: opts.mcp,
+        mcpAllowlist: opts.mcpAllowlist,
         retry: true,
+        // #914: producer 2 (see the doc comment on RunReadyGateOptions.phasePolicies
+        // for why this can't drift from buildExecutionConfig's own assignment).
+        phasePolicies: opts.phasePolicies,
+        // #915: producer 2 (see RunReadyGateOptions.effortEscalation).
+        effortEscalation: opts.effortEscalation,
         ...extra,
     };
 }
@@ -223,14 +247,44 @@ export function formatReadyReport(result) {
     }
     else {
         for (const item of result.remaining) {
-            const tag = item.nonGoal ? " _(Non-Goal — report-only)_" : "";
-            lines.push(`- ${item.description}${tag}`);
+            const tags = [
+                item.category && item.recommendedAction
+                    ? `\`${item.category} · ${item.recommendedAction}\``
+                    : undefined,
+                item.nonGoal ? "_(Non-Goal — report-only)_" : undefined,
+            ].filter(Boolean);
+            const suffix = tags.length > 0 ? ` ${tags.join(" ")}` : "";
+            lines.push(`- ${item.description}${suffix}`);
         }
     }
     lines.push("");
     lines.push("> The human merge gate is intentional: `sequant ready` never merges. Review the gaps above, then merge manually when satisfied.");
+    lines.push("");
+    lines.push(formatReadyGapsMarker(result.remaining));
     return lines.join("\n");
 }
+/**
+ * Render `remaining` as a `SEQUANT_QA_GAPS` marker so the persisted ready
+ * report (#937 AC-4) carries the same machine-readable channel `/qa` itself
+ * emits — only items that came from a structured finding (have a
+ * `category`) round-trip; legacy prose-only gaps are already in the prose
+ * list above and are not re-encoded here.
+ */
+function formatReadyGapsMarker(remaining) {
+    const findings = remaining
+        .filter((g) => g.category !== undefined &&
+        g.evidence !== undefined &&
+        g.recommendedAction !== undefined)
+        .map((g) => ({
+        category: g.category,
+        evidence: g.evidence,
+        description: g.description,
+        recommendedAction: g.recommendedAction,
+        ...(g.affectedAcs && { affectedAcs: g.affectedAcs }),
+        ...(g.nonGoal && { nonGoal: g.nonGoal }),
+    }));
+    return `<!-- SEQUANT_QA_GAPS: ${JSON.stringify({ findings })} -->`;
+}
 /**
  * Drive the policy-bounded `qa → loop → qa` ready gate.
  */
@@ -268,7 +322,10 @@ export async function runReadyGate(opts) {
     const autoFixed = [];
     let remaining = [];
     let tokensUsed = 0;
-    const finish = (reason) => {
+    // #915: escalated (base, escalated) tiers, one entry per QA-pass dispatch
+    // that actually escalated. Populated at the two dispatch sites below.
+    const effortEscalations = [];
+    const finish = async (reason) => {
         const ready = reason === "AC_MET" || reason === "READY_FOR_MERGE";
         const issueStatus = ready
             ? "waiting_for_human_merge"
@@ -285,8 +342,25 @@ export async function runReadyGate(opts) {
             remaining,
             tokensUsed,
             report: "",
+            effortEscalations,
         };
         result.report = formatReadyReport(result);
+        // #937 AC-4: persist the gap report as an issue comment once the gate
+        // reaches a terminal state carrying a QA verdict. `finalVerdict === null`
+        // covers NO_IMPLEMENTATION/UNCOMMITTED_ONLY/NO_VERDICT and the guard
+        // TOKEN_BUDGET check before the first QA pass — none of those have a gap
+        // report worth persisting. Best-effort: a post failure must never fail
+        // the gate — `result.report` (returned either way) is the primary
+        // channel, same rationale as `sequant ready`'s existing state-persistence
+        // try/catch.
+        if (result.finalVerdict !== null && opts.postReport) {
+            try {
+                await opts.postReport(result.report);
+            }
+            catch {
+                // Non-fatal — see comment above.
+            }
+        }
         return result;
     };
     const budgetExceeded = () => typeof tokenBudget === "number" &&
@@ -299,7 +373,12 @@ export async function runReadyGate(opts) {
             return finish("TOKEN_BUDGET");
         }
         iterations++;
-        const qaResult = await runPhaseTracked("qa", buildPhaseConfig(opts, { fullQa: true }), iterations);
+        // #915: iterations > 1 means this QA pass is a retry of a prior
+        // unsatisfied verdict — the ready-gate's retry signal.
+        const qaEscalation = withEscalatedEffort(buildPhaseConfig(opts, { fullQa: true }), "qa", iterations > 1);
+        if (qaEscalation.record)
+            effortEscalations.push(qaEscalation.record);
+        const qaResult = await runPhaseTracked("qa", qaEscalation.config, iterations);
         tokensUsed = readTokensUsed(worktreePath);
         const verdict = qaResult.verdict ?? null;
         // #534 guard: a null verdict is never "ready". #853: report it as
@@ -323,7 +402,7 @@ export async function runReadyGate(opts) {
         }
         finalVerdict = verdict;
         const gaps = qaResult.summary?.gaps ?? [];
-        remaining = classifyGaps(gaps, nonGoals);
+        remaining = classifyGaps(gaps, nonGoals, qaResult.summary?.findings);
         // Policy threshold reached → stop at the human merge gate.
         if (isAtThreshold(policy, verdict)) {
             return finish(verdict === "READY_FOR_MERGE" ? "READY_FOR_MERGE" : "AC_MET");
@@ -338,16 +417,28 @@ export async function runReadyGate(opts) {
         // Run one fix loop. In `ac` mode we only reach here on AC_NOT_MET, so the
         // gaps are AC gaps — feeding them via failedAcs keeps the loop scoped to
         // the AC boundary (quality gaps are never fixed under `ac`). Non-Goal-
-        // touching findings are excluded from what we ask the loop to fix.
+        // touching findings are excluded from what we ask the loop to fix, as are
+        // `SEQUANT_QA_GAPS` findings explicitly marked `document` or
+        // `pause_for_human` (#937 AC-3) — a gap with no `recommendedAction` (the
+        // legacy prose-only path) is still treated as fixable, unchanged from
+        // pre-#937 behavior.
         const fixableGaps = remaining
-            .filter((g) => !g.nonGoal)
+            .filter((g) => !g.nonGoal &&
+            g.recommendedAction !== "document" &&
+            g.recommendedAction !== "pause_for_human")
             .map((g) => g.description);
         const before = snapshotFn(worktreePath);
-        const loopResult = await runPhaseTracked("loop", buildPhaseConfig(opts, {
+        // #915: iterations > 1 means this fix pass follows a QA pass that was
+        // itself a retry — the same ready-gate retry signal as the qa dispatch
+        // above.
+        const loopEscalation = withEscalatedEffort(buildPhaseConfig(opts, {
             lastVerdict: verdict,
             failedAcs: fixableGaps.join("; ") || undefined,
             promptContext: buildLoopContext(policy, verdict, fixableGaps),
-        }), iterations);
+        }), "loop", iterations > 1);
+        if (loopEscalation.record)
+            effortEscalations.push(loopEscalation.record);
+        const loopResult = await runPhaseTracked("loop", loopEscalation.config, iterations);
         tokensUsed = readTokensUsed(worktreePath);
         if (!loopResult.success) {
             return finish("LOOP_FAILED");

package/dist/src/lib/workflow/run-log-schema.d.ts

@@ -48,6 +48,37 @@ export declare const QaVerdictSchema: z.ZodEnum<{
     NEEDS_VERIFICATION: "NEEDS_VERIFICATION";
 }>;
 export type QaVerdict = z.infer<typeof QaVerdictSchema>;
+/**
+ * Source that produced the resolved spec→run phase recommendation (#921).
+ *
+ * Ordered by resolution priority: a durable structured marker in the spec's
+ * GitHub comment beats the same comment's prose section, which beats the
+ * spec agent's ephemeral chat text, which beats label-based guessing.
+ */
+export declare const SpecRecommendationSourceSchema: z.ZodEnum<{
+    marker: "marker";
+    "comment-prose": "comment-prose";
+    chat: "chat";
+    "label-fallback": "label-fallback";
+}>;
+export type SpecRecommendationSource = z.infer<typeof SpecRecommendationSourceSchema>;
+/**
+ * Resolved spec→run phase recommendation, recorded on the issue log so
+ * fallback frequency is auditable (#921 AC-4). Additive/optional — absent on
+ * runs that never reached spec resolution (e.g. spec failed) or predate this
+ * field, keeping the persisted-log schema stable at `version: 1`.
+ */
+export declare const SpecRecommendationSchema: z.ZodObject<{
+    source: z.ZodEnum<{
+        marker: "marker";
+        "comment-prose": "comment-prose";
+        chat: "chat";
+        "label-fallback": "label-fallback";
+    }>;
+    phases: z.ZodArray<z.ZodString>;
+    qualityLoop: z.ZodBoolean;
+}, z.core.$strip>;
+export type SpecRecommendation = z.infer<typeof SpecRecommendationSchema>;
 /**
  * File diff statistics for a single file (AC-3)
  */
@@ -91,12 +122,57 @@ export declare const ErrorContextSchema: z.ZodObject<{
         build_error: "build_error";
         rate_limit: "rate_limit";
         billing: "billing";
+        pr_creation: "pr_creation";
     }>;
     errorType: z.ZodOptional<z.ZodString>;
     errorMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
     isRetryable: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strip>;
 export type ErrorContext = z.infer<typeof ErrorContextSchema>;
+/**
+ * Finite taxonomy for a single gap finding surfaced by `/qa` (#937).
+ *
+ * Replaces the lossy prose-scrape gap channel (`parseListSection` against
+ * `**Issues:**`/`**Gaps**` headers, which misses AC-table NOT_MET rows, §6d
+ * Adversarial Re-Read findings, and §5 Risk Assessment). `evidence` is
+ * required so a finding can't be speculative — see #608's 0%-action-rate
+ * result for open-ended "what might we be missing" findings.
+ */
+export declare const GapCategorySchema: z.ZodEnum<{
+    requirement_gap: "requirement_gap";
+    dependency_gap: "dependency_gap";
+    test_gap: "test_gap";
+    repository_gap: "repository_gap";
+    risk_gap: "risk_gap";
+    execution_gap: "execution_gap";
+}>;
+export type GapCategory = z.infer<typeof GapCategorySchema>;
+export declare const GapActionSchema: z.ZodEnum<{
+    fix_now: "fix_now";
+    document: "document";
+    pause_for_human: "pause_for_human";
+}>;
+export type GapAction = z.infer<typeof GapActionSchema>;
+export declare const GapFindingSchema: z.ZodObject<{
+    category: z.ZodEnum<{
+        requirement_gap: "requirement_gap";
+        dependency_gap: "dependency_gap";
+        test_gap: "test_gap";
+        repository_gap: "repository_gap";
+        risk_gap: "risk_gap";
+        execution_gap: "execution_gap";
+    }>;
+    evidence: z.ZodString;
+    description: z.ZodString;
+    recommendedAction: z.ZodEnum<{
+        fix_now: "fix_now";
+        document: "document";
+        pause_for_human: "pause_for_human";
+    }>;
+    affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    nonGoal: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type GapFinding = z.infer<typeof GapFindingSchema>;
 /**
  * Condensed QA verdict summary for structured log output (#434).
  *
@@ -109,6 +185,25 @@ export declare const QaSummarySchema: z.ZodObject<{
     acTotal: z.ZodNumber;
     gaps: z.ZodArray<z.ZodString>;
     suggestions: z.ZodArray<z.ZodString>;
+    findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        category: z.ZodEnum<{
+            requirement_gap: "requirement_gap";
+            dependency_gap: "dependency_gap";
+            test_gap: "test_gap";
+            repository_gap: "repository_gap";
+            risk_gap: "risk_gap";
+            execution_gap: "execution_gap";
+        }>;
+        evidence: z.ZodString;
+        description: z.ZodString;
+        recommendedAction: z.ZodEnum<{
+            fix_now: "fix_now";
+            document: "document";
+            pause_for_human: "pause_for_human";
+        }>;
+        affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        nonGoal: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export type QaSummary = z.infer<typeof QaSummarySchema>;
 /**
@@ -143,6 +238,25 @@ export declare const PhaseLogSchema: z.ZodObject<{
         acTotal: z.ZodNumber;
         gaps: z.ZodArray<z.ZodString>;
         suggestions: z.ZodArray<z.ZodString>;
+        findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            category: z.ZodEnum<{
+                requirement_gap: "requirement_gap";
+                dependency_gap: "dependency_gap";
+                test_gap: "test_gap";
+                repository_gap: "repository_gap";
+                risk_gap: "risk_gap";
+                execution_gap: "execution_gap";
+            }>;
+            evidence: z.ZodString;
+            description: z.ZodString;
+            recommendedAction: z.ZodEnum<{
+                fix_now: "fix_now";
+                document: "document";
+                pause_for_human: "pause_for_human";
+            }>;
+            affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            nonGoal: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>;
     commitHash: z.ZodOptional<z.ZodString>;
     fileDiffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -174,6 +288,7 @@ export declare const PhaseLogSchema: z.ZodObject<{
             build_error: "build_error";
             rate_limit: "rate_limit";
             billing: "billing";
+            pr_creation: "pr_creation";
         }>;
         errorType: z.ZodOptional<z.ZodString>;
         errorMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -222,6 +337,25 @@ export declare const IssueLogSchema: z.ZodObject<{
             acTotal: z.ZodNumber;
             gaps: z.ZodArray<z.ZodString>;
             suggestions: z.ZodArray<z.ZodString>;
+            findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                category: z.ZodEnum<{
+                    requirement_gap: "requirement_gap";
+                    dependency_gap: "dependency_gap";
+                    test_gap: "test_gap";
+                    repository_gap: "repository_gap";
+                    risk_gap: "risk_gap";
+                    execution_gap: "execution_gap";
+                }>;
+                evidence: z.ZodString;
+                description: z.ZodString;
+                recommendedAction: z.ZodEnum<{
+                    fix_now: "fix_now";
+                    document: "document";
+                    pause_for_human: "pause_for_human";
+                }>;
+                affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                nonGoal: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strip>>>;
         }, z.core.$strip>>;
         commitHash: z.ZodOptional<z.ZodString>;
         fileDiffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -253,6 +387,7 @@ export declare const IssueLogSchema: z.ZodObject<{
                 build_error: "build_error";
                 rate_limit: "rate_limit";
                 billing: "billing";
+                pr_creation: "pr_creation";
             }>;
             errorType: z.ZodOptional<z.ZodString>;
             errorMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -264,6 +399,16 @@ export declare const IssueLogSchema: z.ZodObject<{
     abortReason: z.ZodOptional<z.ZodString>;
     prNumber: z.ZodOptional<z.ZodNumber>;
     prUrl: z.ZodOptional<z.ZodString>;
+    specRecommendation: z.ZodOptional<z.ZodObject<{
+        source: z.ZodEnum<{
+            marker: "marker";
+            "comment-prose": "comment-prose";
+            chat: "chat";
+            "label-fallback": "label-fallback";
+        }>;
+        phases: z.ZodArray<z.ZodString>;
+        qualityLoop: z.ZodBoolean;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export type IssueLog = z.infer<typeof IssueLogSchema>;
 /**
@@ -346,6 +491,25 @@ export declare const RunLogSchema: z.ZodObject<{
                 acTotal: z.ZodNumber;
                 gaps: z.ZodArray<z.ZodString>;
                 suggestions: z.ZodArray<z.ZodString>;
+                findings: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    category: z.ZodEnum<{
+                        requirement_gap: "requirement_gap";
+                        dependency_gap: "dependency_gap";
+                        test_gap: "test_gap";
+                        repository_gap: "repository_gap";
+                        risk_gap: "risk_gap";
+                        execution_gap: "execution_gap";
+                    }>;
+                    evidence: z.ZodString;
+                    description: z.ZodString;
+                    recommendedAction: z.ZodEnum<{
+                        fix_now: "fix_now";
+                        document: "document";
+                        pause_for_human: "pause_for_human";
+                    }>;
+                    affectedAcs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    nonGoal: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>>;
             }, z.core.$strip>>;
             commitHash: z.ZodOptional<z.ZodString>;
             fileDiffStats: z.ZodOptional<z.ZodArray<z.ZodObject<{
@@ -377,6 +541,7 @@ export declare const RunLogSchema: z.ZodObject<{
                     build_error: "build_error";
                     rate_limit: "rate_limit";
                     billing: "billing";
+                    pr_creation: "pr_creation";
                 }>;
                 errorType: z.ZodOptional<z.ZodString>;
                 errorMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
@@ -388,6 +553,16 @@ export declare const RunLogSchema: z.ZodObject<{
         abortReason: z.ZodOptional<z.ZodString>;
         prNumber: z.ZodOptional<z.ZodNumber>;
         prUrl: z.ZodOptional<z.ZodString>;
+        specRecommendation: z.ZodOptional<z.ZodObject<{
+            source: z.ZodEnum<{
+                marker: "marker";
+                "comment-prose": "comment-prose";
+                chat: "chat";
+                "label-fallback": "label-fallback";
+            }>;
+            phases: z.ZodArray<z.ZodString>;
+            qualityLoop: z.ZodBoolean;
+        }, z.core.$strip>>;
     }, z.core.$strip>>;
     summary: z.ZodObject<{
         totalIssues: z.ZodNumber;