@mcoda/mswarm 0.1.57 → 0.1.61

package/dist/vendor/codali/cognitive/SmartPipeline.js

@@ -0,0 +1,4804 @@
+import { createHash } from "node:crypto";
+import { DEFAULT_DEEP_INVESTIGATION_BUDGET, DEFAULT_DEEP_INVESTIGATION_EVIDENCE, DEFAULT_DEEP_INVESTIGATION_TOOL_QUOTA, } from "../config/Config.js";
+import { evaluateEvidenceGate } from "./EvidenceGate.js";
+import { ARCHITECT_WARNING_CONTAINS_FENCE, ARCHITECT_WARNING_CONTAINS_THINK, ARCHITECT_WARNING_MISSING_REQUIRED_SECTIONS, ARCHITECT_WARNING_MULTIPLE_SECTION_BLOCKS, ARCHITECT_WARNING_NON_DSL, ARCHITECT_WARNING_REPAIRED, ARCHITECT_WARNING_USED_PLAINTEXT_FALLBACK, ARCHITECT_WARNING_USED_JSON_FALLBACK, PlanHintValidationError, } from "./ArchitectPlanner.js";
+import { PatchApplyError, } from "./BuilderRunner.js";
+import { createDeepInvestigationBudgetError, createDeepInvestigationEvidenceError, createDeepInvestigationQuotaError, } from "../runtime/DeepInvestigationErrors.js";
+import { buildLaneId } from "./ContextManager.js";
+import { sanitizeContextBundleForOutput, serializeContext } from "./ContextSerializer.js";
+class RuntimePhaseTransitionError extends Error {
+    constructor(metadata) {
+        super(`Invalid runtime phase transition ${metadata.from_phase} -> ${metadata.to_phase} (${metadata.requested_phase})`);
+        this.code = "CODALI_INVALID_PHASE_TRANSITION";
+        this.name = "RuntimePhaseTransitionError";
+        this.metadata = metadata;
+    }
+}
+const PIPELINE_PHASE_TO_RUNTIME_PHASE = {
+    librarian: "plan",
+    architect: "retrieve",
+    architect_review: "verify",
+    builder: "act",
+    critic: "verify",
+    answer: "answer",
+};
+const RUNTIME_PHASE_TRANSITIONS = {
+    start: ["plan"],
+    plan: ["plan", "retrieve"],
+    retrieve: ["plan", "retrieve", "act"],
+    act: ["plan", "retrieve", "act", "verify"],
+    verify: ["plan", "retrieve", "act", "verify", "answer"],
+    answer: [],
+};
+const createRuntimePhaseTracker = () => ({
+    current: "start",
+    trace: [],
+});
+const asObject = (value) => value && typeof value === "object" ? value : undefined;
+const asStringArray = (value) => {
+    if (!Array.isArray(value))
+        return [];
+    return Array.from(new Set(value
+        .map((entry) => (typeof entry === "string" ? entry.trim() : ""))
+        .filter(Boolean)));
+};
+const extractPhaseWarnings = (phase, result) => {
+    const record = asObject(result);
+    if (!record)
+        return [];
+    const warnings = asStringArray(record.warnings);
+    if (warnings.length > 0)
+        return warnings;
+    if (phase === "critic") {
+        return asStringArray(record.reasons);
+    }
+    return [];
+};
+const extractPhaseUsage = (result) => {
+    const record = asObject(result);
+    if (!record)
+        return undefined;
+    const usageRecord = asObject(record.usage);
+    if (!usageRecord)
+        return undefined;
+    const inputTokens = typeof usageRecord.inputTokens === "number" ? usageRecord.inputTokens : undefined;
+    const outputTokens = typeof usageRecord.outputTokens === "number" ? usageRecord.outputTokens : undefined;
+    const totalTokens = typeof usageRecord.totalTokens === "number" ? usageRecord.totalTokens : undefined;
+    if (inputTokens === undefined
+        && outputTokens === undefined
+        && totalTokens === undefined) {
+        return undefined;
+    }
+    return {
+        input_tokens: inputTokens,
+        output_tokens: outputTokens,
+        total_tokens: totalTokens,
+    };
+};
+const ARCHITECT_NON_DSL_WARNING = ARCHITECT_WARNING_NON_DSL;
+const emptyToolUsageCounts = () => ({
+    ok: 0,
+    failed: 0,
+    skipped: 0,
+    total: 0,
+});
+const buildToolUsageSummary = (toolRuns) => {
+    const totals = emptyToolUsageCounts();
+    const byTool = {};
+    for (const run of toolRuns ?? []) {
+        const tool = run.tool || "unknown";
+        const bucket = byTool[tool] ?? emptyToolUsageCounts();
+        if (run.skipped) {
+            bucket.skipped += 1;
+            totals.skipped += 1;
+        }
+        else if (run.ok) {
+            bucket.ok += 1;
+            totals.ok += 1;
+        }
+        else {
+            bucket.failed += 1;
+            totals.failed += 1;
+        }
+        bucket.total += 1;
+        totals.total += 1;
+        byTool[tool] = bucket;
+    }
+    return { totals, byTool };
+};
+const formatToolUsageSummary = (summary) => {
+    const entries = Object.entries(summary.byTool);
+    if (entries.length === 0)
+        return "none";
+    return entries
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([tool, counts]) => `${tool}=${counts.total}`)
+        .join(", ");
+};
+const TOOL_QUOTA_CATEGORIES = [
+    "search",
+    "openOrSnippet",
+    "symbolsOrAst",
+    "impact",
+    "tree",
+    "dagExport",
+];
+const TOOL_QUOTA_CATEGORY_MAP = {
+    "docdex.search": "search",
+    "docdex.snippet": "openOrSnippet",
+    "docdex.open": "openOrSnippet",
+    "docdex.symbols": "symbolsOrAst",
+    "docdex.ast": "symbolsOrAst",
+    "docdex.impact": "impact",
+    "docdex.impact_diagnostics": "impact",
+    "docdex.tree": "tree",
+    "docdex.dag_export": "dagExport",
+};
+const QUOTA_MISSING_WARNING_PREFIXES = {
+    search: ["research_docdex_search_failed"],
+    openOrSnippet: ["research_docdex_open_failed", "research_docdex_snippet_failed"],
+    symbolsOrAst: ["research_docdex_symbols_failed", "research_docdex_ast_failed"],
+    impact: ["research_docdex_impact_failed", "research_docdex_impact_diagnostics_failed"],
+    tree: ["research_docdex_tree_failed"],
+    dagExport: ["research_docdex_dag_export_failed"],
+};
+const warningMatchesPrefix = (warning, prefix) => warning === prefix || warning.startsWith(`${prefix}:`);
+const isRecoverableQuotaFailure = (quotaAssessment, warnings) => {
+    if (quotaAssessment.ok)
+        return false;
+    const warningList = uniqueStrings(warnings);
+    if (warningList.length === 0)
+        return false;
+    return quotaAssessment.missing.every((category) => {
+        const prefixes = QUOTA_MISSING_WARNING_PREFIXES[category] ?? [];
+        if (prefixes.length === 0)
+            return false;
+        return warningList.some((warning) => prefixes.some((prefix) => warningMatchesPrefix(warning, prefix)));
+    });
+};
+const resolveToolQuota = (override) => ({
+    ...DEFAULT_DEEP_INVESTIGATION_TOOL_QUOTA,
+    ...(override ?? {}),
+});
+const resolveInvestigationBudget = (override) => ({
+    ...DEFAULT_DEEP_INVESTIGATION_BUDGET,
+    ...(override ?? {}),
+});
+const resolveEvidenceGate = (override) => ({
+    ...DEFAULT_DEEP_INVESTIGATION_EVIDENCE,
+    ...(override ?? {}),
+});
+const buildToolQuotaAssessment = (toolRuns, quota) => {
+    const observed = {
+        search: 0,
+        openOrSnippet: 0,
+        symbolsOrAst: 0,
+        impact: 0,
+        tree: 0,
+        dagExport: 0,
+    };
+    for (const run of toolRuns ?? []) {
+        if (!run.ok)
+            continue;
+        const category = TOOL_QUOTA_CATEGORY_MAP[run.tool];
+        if (!category)
+            continue;
+        observed[category] += 1;
+    }
+    const missing = [];
+    for (const category of TOOL_QUOTA_CATEGORIES) {
+        if (quota[category] > observed[category]) {
+            missing.push(category);
+        }
+    }
+    return {
+        ok: missing.length === 0,
+        missing,
+        required: { ...quota },
+        observed,
+    };
+};
+const TOOL_USAGE_CATEGORY_MAP = {
+    "docdex.search": "search",
+    "docdex.snippet": "open_or_snippet",
+    "docdex.open": "open_or_snippet",
+    "docdex.symbols": "symbols_or_ast",
+    "docdex.ast": "symbols_or_ast",
+    "docdex.impact": "impact",
+    "docdex.impact_diagnostics": "impact",
+    "docdex.tree": "tree",
+    "docdex.dag_export": "dag_export",
+};
+const buildResearchToolUsage = (toolRuns) => {
+    const counts = {
+        search: 0,
+        open_or_snippet: 0,
+        symbols_or_ast: 0,
+        impact: 0,
+        tree: 0,
+        dag_export: 0,
+    };
+    for (const run of toolRuns ?? []) {
+        if (!run.ok)
+            continue;
+        const category = TOOL_USAGE_CATEGORY_MAP[run.tool];
+        if (!category)
+            continue;
+        counts[category] += 1;
+    }
+    return counts;
+};
+const buildResearchEvidence = (outputs, warnings) => {
+    const searchHitKeys = new Set();
+    for (const result of outputs?.searchResults ?? []) {
+        for (const hit of result.hits ?? []) {
+            const key = `${hit.doc_id ?? ""}:${hit.path ?? ""}`;
+            if (key !== ":")
+                searchHitKeys.add(key);
+        }
+    }
+    const searchHits = searchHitKeys.size;
+    const snippetKeys = new Set();
+    for (const snippet of outputs?.snippets ?? []) {
+        if (snippet.doc_id) {
+            snippetKeys.add(`doc:${snippet.doc_id}`);
+            continue;
+        }
+        if (snippet.path) {
+            snippetKeys.add(`path:${snippet.path}`);
+            continue;
+        }
+        if (snippet.content) {
+            snippetKeys.add(`content:${createHash("sha1").update(snippet.content).digest("hex")}`);
+        }
+    }
+    const snippetCount = snippetKeys.size;
+    const symbolFiles = new Set((outputs?.symbols ?? []).map((entry) => entry.path).filter(Boolean)).size;
+    const astFiles = new Set((outputs?.ast ?? []).map((entry) => entry.path).filter(Boolean)).size;
+    const impactFiles = new Set((outputs?.impact ?? []).map((entry) => entry.file).filter(Boolean)).size;
+    const impactEdgeKeys = new Set();
+    for (const entry of outputs?.impact ?? []) {
+        const file = entry.file ?? "";
+        for (const inbound of entry.inbound ?? []) {
+            impactEdgeKeys.add(`${file}|in|${inbound}`);
+        }
+        for (const outbound of entry.outbound ?? []) {
+            impactEdgeKeys.add(`${file}|out|${outbound}`);
+        }
+    }
+    const impactEdges = impactEdgeKeys.size;
+    const repoMap = Boolean(outputs?.repoMap || outputs?.repoMapRaw);
+    const dagSummary = Boolean(outputs?.dagSummary);
+    const warningList = warnings.length ? Array.from(new Set(warnings)) : [];
+    return {
+        search_hits: searchHits,
+        snippet_count: snippetCount,
+        symbol_files: symbolFiles,
+        ast_files: astFiles,
+        impact_files: impactFiles,
+        impact_edges: impactEdges,
+        repo_map: repoMap,
+        dag_summary: dagSummary,
+        warnings: warningList.length ? warningList : undefined,
+    };
+};
+const mergeResearchEvidence = (evidence, evidenceGate) => {
+    if (!evidence)
+        return evidence;
+    const warnings = uniqueStrings([
+        ...(evidence.warnings ?? []),
+        ...(evidenceGate?.warnings ?? []),
+    ]);
+    const gaps = uniqueStrings([
+        ...(evidence.gaps ?? []),
+        ...(evidenceGate?.gaps ?? []),
+    ]);
+    return {
+        ...evidence,
+        warnings: warnings.length ? warnings : undefined,
+        gaps: gaps.length ? gaps : undefined,
+    };
+};
+const isWarningsOnlyEvidenceGateFailure = (evidenceGate) => {
+    if (!evidenceGate || evidenceGate.status === "pass")
+        return false;
+    const missing = evidenceGate.missing ?? [];
+    if (missing.length === 0)
+        return false;
+    if (missing.some((signal) => signal !== "warnings"))
+        return false;
+    return (evidenceGate.gaps?.length ?? 0) === 0;
+};
+const buildResearchSummary = (phase) => {
+    if (!phase)
+        return undefined;
+    return {
+        status: phase.status,
+        started_at_ms: phase.startedAt,
+        ended_at_ms: phase.endedAt,
+        duration_ms: phase.durationMs,
+        key_findings: buildResearchKeyFindings(phase),
+        tool_usage: phase.toolUsage,
+        evidence: mergeResearchEvidence(phase.evidence, phase.evidenceGate),
+        warnings: phase.warnings?.length ? uniqueStrings(phase.warnings) : undefined,
+        notes: phase.notes?.length ? uniqueStrings(phase.notes) : undefined,
+    };
+};
+const ARCHITECT_STRICT_DSL_HINT = [
+    "STRICT MODE: Your previous response was low-quality or hard to normalize.",
+    "Output a concise plain-text plan using these sections: WHAT IS REQUIRED, CURRENT CONTEXT, FOLDER STRUCTURE, FILES TO TOUCH, IMPLEMENTATION PLAN, RISK, VERIFY.",
+    "Avoid JSON blobs, markdown fences, and long prose paragraphs.",
+    "If context is insufficient, output an AGENT_REQUEST v1 block instead of freeform text.",
+    "Preferred section skeleton:",
+    "WHAT IS REQUIRED:",
+    "- <request requirement>",
+    "CURRENT CONTEXT:",
+    "- <context fact>",
+    "FOLDER STRUCTURE:",
+    "- <relevant folder/file>",
+    "FILES TO TOUCH:",
+    "- <path>",
+    "IMPLEMENTATION PLAN:",
+    "- <step>",
+    "RISK: <low|medium|high> <reason>",
+    "VERIFY:",
+    "- <verification step>",
+].join("\n");
+const ARCHITECT_VERIFY_QUALITY_HINT = [
+    "VERIFY QUALITY: The VERIFY section cannot be empty.",
+    "Include at least one concrete verification step (unit/integration/component/API test, or manual curl/browser check).",
+    "Examples:",
+    "- Run unit tests: `pnpm test --filter <target>`",
+    "- Run integration/API check: `curl -sf http://localhost:3000/healthz`",
+    "- Manual browser check: open http://localhost:3000 and verify expected behavior",
+].join("\n");
+const ARCHITECT_RECOVERY_HINT = [
+    "RECOVERY MODE: Prior architect passes were low-quality or unstructured.",
+    "Respond with request-specific, implementation-ready plain-text sections only.",
+    "Every IMPLEMENTATION PLAN/FILES TO TOUCH/VERIFY line must include concrete target nouns tied to the current request.",
+    "If context is still insufficient, emit AGENT_REQUEST v1 with concrete retrieval needs.",
+].join("\n");
+const ARCHITECT_ALTERNATE_RETRY_HINT = [
+    "ALTERNATE RETRY MODE: Prior architect outputs repeated without quality improvement.",
+    "Keep output in plain-text required sections and avoid repeating prior text.",
+    "Use request-specific nouns and concrete target file paths in every IMPLEMENTATION PLAN/FILES TO TOUCH/VERIFY line.",
+].join("\n");
+const isArchitectNonDsl = (warnings) => Array.isArray(warnings)
+    && warnings.some((warning) => warning === ARCHITECT_NON_DSL_WARNING)
+    && !warnings.some((warning) => warning === ARCHITECT_WARNING_USED_JSON_FALLBACK
+        || warning === ARCHITECT_WARNING_USED_PLAINTEXT_FALLBACK);
+const isNonBlockingArchitectWarning = (warning) => {
+    if (warning === ARCHITECT_WARNING_CONTAINS_THINK)
+        return true;
+    if (warning === ARCHITECT_WARNING_CONTAINS_FENCE)
+        return true;
+    if (warning === ARCHITECT_WARNING_MULTIPLE_SECTION_BLOCKS)
+        return true;
+    if (warning === ARCHITECT_WARNING_REPAIRED)
+        return true;
+    if (warning === ARCHITECT_WARNING_USED_JSON_FALLBACK)
+        return true;
+    if (warning === ARCHITECT_WARNING_USED_PLAINTEXT_FALLBACK)
+        return true;
+    if (warning === "architect_output_prose_request_suppressed")
+        return true;
+    if (warning === "architect_output_repair_reason:wrapper_noise")
+        return true;
+    if (warning === "architect_output_repair_reason:duplicate_sections")
+        return true;
+    if (warning.startsWith("plan_missing_target_change_details:"))
+        return true;
+    return false;
+};
+const isBlockingArchitectWarning = (warning) => {
+    if (isNonBlockingArchitectWarning(warning))
+        return false;
+    if (warning === ARCHITECT_WARNING_NON_DSL)
+        return true;
+    if (warning === ARCHITECT_WARNING_MISSING_REQUIRED_SECTIONS)
+        return true;
+    if (warning === ARCHITECT_WARNING_MULTIPLE_SECTION_BLOCKS)
+        return true;
+    if (warning.startsWith("architect_output_repair_reason:"))
+        return true;
+    if (warning.startsWith("plan_missing_"))
+        return true;
+    return true;
+};
+const NON_FATAL_PRE_BUILDER_WARNING_PATTERNS = [
+    /^architect_degraded_/i,
+    /^architect_retry_skipped_no_new_context$/i,
+    /^architect_invalid_targets$/i,
+    /^architect_plan_quality_warning$/i,
+    /^plan_targets_outside_context:/i,
+    /^plan_target_scope_empty_after_filter$/i,
+];
+const isFatalArchitectWarningBeforeBuilder = (warning) => {
+    if (NON_FATAL_PRE_BUILDER_WARNING_PATTERNS.some((pattern) => pattern.test(warning)))
+        return false;
+    return isBlockingArchitectWarning(warning);
+};
+const REPAIRED_FALLBACK_WARNING_PATTERNS = [
+    /^architect_output_used_json_fallback$/i,
+    /^architect_output_used_plaintext_fallback$/i,
+    /^architect_output_repaired$/i,
+    /^architect_output_repair_reason:(json_fallback|plaintext_fallback|dsl_missing_fields|classifier)$/i,
+];
+const NON_FATAL_REPAIRED_FALLBACK_WARNING_PATTERNS = [
+    /^architect_output_not_object$/i,
+    /^architect_output_adapted_to_request$/i,
+    /^architect_output_prose_request_suppressed$/i,
+    /^plan_missing_/i,
+    /^architect_output_repair_reason:/i,
+    new RegExp(`^${ARCHITECT_WARNING_NON_DSL}$`, "i"),
+    new RegExp(`^${ARCHITECT_WARNING_MISSING_REQUIRED_SECTIONS}$`, "i"),
+];
+const collectPreBuilderBlockingWarnings = (warnings) => {
+    const repairedFallback = warnings.some((warning) => REPAIRED_FALLBACK_WARNING_PATTERNS.some((pattern) => pattern.test(warning)));
+    return warnings.filter((warning) => {
+        if (warning.startsWith("plan_missing_target_change_details:"))
+            return false;
+        if (!isFatalArchitectWarningBeforeBuilder(warning))
+            return false;
+        if (!repairedFallback)
+            return true;
+        if (NON_FATAL_REPAIRED_FALLBACK_WARNING_PATTERNS.some((pattern) => pattern.test(warning)))
+            return false;
+        return true;
+    });
+};
+const ARCHITECT_REVIEW_RETRY_BLOCKING_WARNINGS = new Set([
+    "architect_review_missing_status",
+    "architect_review_missing_reasons",
+    "architect_review_retry_missing_feedback",
+]);
+const collectArchitectReviewRetryBlockingWarnings = (warnings) => uniqueStrings((warnings ?? []).filter((warning) => ARCHITECT_REVIEW_RETRY_BLOCKING_WARNINGS.has(warning)));
+const hashArchitectResult = (result) => {
+    const raw = (result.raw ?? "").trim();
+    const content = raw.length > 0
+        ? `raw:${raw}`
+        : `plan:${JSON.stringify({
+            steps: result.plan.steps,
+            target_files: result.plan.target_files,
+            risk_assessment: result.plan.risk_assessment,
+            verification: result.plan.verification,
+        })}`;
+    return createHash("sha256").update(content).digest("hex");
+};
+const hashAgentRequestShape = (request) => {
+    const content = JSON.stringify({
+        role: request.role,
+        needs: request.needs ?? [],
+        context: request.context ?? {},
+    });
+    return createHash("sha256").update(content).digest("hex");
+};
+const narrowContextForStrictArchitectRetry = (context) => {
+    const focusFromSelection = context.selection?.focus ?? [];
+    const focusFromFiles = (context.files ?? [])
+        .filter((entry) => entry.role === "focus")
+        .map((entry) => entry.path);
+    const focusPaths = new Set([...focusFromSelection, ...focusFromFiles]
+        .map((value) => value.trim())
+        .filter((value) => value.length > 0));
+    const keepPath = (value) => {
+        if (!value)
+            return false;
+        return focusPaths.has(value);
+    };
+    const narrowedFiles = (context.files ?? []).filter((entry) => {
+        if (entry.role !== "focus")
+            return false;
+        if (focusPaths.size === 0)
+            return true;
+        return focusPaths.has(entry.path);
+    });
+    const narrowedSnippets = (context.snippets ?? []).filter((entry) => focusPaths.size === 0 ? Boolean(entry.path) : keepPath(entry.path));
+    const narrowedSymbols = (context.symbols ?? []).filter((entry) => focusPaths.size === 0 ? true : keepPath(entry.path));
+    const narrowedAst = (context.ast ?? []).filter((entry) => focusPaths.size === 0 ? true : keepPath(entry.path));
+    const narrowedImpact = (context.impact ?? []).filter((entry) => focusPaths.size === 0 ? true : keepPath(entry.file));
+    const narrowedImpactDiagnostics = (context.impact_diagnostics ?? []).filter((entry) => focusPaths.size === 0 ? true : keepPath(entry.file));
+    const narrowedSearch = (context.search_results ?? [])
+        .map((result) => ({
+        ...result,
+        hits: (result.hits ?? [])
+            .filter((hit) => (focusPaths.size === 0 ? true : keepPath(hit.path)))
+            .slice(0, 3),
+    }))
+        .filter((result) => result.hits.length > 0)
+        .slice(0, 3);
+    const focusList = focusPaths.size > 0 ? Array.from(focusPaths) : (context.selection?.focus ?? []);
+    return {
+        ...context,
+        queries: (context.queries ?? []).slice(0, 3),
+        search_results: narrowedSearch,
+        snippets: narrowedSnippets.slice(0, 4),
+        symbols: narrowedSymbols.slice(0, 4),
+        ast: narrowedAst.slice(0, 2),
+        impact: narrowedImpact.slice(0, 2),
+        impact_diagnostics: narrowedImpactDiagnostics.slice(0, 2),
+        repo_map: undefined,
+        repo_map_raw: undefined,
+        files: narrowedFiles,
+        selection: {
+            focus: focusList,
+            periphery: [],
+            all: focusList,
+            low_confidence: context.selection?.low_confidence ?? false,
+        },
+        memory: (context.memory ?? []).slice(0, 3),
+        profile: (context.profile ?? []).slice(0, 3),
+        serialized: undefined,
+        warnings: [...context.warnings, "architect_context_narrowed_strict_retry"],
+    };
+};
+const ENDPOINT_SERVER_INTENT_PATTERN = /\b(endpoint|route|router|handler|api|healthz?|status|server|backend)\b/i;
+const BACKEND_TARGET_PATTERN = /(^|\/)(server|backend|api|routes?|router|handlers?|controllers?|services?)($|\/|[._-])/i;
+const FRONTEND_TARGET_PATTERN = /(^|\/)(public|web|ui|views?|pages?|components?|templates?)($|\/|[._-])/i;
+const UI_REQUEST_INTENT_PATTERN = /\b(ui|page|screen|header|footer|form|button|image|style|css|html|landing|homepage|welcome)\b/i;
+const SEMANTIC_STRICT_INTENT_PATTERN = /\b(calculate|compute|estimate|estimation|count|total|store|persist|log|validate|security|secure|auth|engine|workflow|state)\b/i;
+const REQUEST_KEYWORD_STOPWORDS = new Set([
+    "a",
+    "an",
+    "the",
+    "to",
+    "and",
+    "or",
+    "with",
+    "for",
+    "from",
+    "into",
+    "onto",
+    "create",
+    "add",
+    "change",
+    "update",
+    "fix",
+    "implement",
+    "develop",
+    "build",
+    "make",
+    "do",
+    "thing",
+    "review",
+    "context",
+    "needs",
+    "more",
+    "request",
+    "task",
+    "tasks",
+    "system",
+    "engine",
+]);
+const normalizePath = (value) => value.replace(/\\/g, "/").replace(/^\.?\//, "").trim();
+const uniqueStrings = (values) => Array.from(new Set(values));
+const normalizeContextSignatureList = (values, limit = 24) => {
+    if (!values)
+        return [];
+    const cleaned = values
+        .map((value) => (value ?? "").trim())
+        .filter((value) => value.length > 0);
+    if (cleaned.length === 0)
+        return [];
+    return uniqueStrings(cleaned).sort().slice(0, limit);
+};
+const buildContextSignature = (context) => {
+    const signature = {
+        queries: normalizeContextSignatureList(context.queries, 24),
+        selection: context.selection
+            ? {
+                focus: normalizeContextSignatureList(context.selection.focus, 24),
+                periphery: normalizeContextSignatureList(context.selection.periphery, 24),
+                all: normalizeContextSignatureList(context.selection.all, 24),
+                low_confidence: context.selection.low_confidence ?? false,
+                reason_summary: (context.selection.reason_summary ?? [])
+                    .map((entry) => `${entry.code}:${entry.count}`)
+                    .sort()
+                    .slice(0, 24),
+            }
+            : null,
+        retrieval: context.retrieval_report
+            ? {
+                disposition: context.retrieval_disposition ?? context.retrieval_report.disposition,
+                confidence: context.retrieval_report.confidence,
+                preflight: context.retrieval_report.preflight
+                    .map((entry) => `${entry.check}:${entry.status}`)
+                    .sort(),
+                unresolved_gaps: normalizeContextSignatureList(context.retrieval_report.unresolved_gaps, 24),
+            }
+            : null,
+        search_results: (context.search_results ?? []).map((result) => ({
+            query: result.query,
+            hits: normalizeContextSignatureList((result.hits ?? []).map((hit) => hit.path ?? hit.doc_id ?? ""), 12),
+        })),
+        snippets: normalizeContextSignatureList((context.snippets ?? []).map((entry) => entry.path ?? entry.doc_id ?? ""), 24),
+        symbols: normalizeContextSignatureList((context.symbols ?? []).map((entry) => entry.path), 24),
+        ast: normalizeContextSignatureList((context.ast ?? []).map((entry) => entry.path), 24),
+        impact: (context.impact ?? []).map((entry) => ({
+            file: entry.file,
+            inbound: normalizeContextSignatureList(entry.inbound, 12),
+            outbound: normalizeContextSignatureList(entry.outbound, 12),
+        })),
+        files: normalizeContextSignatureList((context.files ?? []).map((entry) => entry.path), 24),
+        research: context.research
+            ? {
+                status: context.research.status,
+                key_findings: normalizeContextSignatureList(context.research.key_findings, 12),
+                tool_usage: context.research.tool_usage ?? null,
+                evidence: context.research.evidence ?? null,
+                warnings: normalizeContextSignatureList(context.research.warnings, 12),
+                notes: normalizeContextSignatureList(context.research.notes, 12),
+            }
+            : null,
+        repo_map: Boolean(context.repo_map ?? context.repo_map_raw),
+        dag_summary: Boolean(context.dag_summary),
+        request_digest: context.request_digest
+            ? {
+                summary: context.request_digest.summary,
+                refined_query: context.request_digest.refined_query,
+                confidence: context.request_digest.confidence,
+                candidate_files: normalizeContextSignatureList(context.request_digest.candidate_files, 24),
+            }
+            : null,
+    };
+    return createHash("sha256").update(JSON.stringify(signature)).digest("hex");
+};
+const truncateText = (value, maxChars) => {
+    if (maxChars <= 0 || value.length <= maxChars)
+        return value;
+    if (maxChars <= 3)
+        return value.slice(0, maxChars);
+    return `${value.slice(0, maxChars - 3)}...`;
+};
+const buildPathHints = (paths, maxHints = 3) => {
+    if (maxHints <= 0)
+        return [];
+    const hints = [];
+    for (const raw of paths) {
+        const normalized = normalizePath(raw);
+        if (!normalized)
+            continue;
+        hints.push(normalized);
+        const base = normalized.split("/").pop();
+        if (base && base !== normalized) {
+            hints.push(base);
+            const stem = base.replace(/\.[^.]+$/, "");
+            if (stem && stem !== base)
+                hints.push(stem);
+        }
+        if (hints.length >= maxHints * 3)
+            break;
+    }
+    return uniqueStrings(hints).slice(0, maxHints);
+};
+const collectResearchPaths = (outputs) => {
+    if (!outputs) {
+        return { search: [], snippets: [], symbols: [], impact: [] };
+    }
+    const searchPaths = uniqueStrings((outputs.searchResults ?? [])
+        .flatMap((result) => result.hits ?? [])
+        .map((hit) => hit.path ?? "")
+        .filter((value) => value.length > 0));
+    const snippetPaths = uniqueStrings((outputs.snippets ?? [])
+        .map((snippet) => snippet.path ?? "")
+        .filter((value) => value.length > 0));
+    const symbolPaths = uniqueStrings([
+        ...(outputs.symbols ?? []).map((entry) => entry.path),
+        ...(outputs.ast ?? []).map((entry) => entry.path),
+    ].filter((value) => value.length > 0));
+    const impactPaths = uniqueStrings((outputs.impact ?? []).map((entry) => entry.file).filter((value) => value.length > 0));
+    return { search: searchPaths, snippets: snippetPaths, symbols: symbolPaths, impact: impactPaths };
+};
+const buildResearchKeyFindings = (phase) => {
+    const outputs = phase?.outputs;
+    if (!outputs)
+        return undefined;
+    const findings = [];
+    const paths = collectResearchPaths(outputs);
+    const topSearch = paths.search.slice(0, 5);
+    const topSnippets = paths.snippets.slice(0, 4);
+    const topSymbols = paths.symbols.slice(0, 4);
+    const topImpact = paths.impact.slice(0, 4);
+    if (topSearch.length)
+        findings.push(`Top search hits: ${topSearch.join(", ")}`);
+    if (topSnippets.length)
+        findings.push(`Snippets reviewed: ${topSnippets.join(", ")}`);
+    if (topSymbols.length)
+        findings.push(`Symbols/AST reviewed: ${topSymbols.join(", ")}`);
+    if (topImpact.length)
+        findings.push(`Impact checked: ${topImpact.join(", ")}`);
+    if (outputs.repoMap || outputs.repoMapRaw)
+        findings.push("Repo map captured");
+    if (outputs.dagSummary)
+        findings.push("Dependency graph snapshot captured");
+    return findings.length ? findings : undefined;
+};
+const buildResearchContextRefresh = (context, outputs, missingSignals = []) => {
+    const missing = new Set(missingSignals);
+    const needsFiles = missing.has("open_or_snippet")
+        || missing.has("symbols_or_ast")
+        || missing.has("impact");
+    const needsSearch = missing.has("search_hits") || missingSignals.length === 0;
+    const paths = collectResearchPaths(outputs);
+    const focusCandidates = uniqueStrings([
+        ...paths.search,
+        ...paths.snippets,
+        ...paths.symbols,
+        ...paths.impact,
+    ]).slice(0, 8);
+    const currentSelection = context.selection ?? {
+        focus: [],
+        periphery: [],
+        all: [],
+        low_confidence: false,
+    };
+    const nextFocus = needsFiles
+        ? uniqueStrings([...currentSelection.focus, ...focusCandidates]).slice(0, 8)
+        : currentSelection.focus;
+    const nextAll = uniqueStrings([
+        ...currentSelection.all,
+        ...currentSelection.periphery,
+        ...nextFocus,
+    ]);
+    const currentQueries = context.queries ?? [];
+    const queryHints = needsSearch ? buildPathHints(focusCandidates, 4) : [];
+    const nextQueries = uniqueStrings([...currentQueries, ...queryHints]).slice(0, 8);
+    const focusChanged = nextFocus.join("\n") !== currentSelection.focus.join("\n");
+    const queriesChanged = nextQueries.join("\n") !== currentQueries.join("\n");
+    const repoMapChanged = Boolean(outputs.repoMap || outputs.repoMapRaw)
+        && !context.repo_map
+        && !context.repo_map_raw;
+    const dagChanged = Boolean(outputs.dagSummary) && !context.dag_summary;
+    if (!focusChanged && !queriesChanged && !repoMapChanged && !dagChanged) {
+        return { context, changed: false };
+    }
+    return {
+        context: {
+            ...context,
+            queries: nextQueries,
+            repo_map: repoMapChanged ? outputs.repoMap ?? context.repo_map : context.repo_map,
+            repo_map_raw: repoMapChanged
+                ? outputs.repoMapRaw ?? context.repo_map_raw
+                : context.repo_map_raw,
+            dag_summary: dagChanged ? outputs.dagSummary ?? context.dag_summary : context.dag_summary,
+            selection: {
+                ...currentSelection,
+                focus: nextFocus,
+                all: nextAll,
+            },
+        },
+        changed: true,
+    };
+};
+const extractAgentRequestContextInputs = (request) => {
+    if (!request)
+        return { additionalQueries: [], preferredFiles: [] };
+    const additionalQueries = [];
+    const preferredFiles = [];
+    for (const need of request.needs ?? []) {
+        if (need.type === "docdex.search" || need.type === "docdex.web") {
+            if (need.query)
+                additionalQueries.push(need.query);
+            continue;
+        }
+        if (need.type === "docdex.open") {
+            preferredFiles.push(need.path);
+            continue;
+        }
+        if (need.type === "docdex.symbols"
+            || need.type === "docdex.ast"
+            || need.type === "docdex.impact") {
+            preferredFiles.push(need.file);
+            continue;
+        }
+        if (need.type === "docdex.impact_diagnostics") {
+            if (need.file)
+                preferredFiles.push(need.file);
+            continue;
+        }
+        if (need.type === "file.read") {
+            preferredFiles.push(need.path);
+        }
+    }
+    return {
+        additionalQueries: uniqueStrings(additionalQueries.filter(Boolean)),
+        preferredFiles: uniqueStrings(preferredFiles.filter(Boolean)),
+    };
+};
+const extractRequestKeywords = (request) => request
+    .toLowerCase()
+    .replace(/[^a-z0-9/_-]/g, " ")
+    .split(/\s+/)
+    .map((token) => token.trim())
+    .filter((token) => token.length >= 3 && !REQUEST_KEYWORD_STOPWORDS.has(token));
+const extractRequestPhrases = (request, keywords) => {
+    const explicitQuoted = Array.from(request.matchAll(/\"([^\"\\n]{3,})\"|'([^'\\n]{3,})'/g))
+        .map((match) => (match[1] ?? match[2] ?? "").trim().toLowerCase())
+        .map((entry) => entry.replace(/[^a-z0-9/_ -]/g, " ").replace(/\s+/g, " ").trim())
+        .filter((entry) => entry.length >= 4 && entry.split(/\s+/).length >= 2);
+    const biGrams = [];
+    for (let index = 0; index < keywords.length - 1; index += 1) {
+        const left = keywords[index];
+        const right = keywords[index + 1];
+        if (!left || !right)
+            continue;
+        biGrams.push(`${left} ${right}`);
+    }
+    return uniqueStrings([...explicitQuoted, ...biGrams]).slice(0, 10);
+};
+const extractRequestAnchors = (request) => {
+    const keywords = extractRequestKeywords(request);
+    const phrases = extractRequestPhrases(request, keywords);
+    const all = uniqueStrings([...phrases, ...keywords]).slice(0, 14);
+    return { keywords, phrases, all };
+};
+const normalizeSemanticText = (value) => value.toLowerCase().replace(/[^a-z0-9/_ -]/g, " ").replace(/\s+/g, " ").trim();
+const hasBackendTarget = (targets) => targets.some((target) => BACKEND_TARGET_PATTERN.test(normalizePath(target).toLowerCase()));
+const hasFrontendTarget = (targets) => targets.some((target) => {
+    const normalized = normalizePath(target).toLowerCase();
+    return FRONTEND_TARGET_PATTERN.test(normalized) || /\.(html|css|scss|sass|less|styl|tsx|jsx|vue|svelte)$/i.test(normalized);
+});
+const collectContextPaths = (context) => {
+    const selection = context.selection?.all ?? [];
+    const files = (context.files ?? []).map((entry) => entry.path);
+    const snippets = (context.snippets ?? []).map((entry) => entry.path ?? "");
+    const symbols = (context.symbols ?? []).map((entry) => entry.path);
+    const ast = (context.ast ?? []).map((entry) => entry.path);
+    const impact = (context.impact ?? []).map((entry) => entry.file);
+    const search = (context.search_results ?? [])
+        .flatMap((result) => result.hits ?? [])
+        .map((hit) => hit.path ?? "");
+    return uniqueStrings([...selection, ...files, ...snippets, ...symbols, ...ast, ...impact, ...search]
+        .map((entry) => normalizePath(entry))
+        .filter(Boolean));
+};
+const parseRepoMapPaths = (repoMap) => {
+    if (!repoMap)
+        return [];
+    const lines = repoMap
+        .split(/\r?\n/)
+        .map((line) => line.replace(/\s+$/g, ""))
+        .filter((line) => line.length > 0);
+    if (lines.length <= 1)
+        return [];
+    const stack = [];
+    const paths = [];
+    for (let index = 1; index < lines.length; index += 1) {
+        const line = lines[index];
+        const branchIndex = line.indexOf("├── ");
+        const leafIndex = line.indexOf("└── ");
+        const markerIndex = branchIndex >= 0 ? branchIndex : leafIndex >= 0 ? leafIndex : -1;
+        if (markerIndex < 0)
+            continue;
+        const nameRaw = line.slice(markerIndex + 4).trim();
+        if (!nameRaw)
+            continue;
+        const name = nameRaw.replace(/\s+\(.*\)\s*$/g, "").trim();
+        if (!name)
+            continue;
+        const depth = Math.floor(markerIndex / 4);
+        stack[depth] = name;
+        stack.length = depth + 1;
+        paths.push(normalizePath(stack.join("/")));
+    }
+    return uniqueStrings(paths).filter(Boolean);
+};
+const collectKnownContextPaths = (context) => {
+    const repoMapPaths = parseRepoMapPaths(context.repo_map_raw ?? context.repo_map);
+    return uniqueStrings([
+        ...collectContextPaths(context),
+        ...repoMapPaths,
+    ]);
+};
+const backendCandidatesFromContext = (context) => collectContextPaths(context).filter((path) => BACKEND_TARGET_PATTERN.test(path.toLowerCase()));
+const scoreRequestTargetAlignment = (request, targetFiles) => {
+    const keywords = extractRequestAnchors(request).keywords;
+    if (keywords.length === 0) {
+        return { score: 1, keywords, matches: [] };
+    }
+    const normalizedTargets = targetFiles.map((entry) => normalizePath(entry).toLowerCase());
+    const matches = keywords.filter((keyword) => normalizedTargets.some((target) => target.includes(keyword)));
+    let score = matches.length / keywords.length;
+    const endpointIntent = ENDPOINT_SERVER_INTENT_PATTERN.test(request);
+    const uiIntent = UI_REQUEST_INTENT_PATTERN.test(request) && !endpointIntent;
+    if (uiIntent && hasFrontendTarget(targetFiles)) {
+        score = Math.max(score, 0.45);
+        if (!matches.includes("__intent_frontend__")) {
+            matches.push("__intent_frontend__");
+        }
+    }
+    if (endpointIntent && hasBackendTarget(targetFiles)) {
+        score = Math.max(score, 0.45);
+        if (!matches.includes("__intent_backend__")) {
+            matches.push("__intent_backend__");
+        }
+    }
+    return { score: Number(Math.min(score, 1).toFixed(3)), keywords, matches };
+};
+const FALLBACK_WARNING_PATTERNS = [
+    /^plan_missing_/i,
+    new RegExp(`^${ARCHITECT_WARNING_USED_JSON_FALLBACK}$`, "i"),
+    new RegExp(`^${ARCHITECT_WARNING_USED_PLAINTEXT_FALLBACK}$`, "i"),
+    /^architect_output_not_object$/i,
+    /^architect_output_repair_reason:(dsl_missing_fields|json_fallback|plaintext_fallback|classifier)$/i,
+];
+const GENERIC_PLAN_STEP_PATTERNS = [
+    /^review focus files/i,
+    /^map request requirements/i,
+    /^apply changes aligned/i,
+    /^run verification steps/i,
+    /^implement the requested change/i,
+];
+const collectTargetTokens = (targets) => uniqueStrings(targets
+    .map((entry) => normalizePath(entry).toLowerCase())
+    .flatMap((entry) => {
+    const file = entry.split("/").pop() ?? "";
+    return [entry, file].filter(Boolean);
+})
+    .filter((entry) => entry !== "unknown"));
+const hasTargetReferenceInSteps = (steps, targetFiles) => {
+    const targetTokens = collectTargetTokens(targetFiles);
+    if (targetTokens.length === 0)
+        return false;
+    return steps.some((step) => {
+        const normalized = step.toLowerCase();
+        return targetTokens.some((token) => normalized.includes(token));
+    });
+};
+const assessFallbackOrGenericPlan = (plan, warnings) => {
+    const reasons = [];
+    if (warnings.some((warning) => FALLBACK_WARNING_PATTERNS.some((pattern) => pattern.test(warning)))) {
+        reasons.push("architect_plan_fallback_warning");
+    }
+    if ((plan.target_files ?? []).some((target) => normalizePath(target) === "unknown")) {
+        reasons.push("architect_plan_unknown_target");
+    }
+    if ((plan.risk_assessment ?? "").toLowerCase().includes("fallback")) {
+        reasons.push("architect_plan_fallback_risk");
+    }
+    const steps = (plan.steps ?? []).map((entry) => entry.trim()).filter(Boolean);
+    const generic_step_hits = steps.filter((step) => GENERIC_PLAN_STEP_PATTERNS.some((pattern) => pattern.test(step))).length;
+    if (generic_step_hits >= 2 && !hasTargetReferenceInSteps(steps, plan.target_files ?? [])) {
+        reasons.push("architect_plan_generic_steps");
+    }
+    return {
+        fallback_or_generic: reasons.length > 0,
+        reasons,
+        generic_step_hits,
+    };
+};
+const inferBuilderTouchedFiles = (output) => {
+    const trimmed = output.trim();
+    if (!trimmed || !(trimmed.startsWith("{") || trimmed.startsWith("["))) {
+        return [];
+    }
+    try {
+        const payload = JSON.parse(trimmed);
+        const patches = Array.isArray(payload.patches) ? payload.patches : [];
+        if (patches.length > 0) {
+            return uniqueStrings(patches
+                .map((patch) => patch.file)
+                .filter((file) => typeof file === "string" && file.length > 0)
+                .map((file) => normalizePath(file)));
+        }
+        const files = Array.isArray(payload.files) ? payload.files : [];
+        if (files.length > 0) {
+            return uniqueStrings(files
+                .map((entry) => entry.path)
+                .filter((file) => typeof file === "string" && file.length > 0)
+                .map((file) => normalizePath(file)));
+        }
+    }
+    catch {
+        return [];
+    }
+    return [];
+};
+const assessBuilderSemanticAlignment = (request, plan, builderOutput) => {
+    const requestAnchors = extractRequestAnchors(request);
+    const anchors = requestAnchors.all;
+    const normalizedOutput = normalizeSemanticText(builderOutput);
+    const matches = anchors.filter((anchor) => normalizedOutput.includes(normalizeSemanticText(anchor)));
+    const rawScore = anchors.length > 0 ? matches.length / anchors.length : 1;
+    const touchedFiles = inferBuilderTouchedFiles(builderOutput);
+    const normalizedTargets = uniqueStrings((plan.target_files ?? []).map((target) => normalizePath(target)).filter(Boolean));
+    const targetSignals = uniqueStrings([
+        ...touchedFiles.filter((file) => normalizedTargets.includes(file)),
+        ...normalizedTargets.filter((target) => normalizedOutput.includes(target.toLowerCase())),
+    ]);
+    const hasActionSignal = /\\b(add|update|change|create|remove|refactor|implement|wire|persist|store|render|validate|handle|log)\\b/i.test(builderOutput) || touchedFiles.length > 0;
+    const strongPatchTargetSignal = touchedFiles.length > 0 && targetSignals.length > 0 && hasActionSignal;
+    const score = Number(Math.min(rawScore, 1).toFixed(3));
+    const reasons = [];
+    const hasRichRequestAnchors = requestAnchors.keywords.length >= 3;
+    const minSemanticScore = strongPatchTargetSignal ? 0.1 : 0.25;
+    if (hasRichRequestAnchors && score < minSemanticScore) {
+        reasons.push("builder_request_semantic_low");
+    }
+    if (hasRichRequestAnchors && normalizedTargets.length > 0 && targetSignals.length === 0) {
+        reasons.push("builder_missing_plan_target_signal");
+    }
+    if (hasRichRequestAnchors && !hasActionSignal) {
+        reasons.push("builder_missing_action_signal");
+    }
+    return {
+        ok: reasons.length === 0,
+        score,
+        anchors,
+        matches,
+        targetSignals,
+        reasons,
+        source: touchedFiles.length > 0 ? "patch_payload" : "text",
+    };
+};
+const buildFallbackRecoveryQueries = (request, context) => {
+    const keywords = extractRequestKeywords(request).slice(0, 5);
+    const keywordPhrase = keywords.join(" ");
+    const endpointIntent = ENDPOINT_SERVER_INTENT_PATTERN.test(request);
+    const candidates = [
+        request,
+        keywordPhrase ? `${keywordPhrase} implementation` : "",
+        endpointIntent
+            ? `${request} route handlers server entrypoint`
+            : `${request} module entrypoint implementation`,
+        endpointIntent
+            ? `${request} api specification openapi contract`
+            : `${request} api specification contract interface`,
+        ...((context.queries ?? []).slice(0, 2)),
+    ];
+    return uniqueStrings(candidates.filter(Boolean)).slice(0, 4);
+};
+const keywordMatchedPathsFromContext = (context, request) => {
+    const keywords = extractRequestKeywords(request);
+    if (keywords.length === 0)
+        return [];
+    return collectContextPaths(context)
+        .filter((path) => {
+        const normalized = path.toLowerCase();
+        return keywords.some((keyword) => normalized.includes(keyword));
+    })
+        .slice(0, 8);
+};
+const buildFallbackRecoveryRequest = (request, context, pass) => {
+    const additionalQueries = buildFallbackRecoveryQueries(request, context);
+    const endpointIntent = ENDPOINT_SERVER_INTENT_PATTERN.test(request);
+    const needs = additionalQueries.map((query) => ({
+        type: "docdex.search",
+        query,
+        limit: 8,
+    }));
+    if (endpointIntent) {
+        needs.push({ type: "file.list", root: "src", pattern: "*server*" }, { type: "file.list", root: "src", pattern: "*route*" }, { type: "file.list", root: "docs", pattern: "*api*" });
+    }
+    else {
+        needs.push({ type: "file.list", root: "src", pattern: "*" }, { type: "file.list", root: "docs", pattern: "*spec*" });
+    }
+    const preferredFiles = uniqueStrings([
+        ...(endpointIntent ? backendCandidatesFromContext(context).slice(0, 8) : keywordMatchedPathsFromContext(context, request)),
+        ...(context.selection?.focus ?? []),
+    ]).slice(0, 12);
+    const recentFiles = uniqueStrings([...(context.selection?.all ?? []), ...preferredFiles]).slice(0, 24);
+    return {
+        requestPayload: {
+            version: "v1",
+            role: "architect",
+            request_id: `architect-fallback-${Date.now()}-${pass}`,
+            needs,
+            context: {
+                summary: "Architect plan appears fallback/generic. Gather concrete implementation context (entrypoints, handlers, and API/spec references) before finalizing.",
+            },
+        },
+        additionalQueries,
+        preferredFiles,
+        recentFiles,
+    };
+};
+const VERIFICATION_COMMAND_PATTERN = /\b(pnpm|npm|yarn|bun|node|jest|vitest|mocha|ava|pytest|cargo|go|dotnet|mvn|gradle)\b.*\b(test|tests?|spec|check)\b/i;
+const VERIFICATION_ACTION_PATTERN = /\b(run|execute|verify|check|assert|validate|curl|open|visit|navigate|request|hit|test)\b/i;
+const VERIFICATION_TYPE_PATTERN = /\b(unit|integration|component|e2e|end[- ]to[- ]end|api|curl|httpie|wget|browser|manual)\b/i;
+const VERIFICATION_HTTP_URL_PATTERN = /\bhttps?:\/\/\S+/i;
+const isConcreteVerificationStep = (step) => {
+    const value = step.trim();
+    if (!value)
+        return false;
+    if (VERIFICATION_COMMAND_PATTERN.test(value))
+        return true;
+    if (/\bcurl\b/i.test(value) && VERIFICATION_HTTP_URL_PATTERN.test(value))
+        return true;
+    if (/\b(open|visit|navigate)\b/i.test(value) && /\b(browser|localhost|https?:\/\/)\b/i.test(value)) {
+        return true;
+    }
+    return VERIFICATION_ACTION_PATTERN.test(value) && VERIFICATION_TYPE_PATTERN.test(value);
+};
+const assessVerificationQuality = (verification) => {
+    const steps = (verification ?? []).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    if (steps.length === 0)
+        return { ok: false, steps, reason: "empty" };
+    const matched_step = steps.find((step) => isConcreteVerificationStep(step));
+    if (!matched_step)
+        return { ok: false, steps, reason: "non_concrete" };
+    return { ok: true, steps, matched_step };
+};
+const isConcreteTargetPath = (target) => {
+    const normalized = normalizePath(target).toLowerCase();
+    if (!normalized || normalized === "unknown")
+        return false;
+    if (normalized.includes("<path"))
+        return false;
+    if (/^path\/to\/file\.[a-z0-9]+$/.test(normalized))
+        return false;
+    if (!normalized.includes("."))
+        return false;
+    return !/^<[^>]+>$/.test(normalized);
+};
+const classifyDeterministicPatchApplyFailure = (failure) => {
+    const classified = failure.classification;
+    if (classified) {
+        if (classified.failure_class === "search_match")
+            return "search_block";
+        if (classified.failure_class === "scope")
+            return "disallowed_files";
+        if (classified.failure_class === "filesystem" && classified.failure_code === "patch_file_not_found") {
+            return "missing_path";
+        }
+        if (classified.failure_class === "schema") {
+            if (classified.failure_code === "patch_placeholder_payload")
+                return "placeholder_payload";
+            return "patch_parse";
+        }
+        if (classified.failure_class === "guardrail"
+            && classified.failure_code === "patch_delete_without_plan_intent") {
+            return "placeholder_payload";
+        }
+    }
+    const message = `${failure.error} ${failure.source}`.toLowerCase();
+    if (message.includes("enoent") || message.includes("no such file or directory"))
+        return "missing_path";
+    if (message.includes("search block not found"))
+        return "search_block";
+    if (message.includes("replace block not found"))
+        return "replace_block";
+    if (message.includes("placeholder replace blocks"))
+        return "placeholder_payload";
+    if (message.includes("placeholder create content"))
+        return "placeholder_payload";
+    if (message.includes("delete action without delete intent"))
+        return "placeholder_payload";
+    if (message.includes("disallowed files"))
+        return "disallowed_files";
+    if (message.includes("patch parsing failed"))
+        return "patch_parse";
+    if (message.includes("patch payload includes empty patches array"))
+        return "patch_parse";
+    if (message.includes("patch payload includes empty files array"))
+        return "patch_parse";
+    if (message.includes("patch payload is missing required 'patches' array"))
+        return "patch_parse";
+    if (message.includes("patch payload is missing required 'files' array"))
+        return "patch_parse";
+    if (message.includes("patch payload field 'patches' must be an array"))
+        return "patch_parse";
+    if (message.includes("patch payload field 'files' must be an array"))
+        return "patch_parse";
+    if (message.includes("patch payload must include patches array"))
+        return "patch_parse";
+    if (message.includes("patch output is not valid json"))
+        return "patch_parse";
+    if (message.includes("patch output is empty"))
+        return "patch_parse";
+    if (message.includes("patch field"))
+        return "patch_parse";
+    if (message.includes("placeholder file paths"))
+        return "placeholder_payload";
+    return null;
+};
+const isDeterministicPatchApplyFailure = (failure) => classifyDeterministicPatchApplyFailure(failure) !== null;
+const MAX_DETERMINISTIC_ARCHITECT_REPAIRS = 2;
+const isArchitectRepairEligibleDeterministicFailure = (kind, usedKinds) => kind !== null && !usedKinds.has(kind) && usedKinds.size < MAX_DETERMINISTIC_ARCHITECT_REPAIRS;
+const buildDeterministicRecoveryQuery = (request, kind) => {
+    switch (kind) {
+        case "missing_path":
+            return `${request} use existing repository target paths or explicit create-file targets`;
+        case "search_block":
+        case "replace_block":
+            return `${request} use exact current file content for search and replace blocks`;
+        case "patch_parse":
+            return `${request} produce valid JSON patch output with non-empty patches and concrete paths`;
+        case "placeholder_payload":
+            return `${request} remove placeholders and emit concrete patch blocks only`;
+        case "disallowed_files":
+            return `${request} confine changes to allowed target files only`;
+        default:
+            return `${request} repair patch apply failure`;
+    }
+};
+const BLOCKING_PLAN_QUALITY_REASONS = new Set([
+    "missing_concrete_targets",
+    "invalid_target_paths",
+    "verification_empty",
+    "verification_non_concrete",
+    "low_request_target_alignment_critical",
+]);
+const collectBlockingPlanQualityReasons = (quality) => quality.reasons.filter((reason) => BLOCKING_PLAN_QUALITY_REASONS.has(reason));
+const assessPlanTargetValidation = (plan, context) => {
+    const knownTargets = collectKnownContextPaths(context);
+    const repoMapTargets = parseRepoMapPaths(context.repo_map_raw ?? context.repo_map);
+    const existingTargets = repoMapTargets.length > 0 ? repoMapTargets : knownTargets;
+    if (knownTargets.length === 0) {
+        return {
+            ok: true,
+            knownTargets,
+            existingTargets,
+            createTargets: uniqueStrings((plan.create_files ?? [])
+                .filter((target) => isConcreteTargetPath(target))
+                .map((target) => normalizePath(target))),
+            unresolvedTargets: [],
+        };
+    }
+    const existingTargetSet = new Set(existingTargets.map((entry) => entry.toLowerCase()));
+    const createTargets = uniqueStrings((plan.create_files ?? [])
+        .filter((target) => isConcreteTargetPath(target))
+        .map((target) => normalizePath(target)));
+    const createTargetSet = new Set(createTargets.map((entry) => entry.toLowerCase()));
+    const concreteTargets = uniqueStrings((plan.target_files ?? [])
+        .filter((target) => isConcreteTargetPath(target))
+        .map((target) => normalizePath(target)));
+    const unresolvedTargets = concreteTargets.filter((target) => !existingTargetSet.has(target.toLowerCase()) && !createTargetSet.has(target.toLowerCase()));
+    return {
+        ok: unresolvedTargets.length === 0,
+        knownTargets,
+        existingTargets,
+        createTargets,
+        unresolvedTargets,
+    };
+};
+const STRUCTURAL_WARNING_PREFIXES = [
+    "docdex_symbols_failed:",
+    "docdex_ast_failed:",
+    "docdex_impact_failed:",
+    "impact_graph_sparse:",
+    "docdex_snippet_failed:",
+    "docdex_open_failed:",
+    "docdex_search_failed:",
+];
+const STRUCTURAL_WARNING_EXACT = new Set([
+    "docdex_no_hits",
+    "docdex_low_confidence",
+    "docdex_index_empty",
+    "docdex_unavailable",
+    "docdex_initialize_failed",
+]);
+const collectStructuralWarningHits = (warnings) => {
+    if (!Array.isArray(warnings) || warnings.length === 0)
+        return [];
+    return warnings.filter((warning) => {
+        if (STRUCTURAL_WARNING_EXACT.has(warning))
+            return true;
+        return STRUCTURAL_WARNING_PREFIXES.some((prefix) => warning.startsWith(prefix));
+    });
+};
+const assessStructuralGrounding = (context, plan) => {
+    const warningHits = collectStructuralWarningHits(context.warnings);
+    const lowConfidence = context.selection?.low_confidence === true;
+    const hasFocus = [
+        ...(context.selection?.focus ?? []),
+        ...(plan.target_files ?? []),
+    ].some((entry) => isConcreteTargetPath(entry));
+    const hasStructuralSignals = (context.symbols ?? []).length > 0 ||
+        (context.ast ?? []).length > 0 ||
+        (context.impact ?? []).length > 0;
+    const hasFallbackSignals = (context.snippets ?? []).length > 0 ||
+        (context.files ?? []).length > 0 ||
+        (context.selection?.focus.length ?? 0) > 0 ||
+        collectContextPaths(context).length > 0 ||
+        ((context.repo_map ?? "").trim().length > 0);
+    if (warningHits.length === 0 && !lowConfidence && (hasStructuralSignals || hasFallbackSignals)) {
+        return {
+            ok: true,
+            score: 1,
+            reasons: [],
+            warningHits: [],
+            hasFocus,
+            hasStructuralSignals,
+            hasFallbackSignals,
+        };
+    }
+    const reasons = [];
+    let score = 1;
+    if (!hasFocus) {
+        reasons.push("no_concrete_focus");
+        score -= 0.35;
+    }
+    if (!hasStructuralSignals && !hasFallbackSignals) {
+        reasons.push("missing_structural_signals");
+        score -= 0.25;
+    }
+    else if (!hasStructuralSignals && hasFallbackSignals) {
+        reasons.push("fallback_signals_only");
+        score -= 0.08;
+    }
+    if (warningHits.length > 0) {
+        reasons.push("structural_tool_warnings");
+        score -= Math.min(0.4, warningHits.length * 0.1);
+    }
+    if (lowConfidence) {
+        reasons.push("low_confidence_selection");
+        score -= 0.2;
+    }
+    const clampedScore = Math.max(0, Number(score.toFixed(3)));
+    const ok = clampedScore >= 0.45;
+    return {
+        ok,
+        score: clampedScore,
+        reasons,
+        warningHits,
+        hasFocus,
+        hasStructuralSignals,
+        hasFallbackSignals,
+    };
+};
+const jaccardSimilarity = (left, right) => {
+    if (left.length === 0 && right.length === 0)
+        return 1;
+    if (left.length === 0 || right.length === 0)
+        return 0;
+    const leftSet = new Set(left.map((value) => value.toLowerCase()));
+    const rightSet = new Set(right.map((value) => value.toLowerCase()));
+    let intersection = 0;
+    for (const entry of leftSet) {
+        if (rightSet.has(entry))
+            intersection += 1;
+    }
+    const union = new Set([...leftSet, ...rightSet]).size;
+    if (union === 0)
+        return 1;
+    return Number((intersection / union).toFixed(3));
+};
+const assessTargetDrift = (previousTargets, currentTargets) => {
+    const previous = uniqueStrings((previousTargets ?? []).filter((entry) => entry.trim().length > 0));
+    const current = uniqueStrings((currentTargets ?? []).filter((entry) => entry.trim().length > 0));
+    if (previous.length === 0 || current.length === 0) {
+        return { high: false, similarity: 1, drift: 0, previous, current };
+    }
+    const similarity = jaccardSimilarity(previous, current);
+    const drift = Number((1 - similarity).toFixed(3));
+    const high = similarity < 0.2;
+    return { high, similarity, drift, previous, current };
+};
+const scoreRequestPlanSemanticCoverage = (request, plan) => {
+    const anchors = extractRequestAnchors(request).all;
+    if (anchors.length === 0) {
+        return { score: 1, anchors, matches: [] };
+    }
+    const corpus = normalizeSemanticText([
+        ...(plan.steps ?? []),
+        ...(plan.target_files ?? []),
+        plan.risk_assessment ?? "",
+        ...(plan.verification ?? []),
+    ].join(" "));
+    if (!corpus) {
+        return { score: 0, anchors, matches: [] };
+    }
+    const matches = anchors.filter((anchor) => corpus.includes(normalizeSemanticText(anchor)));
+    const score = matches.length / anchors.length;
+    return {
+        score: Number(Math.min(score, 1).toFixed(3)),
+        anchors,
+        matches,
+    };
+};
+const assessPlanQualityGate = (request, plan, context) => {
+    const requestAnchors = extractRequestAnchors(request);
+    const concreteTargets = uniqueStrings((plan.target_files ?? []).filter((target) => isConcreteTargetPath(target)));
+    const reasons = [];
+    if (concreteTargets.length === 0)
+        reasons.push("missing_concrete_targets");
+    const targetValidation = context ? assessPlanTargetValidation(plan, context) : undefined;
+    if (targetValidation && !targetValidation.ok) {
+        reasons.push("invalid_target_paths");
+    }
+    const verification = assessVerificationQuality(plan.verification);
+    if (!verification.ok)
+        reasons.push(`verification_${verification.reason}`);
+    const alignment = scoreRequestTargetAlignment(request, concreteTargets);
+    const needsAlignment = alignment.keywords.length >= 3;
+    if (needsAlignment && alignment.score < 0.1) {
+        reasons.push("low_request_target_alignment_critical");
+    }
+    else if (needsAlignment && alignment.score < 0.2) {
+        reasons.push("low_request_target_alignment");
+    }
+    const semanticCoverage = scoreRequestPlanSemanticCoverage(request, plan);
+    const strictSemanticIntent = SEMANTIC_STRICT_INTENT_PATTERN.test(request);
+    if (strictSemanticIntent && requestAnchors.keywords.length >= 3 && semanticCoverage.score < 0.3) {
+        reasons.push("low_request_plan_semantic_coverage");
+    }
+    return {
+        ok: reasons.length === 0,
+        reasons,
+        concreteTargets,
+        verification,
+        targetValidation,
+        alignmentScore: alignment.score,
+        alignmentKeywords: alignment.keywords,
+        semanticScore: semanticCoverage.score,
+        semanticAnchors: semanticCoverage.anchors,
+        semanticMatches: semanticCoverage.matches,
+    };
+};
+const buildQualityDegradedPlan = (request, context, priorPlan) => {
+    const existingTargets = parseRepoMapPaths(context.repo_map_raw ?? context.repo_map);
+    const effectiveKnownTargets = existingTargets.length > 0
+        ? existingTargets
+        : collectKnownContextPaths(context);
+    const knownTargetSet = new Set(effectiveKnownTargets.map((entry) => normalizePath(entry).toLowerCase()));
+    const hasKnownTargets = knownTargetSet.size > 0;
+    const explicitCreateTargets = uniqueStrings((priorPlan.create_files ?? [])
+        .filter((target) => isConcreteTargetPath(target))
+        .map((target) => normalizePath(target)));
+    const explicitCreateTargetSet = new Set(explicitCreateTargets.map((entry) => entry.toLowerCase()));
+    const priorConcreteTargets = uniqueStrings((priorPlan.target_files ?? [])
+        .filter((target) => isConcreteTargetPath(target))
+        .map((target) => normalizePath(target)));
+    const priorHasConcreteTargets = priorConcreteTargets.length > 0;
+    const unresolvedPriorTargets = priorConcreteTargets.filter((target) => hasKnownTargets
+        ? !knownTargetSet.has(target.toLowerCase()) && !explicitCreateTargetSet.has(target.toLowerCase())
+        : false);
+    const priorHasUnresolvedTargets = unresolvedPriorTargets.length > 0;
+    const focusTargets = uniqueStrings((context.selection?.focus ?? [])
+        .filter((target) => isConcreteTargetPath(target))
+        .map((target) => normalizePath(target)));
+    const requestKeywords = extractRequestAnchors(request).keywords;
+    const docPathPattern = /(^|\/)(docs?|openapi|specs?)\//i;
+    const testPathPattern = /(^|\/)(__tests__|tests?|test)\//i;
+    const scoreContextTarget = (target) => {
+        const normalized = normalizePath(target).toLowerCase();
+        let score = 0;
+        if (focusTargets.includes(target))
+            score += 4;
+        for (const keyword of requestKeywords) {
+            if (normalized.includes(keyword))
+                score += 2;
+        }
+        if (normalized.includes("/src/") || normalized.startsWith("src/"))
+            score += 1;
+        if (docPathPattern.test(normalized) || /\.(md|mdx|txt|rst|ya?ml)$/i.test(normalized))
+            score -= 3;
+        if (testPathPattern.test(normalized) || /\.(test|spec)\.[^.]+$/i.test(normalized))
+            score -= 1;
+        return score;
+    };
+    const contextTargets = uniqueStrings([
+        ...focusTargets,
+        ...((context.selection?.all ?? []).filter((target) => isConcreteTargetPath(target))),
+        ...((context.files ?? []).map((entry) => entry.path).filter((target) => isConcreteTargetPath(target))),
+    ].map((target) => normalizePath(target)))
+        .sort((left, right) => scoreContextTarget(right) - scoreContextTarget(left))
+        .slice(0, 4);
+    const fallbackTargets = uniqueStrings([
+        ...(priorPlan.target_files ?? [])
+            .filter((target) => isConcreteTargetPath(target))
+            .map((target) => normalizePath(target))
+            .filter((target) => {
+            if (!hasKnownTargets)
+                return true;
+            return (knownTargetSet.has(target.toLowerCase())
+                || explicitCreateTargetSet.has(target.toLowerCase()));
+        }),
+        ...(!priorHasUnresolvedTargets && priorHasConcreteTargets
+            ? contextTargets.filter((target) => {
+                if (!hasKnownTargets)
+                    return true;
+                return knownTargetSet.has(target.toLowerCase());
+            })
+            : []),
+        ...explicitCreateTargets,
+    ].filter(Boolean));
+    const targets = fallbackTargets.length > 0 ? fallbackTargets.slice(0, 4) : [];
+    const targetSet = new Set(targets.map((target) => target.toLowerCase()));
+    const createTargets = explicitCreateTargets.filter((target) => targetSet.has(target.toLowerCase()));
+    const normalizedRequest = request.trim() || "the requested change";
+    const verify = [
+        targets.length > 0
+            ? `Run unit/integration tests that cover: ${targets.join(", ")}.`
+            : `Run unit/integration tests that validate "${normalizedRequest}".`,
+        `Perform a manual verification for "${normalizedRequest}" against ${targets[0] ?? "the affected target"}.`,
+    ];
+    const steps = [
+        ...((priorPlan.steps ?? []).filter((step) => step.trim().length > 0)),
+        targets.length > 0
+            ? `Finalize implementation details for ${targets.join(", ")} with request-specific behavior for "${normalizedRequest}".`
+            : `Refine plan targets for "${normalizedRequest}" to concrete in-repo files before implementation.`,
+    ];
+    return {
+        steps: uniqueStrings(steps),
+        target_files: targets,
+        create_files: createTargets.length > 0 ? createTargets : undefined,
+        risk_assessment: priorPlan.risk_assessment && priorPlan.risk_assessment.trim().length > 0
+            ? priorPlan.risk_assessment
+            : `medium: degraded architect quality gate fallback for "${normalizedRequest}"`,
+        verification: uniqueStrings(verify),
+    };
+};
+const buildDriftStabilizedPlan = (request, priorPlan, previousTargets) => {
+    const stableTargets = previousTargets.filter((entry) => isConcreteTargetPath(entry));
+    if (stableTargets.length === 0)
+        return priorPlan;
+    const normalizedRequest = request.trim() || "the requested change";
+    const steps = uniqueStrings([
+        ...(priorPlan.steps ?? []),
+        `Stabilize target scope for "${normalizedRequest}" and avoid cross-pass drift into unrelated files.`,
+    ]);
+    return {
+        ...priorPlan,
+        steps,
+        target_files: stableTargets,
+    };
+};
+const buildArchitectOutputArtifactPayload = (input) => ({
+    pass: input.pass,
+    strict_retry: input.strictRetry,
+    source: input.source ?? "architect_pass",
+    plan_hint_present: Boolean(input.planHint && input.planHint.trim().length > 0),
+    instruction_hint_present: Boolean(input.instructionHint && input.instructionHint.trim().length > 0),
+    warnings: input.result.warnings ?? [],
+    raw_output: input.result.raw ?? "",
+    normalized_output: input.result.plan,
+    request: input.result.request ?? null,
+    request_response: input.requestResponse ?? null,
+    plan_hash: input.planHash ?? null,
+    classification: input.classification ?? null,
+    repair_applied: input.repairApplied ?? false,
+    recovery_action: input.recoveryAction ?? null,
+    quality_gate: input.qualityGate ?? null,
+    structural_grounding: input.structuralGrounding ?? null,
+    target_drift: input.targetDrift ?? null,
+    response_format_type: input.responseFormat?.type ?? "default",
+    response_format_schema: input.responseFormat?.type === "json_schema"
+        ? (input.responseFormat.schema ?? null)
+        : null,
+    response_format_grammar_present: input.responseFormat?.type === "gbnf" ? Boolean(input.responseFormat.grammar) : false,
+});
+const classifyArchitectWarnings = (warnings) => {
+    if (warnings.some((warning) => warning === ARCHITECT_NON_DSL_WARNING)) {
+        return "unstructured_plaintext";
+    }
+    if (warnings.some((warning) => warning === ARCHITECT_WARNING_REPAIRED))
+        return "repaired";
+    return "sectioned_plaintext";
+};
+const hasRepairWarnings = (warnings) => warnings.some((warning) => warning === ARCHITECT_WARNING_REPAIRED || warning.startsWith("architect_output_repair_reason:"));
+const formatPlanForArchitectRevision = (plan) => [
+    "FILES TO TOUCH:",
+    ...(plan.target_files.length > 0 ? plan.target_files.map((entry) => `- ${entry}`) : ["- <none>"]),
+    ...(plan.create_files && plan.create_files.length > 0
+        ? ["CREATE FILES:", ...plan.create_files.map((entry) => `- ${entry}`)]
+        : []),
+    "IMPLEMENTATION PLAN:",
+    ...(plan.steps.length > 0 ? plan.steps.map((entry) => `- ${entry}`) : ["- <none>"]),
+    `RISK: ${plan.risk_assessment}`,
+    "VERIFY:",
+    ...(plan.verification.length > 0 ? plan.verification.map((entry) => `- ${entry}`) : ["- <none>"]),
+].join("\n");
+const buildArchitectRevisionHint = (input) => {
+    const detailLines = input.details.length > 0
+        ? input.details.slice(0, 8).map((entry) => `- ${entry}`)
+        : ["- <unspecified>"];
+    return [
+        "REVISION REQUIRED:",
+        `- Previous architect output was rejected: ${input.reason}.`,
+        ...detailLines,
+        "Do not restart from scratch. Revise the previous plan in the same context and preserve valid parts.",
+        "Use the SAME context bundle and lane history; only change the parts called out above.",
+        "Do not emit AGENT_REQUEST in this revision unless there is a hard blocker that cannot be resolved from current context.",
+        "Return plain text with sections: WHAT IS REQUIRED, CURRENT CONTEXT, FOLDER STRUCTURE, FILES TO TOUCH, CREATE FILES (optional), IMPLEMENTATION PLAN, RISK, VERIFY.",
+        "PREVIOUS PLAN SNAPSHOT:",
+        formatPlanForArchitectRevision(input.plan),
+    ].join("\n");
+};
+const formatArchitectRevisionFeedback = (input) => {
+    const detailLines = input.details.length > 0
+        ? input.details.slice(0, 8).map((entry) => `- ${entry}`)
+        : ["- <unspecified>"];
+    return [
+        "ARCHITECT_REVISION_FEEDBACK v1",
+        `reason: ${input.reason}`,
+        "details:",
+        ...detailLines,
+        "instruction: Revise the previous plan in-place using the same context and lane history. Keep valid parts and only fix rejected parts.",
+        "previous_plan_snapshot:",
+        formatPlanForArchitectRevision(input.plan),
+    ].join("\n");
+};
+const formatArchitectNeedForRevision = (need) => {
+    const type = typeof need.type === "string" ? need.type : "unknown";
+    const detailParts = [];
+    if ("query" in need && typeof need.query === "string" && need.query.trim().length > 0) {
+        detailParts.push(`query=${need.query.trim()}`);
+    }
+    if ("path" in need && typeof need.path === "string" && need.path.trim().length > 0) {
+        detailParts.push(`path=${need.path.trim()}`);
+    }
+    if ("file" in need && typeof need.file === "string" && need.file.trim().length > 0) {
+        detailParts.push(`file=${need.file.trim()}`);
+    }
+    if ("root" in need && typeof need.root === "string" && need.root.trim().length > 0) {
+        detailParts.push(`root=${need.root.trim()}`);
+    }
+    return detailParts.length > 0
+        ? `Requested ${type}: ${detailParts.join(", ")}`
+        : `Requested ${type}`;
+};
+const buildArchitectRequestRevisionDetails = (request, warnings) => {
+    const details = [];
+    const summary = request.context?.summary;
+    if (typeof summary === "string" && summary.trim().length > 0) {
+        details.push(summary.trim());
+    }
+    for (const need of (request.needs ?? []).slice(0, 6)) {
+        details.push(formatArchitectNeedForRevision(need));
+    }
+    for (const warning of warnings.slice(0, 4)) {
+        details.push(`warning:${warning}`);
+    }
+    return uniqueStrings(details).slice(0, 8);
+};
+const PROVIDER_FAILURE_PATTERNS = [
+    /\bauth_error\b/i,
+    /\busage_limit_reached\b/i,
+    /\binsufficient_quota\b/i,
+    /\btoo many requests\b/i,
+    /\brate[\s_-]?limit\b/i,
+    /\b429\b/i,
+];
+const isProviderAuthOrRateLimitError = (error) => {
+    const message = error instanceof Error
+        ? `${error.name} ${error.message}`
+        : typeof error === "string"
+            ? error
+            : "";
+    if (!message)
+        return false;
+    return PROVIDER_FAILURE_PATTERNS.some((pattern) => pattern.test(message));
+};
+const buildFastPlan = (context) => {
+    const targetFiles = context.snippets
+        .map((snippet) => snippet.path)
+        .filter((path) => typeof path === "string" && path.length > 0);
+    return {
+        steps: ["Implement the requested change."],
+        target_files: targetFiles.length ? targetFiles : ["unknown"],
+        risk_assessment: "low",
+        verification: [],
+    };
+};
+export class SmartPipeline {
+    constructor(options) {
+        this.phaseTracker = createRuntimePhaseTracker();
+        this.options = options;
+    }
+    resetPhaseTracker() {
+        this.phaseTracker = createRuntimePhaseTracker();
+    }
+    transitionPhase(phase) {
+        const canonical = PIPELINE_PHASE_TO_RUNTIME_PHASE[phase];
+        if (!canonical)
+            return undefined;
+        const allowedNext = RUNTIME_PHASE_TRANSITIONS[this.phaseTracker.current];
+        if (!allowedNext.includes(canonical)) {
+            const metadata = {
+                code: "CODALI_INVALID_PHASE_TRANSITION",
+                from_phase: this.phaseTracker.current,
+                to_phase: canonical,
+                requested_phase: phase,
+                allowed_next_phases: [...allowedNext],
+                phase_trace: [...this.phaseTracker.trace],
+            };
+            throw new RuntimePhaseTransitionError(metadata);
+        }
+        this.phaseTracker.current = canonical;
+        this.phaseTracker.trace.push(canonical);
+        return canonical;
+    }
+    async run(request) {
+        this.resetPhaseTracker();
+        if (this.options.deepScanPreset) {
+            this.options.contextAssembler.applyDeepScanPreset();
+        }
+        const deepMode = this.options.deepMode ?? false;
+        const architectPlannerWithHint = this.options
+            .architectPlanner;
+        const configuredPlanHint = typeof architectPlannerWithHint.planHint === "string"
+            ? architectPlannerWithHint.planHint
+            : undefined;
+        let planHintSuppressedLogged = false;
+        const laneScope = this.options.laneScope ?? {};
+        const architectLaneId = this.options.contextManager
+            ? buildLaneId({ ...laneScope, role: "architect" })
+            : undefined;
+        const builderLaneId = this.options.contextManager
+            ? buildLaneId({ ...laneScope, role: "builder" })
+            : undefined;
+        const criticLaneId = this.options.contextManager
+            ? buildLaneId({ ...laneScope, role: "critic" })
+            : undefined;
+        const logLaneSummary = async (role, laneId) => {
+            if (!this.options.contextManager || !this.options.logger || !laneId)
+                return;
+            const lane = await this.options.contextManager.getLane({ ...laneScope, role });
+            await this.options.logger.log("context_lane_summary", {
+                role,
+                laneId: lane.id,
+                messageCount: lane.messages.length,
+                tokenEstimate: lane.tokenEstimate,
+            });
+        };
+        const logPhaseArtifact = async (phase, kind, payload) => {
+            if (!this.options.logger)
+                return undefined;
+            const path = await this.options.logger.writePhaseArtifact(phase, kind, payload);
+            await this.options.logger.log(`phase_${kind}`, { phase, path });
+            return path;
+        };
+        const toRuntimePhase = (phase) => PIPELINE_PHASE_TO_RUNTIME_PHASE[phase] ?? "act";
+        const logRetryDecision = async (decision) => {
+            if (!this.options.logger)
+                return;
+            await this.options.logger.log("retry_decision", { ...decision });
+        };
+        const sanitizeForOutput = (bundle) => {
+            const sanitized = sanitizeContextBundleForOutput(bundle);
+            const mode = bundle.serialized?.mode ?? "bundle_text";
+            sanitized.serialized = serializeContext(sanitized, { mode, audience: "librarian" });
+            return sanitized;
+        };
+        const buildSerializedContext = (bundle, audience = "librarian") => {
+            const mode = bundle.serialized?.mode ?? "bundle_text";
+            const target = audience === "librarian" ? sanitizeContextBundleForOutput(bundle) : bundle;
+            return serializeContext(target, { mode, audience });
+        };
+        const formatCodaliResponse = (response) => ["CODALI_RESPONSE v1", JSON.stringify(response, null, 2)].join("\n");
+        const buildResearchProtocolResponse = (phase) => {
+            const outputs = phase.outputs;
+            if (!outputs)
+                return undefined;
+            const results = [];
+            const searchResults = outputs.searchResults ?? [];
+            for (const entry of searchResults.slice(0, 3)) {
+                results.push({
+                    type: "docdex.search",
+                    query: entry.query,
+                    hits: (entry.hits ?? []).slice(0, 5).map((hit) => ({
+                        path: hit.path,
+                        doc_id: hit.doc_id,
+                        score: hit.score,
+                    })),
+                });
+            }
+            const snippets = outputs.snippets ?? [];
+            for (const snippet of snippets.slice(0, 3)) {
+                if (snippet.doc_id) {
+                    results.push({
+                        type: "docdex.snippet",
+                        doc_id: snippet.doc_id,
+                        content: truncateText(snippet.content ?? "", 600),
+                    });
+                }
+                else if (snippet.path) {
+                    results.push({
+                        type: "docdex.open",
+                        path: snippet.path,
+                        content: truncateText(snippet.content ?? "", 600),
+                    });
+                }
+            }
+            const symbols = outputs.symbols ?? [];
+            for (const symbol of symbols.slice(0, 3)) {
+                results.push({
+                    type: "docdex.symbols",
+                    file: symbol.path,
+                    symbols: { summary: symbol.summary },
+                });
+            }
+            const ast = outputs.ast ?? [];
+            for (const node of ast.slice(0, 2)) {
+                results.push({
+                    type: "docdex.ast",
+                    file: node.path,
+                    nodes: Array.isArray(node.nodes) ? node.nodes.slice(0, 6) : node.nodes,
+                });
+            }
+            const impact = outputs.impact ?? [];
+            for (const entry of impact.slice(0, 3)) {
+                results.push({
+                    type: "docdex.impact",
+                    file: entry.file,
+                    inbound: (entry.inbound ?? []).slice(0, 6),
+                    outbound: (entry.outbound ?? []).slice(0, 6),
+                });
+            }
+            if (!results.length)
+                return undefined;
+            return {
+                version: "v1",
+                request_id: `research-${Date.now()}`,
+                results,
+                meta: {
+                    warnings: uniqueStrings([
+                        ...(phase.warnings ?? []),
+                        ...(phase.evidenceGate?.warnings ?? []),
+                    ]),
+                },
+            };
+        };
+        const formatGbfnMemory = (requestText, phase, quotaAssessment, budgetStatus) => {
+            const findings = buildResearchKeyFindings(phase) ?? [];
+            const blockers = [];
+            if (!quotaAssessment.ok) {
+                blockers.push(`quota_unmet:${quotaAssessment.missing.join(",")}`);
+            }
+            if (budgetStatus?.status !== "met") {
+                blockers.push(`budget_unmet:cycles=${budgetStatus?.cycles ?? 0}/${budgetStatus?.minCycles ?? 0},elapsed_s=${Math.round((budgetStatus?.elapsedMs ?? 0) / 1000)}/${budgetStatus?.minSeconds ?? 0}`);
+            }
+            if (phase.evidenceGate?.status
+                && phase.evidenceGate.status !== "pass"
+                && !isWarningsOnlyEvidenceGateFailure(phase.evidenceGate)) {
+                blockers.push(`evidence_unmet:${(phase.evidenceGate.missing ?? []).join(",")}`);
+            }
+            else if (isWarningsOnlyEvidenceGateFailure(phase.evidenceGate)) {
+                blockers.push("evidence_warning_threshold_exceeded");
+            }
+            const warningList = uniqueStrings([
+                ...(phase.warnings ?? []),
+                ...(phase.evidenceGate?.warnings ?? []),
+            ]);
+            if (warningList.length)
+                blockers.push(`warnings:${warningList.join(",")}`);
+            const facts = [];
+            const relations = [];
+            const goalId = "goal_request";
+            facts.push({ id: goalId, type: "goal", value: requestText, confidence: "high" });
+            if (phase.evidence) {
+                const evidenceId = "research_evidence";
+                facts.push({
+                    id: evidenceId,
+                    type: "evidence",
+                    value: [
+                        `search_hits=${phase.evidence.search_hits}`,
+                        `snippet_count=${phase.evidence.snippet_count}`,
+                        `symbol_files=${phase.evidence.symbol_files}`,
+                        `ast_files=${phase.evidence.ast_files}`,
+                        `impact_files=${phase.evidence.impact_files}`,
+                        `impact_edges=${phase.evidence.impact_edges}`,
+                        `repo_map=${phase.evidence.repo_map ? "yes" : "no"}`,
+                        `dag_summary=${phase.evidence.dag_summary ? "yes" : "no"}`,
+                    ].join(", "),
+                    confidence: "medium",
+                });
+                relations.push({ from: goalId, to: evidenceId, relation: "supported_by" });
+            }
+            findings.slice(0, 6).forEach((finding, index) => {
+                const id = `finding_${index + 1}`;
+                facts.push({ id, type: "finding", value: finding, confidence: "medium" });
+                relations.push({ from: goalId, to: id, relation: "supported_by" });
+            });
+            const researchPaths = collectResearchPaths(phase.outputs);
+            const fileCandidates = researchPaths.search
+                .concat(researchPaths.snippets)
+                .concat(researchPaths.symbols)
+                .concat(researchPaths.impact)
+                .filter(Boolean);
+            const uniqueFiles = uniqueStrings(fileCandidates).slice(0, 6);
+            uniqueFiles.forEach((file, index) => {
+                const id = `file_${index + 1}`;
+                facts.push({ id, type: "file_candidate", value: file, confidence: "medium" });
+                relations.push({ from: goalId, to: id, relation: "potential_target" });
+            });
+            blockers.slice(0, 6).forEach((blocker, index) => {
+                const id = `blocker_${index + 1}`;
+                facts.push({ id, type: "blocker", value: blocker, confidence: "high" });
+                relations.push({ from: goalId, to: id, relation: "blocked_by" });
+            });
+            const memory = {
+                memory: {
+                    facts,
+                    relations,
+                    ttl: {
+                        thread: "ephemeral",
+                        memory: "persistent_opt_in",
+                    },
+                },
+            };
+            return ["GBFN MEMORY v1", JSON.stringify(memory, null, 2)].join("\n");
+        };
+        const emitAgentRequestRecoveryStatus = (reason) => {
+            this.emitStatus("thinking", `architect: AGENT_REQUEST recovery (${reason})`);
+        };
+        const appendLaneHistory = async (laneId, role, content) => {
+            if (!this.options.contextManager || !laneId)
+                return false;
+            if (typeof this.options.contextManager.append !== "function")
+                return false;
+            await this.options.contextManager.append(laneId, { role: "system", content }, { role });
+            return true;
+        };
+        const appendArchitectHistory = async (content) => {
+            await appendLaneHistory(architectLaneId, "architect", content);
+        };
+        const appendBuilderHistory = async (content) => {
+            await appendLaneHistory(builderLaneId, "builder", content);
+        };
+        const appendCriticHistory = async (content) => {
+            await appendLaneHistory(criticLaneId, "critic", content);
+        };
+        const appendProtocolToLanes = async (content, label) => {
+            const appended = [];
+            if (await appendLaneHistory(architectLaneId, "architect", content)) {
+                appended.push("architect");
+            }
+            if (await appendLaneHistory(builderLaneId, "builder", content)) {
+                appended.push("builder");
+            }
+            if (await appendLaneHistory(criticLaneId, "critic", content)) {
+                appended.push("critic");
+            }
+            if (appended.length) {
+                this.emitStatus("thinking", `${label}: appended to ${appended.join(", ")}`);
+            }
+        };
+        const logPlanHintSuppressed = async (hint) => {
+            if (!deepMode || planHintSuppressedLogged)
+                return;
+            if (typeof hint !== "string" || hint.trim().length === 0)
+                return;
+            if (!this.options.logger)
+                return;
+            await this.options.logger.log("plan_hint_suppressed", {
+                reason: "deep_mode",
+            });
+            planHintSuppressedLogged = true;
+        };
+        if (deepMode) {
+            await logPlanHintSuppressed(configuredPlanHint);
+        }
+        const buildApplyFailureResponse = (failure) => ({
+            version: "v1",
+            request_id: `apply-failure-${Date.now()}`,
+            results: [
+                {
+                    type: "patch.apply_failure",
+                    error: failure.error,
+                    patches: failure.patches.map((patch) => patch.file),
+                    rollback: failure.rollback,
+                },
+            ],
+            meta: {
+                warnings: ["patch_apply_failed"],
+            },
+        });
+        const buildCriticResponse = (critic) => ({
+            version: "v1",
+            request_id: `critic-${Date.now()}`,
+            results: [
+                {
+                    type: "critic.result",
+                    status: critic.report?.status ?? critic.status,
+                    reasons: critic.report?.reasons ?? critic.reasons,
+                    suggested_fixes: critic.report?.suggested_fixes ?? [],
+                    touched_files: critic.report?.touched_files,
+                    plan_targets: critic.report?.plan_targets,
+                    guardrail: critic.report?.guardrail ?? critic.guardrail,
+                    high_confidence: critic.report?.high_confidence ?? critic.high_confidence ?? false,
+                    verification: critic.report?.verification ?? critic.verification,
+                },
+            ],
+            meta: {
+                warnings: critic.status === "FAIL" ? ["critic_failed"] : undefined,
+            },
+        });
+        const runDeepResearchPhase = async (bundle, reason) => {
+            await logPhaseArtifact("research", "input", {
+                request,
+                context_digest: bundle.request_digest ?? null,
+                focus_files: bundle.selection?.focus ?? [],
+                queries: bundle.queries ?? [],
+                reason: reason ?? null,
+            });
+            const resolvedQuota = resolveToolQuota(this.options.deepInvestigation?.toolQuota);
+            const resolvedBudget = resolveInvestigationBudget(this.options.deepInvestigation?.investigationBudget);
+            const resolvedEvidenceGate = resolveEvidenceGate(this.options.deepInvestigation?.evidenceGate);
+            const minCycles = Math.max(0, Math.floor(resolvedBudget.minCycles ?? 0));
+            const minSeconds = Math.max(0, resolvedBudget.minSeconds ?? 0);
+            const maxCycles = Math.max(0, Math.floor(resolvedBudget.maxCycles ?? minCycles));
+            const researchStartedAt = Date.now();
+            const notes = [];
+            const pushNote = (note) => {
+                if (!notes.includes(note))
+                    notes.push(note);
+            };
+            const phaseResult = await this.runPhase("research", async () => {
+                const researchRunner = this.options.contextAssembler;
+                const outputs = {
+                    searchResults: [],
+                    snippets: [],
+                    symbols: [],
+                    ast: [],
+                    impact: [],
+                    impactDiagnostics: [],
+                };
+                const toolRuns = [];
+                const warnings = [];
+                const buildEvidenceGateAssessment = () => {
+                    const evidence = buildResearchEvidence(outputs, warnings);
+                    const toolUsage = buildResearchToolUsage(toolRuns);
+                    const evidenceGate = evaluateEvidenceGate({
+                        config: resolvedEvidenceGate,
+                        evidence,
+                        toolUsage,
+                        warnings,
+                    });
+                    return { evidence, toolUsage, evidenceGate };
+                };
+                if (typeof researchRunner.runResearchTools !== "function") {
+                    warnings.push("research_executor_missing");
+                    const { evidence, toolUsage, evidenceGate } = buildEvidenceGateAssessment();
+                    return {
+                        status: "completed",
+                        startedAt: researchStartedAt,
+                        warnings: uniqueStrings(warnings),
+                        toolRuns: [],
+                        outputs,
+                        cycles: 0,
+                        budget: {
+                            status: "unmet",
+                            minCycles,
+                            minSeconds,
+                            maxCycles,
+                            elapsedMs: 0,
+                            cycles: 0,
+                        },
+                        evidence,
+                        toolUsage,
+                        evidenceGate,
+                    };
+                }
+                let cycles = 0;
+                let researchContext = bundle;
+                let lastRefreshSignature = "";
+                let lastEvidenceSignature = "";
+                let stalledEvidenceCycles = 0;
+                while (true) {
+                    cycles += 1;
+                    const execution = await researchRunner.runResearchTools(request, researchContext);
+                    toolRuns.push(...execution.toolRuns);
+                    warnings.push(...execution.warnings);
+                    outputs.searchResults.push(...execution.outputs.searchResults);
+                    outputs.snippets.push(...execution.outputs.snippets);
+                    outputs.symbols.push(...execution.outputs.symbols);
+                    outputs.ast.push(...execution.outputs.ast);
+                    outputs.impact.push(...execution.outputs.impact);
+                    outputs.impactDiagnostics.push(...execution.outputs.impactDiagnostics);
+                    if (execution.outputs.repoMap)
+                        outputs.repoMap = execution.outputs.repoMap;
+                    if (execution.outputs.repoMapRaw)
+                        outputs.repoMapRaw = execution.outputs.repoMapRaw;
+                    if (execution.outputs.dagSummary)
+                        outputs.dagSummary = execution.outputs.dagSummary;
+                    const elapsedMs = Date.now() - researchStartedAt;
+                    const quotaAssessment = buildToolQuotaAssessment(toolRuns, resolvedQuota);
+                    const quotaRecoverable = isRecoverableQuotaFailure(quotaAssessment, warnings);
+                    const quotaMet = quotaAssessment.ok || quotaRecoverable;
+                    const budgetMet = cycles >= minCycles && elapsedMs >= minSeconds * 1000;
+                    const { evidence, toolUsage, evidenceGate } = buildEvidenceGateAssessment();
+                    const evidenceMet = evidenceGate.status === "pass"
+                        || isWarningsOnlyEvidenceGateFailure(evidenceGate);
+                    const needsMore = !budgetMet || !quotaMet || !evidenceMet;
+                    if (quotaMet
+                        && evidenceMet
+                        && !budgetMet
+                        && minSeconds > 0
+                        && cycles >= minCycles) {
+                        const remainingMs = minSeconds * 1000 - elapsedMs;
+                        if (remainingMs > 0) {
+                            await new Promise((resolve) => setTimeout(resolve, remainingMs));
+                        }
+                        const waitedElapsed = Date.now() - researchStartedAt;
+                        return {
+                            status: "completed",
+                            startedAt: researchStartedAt,
+                            warnings: uniqueStrings(warnings),
+                            toolRuns,
+                            outputs,
+                            cycles,
+                            budget: {
+                                status: "met",
+                                minCycles,
+                                minSeconds,
+                                maxCycles,
+                                elapsedMs: waitedElapsed,
+                                cycles,
+                            },
+                            evidence,
+                            toolUsage,
+                            evidenceGate,
+                        };
+                    }
+                    if (!needsMore || cycles >= maxCycles) {
+                        return {
+                            status: "completed",
+                            startedAt: researchStartedAt,
+                            warnings: uniqueStrings(warnings),
+                            toolRuns,
+                            outputs,
+                            cycles,
+                            budget: {
+                                status: budgetMet ? "met" : "unmet",
+                                minCycles,
+                                minSeconds,
+                                maxCycles,
+                                elapsedMs,
+                                cycles,
+                            },
+                            evidence,
+                            toolUsage,
+                            evidenceGate,
+                        };
+                    }
+                    const refresh = buildResearchContextRefresh(researchContext, outputs, evidenceGate.missing);
+                    const { warnings: _ignoredWarnings, gaps: _ignoredGaps, ...evidenceCore } = evidence;
+                    const evidenceSignature = createHash("sha1")
+                        .update(JSON.stringify({ evidence: evidenceCore, toolUsage }))
+                        .digest("hex");
+                    const evidenceUnchanged = evidenceSignature === lastEvidenceSignature;
+                    if (!evidenceUnchanged) {
+                        lastEvidenceSignature = evidenceSignature;
+                        stalledEvidenceCycles = 0;
+                    }
+                    if (!refresh.changed) {
+                        warnings.push("research_stalled_no_new_inputs");
+                        if (evidenceUnchanged) {
+                            stalledEvidenceCycles += 1;
+                            warnings.push("research_no_new_evidence");
+                            pushNote(`Research cycle ${cycles} produced no new evidence; stopping additional tool calls.`);
+                            if (cycles >= minCycles) {
+                                const remainingMs = minSeconds * 1000 - elapsedMs;
+                                if (remainingMs > 0) {
+                                    await new Promise((resolve) => setTimeout(resolve, remainingMs));
+                                }
+                                const waitedElapsed = Date.now() - researchStartedAt;
+                                return {
+                                    status: "completed",
+                                    startedAt: researchStartedAt,
+                                    warnings: uniqueStrings(warnings),
+                                    toolRuns,
+                                    outputs,
+                                    cycles,
+                                    budget: {
+                                        status: waitedElapsed >= minSeconds * 1000 ? "met" : "unmet",
+                                        minCycles,
+                                        minSeconds,
+                                        maxCycles,
+                                        elapsedMs: waitedElapsed,
+                                        cycles,
+                                    },
+                                    evidence,
+                                    toolUsage,
+                                    evidenceGate,
+                                };
+                            }
+                        }
+                        if (needsMore && cycles >= minCycles && evidenceMet && quotaMet) {
+                            return {
+                                status: "completed",
+                                startedAt: researchStartedAt,
+                                warnings: uniqueStrings(warnings),
+                                toolRuns,
+                                outputs,
+                                cycles,
+                                budget: {
+                                    status: budgetMet ? "met" : "unmet",
+                                    minCycles,
+                                    minSeconds,
+                                    maxCycles,
+                                    elapsedMs,
+                                    cycles,
+                                },
+                                evidence,
+                                toolUsage,
+                                evidenceGate,
+                            };
+                        }
+                    }
+                    else {
+                        if (evidenceUnchanged) {
+                            stalledEvidenceCycles = 0;
+                        }
+                        const signature = JSON.stringify({
+                            queries: refresh.context.queries ?? [],
+                            focus: refresh.context.selection?.focus ?? [],
+                        });
+                        if (signature === lastRefreshSignature) {
+                            warnings.push("research_stalled_no_new_inputs");
+                        }
+                        else {
+                            lastRefreshSignature = signature;
+                            researchContext = refresh.context;
+                        }
+                    }
+                }
+            });
+            const researchEndedAt = Date.now();
+            const evidence = phaseResult.evidence ??
+                buildResearchEvidence(phaseResult.outputs, phaseResult.warnings);
+            const researchToolUsage = phaseResult.toolUsage ?? buildResearchToolUsage(phaseResult.toolRuns);
+            const evidenceGate = phaseResult.evidenceGate ??
+                evaluateEvidenceGate({
+                    config: resolvedEvidenceGate,
+                    evidence,
+                    toolUsage: researchToolUsage,
+                    warnings: phaseResult.warnings,
+                });
+            const mergedNotes = uniqueStrings([...(phaseResult.notes ?? []), ...notes]);
+            const researchPhase = {
+                ...phaseResult,
+                endedAt: researchEndedAt,
+                durationMs: researchEndedAt - researchStartedAt,
+                evidence,
+                toolUsage: researchToolUsage,
+                evidenceGate,
+                notes: mergedNotes.length ? mergedNotes : undefined,
+            };
+            await logPhaseArtifact("research", "output", researchPhase);
+            const toolUsage = buildToolUsageSummary(researchPhase.toolRuns);
+            const quotaAssessment = buildToolQuotaAssessment(researchPhase.toolRuns, resolvedQuota);
+            const quotaRecoverable = isRecoverableQuotaFailure(quotaAssessment, uniqueStrings([
+                ...(researchPhase.warnings ?? []),
+                ...(researchPhase.evidenceGate?.warnings ?? []),
+            ]));
+            const quotaMet = quotaAssessment.ok || quotaRecoverable;
+            const budgetStatus = researchPhase.budget ?? {
+                status: "unmet",
+                minCycles,
+                minSeconds,
+                maxCycles,
+                elapsedMs: researchPhase.durationMs ?? 0,
+                cycles: researchPhase.cycles ?? 0,
+            };
+            const researchProtocol = buildResearchProtocolResponse(researchPhase);
+            if (researchProtocol) {
+                await appendProtocolToLanes(formatCodaliResponse(researchProtocol), "research protocol");
+            }
+            await appendProtocolToLanes(formatGbfnMemory(request, researchPhase, quotaAssessment, budgetStatus), "research memory");
+            if (this.options.logger) {
+                const evidenceGate = researchPhase.evidenceGate ?? {
+                    status: "not_checked",
+                    reason: "evidence_gate_not_enforced",
+                };
+                const quota = {
+                    status: quotaMet ? "met" : "unmet",
+                    missing: quotaAssessment.missing,
+                    required: quotaAssessment.required,
+                    observed: quotaAssessment.observed,
+                };
+                const budget = {
+                    status: budgetStatus.status,
+                    required_cycles: budgetStatus.minCycles,
+                    cycles: budgetStatus.cycles,
+                    required_ms: budgetStatus.minSeconds * 1000,
+                    elapsed_ms: budgetStatus.elapsedMs,
+                };
+                const summary = [
+                    `Research ${researchPhase.status} in ${researchPhase.durationMs ?? 0}ms.`,
+                    `Cycles: ${budgetStatus.cycles}/${budgetStatus.minCycles}.`,
+                    `Tools: ${formatToolUsageSummary(toolUsage)}.`,
+                    `Evidence gate: ${evidenceGate.status}.`,
+                    `Quota: ${quota.status}.`,
+                    `Budget: ${budget.status}.`,
+                ].join(" ");
+                await this.options.logger.log("investigation_telemetry", {
+                    phase: "research",
+                    status: researchPhase.status,
+                    duration_ms: researchPhase.durationMs ?? 0,
+                    tool_usage: toolUsage.byTool,
+                    tool_usage_totals: toolUsage.totals,
+                    evidence_gate: evidenceGate,
+                    quota,
+                    budget,
+                    warnings: researchPhase.warnings,
+                    summary,
+                });
+            }
+            if (!quotaAssessment.ok) {
+                if (quotaRecoverable) {
+                    if (this.options.logger) {
+                        await this.options.logger.log("investigation_quota_warning_tolerated", {
+                            status: "degraded",
+                            missing: quotaAssessment.missing,
+                            required: quotaAssessment.required,
+                            observed: quotaAssessment.observed,
+                        });
+                    }
+                }
+                else {
+                    if (this.options.logger) {
+                        await this.options.logger.log("investigation_quota_failed", {
+                            status: "unmet",
+                            missing: quotaAssessment.missing,
+                            required: quotaAssessment.required,
+                            observed: quotaAssessment.observed,
+                        });
+                    }
+                    throw createDeepInvestigationQuotaError({
+                        missing: quotaAssessment.missing,
+                        required: quotaAssessment.required,
+                        observed: quotaAssessment.observed,
+                    });
+                }
+            }
+            if (budgetStatus.status !== "met") {
+                if (this.options.logger) {
+                    await this.options.logger.log("investigation_budget_failed", {
+                        status: "unmet",
+                        required_cycles: budgetStatus.minCycles,
+                        cycles: budgetStatus.cycles,
+                        required_ms: budgetStatus.minSeconds * 1000,
+                        elapsed_ms: budgetStatus.elapsedMs,
+                    });
+                }
+                throw createDeepInvestigationBudgetError({
+                    minCycles: budgetStatus.minCycles,
+                    minSeconds: budgetStatus.minSeconds,
+                    maxCycles: budgetStatus.maxCycles,
+                    cycles: budgetStatus.cycles,
+                    elapsedMs: budgetStatus.elapsedMs,
+                });
+            }
+            if (researchPhase.evidenceGate?.status !== "pass") {
+                const warningsOnlyFailure = isWarningsOnlyEvidenceGateFailure(researchPhase.evidenceGate);
+                if (warningsOnlyFailure) {
+                    if (this.options.logger) {
+                        await this.options.logger.log("investigation_evidence_warning_tolerated", {
+                            status: "degraded",
+                            missing: researchPhase.evidenceGate?.missing ?? [],
+                            required: researchPhase.evidenceGate?.required ?? {},
+                            observed: researchPhase.evidenceGate?.observed ?? {},
+                            warnings: researchPhase.evidenceGate?.warnings ?? [],
+                            gaps: researchPhase.evidenceGate?.gaps ?? [],
+                        });
+                    }
+                }
+                else {
+                    if (this.options.logger) {
+                        await this.options.logger.log("investigation_evidence_failed", {
+                            status: "unmet",
+                            missing: researchPhase.evidenceGate?.missing ?? [],
+                            required: researchPhase.evidenceGate?.required ?? {},
+                            observed: researchPhase.evidenceGate?.observed ?? {},
+                            warnings: researchPhase.evidenceGate?.warnings ?? [],
+                            gaps: researchPhase.evidenceGate?.gaps ?? [],
+                        });
+                    }
+                    const emptyEvidenceMetrics = {
+                        search_hits: 0,
+                        open_or_snippet: 0,
+                        symbols_or_ast: 0,
+                        impact: 0,
+                        warnings: 0,
+                    };
+                    throw createDeepInvestigationEvidenceError({
+                        missing: researchPhase.evidenceGate?.missing ?? [],
+                        required: researchPhase.evidenceGate?.required ?? emptyEvidenceMetrics,
+                        observed: researchPhase.evidenceGate?.observed ?? emptyEvidenceMetrics,
+                        warnings: researchPhase.evidenceGate?.warnings ?? [],
+                        gaps: researchPhase.evidenceGate?.gaps ?? [],
+                    });
+                }
+            }
+            return researchPhase;
+        };
+        let context;
+        if (this.options.initialContext) {
+            await logPhaseArtifact("librarian", "input", { request });
+            const preflightContext = this.options.initialContext;
+            context = await this.runPhase("librarian", async () => preflightContext);
+            await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+            this.emitStatus("thinking", "librarian: using preflight context");
+        }
+        else {
+            await logPhaseArtifact("librarian", "input", { request });
+            context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request));
+            await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+        }
+        if (this.options.logger) {
+            const files = context.files ?? [];
+            const focusCount = files.filter((file) => file.role === "focus").length;
+            const peripheryCount = files.filter((file) => file.role === "periphery").length;
+            const retrievalReport = context.retrieval_report;
+            await this.options.logger.log("context_summary", {
+                focusCount,
+                peripheryCount,
+                serializedMode: context.serialized?.mode ?? null,
+                serializedBytes: context.serialized?.content.length ?? 0,
+                warnings: context.warnings.length,
+                redactionCount: context.redaction?.count ?? 0,
+                ignoredFiles: context.redaction?.ignored ?? [],
+                retrievalDisposition: context.retrieval_disposition ?? null,
+                retrievalConfidence: retrievalReport?.confidence ?? null,
+                retrievalUnresolvedGaps: retrievalReport?.unresolved_gaps ?? [],
+                retrievalToolExecution: retrievalReport?.tool_execution ?? [],
+            });
+            if (retrievalReport) {
+                await this.options.logger.log("retrieval_report", {
+                    schema_version: retrievalReport.schema_version,
+                    mode: retrievalReport.mode,
+                    confidence: retrievalReport.confidence,
+                    disposition: retrievalReport.disposition,
+                    preflight: retrievalReport.preflight,
+                    selection: retrievalReport.selection,
+                    dropped: retrievalReport.dropped,
+                    truncated: retrievalReport.truncated,
+                    unresolved_gaps: retrievalReport.unresolved_gaps,
+                    tool_execution: retrievalReport.tool_execution,
+                    capabilities: retrievalReport.capabilities ?? null,
+                    warnings: retrievalReport.warnings,
+                });
+                await logPhaseArtifact("retrieve", "retrieval_report", retrievalReport);
+            }
+        }
+        let researchPhase = {
+            status: "skipped",
+            warnings: [],
+            toolRuns: [],
+        };
+        if (deepMode) {
+            researchPhase = await runDeepResearchPhase(context, "initial");
+            const researchSummary = buildResearchSummary(researchPhase);
+            if (researchSummary) {
+                const updated = { ...context, research: researchSummary };
+                updated.serialized = buildSerializedContext(updated);
+                context = updated;
+            }
+        }
+        let contextSignature = buildContextSignature(context);
+        const updateContextSignature = async (reason, pass, extra = {}) => {
+            const nextSignature = buildContextSignature(context);
+            if (nextSignature === contextSignature) {
+                if (this.options.logger) {
+                    await this.options.logger.log("architect_retry_skipped_no_new_context", {
+                        pass,
+                        reason,
+                        ...extra,
+                    });
+                }
+                return false;
+            }
+            contextSignature = nextSignature;
+            return true;
+        };
+        const configuredFastPath = this.options.fastPath?.(request) ?? false;
+        const useFastPath = deepMode ? false : configuredFastPath;
+        if (deepMode && configuredFastPath && this.options.logger) {
+            await this.options.logger.log("fast_path_overridden", {
+                reason: "deep_mode",
+            });
+        }
+        let lastPlanHintUsed;
+        const runArchitectPass = async (pass, options = {}) => {
+            const planner = this.options.architectPlanner;
+            const hasPlanHintOverride = Object.prototype.hasOwnProperty.call(options, "planHint");
+            const effectivePlanHint = deepMode
+                ? undefined
+                : hasPlanHintOverride
+                    ? options.planHint
+                    : configuredPlanHint;
+            if (deepMode) {
+                await logPlanHintSuppressed(options.planHint);
+            }
+            lastPlanHintUsed = effectivePlanHint;
+            const architectContext = options.contextOverride ?? context;
+            await logPhaseArtifact("architect", "input", {
+                pass,
+                request,
+                context: buildSerializedContext(architectContext),
+                plan_hint: effectivePlanHint ?? null,
+                instruction_hint: options.instructionHint ?? null,
+                validate_only: options.validateOnly ?? false,
+            });
+            const buildPlannerOptions = (extra = {}) => {
+                const baseOptions = {
+                    contextManager: this.options.contextManager,
+                    laneId: architectLaneId,
+                    instructionHint: options.instructionHint,
+                    responseFormat: options.responseFormat,
+                    ...extra,
+                };
+                if (deepMode || hasPlanHintOverride) {
+                    baseOptions.planHint = effectivePlanHint;
+                }
+                return baseOptions;
+            };
+            if (planner.planWithRequest) {
+                try {
+                    return await this.runPhase("architect", () => planner.planWithRequest(architectContext, buildPlannerOptions({
+                        validateOnly: options.validateOnly ?? false,
+                    })));
+                }
+                catch (error) {
+                    if (options.validateOnly && error instanceof PlanHintValidationError) {
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_plan_hint_validate_fallback", {
+                                pass,
+                                issues: error.issues,
+                                warnings: error.warnings,
+                                parseError: error.parseError,
+                            });
+                        }
+                        lastPlanHintUsed = undefined;
+                        return this.runPhase("architect", () => planner.planWithRequest(architectContext, {
+                            contextManager: this.options.contextManager,
+                            laneId: architectLaneId,
+                            planHint: "",
+                            instructionHint: options.instructionHint,
+                            validateOnly: false,
+                            responseFormat: options.responseFormat,
+                        }));
+                    }
+                    throw error;
+                }
+            }
+            const plan = await this.runPhase("architect", () => planner.plan(architectContext, buildPlannerOptions()));
+            return { plan, raw: "", warnings: [] };
+        };
+        let plan;
+        if (useFastPath) {
+            const fastPathResult = await this.runPhase("architect", async () => ({
+                plan: buildFastPlan(context),
+                raw: "",
+                warnings: [],
+            }));
+            plan = fastPathResult.plan;
+            await logPhaseArtifact("architect", "output", {
+                pass: 0,
+                source: "fast_path",
+                raw_output: fastPathResult.raw,
+                normalized_output: plan,
+                warnings: fastPathResult.warnings ?? [],
+            });
+        }
+        else {
+            let pass = 1;
+            let lastPlan;
+            const allowAutoRetry = false;
+            const maxRequestRecovery = 1;
+            const maxPasses = 1 + maxRequestRecovery;
+            const reflectionHint = "REFINE the previous plan. Re-check constraints and request specificity. Output full plain-text sections (WHAT IS REQUIRED, CURRENT CONTEXT, FOLDER STRUCTURE, FILES TO TOUCH, IMPLEMENTATION PLAN, RISK, VERIFY).";
+            let strictRetryTriggered = false;
+            let verificationRetryTriggered = false;
+            let fallbackRecoveryTriggered = false;
+            let previousPlanHash;
+            let previousConcreteTargets;
+            let alternateStrategyUsed = false;
+            let alternateHintPending = false;
+            let structuralRecoveryTriggered = false;
+            let driftRecoveryTriggered = false;
+            let invalidTargetRecoveryTriggered = false;
+            let requestRecoveryCount = 0;
+            let previousRequestFingerprint;
+            let requestRecoveryPending = false;
+            let pendingRevisionHint;
+            while (pass <= maxPasses) {
+                if (pass > 1 && !allowAutoRetry && !requestRecoveryPending) {
+                    break;
+                }
+                const strictRetryPass = allowAutoRetry && strictRetryTriggered && pass === 2;
+                const recoveryPass = allowAutoRetry && maxPasses > 1 && pass === maxPasses;
+                const hintParts = [];
+                if (pendingRevisionHint?.trim()) {
+                    hintParts.push(pendingRevisionHint.trim());
+                    pendingRevisionHint = undefined;
+                }
+                if (allowAutoRetry && pass > 1)
+                    hintParts.push(reflectionHint);
+                if (strictRetryPass)
+                    hintParts.push(ARCHITECT_STRICT_DSL_HINT);
+                if (verificationRetryTriggered)
+                    hintParts.push(ARCHITECT_VERIFY_QUALITY_HINT);
+                if (recoveryPass)
+                    hintParts.push(ARCHITECT_RECOVERY_HINT);
+                if (alternateHintPending) {
+                    hintParts.push(ARCHITECT_ALTERNATE_RETRY_HINT);
+                    alternateHintPending = false;
+                }
+                const instructionHint = hintParts.length > 0 ? hintParts.join("\n\n") : undefined;
+                const passContext = strictRetryPass
+                    ? narrowContextForStrictArchitectRetry(context)
+                    : context;
+                const responseFormat = undefined;
+                const result = await runArchitectPass(pass, {
+                    instructionHint,
+                    contextOverride: passContext,
+                    validateOnly: pass === 1,
+                    responseFormat,
+                });
+                const warnings = [...(result.warnings ?? [])];
+                const planHash = hashArchitectResult(result);
+                const classification = classifyArchitectWarnings(warnings);
+                const repairApplied = hasRepairWarnings(warnings);
+                const qualityGate = assessPlanQualityGate(request, result.plan, passContext);
+                const structuralGrounding = assessStructuralGrounding(passContext, result.plan);
+                const targetDrift = assessTargetDrift(previousConcreteTargets, qualityGate.concreteTargets);
+                const nonDsl = isArchitectNonDsl(warnings);
+                if (result.request) {
+                    if (nonDsl && pass === 1 && allowAutoRetry) {
+                        strictRetryTriggered = true;
+                    }
+                    requestRecoveryCount += 1;
+                    const requestFingerprint = hashAgentRequestShape(result.request);
+                    const repeatedRequest = previousRequestFingerprint === requestFingerprint;
+                    previousRequestFingerprint = requestFingerprint;
+                    if (repeatedRequest && !alternateStrategyUsed) {
+                        alternateStrategyUsed = true;
+                        alternateHintPending = true;
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_retry_strategy", {
+                                pass,
+                                action: "repeat_request_with_alternate_hint",
+                                request_recovery_count: requestRecoveryCount,
+                            });
+                        }
+                    }
+                    emitAgentRequestRecoveryStatus("architect_request");
+                    const response = await this.options.contextAssembler.fulfillAgentRequest(result.request);
+                    const responseText = formatCodaliResponse(response);
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_request_fulfilled", {
+                            request_id: result.request.request_id,
+                            results: response.results.length,
+                            warnings: response.meta?.warnings ?? [],
+                        });
+                    }
+                    await appendArchitectHistory(responseText);
+                    await logPhaseArtifact("architect", "output", buildArchitectOutputArtifactPayload({
+                        pass,
+                        strictRetry: strictRetryPass,
+                        planHint: lastPlanHintUsed,
+                        instructionHint,
+                        result,
+                        requestResponse: response,
+                        source: "architect_request",
+                        planHash,
+                        classification,
+                        repairApplied,
+                        recoveryAction: "architect_request_fulfilled",
+                        structuralGrounding,
+                        targetDrift,
+                        responseFormat,
+                    }));
+                    let contextRefreshed = false;
+                    if (pass < maxPasses && requestRecoveryCount <= maxRequestRecovery) {
+                        let refreshInputs = extractAgentRequestContextInputs(result.request);
+                        if (typeof this.options.contextAssembler.buildContextRefreshOptions === "function") {
+                            try {
+                                refreshInputs = this.options.contextAssembler.buildContextRefreshOptions(result.request);
+                            }
+                            catch (error) {
+                                if (this.options.logger) {
+                                    await this.options.logger.log("architect_request_refresh_failed", {
+                                        request_id: result.request.request_id,
+                                        error: error instanceof Error ? error.message : String(error),
+                                    });
+                                }
+                            }
+                        }
+                        const additionalQueries = uniqueStrings(refreshInputs.additionalQueries ?? []);
+                        const preferredFiles = uniqueStrings(refreshInputs.preferredFiles ?? []);
+                        const recentFiles = uniqueStrings([
+                            ...(context.selection?.all ?? []),
+                            ...preferredFiles,
+                        ]).slice(0, 24);
+                        await logPhaseArtifact("librarian", "input", {
+                            request,
+                            reason: "architect_request",
+                            request_id: result.request.request_id,
+                            additional_queries: additionalQueries,
+                            preferred_files: preferredFiles,
+                        });
+                        context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                            additionalQueries,
+                            preferredFiles,
+                            recentFiles,
+                        }));
+                        await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                        if (deepMode) {
+                            researchPhase = await runDeepResearchPhase(context, "architect_request");
+                            const researchSummary = buildResearchSummary(researchPhase);
+                            if (researchSummary) {
+                                const updated = { ...context, research: researchSummary };
+                                updated.serialized = buildSerializedContext(updated);
+                                context = updated;
+                            }
+                        }
+                        contextRefreshed = await updateContextSignature("architect_request", pass, {
+                            request_id: result.request.request_id,
+                        });
+                    }
+                    if (pass < maxPasses
+                        && requestRecoveryCount <= maxRequestRecovery
+                        && !contextRefreshed) {
+                        warnings.push("architect_retry_skipped_no_new_context");
+                        lastPlan = { ...result, warnings: uniqueStrings(warnings) };
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_degraded", {
+                                pass,
+                                reason: "request_loop_no_new_context",
+                                request_recovery_count: requestRecoveryCount,
+                                warnings: uniqueStrings(warnings),
+                            });
+                        }
+                        break;
+                    }
+                    if (pass >= maxPasses || requestRecoveryCount > maxRequestRecovery) {
+                        warnings.push("architect_degraded_request_loop");
+                        lastPlan = { ...result, warnings: uniqueStrings(warnings) };
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_degraded", {
+                                pass,
+                                reason: "request_loop_after_recovery",
+                                request_recovery_count: requestRecoveryCount,
+                                warnings: uniqueStrings(warnings),
+                            });
+                        }
+                        break;
+                    }
+                    const requestRecoveryDetails = buildArchitectRequestRevisionDetails(result.request, warnings);
+                    pendingRevisionHint = buildArchitectRevisionHint({
+                        reason: "architect_request_recovery",
+                        details: requestRecoveryDetails.length > 0
+                            ? requestRecoveryDetails
+                            : ["Architect requested extra context; revise the prior plan with the new context."],
+                        plan: result.plan,
+                    });
+                    requestRecoveryPending = true;
+                    pass += 1;
+                    continue;
+                }
+                requestRecoveryPending = false;
+                requestRecoveryCount = 0;
+                previousRequestFingerprint = undefined;
+                lastPlan = result;
+                if (this.options.logger) {
+                    await this.options.logger.log("architect_output", {
+                        steps: result.plan.steps.length,
+                        target_files: result.plan.target_files.length,
+                        pass,
+                        warnings,
+                        strict_retry: strictRetryPass,
+                        classification,
+                        repair_applied: repairApplied,
+                        structural_grounding_score: structuralGrounding.score,
+                        structural_grounding_reasons: structuralGrounding.reasons,
+                        target_drift: targetDrift.drift,
+                        target_similarity: targetDrift.similarity,
+                    });
+                }
+                await logPhaseArtifact("architect", "output", buildArchitectOutputArtifactPayload({
+                    pass,
+                    strictRetry: strictRetryPass,
+                    planHint: lastPlanHintUsed,
+                    instructionHint,
+                    result,
+                    planHash,
+                    classification,
+                    repairApplied,
+                    qualityGate,
+                    structuralGrounding,
+                    targetDrift,
+                    responseFormat,
+                }));
+                const repeatedOutput = previousPlanHash === planHash;
+                if (allowAutoRetry && nonDsl && pass === 1) {
+                    previousPlanHash = planHash;
+                    previousConcreteTargets = qualityGate.concreteTargets;
+                    strictRetryTriggered = true;
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_non_dsl_detected", {
+                            pass,
+                            warnings,
+                            action: "strict_retry",
+                        });
+                    }
+                    pass += 1;
+                    continue;
+                }
+                if (nonDsl && strictRetryPass) {
+                    if (allowAutoRetry && pass < maxPasses) {
+                        const recovery = buildFallbackRecoveryRequest(request, context, pass);
+                        emitAgentRequestRecoveryStatus("non_dsl_repeated_after_strict_retry");
+                        const response = await this.options.contextAssembler.fulfillAgentRequest(recovery.requestPayload);
+                        await appendArchitectHistory(formatCodaliResponse(response));
+                        await logPhaseArtifact("architect", "output", {
+                            request_id: recovery.requestPayload.request_id,
+                            response,
+                            source: "non_dsl_recovery",
+                        });
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_guardrail_request", {
+                                pass,
+                                reason: "non_dsl_repeated_after_strict_retry",
+                                request_id: recovery.requestPayload.request_id,
+                                warnings,
+                            });
+                        }
+                        await logPhaseArtifact("librarian", "input", {
+                            request,
+                            reason: "architect_non_dsl_recovery",
+                            additional_queries: recovery.additionalQueries,
+                            preferred_files: recovery.preferredFiles,
+                        });
+                        context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                            additionalQueries: recovery.additionalQueries,
+                            preferredFiles: recovery.preferredFiles,
+                            recentFiles: recovery.recentFiles,
+                        }));
+                        await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                        const contextRefreshed = await updateContextSignature("non_dsl_recovery", pass, { request_id: recovery.requestPayload.request_id });
+                        if (!contextRefreshed) {
+                            warnings.push("architect_retry_skipped_no_new_context");
+                            warnings.push("architect_degraded_non_dsl");
+                            lastPlan = { ...result, warnings: uniqueStrings(warnings) };
+                            if (this.options.logger) {
+                                await this.options.logger.log("architect_degraded", {
+                                    pass,
+                                    reason: "non_dsl_recovery_no_new_context",
+                                    warnings: uniqueStrings(warnings),
+                                });
+                            }
+                            break;
+                        }
+                        fallbackRecoveryTriggered = true;
+                        previousPlanHash = undefined;
+                        previousConcreteTargets = qualityGate.concreteTargets;
+                        pass += 1;
+                        continue;
+                    }
+                    warnings.push("architect_degraded_non_dsl");
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_degraded", {
+                            pass,
+                            reason: "non_dsl_repeated_after_strict_retry",
+                            warnings,
+                        });
+                    }
+                    break;
+                }
+                if (nonDsl && recoveryPass) {
+                    warnings.push("architect_degraded_non_dsl");
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_degraded", {
+                            pass,
+                            reason: "non_dsl_after_recovery_pass",
+                            warnings,
+                        });
+                    }
+                    break;
+                }
+                if (!structuralGrounding.ok) {
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_structural_grounding", {
+                            pass,
+                            ok: false,
+                            score: structuralGrounding.score,
+                            reasons: structuralGrounding.reasons,
+                            warning_hits: structuralGrounding.warningHits,
+                            has_focus: structuralGrounding.hasFocus,
+                            has_structural_signals: structuralGrounding.hasStructuralSignals,
+                            has_fallback_signals: structuralGrounding.hasFallbackSignals,
+                        });
+                    }
+                    if (allowAutoRetry && pass < maxPasses && !structuralRecoveryTriggered) {
+                        const recovery = buildFallbackRecoveryRequest(request, context, pass);
+                        emitAgentRequestRecoveryStatus("weak_structural_grounding");
+                        const response = await this.options.contextAssembler.fulfillAgentRequest(recovery.requestPayload);
+                        await appendArchitectHistory(formatCodaliResponse(response));
+                        await logPhaseArtifact("architect", "output", {
+                            request_id: recovery.requestPayload.request_id,
+                            response,
+                            source: "structural_grounding_recovery",
+                            structural_grounding: structuralGrounding,
+                        });
+                        await logPhaseArtifact("librarian", "input", {
+                            request,
+                            reason: "architect_structural_grounding",
+                            additional_queries: recovery.additionalQueries,
+                            preferred_files: recovery.preferredFiles,
+                        });
+                        context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                            additionalQueries: recovery.additionalQueries,
+                            preferredFiles: recovery.preferredFiles,
+                            recentFiles: recovery.recentFiles,
+                        }));
+                        await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                        const contextRefreshed = await updateContextSignature("structural_grounding_recovery", pass, { request_id: recovery.requestPayload.request_id });
+                        if (!contextRefreshed) {
+                            warnings.push("architect_retry_skipped_no_new_context");
+                            warnings.push("architect_degraded_structural_grounding");
+                            const degradedPlan = buildQualityDegradedPlan(request, context, result.plan);
+                            lastPlan = {
+                                ...result,
+                                plan: degradedPlan,
+                                warnings: uniqueStrings(warnings),
+                            };
+                            if (this.options.logger) {
+                                await this.options.logger.log("architect_degraded", {
+                                    pass,
+                                    reason: "structural_grounding_no_new_context",
+                                    warnings: uniqueStrings(warnings),
+                                });
+                            }
+                            break;
+                        }
+                        structuralRecoveryTriggered = true;
+                        previousPlanHash = undefined;
+                        previousConcreteTargets = qualityGate.concreteTargets;
+                        pass += 1;
+                        continue;
+                    }
+                    warnings.push("architect_degraded_structural_grounding");
+                    const degradedPlan = buildQualityDegradedPlan(request, context, result.plan);
+                    lastPlan = { ...result, plan: degradedPlan, warnings: uniqueStrings(warnings) };
+                    break;
+                }
+                structuralRecoveryTriggered = false;
+                const verificationQuality = assessVerificationQuality(result.plan.verification);
+                if (!verificationQuality.ok) {
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_verification_insufficient", {
+                            pass,
+                            reason: verificationQuality.reason,
+                            verification_steps: verificationQuality.steps,
+                        });
+                    }
+                    if (allowAutoRetry && pass < maxPasses) {
+                        const recovery = buildFallbackRecoveryRequest(request, context, pass);
+                        emitAgentRequestRecoveryStatus("verification_quality");
+                        const response = await this.options.contextAssembler.fulfillAgentRequest(recovery.requestPayload);
+                        await appendArchitectHistory(formatCodaliResponse(response));
+                        await logPhaseArtifact("architect", "output", {
+                            request_id: recovery.requestPayload.request_id,
+                            response,
+                            source: "verification_recovery",
+                            verification_reason: verificationQuality.reason,
+                        });
+                        await logPhaseArtifact("librarian", "input", {
+                            request,
+                            reason: "architect_verification_insufficient",
+                            additional_queries: recovery.additionalQueries,
+                            preferred_files: recovery.preferredFiles,
+                        });
+                        context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                            additionalQueries: recovery.additionalQueries,
+                            preferredFiles: recovery.preferredFiles,
+                            recentFiles: recovery.recentFiles,
+                        }));
+                        await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                        const contextRefreshed = await updateContextSignature("verification_recovery", pass, { request_id: recovery.requestPayload.request_id });
+                        if (!contextRefreshed) {
+                            warnings.push("architect_retry_skipped_no_new_context");
+                            lastPlan = {
+                                ...result,
+                                warnings: uniqueStrings(warnings),
+                            };
+                            if (this.options.logger) {
+                                await this.options.logger.log("architect_quality_gate", {
+                                    stage: "architect_pass",
+                                    pass,
+                                    ok: false,
+                                    reasons: [`verification_${verificationQuality.reason}`],
+                                    action: "fail_closed_non_concrete_verification",
+                                    verification_reason: verificationQuality.reason,
+                                    verification_steps: verificationQuality.steps,
+                                    warnings: uniqueStrings(warnings),
+                                });
+                            }
+                            break;
+                        }
+                        fallbackRecoveryTriggered = true;
+                        verificationRetryTriggered = true;
+                        previousPlanHash = planHash;
+                        previousConcreteTargets = qualityGate.concreteTargets;
+                        pass += 1;
+                        continue;
+                    }
+                    lastPlan = { ...result, warnings: uniqueStrings(warnings) };
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_quality_gate", {
+                            stage: "architect_pass",
+                            pass,
+                            ok: false,
+                            reasons: [`verification_${verificationQuality.reason}`],
+                            action: "fail_closed_non_concrete_verification",
+                            verification_reason: verificationQuality.reason,
+                            verification_steps: verificationQuality.steps,
+                            warnings: uniqueStrings(warnings),
+                        });
+                    }
+                    break;
+                }
+                verificationRetryTriggered = false;
+                const fallbackGenericAssessment = assessFallbackOrGenericPlan(result.plan, warnings);
+                if (allowAutoRetry
+                    && fallbackGenericAssessment.fallback_or_generic
+                    && !fallbackRecoveryTriggered
+                    && pass < maxPasses) {
+                    const recovery = buildFallbackRecoveryRequest(request, context, pass);
+                    emitAgentRequestRecoveryStatus("fallback_or_generic_plan");
+                    const response = await this.options.contextAssembler.fulfillAgentRequest(recovery.requestPayload);
+                    await appendArchitectHistory(formatCodaliResponse(response));
+                    await logPhaseArtifact("architect", "output", {
+                        request_id: recovery.requestPayload.request_id,
+                        response,
+                        source: "fallback_generic_recovery",
+                    });
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_guardrail_request", {
+                            pass,
+                            reason: "fallback_or_generic_plan",
+                            request_id: recovery.requestPayload.request_id,
+                            generic_step_hits: fallbackGenericAssessment.generic_step_hits,
+                            reasons: fallbackGenericAssessment.reasons,
+                        });
+                    }
+                    await logPhaseArtifact("librarian", "input", {
+                        request,
+                        reason: "architect_fallback_or_generic_plan",
+                        additional_queries: recovery.additionalQueries,
+                        preferred_files: recovery.preferredFiles,
+                    });
+                    context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                        additionalQueries: recovery.additionalQueries,
+                        preferredFiles: recovery.preferredFiles,
+                        recentFiles: recovery.recentFiles,
+                    }));
+                    await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                    const contextRefreshed = await updateContextSignature("fallback_generic_recovery", pass, { request_id: recovery.requestPayload.request_id });
+                    if (!contextRefreshed) {
+                        warnings.push("architect_retry_skipped_no_new_context");
+                        lastPlan = { ...result, warnings: uniqueStrings(warnings) };
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_degraded", {
+                                pass,
+                                reason: "fallback_generic_no_new_context",
+                                warnings: uniqueStrings(warnings),
+                            });
+                        }
+                        break;
+                    }
+                    fallbackRecoveryTriggered = true;
+                    previousPlanHash = undefined;
+                    previousConcreteTargets = qualityGate.concreteTargets;
+                    pass += 1;
+                    continue;
+                }
+                const alignment = scoreRequestTargetAlignment(request, result.plan.target_files ?? []);
+                const endpointIntent = ENDPOINT_SERVER_INTENT_PATTERN.test(request);
+                const backendTargetPresent = hasBackendTarget(result.plan.target_files ?? []);
+                const backendCandidates = backendCandidatesFromContext(context);
+                const lowAlignment = !endpointIntent && alignment.keywords.length >= 3 && alignment.score < 0.2;
+                const endpointMissingBackend = endpointIntent && !backendTargetPresent;
+                if (this.options.logger) {
+                    await this.options.logger.log("architect_relevance", {
+                        pass,
+                        alignment_score: alignment.score,
+                        alignment_keywords: alignment.keywords,
+                        alignment_matches: alignment.matches,
+                        endpoint_intent: endpointIntent,
+                        backend_target_present: backendTargetPresent,
+                        backend_candidates: backendCandidates.slice(0, 8),
+                    });
+                }
+                if (lowAlignment || endpointMissingBackend) {
+                    if (allowAutoRetry && pass <= maxPasses) {
+                        if (endpointMissingBackend) {
+                            const guardRequest = {
+                                version: "v1",
+                                role: "architect",
+                                request_id: `architect-guard-${Date.now()}-${pass}`,
+                                needs: [
+                                    {
+                                        type: "docdex.search",
+                                        query: `${request} backend server route handler api`,
+                                        limit: 8,
+                                    },
+                                    {
+                                        type: "file.list",
+                                        root: "src",
+                                        pattern: "*server*",
+                                    },
+                                ],
+                                context: {
+                                    summary: "Endpoint/server intent detected, but plan has no backend/server target. Need backend candidates before finalizing plan.",
+                                },
+                            };
+                            emitAgentRequestRecoveryStatus("endpoint_missing_backend_target");
+                            const response = await this.options.contextAssembler.fulfillAgentRequest(guardRequest);
+                            await appendArchitectHistory(formatCodaliResponse(response));
+                            await logPhaseArtifact("architect", "output", {
+                                request_id: guardRequest.request_id,
+                                response,
+                                source: "relevance_guard",
+                            });
+                            if (this.options.logger) {
+                                await this.options.logger.log("architect_guardrail_request", {
+                                    pass,
+                                    reason: "endpoint_missing_backend_target",
+                                    request_id: guardRequest.request_id,
+                                });
+                            }
+                        }
+                        if (pass < maxPasses) {
+                            const additionalQueries = uniqueStrings([
+                                `${request} backend server route handler`,
+                                ...((context.queries ?? []).slice(0, 2)),
+                            ].filter(Boolean));
+                            const preferredFiles = uniqueStrings([
+                                ...backendCandidates.slice(0, 8),
+                                ...(context.selection?.focus ?? []),
+                            ]);
+                            const recentFiles = uniqueStrings([
+                                ...(context.selection?.all ?? []),
+                                ...preferredFiles,
+                            ]);
+                            await logPhaseArtifact("librarian", "input", {
+                                request,
+                                reason: endpointMissingBackend
+                                    ? "architect_relevance_endpoint_missing_backend"
+                                    : "architect_relevance_low_alignment",
+                                additional_queries: additionalQueries,
+                                preferred_files: preferredFiles,
+                            });
+                            context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                                additionalQueries,
+                                preferredFiles,
+                                recentFiles,
+                            }));
+                            await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                            const contextRefreshed = await updateContextSignature(endpointMissingBackend
+                                ? "relevance_endpoint_missing_backend"
+                                : "relevance_low_alignment", pass);
+                            if (!contextRefreshed) {
+                                warnings.push("architect_retry_skipped_no_new_context");
+                                warnings.push(endpointMissingBackend
+                                    ? "architect_degraded_relevance_endpoint_missing_backend"
+                                    : "architect_degraded_relevance_low_alignment");
+                                lastPlan = { ...result, warnings: uniqueStrings(warnings) };
+                                if (this.options.logger) {
+                                    await this.options.logger.log("architect_degraded", {
+                                        pass,
+                                        reason: endpointMissingBackend
+                                            ? "relevance_endpoint_missing_backend_no_new_context"
+                                            : "relevance_low_alignment_no_new_context",
+                                        alignment_score: alignment.score,
+                                        alignment_keywords: alignment.keywords,
+                                        alignment_matches: alignment.matches,
+                                        warnings: uniqueStrings(warnings),
+                                    });
+                                }
+                                break;
+                            }
+                            previousPlanHash = undefined;
+                            previousConcreteTargets = qualityGate.concreteTargets;
+                            pass += 1;
+                            continue;
+                        }
+                    }
+                    warnings.push(endpointMissingBackend
+                        ? "architect_degraded_relevance_endpoint_missing_backend"
+                        : "architect_degraded_relevance_low_alignment");
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_degraded", {
+                            pass,
+                            reason: endpointMissingBackend
+                                ? "relevance_endpoint_missing_backend"
+                                : "relevance_low_alignment",
+                            alignment_score: alignment.score,
+                            alignment_keywords: alignment.keywords,
+                            alignment_matches: alignment.matches,
+                            warnings,
+                        });
+                    }
+                    break;
+                }
+                if (targetDrift.high && warnings.length > 0 && !fallbackRecoveryTriggered && !verificationRetryTriggered) {
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_target_drift", {
+                            pass,
+                            high: true,
+                            similarity: targetDrift.similarity,
+                            drift: targetDrift.drift,
+                            previous: targetDrift.previous,
+                            current: targetDrift.current,
+                        });
+                    }
+                    if (allowAutoRetry && pass < maxPasses && !driftRecoveryTriggered) {
+                        const recovery = buildFallbackRecoveryRequest(request, context, pass);
+                        emitAgentRequestRecoveryStatus("high_target_drift");
+                        const response = await this.options.contextAssembler.fulfillAgentRequest(recovery.requestPayload);
+                        await appendArchitectHistory(formatCodaliResponse(response));
+                        await logPhaseArtifact("architect", "output", {
+                            request_id: recovery.requestPayload.request_id,
+                            response,
+                            source: "target_drift_recovery",
+                            target_drift: targetDrift,
+                        });
+                        await logPhaseArtifact("librarian", "input", {
+                            request,
+                            reason: "architect_target_drift",
+                            additional_queries: recovery.additionalQueries,
+                            preferred_files: recovery.preferredFiles,
+                            target_drift: targetDrift,
+                        });
+                        context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                            additionalQueries: recovery.additionalQueries,
+                            preferredFiles: recovery.preferredFiles,
+                            recentFiles: recovery.recentFiles,
+                        }));
+                        await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                        const contextRefreshed = await updateContextSignature("target_drift_recovery", pass, { request_id: recovery.requestPayload.request_id });
+                        if (!contextRefreshed) {
+                            warnings.push("architect_retry_skipped_no_new_context");
+                            warnings.push("architect_degraded_target_drift");
+                            const stabilizedPlan = buildDriftStabilizedPlan(request, result.plan, targetDrift.previous);
+                            lastPlan = {
+                                ...result,
+                                plan: stabilizedPlan,
+                                warnings: uniqueStrings(warnings),
+                            };
+                            if (this.options.logger) {
+                                await this.options.logger.log("architect_degraded", {
+                                    pass,
+                                    reason: "target_drift_no_new_context",
+                                    warnings: uniqueStrings(warnings),
+                                });
+                            }
+                            break;
+                        }
+                        driftRecoveryTriggered = true;
+                        previousPlanHash = undefined;
+                        previousConcreteTargets = qualityGate.concreteTargets;
+                        pass += 1;
+                        continue;
+                    }
+                    warnings.push("architect_degraded_target_drift");
+                    const stabilizedPlan = buildDriftStabilizedPlan(request, result.plan, targetDrift.previous);
+                    lastPlan = { ...result, plan: stabilizedPlan, warnings: uniqueStrings(warnings) };
+                    break;
+                }
+                driftRecoveryTriggered = false;
+                if (!qualityGate.ok) {
+                    const unresolvedTargets = qualityGate.targetValidation?.unresolvedTargets ?? [];
+                    const hasInvalidTargets = unresolvedTargets.length > 0;
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_quality_gate", {
+                            stage: "architect_pass",
+                            pass,
+                            ok: false,
+                            reasons: qualityGate.reasons,
+                            concrete_targets: qualityGate.concreteTargets,
+                            alignment_score: qualityGate.alignmentScore,
+                            alignment_keywords: qualityGate.alignmentKeywords,
+                            semantic_score: qualityGate.semanticScore,
+                            semantic_anchors: qualityGate.semanticAnchors,
+                            semantic_matches: qualityGate.semanticMatches,
+                            target_validation: qualityGate.targetValidation ?? null,
+                            unresolved_targets: unresolvedTargets,
+                        });
+                    }
+                    const canAttemptInvalidTargetRecovery = hasInvalidTargets && !invalidTargetRecoveryTriggered && pass < maxPasses;
+                    if (canAttemptInvalidTargetRecovery) {
+                        const revisionReason = "invalid_target_paths";
+                        const revisionDetails = uniqueStrings([
+                            ...qualityGate.reasons,
+                            ...unresolvedTargets.map((target) => `unresolved_target:${target}`),
+                        ]);
+                        pendingRevisionHint = buildArchitectRevisionHint({
+                            reason: revisionReason,
+                            details: revisionDetails.length > 0 ? revisionDetails : ["Refine plan quality."],
+                            plan: result.plan,
+                        });
+                        await appendArchitectHistory(formatArchitectRevisionFeedback({
+                            reason: revisionReason,
+                            details: revisionDetails,
+                            plan: result.plan,
+                        }));
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_retry_strategy", {
+                                pass,
+                                action: "revision_retry_same_context_invalid_targets",
+                                reasons: qualityGate.reasons,
+                                unresolved_targets: unresolvedTargets,
+                            });
+                        }
+                        invalidTargetRecoveryTriggered = true;
+                        requestRecoveryPending = true;
+                        previousPlanHash = undefined;
+                        previousConcreteTargets = qualityGate.concreteTargets;
+                        pass += 1;
+                        continue;
+                    }
+                    if (allowAutoRetry && pass < maxPasses) {
+                        const recovery = buildFallbackRecoveryRequest(request, context, pass);
+                        emitAgentRequestRecoveryStatus(hasInvalidTargets ? "invalid_targets" : "quality_gate");
+                        const response = await this.options.contextAssembler.fulfillAgentRequest(recovery.requestPayload);
+                        await appendArchitectHistory(formatCodaliResponse(response));
+                        await logPhaseArtifact("architect", "output", {
+                            request_id: recovery.requestPayload.request_id,
+                            response,
+                            source: hasInvalidTargets ? "invalid_target_recovery" : "quality_gate_recovery",
+                            quality_gate: qualityGate,
+                        });
+                        await logPhaseArtifact("librarian", "input", {
+                            request,
+                            reason: hasInvalidTargets ? "architect_invalid_targets" : "architect_quality_gate",
+                            additional_queries: recovery.additionalQueries,
+                            preferred_files: recovery.preferredFiles,
+                        });
+                        context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                            additionalQueries: recovery.additionalQueries,
+                            preferredFiles: recovery.preferredFiles,
+                            recentFiles: recovery.recentFiles,
+                        }));
+                        await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                        const contextRefreshed = await updateContextSignature(hasInvalidTargets ? "invalid_target_recovery" : "quality_gate_recovery", pass, { request_id: recovery.requestPayload.request_id });
+                        if (!contextRefreshed) {
+                            const hasNonConcreteVerification = qualityGate.reasons.includes("verification_non_concrete")
+                                || qualityGate.reasons.includes("verification_empty");
+                            let degradedPlan = result.plan;
+                            let degradedQuality;
+                            warnings.push("architect_retry_skipped_no_new_context");
+                            warnings.push("architect_degraded_quality_gate");
+                            if (hasInvalidTargets)
+                                warnings.push("architect_invalid_targets");
+                            if (hasNonConcreteVerification && !hasInvalidTargets) {
+                                degradedPlan = buildQualityDegradedPlan(request, context, result.plan);
+                                degradedQuality = assessPlanQualityGate(request, degradedPlan, context);
+                                warnings.push("architect_degraded_verification");
+                            }
+                            lastPlan = {
+                                ...result,
+                                plan: degradedPlan,
+                                warnings: uniqueStrings(warnings),
+                            };
+                            if (this.options.logger) {
+                                await this.options.logger.log("architect_degraded", {
+                                    pass,
+                                    reason: hasInvalidTargets
+                                        ? "invalid_targets_no_new_context"
+                                        : "quality_gate_no_new_context",
+                                    warnings: uniqueStrings(warnings),
+                                    quality_gate: qualityGate,
+                                    degraded_quality: degradedQuality ?? null,
+                                    semantic_score: qualityGate.semanticScore,
+                                    semantic_anchors: qualityGate.semanticAnchors,
+                                    semantic_matches: qualityGate.semanticMatches,
+                                });
+                            }
+                            break;
+                        }
+                        previousPlanHash = undefined;
+                        previousConcreteTargets = qualityGate.concreteTargets;
+                        if (hasInvalidTargets) {
+                            invalidTargetRecoveryTriggered = true;
+                        }
+                        const revisionReason = hasInvalidTargets
+                            ? "invalid_target_paths"
+                            : "quality_gate_recovery";
+                        const revisionDetails = uniqueStrings([
+                            ...qualityGate.reasons,
+                            ...unresolvedTargets.map((target) => `unresolved_target:${target}`),
+                        ]);
+                        pendingRevisionHint = buildArchitectRevisionHint({
+                            reason: revisionReason,
+                            details: revisionDetails.length > 0 ? revisionDetails : ["Refine plan quality."],
+                            plan: result.plan,
+                        });
+                        requestRecoveryPending = true;
+                        pass += 1;
+                        continue;
+                    }
+                    const hasNonConcreteVerification = qualityGate.reasons.includes("verification_non_concrete")
+                        || qualityGate.reasons.includes("verification_empty");
+                    if (hasNonConcreteVerification) {
+                        warnings.push("architect_verification_non_concrete");
+                        lastPlan = {
+                            ...result,
+                            warnings: uniqueStrings(warnings),
+                        };
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_quality_gate", {
+                                stage: "architect_pass",
+                                pass,
+                                ok: false,
+                                reasons: qualityGate.reasons,
+                                action: "fail_closed_non_concrete_verification",
+                            });
+                        }
+                        break;
+                    }
+                    warnings.push("architect_degraded_quality_gate");
+                    if (hasInvalidTargets)
+                        warnings.push("architect_invalid_targets");
+                    const degradedPlan = hasInvalidTargets
+                        ? result.plan
+                        : buildQualityDegradedPlan(request, context, result.plan);
+                    const degradedQuality = assessPlanQualityGate(request, degradedPlan, context);
+                    lastPlan = { ...result, plan: degradedPlan, warnings: uniqueStrings(warnings) };
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_degraded", {
+                            pass,
+                            reason: "quality_gate_failed_after_retries",
+                            warnings: uniqueStrings(warnings),
+                            quality_gate: qualityGate,
+                            degraded_quality: degradedQuality,
+                            semantic_score: qualityGate.semanticScore,
+                            semantic_anchors: qualityGate.semanticAnchors,
+                            semantic_matches: qualityGate.semanticMatches,
+                        });
+                    }
+                    break;
+                }
+                const blockingWarnings = warnings.filter((warning) => isBlockingArchitectWarning(warning));
+                if (blockingWarnings.length === 0) {
+                    previousPlanHash = planHash;
+                    previousConcreteTargets = qualityGate.concreteTargets;
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_early_stop", {
+                            pass,
+                            reason: warnings.length === 0
+                                ? "acceptable_plan_quality"
+                                : "acceptable_plan_quality_with_non_blocking_warnings",
+                            warnings,
+                        });
+                    }
+                    break;
+                }
+                if (allowAutoRetry && repeatedOutput && !alternateStrategyUsed && pass < maxPasses) {
+                    alternateStrategyUsed = true;
+                    alternateHintPending = true;
+                    const additionalQueries = (context.queries ?? []).slice(0, 3);
+                    const preferredFiles = context.selection?.focus ?? [];
+                    const recentFiles = context.selection?.all ?? preferredFiles;
+                    await logPhaseArtifact("librarian", "input", {
+                        request,
+                        reason: "architect_identical_output",
+                        additional_queries: additionalQueries,
+                        preferred_files: preferredFiles,
+                    });
+                    context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                        additionalQueries,
+                        preferredFiles,
+                        recentFiles,
+                    }));
+                    await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                    const contextRefreshed = await updateContextSignature("identical_output_refresh", pass);
+                    if (!contextRefreshed) {
+                        warnings.push("architect_retry_skipped_no_new_context");
+                        lastPlan = { ...result, warnings: uniqueStrings(warnings) };
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_degraded", {
+                                pass,
+                                reason: "identical_output_no_new_context",
+                                warnings: uniqueStrings(warnings),
+                            });
+                        }
+                        break;
+                    }
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_retry_strategy", {
+                            pass,
+                            action: "context_refresh_with_alternate_hint",
+                            repeated_output_hash: planHash,
+                        });
+                    }
+                    previousPlanHash = undefined;
+                    previousConcreteTargets = qualityGate.concreteTargets;
+                    pass += 1;
+                    continue;
+                }
+                previousPlanHash = planHash;
+                previousConcreteTargets = qualityGate.concreteTargets;
+                if (!allowAutoRetry) {
+                    break;
+                }
+                pass += 1;
+            }
+            if (!lastPlan) {
+                throw new Error("Architect failed to produce a plan");
+            }
+            let revisionAttempted = false;
+            let revisionPass = pass;
+            const attemptArchitectRevision = async (reason, details) => {
+                if (revisionAttempted)
+                    return false;
+                revisionAttempted = true;
+                revisionPass += 1;
+                const revisionDetails = uniqueStrings(details).filter((entry) => entry.trim().length > 0);
+                const currentPlan = lastPlan?.plan ?? plan;
+                const hint = buildArchitectRevisionHint({
+                    reason,
+                    details: revisionDetails,
+                    plan: currentPlan,
+                });
+                await appendArchitectHistory(formatArchitectRevisionFeedback({
+                    reason,
+                    details: revisionDetails,
+                    plan: currentPlan,
+                }));
+                if (this.options.logger) {
+                    await this.options.logger.log("architect_revision_requested", {
+                        pass: revisionPass,
+                        reason,
+                        details: revisionDetails,
+                    });
+                }
+                const revised = await runArchitectPass(revisionPass, {
+                    // Keep prior plan in instruction hint, but disable plan-hint short-circuit.
+                    planHint: "",
+                    instructionHint: hint,
+                    contextOverride: context,
+                    validateOnly: false,
+                    responseFormat: undefined,
+                });
+                const revisedWarnings = uniqueStrings([...(revised.warnings ?? [])]);
+                const revisedQuality = assessPlanQualityGate(request, revised.plan, context);
+                await logPhaseArtifact("architect", "output", buildArchitectOutputArtifactPayload({
+                    pass: revisionPass,
+                    strictRetry: false,
+                    planHint: lastPlanHintUsed,
+                    instructionHint: hint,
+                    result: { ...revised, warnings: revisedWarnings },
+                    source: "revision_retry",
+                    planHash: hashArchitectResult(revised),
+                    classification: classifyArchitectWarnings(revisedWarnings),
+                    repairApplied: hasRepairWarnings(revisedWarnings),
+                    qualityGate: revisedQuality,
+                }));
+                if (this.options.logger) {
+                    await this.options.logger.log("architect_revision_result", {
+                        pass: revisionPass,
+                        reason,
+                        warnings: revisedWarnings,
+                        quality_ok: revisedQuality.ok,
+                        quality_reasons: revisedQuality.reasons,
+                    });
+                }
+                lastPlan = { ...revised, warnings: revisedWarnings };
+                return true;
+            };
+            while (true) {
+                const hasUnresolvedArchitectRequest = Boolean(lastPlan.request);
+                const hasRequestLoopDegradeWarning = (lastPlan.warnings ?? []).includes("architect_degraded_request_loop");
+                if (hasUnresolvedArchitectRequest || hasRequestLoopDegradeWarning) {
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_quality_gate", {
+                            stage: "pre_builder",
+                            pass: "final",
+                            ok: false,
+                            reasons: ["unresolved_architect_request"],
+                            request_present: hasUnresolvedArchitectRequest,
+                            warnings: lastPlan.warnings ?? [],
+                        });
+                    }
+                    const revised = await attemptArchitectRevision("unresolved_architect_request", [
+                        ...(lastPlan.warnings ?? []),
+                        "Return a complete plan instead of AGENT_REQUEST for this pass.",
+                    ]);
+                    if (revised)
+                        continue;
+                    throw new Error("Architect quality gate failed before builder: unresolved_architect_request.");
+                }
+                plan = lastPlan.plan;
+                const finalBlockingWarnings = collectPreBuilderBlockingWarnings(lastPlan.warnings ?? []);
+                if (finalBlockingWarnings.length > 0) {
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_quality_gate", {
+                            stage: "pre_builder",
+                            pass: "final",
+                            ok: false,
+                            reasons: ["blocking_architect_warnings"],
+                            blocking_warnings: finalBlockingWarnings,
+                        });
+                    }
+                    const revised = await attemptArchitectRevision("blocking_architect_warnings", finalBlockingWarnings);
+                    if (revised)
+                        continue;
+                    throw new Error(`Architect quality gate failed before builder: blocking_architect_warnings (${finalBlockingWarnings.join(",")}).`);
+                }
+                const finalPlanQuality = assessPlanQualityGate(request, plan, context);
+                if (!finalPlanQuality.ok) {
+                    const hadInvalidTargetFailures = (lastPlan.warnings ?? []).includes("architect_invalid_targets");
+                    const hasInvalidTargets = finalPlanQuality.reasons.includes("invalid_target_paths");
+                    const hasNonConcreteVerification = finalPlanQuality.reasons.includes("verification_non_concrete")
+                        || finalPlanQuality.reasons.includes("verification_empty");
+                    const unresolved = finalPlanQuality.targetValidation?.unresolvedTargets ?? [];
+                    const unresolvedPart = unresolved.length > 0 ? ` unresolved_targets=${unresolved.join(",")}` : "";
+                    if (hasInvalidTargets || (hadInvalidTargetFailures && finalPlanQuality.reasons.includes("missing_concrete_targets"))) {
+                        const revised = await attemptArchitectRevision("invalid_target_paths", [
+                            ...finalPlanQuality.reasons,
+                            ...unresolved.map((entry) => `unresolved_target:${entry}`),
+                        ]);
+                        if (revised)
+                            continue;
+                        throw new Error(`Architect quality gate failed before builder: invalid_target_paths.${unresolvedPart}`);
+                    }
+                    if (hasNonConcreteVerification) {
+                        const revised = await attemptArchitectRevision("verification_non_concrete", finalPlanQuality.reasons);
+                        if (revised)
+                            continue;
+                        const degradedPlan = buildQualityDegradedPlan(request, context, plan);
+                        const degradedQuality = assessPlanQualityGate(request, degradedPlan, context);
+                        const degradedBlockingReasons = collectBlockingPlanQualityReasons(degradedQuality);
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_quality_gate", {
+                                stage: "pre_builder",
+                                pass: "final",
+                                ok: false,
+                                reasons: finalPlanQuality.reasons,
+                                action: "degrade_non_concrete_verification",
+                                degraded_ok: degradedQuality.ok,
+                                degraded_target_validation: degradedQuality.targetValidation ?? null,
+                            });
+                        }
+                        await logPhaseArtifact("architect", "output", {
+                            source: "verification_degrade",
+                            plan_before: plan,
+                            quality_before: finalPlanQuality,
+                            plan_after: degradedPlan,
+                            quality_after: degradedQuality,
+                            blocking_reasons_after: degradedBlockingReasons,
+                        });
+                        if (degradedBlockingReasons.length > 0) {
+                            throw new Error("Architect quality gate failed before builder: verification_non_concrete.");
+                        }
+                        plan = degradedPlan;
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_degraded", {
+                                pass: "final",
+                                reason: "verification_non_concrete",
+                                warnings: uniqueStrings([...(lastPlan.warnings ?? []), "architect_degraded_verification"]),
+                                quality_gate: finalPlanQuality,
+                                degraded_quality: degradedQuality,
+                            });
+                        }
+                        if (!degradedQuality.ok) {
+                            throw new Error("Architect quality gate failed before builder: verification_non_concrete.");
+                        }
+                        break;
+                    }
+                    const revised = await attemptArchitectRevision("pre_builder_quality_gate", finalPlanQuality.reasons);
+                    if (revised)
+                        continue;
+                    const degradedPlan = buildQualityDegradedPlan(request, context, plan);
+                    const degradedQuality = assessPlanQualityGate(request, degradedPlan, context);
+                    const degradedBlockingReasons = collectBlockingPlanQualityReasons(degradedQuality);
+                    if (this.options.logger) {
+                        await this.options.logger.log("architect_quality_gate", {
+                            stage: "pre_builder",
+                            pass: "final",
+                            ok: false,
+                            reasons: finalPlanQuality.reasons,
+                            concrete_targets: finalPlanQuality.concreteTargets,
+                            alignment_score: finalPlanQuality.alignmentScore,
+                            alignment_keywords: finalPlanQuality.alignmentKeywords,
+                            semantic_score: finalPlanQuality.semanticScore,
+                            semantic_anchors: finalPlanQuality.semanticAnchors,
+                            semantic_matches: finalPlanQuality.semanticMatches,
+                            target_validation: finalPlanQuality.targetValidation ?? null,
+                            degraded_ok: degradedQuality.ok,
+                            degraded_target_validation: degradedQuality.targetValidation ?? null,
+                        });
+                    }
+                    await logPhaseArtifact("architect", "output", {
+                        source: "quality_gate_degrade",
+                        plan_before: plan,
+                        quality_before: finalPlanQuality,
+                        plan_after: degradedPlan,
+                        quality_after: degradedQuality,
+                        blocking_reasons_after: degradedBlockingReasons,
+                    });
+                    if (degradedBlockingReasons.length > 0) {
+                        const unresolved = degradedQuality.targetValidation?.unresolvedTargets ?? [];
+                        const unresolvedPart = unresolved.length > 0 ? ` unresolved_targets=${unresolved.join(",")}` : "";
+                        throw new Error(`Architect quality gate failed before builder: ${degradedBlockingReasons.join(", ")}.${unresolvedPart}`);
+                    }
+                    plan = degradedPlan;
+                }
+                break;
+            }
+            if (this.options.logger) {
+                const planPath = await this.options.logger.writePhaseArtifact("architect", "plan", plan);
+                await this.options.logger.log("plan_json", { phase: "architect", path: planPath });
+            }
+            await logLaneSummary("architect", architectLaneId);
+        }
+        let attempts = 0;
+        let builderResult;
+        let criticResult;
+        let refreshes = 0;
+        const maxContextRefreshes = this.options.maxContextRefreshes ?? 0;
+        const refreshStartedAtMs = Date.now();
+        let builderNote;
+        let lastContextRequestFingerprint;
+        let forcedNoContextAttemptUsed = false;
+        let contextRefreshTerminationReason;
+        const deterministicApplyRepairKinds = new Set();
+        let builderAttemptOrdinal = 0;
+        while (attempts <= this.options.maxRetries) {
+            attempts += 1;
+            builderAttemptOrdinal += 1;
+            const note = builderNote;
+            builderNote = undefined;
+            const builderAttemptLaneId = builderAttemptOrdinal === 1
+                ? builderLaneId
+                : `${builderLaneId}:attempt-${builderAttemptOrdinal}`;
+            const touchedBefore = this.options.getTouchedFiles?.() ?? [];
+            const builderContext = buildSerializedContext(context, "builder");
+            const builderInputPath = await logPhaseArtifact("builder", "input", {
+                plan,
+                context: builderContext,
+            });
+            if (this.options.logger) {
+                await this.options.logger.log("builder_input", {
+                    plan_targets: plan.target_files.length,
+                    context_bytes: builderContext.content.length,
+                    path: builderInputPath ?? null,
+                });
+            }
+            let built;
+            try {
+                built = await this.runPhase("builder", () => this.options.builderRunner.run(plan, context, {
+                    contextManager: this.options.contextManager,
+                    laneId: builderAttemptLaneId,
+                    note,
+                }));
+            }
+            catch (error) {
+                if (error instanceof PatchApplyError) {
+                    const failure = error.details;
+                    const deterministicFailureKind = classifyDeterministicPatchApplyFailure(failure);
+                    const deterministicApplyFailure = isDeterministicPatchApplyFailure(failure);
+                    const deterministicRepairEligible = isArchitectRepairEligibleDeterministicFailure(deterministicFailureKind, deterministicApplyRepairKinds);
+                    builderResult = {
+                        finalMessage: { role: "assistant", content: failure.rawOutput },
+                        messages: [],
+                        toolCallsExecuted: 0,
+                    };
+                    const failurePath = await logPhaseArtifact("builder", "apply_failure", failure);
+                    if (this.options.logger) {
+                        await this.options.logger.log("builder_apply_failed", {
+                            error: failure.error,
+                            source: failure.source,
+                            classification: failure.classification ?? null,
+                            attempt_history: failure.attemptHistory ?? [],
+                            rollback: failure.rollback,
+                            path: failurePath ?? null,
+                        });
+                    }
+                    await appendArchitectHistory(formatCodaliResponse(buildApplyFailureResponse(failure)));
+                    if (deterministicApplyFailure && deterministicRepairEligible) {
+                        deterministicApplyRepairKinds.add(deterministicFailureKind);
+                        if (this.options.logger) {
+                            await this.options.logger.log("builder_apply_failed_deterministic", {
+                                error: failure.error,
+                                source: failure.source,
+                                kind: deterministicFailureKind,
+                                action: "architect_repair_once_per_kind",
+                                repair_count: deterministicApplyRepairKinds.size,
+                            });
+                        }
+                        const recoveryQueries = uniqueStrings([
+                            buildDeterministicRecoveryQuery(request, deterministicFailureKind),
+                            ...((context.queries ?? []).slice(0, 2)),
+                        ].filter(Boolean));
+                        const recoveryFiles = uniqueStrings(plan.target_files ?? []);
+                        const recoveryRecentFiles = uniqueStrings([
+                            ...(context.selection?.all ?? []),
+                            ...recoveryFiles,
+                        ]).slice(0, 24);
+                        await logPhaseArtifact("librarian", "input", {
+                            request,
+                            reason: `builder_apply_failed_deterministic:${deterministicFailureKind}`,
+                            additional_queries: recoveryQueries,
+                            preferred_files: recoveryFiles,
+                        });
+                        context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                            additionalQueries: recoveryQueries,
+                            preferredFiles: recoveryFiles,
+                            recentFiles: recoveryRecentFiles,
+                        }));
+                        await logPhaseArtifact("librarian", "output", sanitizeForOutput(context));
+                        await logPhaseArtifact("architect", "input", {
+                            request,
+                            reason: `builder_apply_failed_deterministic:${deterministicFailureKind}`,
+                            context: buildSerializedContext(context),
+                        });
+                        const planBeforeRepair = plan;
+                        const repairDetails = uniqueStrings([
+                            `deterministic_failure_kind:${deterministicFailureKind}`,
+                            `patch_apply_error:${failure.error}`,
+                            ...(planBeforeRepair.target_files ?? []).map((file) => `target:${file}`),
+                        ]);
+                        const repairInstructionHint = buildArchitectRevisionHint({
+                            reason: `builder_apply_failed_deterministic:${deterministicFailureKind}`,
+                            details: repairDetails,
+                            plan: planBeforeRepair,
+                        });
+                        const planner = this.options.architectPlanner;
+                        const repairedPlanResult = useFastPath
+                            ? { plan: buildFastPlan(context), raw: "", warnings: [] }
+                            : planner.planWithRequest
+                                ? await this.runPhase("architect", () => planner.planWithRequest(context, {
+                                    contextManager: this.options.contextManager,
+                                    laneId: architectLaneId,
+                                    instructionHint: repairInstructionHint,
+                                    // Keep prior plan in instruction hint, but disable plan-hint short-circuit.
+                                    planHint: "",
+                                    validateOnly: false,
+                                    responseFormat: undefined,
+                                }))
+                                : {
+                                    plan: await this.runPhase("architect", () => planner.plan(context, {
+                                        contextManager: this.options.contextManager,
+                                        laneId: architectLaneId,
+                                        instructionHint: repairInstructionHint,
+                                        responseFormat: undefined,
+                                    })),
+                                    raw: "",
+                                    warnings: [],
+                                };
+                        if (repairedPlanResult.request) {
+                            if (this.options.logger) {
+                                await this.options.logger.log("architect_repair_after_builder_apply_failure_failed", {
+                                    deterministic: true,
+                                    kind: deterministicFailureKind,
+                                    reasons: ["unresolved_architect_request"],
+                                    request_id: repairedPlanResult.request.request_id,
+                                });
+                            }
+                            plan = planBeforeRepair;
+                            attempts -= 1;
+                            builderNote =
+                                `Patch apply failed with deterministic error (${failure.error}). ` +
+                                    "Architect repair requested extra context; keep current plan and produce a schema-valid patch only for listed targets.";
+                            continue;
+                        }
+                        let repairedPlanCandidate = repairedPlanResult.plan;
+                        let repairedPlanQuality = assessPlanQualityGate(request, repairedPlanCandidate, context);
+                        if (!repairedPlanQuality.ok) {
+                            const degradedRepairPlan = buildQualityDegradedPlan(request, context, repairedPlanCandidate);
+                            const degradedRepairQuality = assessPlanQualityGate(request, degradedRepairPlan, context);
+                            const degradedBlockingReasons = collectBlockingPlanQualityReasons(degradedRepairQuality);
+                            if (this.options.logger) {
+                                await this.options.logger.log("architect_quality_gate", {
+                                    stage: "post_builder_apply_failure_repair",
+                                    ok: false,
+                                    reasons: repairedPlanQuality.reasons,
+                                    concrete_targets: repairedPlanQuality.concreteTargets,
+                                    alignment_score: repairedPlanQuality.alignmentScore,
+                                    alignment_keywords: repairedPlanQuality.alignmentKeywords,
+                                    semantic_score: repairedPlanQuality.semanticScore,
+                                    semantic_anchors: repairedPlanQuality.semanticAnchors,
+                                    semantic_matches: repairedPlanQuality.semanticMatches,
+                                    target_validation: repairedPlanQuality.targetValidation ?? null,
+                                    degraded_ok: degradedRepairQuality.ok,
+                                    degraded_reasons: degradedRepairQuality.reasons,
+                                    degraded_target_validation: degradedRepairQuality.targetValidation ?? null,
+                                    degraded_blocking_reasons: degradedBlockingReasons,
+                                });
+                            }
+                            if (degradedBlockingReasons.length === 0) {
+                                repairedPlanCandidate = degradedRepairPlan;
+                                repairedPlanQuality = degradedRepairQuality;
+                            }
+                            else {
+                                const unresolved = degradedRepairQuality.targetValidation?.unresolvedTargets
+                                    ?? repairedPlanQuality.targetValidation?.unresolvedTargets
+                                    ?? [];
+                                const unresolvedSuffix = unresolved.length > 0 ? ` unresolved_targets=${unresolved.join(",")}` : "";
+                                if (this.options.logger) {
+                                    await this.options.logger.log("architect_repair_after_builder_apply_failure_failed", {
+                                        deterministic: true,
+                                        kind: deterministicFailureKind,
+                                        reasons: degradedBlockingReasons,
+                                        unresolved_targets: unresolved,
+                                    });
+                                }
+                                plan = planBeforeRepair;
+                                attempts -= 1;
+                                builderNote =
+                                    `Patch apply failed with deterministic error (${failure.error}). ` +
+                                        `Architect repair plan was non-actionable (${degradedBlockingReasons.join(",")}${unresolvedSuffix}). ` +
+                                        `Use existing repository targets only (${plan.target_files.join(", ") || "none"}) and include concrete verification.`;
+                                continue;
+                            }
+                        }
+                        plan = repairedPlanCandidate;
+                        if (this.options.logger) {
+                            const planPath = await this.options.logger.writePhaseArtifact("architect", "plan", plan);
+                            await this.options.logger.log("plan_json", { phase: "architect", path: planPath });
+                            await this.options.logger.log("architect_repair_after_builder_apply_failure", {
+                                deterministic: true,
+                                kind: deterministicFailureKind,
+                                reasons: repairedPlanQuality.reasons,
+                            });
+                        }
+                        attempts -= 1;
+                        builderNote =
+                            `Patch apply failed with deterministic error (${failure.error}). ` +
+                                `Use existing repository targets only (${plan.target_files.join(", ") || "none"}).`;
+                        continue;
+                    }
+                    if (deterministicApplyFailure) {
+                        if (deterministicFailureKind === "patch_parse" && this.options.onPhaseProviderFailure) {
+                            const fallbackError = new Error(`Deterministic patch parsing failure: ${failure.error}`);
+                            const recovery = await this.options.onPhaseProviderFailure({
+                                phase: "builder",
+                                attempt: builderAttemptOrdinal,
+                                error: fallbackError,
+                            });
+                            const switched = typeof recovery === "boolean" ? recovery : recovery.switched;
+                            const noteFromRecovery = typeof recovery === "boolean" ? undefined : recovery.note;
+                            if (switched) {
+                                deterministicApplyRepairKinds.clear();
+                                if (this.options.logger) {
+                                    await this.options.logger.log("phase_provider_fallback", {
+                                        phase: "builder",
+                                        attempt: builderAttemptOrdinal,
+                                        error: fallbackError.message,
+                                        reason: "deterministic_patch_parse",
+                                        note: noteFromRecovery ?? null,
+                                        reset_deterministic_repair_kinds: true,
+                                    });
+                                }
+                                this.emitStatus("thinking", "builder: deterministic patch parse failed, switching phase agent");
+                                attempts -= 1;
+                                builderNote =
+                                    noteFromRecovery && noteFromRecovery.trim().length > 0
+                                        ? noteFromRecovery
+                                        : `Deterministic patch parsing failure (${failure.error}). Continue with replacement builder agent and return schema-valid patch output.`;
+                                await logRetryDecision({
+                                    phase: toRuntimePhase("builder"),
+                                    reason_code: "phase_provider_fallback_retry",
+                                    disposition: "retry",
+                                    attempt: attempts + 1,
+                                    max_attempts: this.options.maxRetries + 1,
+                                    details: [failure.error],
+                                });
+                                continue;
+                            }
+                        }
+                        if (this.options.logger) {
+                            await this.options.logger.log("builder_apply_failed_deterministic_no_repair", {
+                                error: failure.error,
+                                source: failure.source,
+                                kind: deterministicFailureKind,
+                                repair_count: deterministicApplyRepairKinds.size,
+                                action: "fail_closed",
+                            });
+                        }
+                        criticResult = {
+                            status: "FAIL",
+                            reasons: [`patch_apply_failed_deterministic_no_repair: ${failure.error}`],
+                            retryable: false,
+                            report: {
+                                status: "FAIL",
+                                reasons: [`patch_apply_failed_deterministic_no_repair: ${failure.error}`],
+                                suggested_fixes: [
+                                    "Architect repair was already attempted for this deterministic failure kind. Stop retry loop and request fresh plan/context before another builder attempt.",
+                                ],
+                            },
+                        };
+                        await logRetryDecision({
+                            phase: toRuntimePhase("builder"),
+                            reason_code: "builder_patch_apply_deterministic_no_repair",
+                            disposition: "terminate",
+                            attempt: attempts,
+                            max_attempts: this.options.maxRetries + 1,
+                            details: [failure.error, deterministicFailureKind].filter((detail) => typeof detail === "string" && detail.length > 0),
+                        });
+                        break;
+                    }
+                    if (!deterministicApplyFailure && attempts <= this.options.maxRetries) {
+                        const patchRetryable = failure.classification?.retryable ?? true;
+                        if (!patchRetryable) {
+                            criticResult = {
+                                status: "FAIL",
+                                reasons: [
+                                    `patch_apply_failed_non_retryable:${failure.classification?.failure_code ?? failure.error}`,
+                                    `patch_apply_failed: ${failure.error}`,
+                                ],
+                                retryable: false,
+                                report: {
+                                    status: "FAIL",
+                                    reasons: [
+                                        `patch_apply_failed_non_retryable:${failure.classification?.failure_code ?? failure.error}`,
+                                        `patch_apply_failed: ${failure.error}`,
+                                    ],
+                                    suggested_fixes: [
+                                        failure.classification?.remediation_key
+                                            ? `Apply remediation: ${failure.classification.remediation_key}`
+                                            : "Provide a corrected patch that applies cleanly.",
+                                    ],
+                                },
+                            };
+                            break;
+                        }
+                        builderNote = `Patch apply failed: ${failure.error}. Rollback ok=${failure.rollback.ok}. Fix the patch output and avoid disallowed paths.`;
+                        await logRetryDecision({
+                            phase: toRuntimePhase("builder"),
+                            reason_code: "builder_patch_apply_retry",
+                            disposition: "retry",
+                            attempt: attempts,
+                            max_attempts: this.options.maxRetries + 1,
+                            details: [failure.error],
+                        });
+                        continue;
+                    }
+                    criticResult = {
+                        status: "FAIL",
+                        reasons: [`patch_apply_failed: ${failure.error}`],
+                        retryable: false,
+                        report: {
+                            status: "FAIL",
+                            reasons: [`patch_apply_failed: ${failure.error}`],
+                            suggested_fixes: ["Provide a corrected patch that applies cleanly."],
+                        },
+                    };
+                    break;
+                }
+                const providerFailureError = error instanceof Error ? error : new Error(String(error));
+                if (isProviderAuthOrRateLimitError(providerFailureError)
+                    && this.options.onPhaseProviderFailure) {
+                    const recovery = await this.options.onPhaseProviderFailure({
+                        phase: "builder",
+                        attempt: builderAttemptOrdinal,
+                        error: providerFailureError,
+                    });
+                    const switched = typeof recovery === "boolean" ? recovery : recovery.switched;
+                    const noteFromRecovery = typeof recovery === "boolean" ? undefined : recovery.note;
+                    if (switched) {
+                        deterministicApplyRepairKinds.clear();
+                        if (this.options.logger) {
+                            await this.options.logger.log("phase_provider_fallback", {
+                                phase: "builder",
+                                attempt: builderAttemptOrdinal,
+                                error: providerFailureError.message,
+                                note: noteFromRecovery ?? null,
+                                reset_deterministic_repair_kinds: true,
+                            });
+                        }
+                        this.emitStatus("thinking", "builder: provider failed, switching phase agent");
+                        attempts -= 1;
+                        builderNote =
+                            noteFromRecovery && noteFromRecovery.trim().length > 0
+                                ? noteFromRecovery
+                                : `Provider failure encountered (${providerFailureError.message}). Continue with replacement builder agent and keep patch output schema-compliant.`;
+                        await logRetryDecision({
+                            phase: toRuntimePhase("builder"),
+                            reason_code: "phase_provider_fallback_retry",
+                            disposition: "retry",
+                            attempt: attempts + 1,
+                            max_attempts: this.options.maxRetries + 1,
+                            details: [providerFailureError.message],
+                        });
+                        continue;
+                    }
+                }
+                throw error;
+            }
+            builderResult = built;
+            await logPhaseArtifact("builder", "output", {
+                finalMessage: built.finalMessage,
+                contextRequest: built.contextRequest ?? null,
+                usage: built.usage ?? null,
+            });
+            if (this.options.logger) {
+                await this.options.logger.log("builder_output", {
+                    length: built.finalMessage.content.length,
+                    context_request: Boolean(built.contextRequest),
+                });
+            }
+            await logLaneSummary("builder", builderAttemptLaneId);
+            if (built.contextRequest) {
+                const contextRequest = built.contextRequest;
+                const contextRequestFingerprint = JSON.stringify({
+                    reason: contextRequest.reason ?? "",
+                    queries: uniqueStrings((contextRequest.queries ?? []).map((entry) => entry.trim()).filter(Boolean)),
+                    files: uniqueStrings((contextRequest.files ?? []).map((entry) => entry.trim()).filter(Boolean)),
+                });
+                const repeatedContextRequest = contextRequestFingerprint === lastContextRequestFingerprint;
+                const refreshTimeoutExceeded = this.options.maxContextRefreshMs !== undefined
+                    && Date.now() - refreshStartedAtMs >= this.options.maxContextRefreshMs;
+                if (refreshTimeoutExceeded) {
+                    contextRefreshTerminationReason = "phase_timeout";
+                    criticResult = {
+                        status: "FAIL",
+                        reasons: ["context_refresh_terminated:phase_timeout"],
+                        retryable: false,
+                    };
+                    await logRetryDecision({
+                        phase: toRuntimePhase("builder"),
+                        reason_code: "builder_context_refresh_terminated",
+                        disposition: "terminate",
+                        attempt: attempts,
+                        max_attempts: this.options.maxRetries + 1,
+                        details: ["phase_timeout"],
+                    });
+                    if (this.options.logger) {
+                        await this.options.logger.log("context_refresh_terminated", {
+                            reason: contextRefreshTerminationReason,
+                            refreshes,
+                            max_refreshes: maxContextRefreshes,
+                            elapsed_ms: Date.now() - refreshStartedAtMs,
+                        });
+                    }
+                    break;
+                }
+                if (refreshes < maxContextRefreshes && !repeatedContextRequest) {
+                    lastContextRequestFingerprint = contextRequestFingerprint;
+                    forcedNoContextAttemptUsed = false;
+                    refreshes += 1;
+                    attempts -= 1;
+                    await logRetryDecision({
+                        phase: toRuntimePhase("builder"),
+                        reason_code: "builder_context_refresh_retry",
+                        disposition: "retry",
+                        attempt: attempts + 1,
+                        max_attempts: this.options.maxRetries + 1,
+                        details: [
+                            contextRequest.reason ?? "builder_needs_context",
+                            `refresh=${refreshes}/${maxContextRefreshes}`,
+                        ],
+                    });
+                    if (this.options.logger) {
+                        await this.options.logger.log("context_refresh", {
+                            refresh: refreshes,
+                            queries: contextRequest.queries ?? [],
+                            files: contextRequest.files ?? [],
+                        });
+                    }
+                    await logPhaseArtifact("librarian", "input", {
+                        request,
+                        additional_queries: contextRequest.queries ?? [],
+                        preferred_files: contextRequest.files ?? [],
+                    });
+                    context = await this.runPhase("librarian", () => this.options.contextAssembler.assemble(request, {
+                        additionalQueries: contextRequest.queries,
+                        preferredFiles: contextRequest.files,
+                        recentFiles: contextRequest.files,
+                        forceFocusFiles: contextRequest.files,
+                    }));
+                    await logPhaseArtifact("librarian", "output", context);
+                    const revisionDetails = uniqueStrings([
+                        contextRequest.reason ? `Builder reason: ${contextRequest.reason}` : "",
+                        contextRequest.queries && contextRequest.queries.length > 0
+                            ? `Requested queries: ${contextRequest.queries.join(", ")}`
+                            : "",
+                        contextRequest.files && contextRequest.files.length > 0
+                            ? `Requested files: ${contextRequest.files.join(", ")}`
+                            : "",
+                    ].filter((entry) => entry.trim().length > 0));
+                    const architectRevisionHint = buildArchitectRevisionHint({
+                        reason: "builder_needs_context",
+                        details: revisionDetails.length > 0
+                            ? revisionDetails
+                            : ["Builder requested additional context to continue implementation."],
+                        plan,
+                    });
+                    await logPhaseArtifact("architect", "input", {
+                        request,
+                        reason: "builder_needs_context",
+                        context: buildSerializedContext(context),
+                        instruction_hint: architectRevisionHint,
+                        context_request: contextRequest,
+                    });
+                    if (useFastPath) {
+                        plan = buildFastPlan(context);
+                    }
+                    else {
+                        const planner = this.options.architectPlanner;
+                        const revisedPlanResult = planner.planWithRequest
+                            ? await this.runPhase("architect", () => planner.planWithRequest(context, {
+                                contextManager: this.options.contextManager,
+                                laneId: architectLaneId,
+                                instructionHint: architectRevisionHint,
+                                // Keep prior plan in instruction hint, but disable plan-hint short-circuit.
+                                planHint: "",
+                                responseFormat: undefined,
+                                validateOnly: false,
+                            }))
+                            : {
+                                plan: await this.runPhase("architect", () => planner.plan(context, {
+                                    contextManager: this.options.contextManager,
+                                    laneId: architectLaneId,
+                                    instructionHint: architectRevisionHint,
+                                    planHint: "",
+                                    responseFormat: undefined,
+                                })),
+                                raw: "",
+                                warnings: [],
+                            };
+                        const revisedWarnings = uniqueStrings([...(revisedPlanResult.warnings ?? [])]);
+                        const revisedQuality = assessPlanQualityGate(request, revisedPlanResult.plan, context);
+                        const blockingReasons = collectBlockingPlanQualityReasons(revisedQuality);
+                        await logPhaseArtifact("architect", "output", {
+                            source: "builder_context_refresh_revision",
+                            warnings: revisedWarnings,
+                            raw_output: revisedPlanResult.raw ?? "",
+                            normalized_output: revisedPlanResult.plan,
+                            quality_gate: revisedQuality,
+                        });
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_output", {
+                                source: "builder_context_refresh_revision",
+                                steps: revisedPlanResult.plan.steps.length,
+                                target_files: revisedPlanResult.plan.target_files.length,
+                                warnings: revisedWarnings,
+                                quality_ok: revisedQuality.ok,
+                                quality_reasons: revisedQuality.reasons,
+                                target_validation: revisedQuality.targetValidation ?? null,
+                            });
+                        }
+                        if (blockingReasons.length > 0) {
+                            const unresolved = revisedQuality.targetValidation?.unresolvedTargets ?? [];
+                            if (this.options.logger) {
+                                await this.options.logger.log("architect_quality_gate", {
+                                    stage: "builder_context_refresh_replan",
+                                    ok: false,
+                                    reasons: blockingReasons,
+                                    unresolved_targets: unresolved,
+                                });
+                            }
+                            criticResult = {
+                                status: "FAIL",
+                                reasons: [
+                                    `architect_replan_failed:${blockingReasons.join(",")}`,
+                                    ...unresolved.map((target) => `unresolved_target:${target}`),
+                                ],
+                                retryable: false,
+                            };
+                            break;
+                        }
+                        plan = revisedPlanResult.plan;
+                    }
+                    if (this.options.logger) {
+                        const planPath = await this.options.logger.writePhaseArtifact("architect", "plan", plan);
+                        await this.options.logger.log("architect_output", {
+                            steps: plan.steps.length,
+                            target_files: plan.target_files.length,
+                        });
+                        await this.options.logger.log("plan_json", { phase: "architect", path: planPath });
+                    }
+                    await logPhaseArtifact("architect", "output", plan);
+                    continue;
+                }
+                if (!forcedNoContextAttemptUsed) {
+                    forcedNoContextAttemptUsed = true;
+                    lastContextRequestFingerprint = contextRequestFingerprint;
+                    attempts -= 1;
+                    contextRefreshTerminationReason = "no_new_context";
+                    if (this.options.logger) {
+                        await this.options.logger.log("context_request_repeated_forced_builder_attempt", {
+                            reason: contextRequest.reason ?? null,
+                            queries: contextRequest.queries ?? [],
+                            files: contextRequest.files ?? [],
+                            repeated: repeatedContextRequest,
+                            refreshes,
+                            max_refreshes: maxContextRefreshes,
+                        });
+                    }
+                    await logRetryDecision({
+                        phase: toRuntimePhase("builder"),
+                        reason_code: "builder_context_refresh_retry",
+                        disposition: "retry",
+                        attempt: attempts + 1,
+                        max_attempts: this.options.maxRetries + 1,
+                        details: ["no_new_context", contextRequest.reason ?? "builder_needs_context"],
+                    });
+                    builderNote =
+                        "Context was already refreshed for this request. Do not emit needs_context again. " +
+                            "Proceed with a best-effort patch using current context, plan targets, and focus files only.";
+                    continue;
+                }
+                contextRefreshTerminationReason = repeatedContextRequest
+                    ? "no_new_context"
+                    : "refresh_budget_exhausted";
+                criticResult = {
+                    status: "FAIL",
+                    reasons: [`context_refresh_terminated:${contextRefreshTerminationReason}`],
+                    retryable: false,
+                };
+                await logRetryDecision({
+                    phase: toRuntimePhase("builder"),
+                    reason_code: "builder_context_refresh_terminated",
+                    disposition: "terminate",
+                    attempt: attempts,
+                    max_attempts: this.options.maxRetries + 1,
+                    details: [contextRefreshTerminationReason],
+                });
+                if (this.options.logger) {
+                    await this.options.logger.log("context_refresh_terminated", {
+                        reason: contextRefreshTerminationReason,
+                        repeated_request: repeatedContextRequest,
+                        refreshes,
+                        max_refreshes: maxContextRefreshes,
+                    });
+                }
+                break;
+            }
+            if (built.usage) {
+                await this.options.logger?.log("phase_usage", { phase: "builder", usage: built.usage });
+            }
+            const reviewer = this.options.architectPlanner;
+            if (reviewer.reviewBuilderOutput) {
+                await logPhaseArtifact("architect_review", "input", {
+                    plan,
+                    builder_output: built.finalMessage.content,
+                });
+                const review = await this.runPhase("architect_review", () => reviewer.reviewBuilderOutput(plan, built.finalMessage.content, context, {
+                    contextManager: this.options.contextManager,
+                    laneId: architectLaneId,
+                }));
+                await logPhaseArtifact("architect_review", "output", review);
+                if (this.options.logger) {
+                    await this.options.logger.log("architect_review", {
+                        status: review.status,
+                        reasons: review.reasons ?? [],
+                        feedback: review.feedback,
+                        warnings: review.warnings ?? [],
+                    });
+                }
+                if (review.status === "RETRY") {
+                    const reviewBlockingWarnings = collectArchitectReviewRetryBlockingWarnings(review.warnings ?? []);
+                    const reviewFixes = uniqueStrings([
+                        ...(review.feedback ?? []),
+                        ...((review.reasons ?? []).map((reason) => `Address: ${reason}`)),
+                        ...(reviewBlockingWarnings.length === 0
+                            ? ((review.warnings ?? []).map((warning) => `review_warning:${warning}`))
+                            : []),
+                    ])
+                        .map((entry) => entry.trim())
+                        .filter((entry) => entry.length > 0)
+                        .slice(0, 8);
+                    const reviewRetryActionable = reviewBlockingWarnings.length === 0 && reviewFixes.length > 0;
+                    if (!reviewRetryActionable) {
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_review_retry_non_actionable", {
+                                status: review.status,
+                                reasons: review.reasons ?? [],
+                                feedback: review.feedback ?? [],
+                                warnings: review.warnings ?? [],
+                                blocking_warnings: reviewBlockingWarnings,
+                            });
+                        }
+                        await logPhaseArtifact("architect_review", "non_actionable", {
+                            status: review.status,
+                            reasons: review.reasons ?? [],
+                            feedback: review.feedback ?? [],
+                            warnings: review.warnings ?? [],
+                            blocking_warnings: reviewBlockingWarnings,
+                        });
+                    }
+                    if (reviewRetryActionable && attempts <= this.options.maxRetries) {
+                        const revisionHint = buildArchitectRevisionHint({
+                            reason: "architect_review_retry",
+                            details: reviewFixes.length > 0
+                                ? reviewFixes
+                                : ["Architect review returned RETRY without concrete reasons. Repair the weakest plan sections."],
+                            plan,
+                        });
+                        await appendArchitectHistory(formatArchitectRevisionFeedback({
+                            reason: "architect_review_retry",
+                            details: reviewFixes.length > 0
+                                ? reviewFixes
+                                : ["Architect review returned RETRY without concrete reasons. Repair the weakest plan sections."],
+                            plan,
+                        }));
+                        const planner = this.options.architectPlanner;
+                        const revisedPlanResult = planner.planWithRequest
+                            ? await this.runPhase("architect", () => planner.planWithRequest(context, {
+                                contextManager: this.options.contextManager,
+                                laneId: architectLaneId,
+                                instructionHint: revisionHint,
+                                // Keep prior plan in instruction hint, but disable plan-hint short-circuit.
+                                planHint: "",
+                                validateOnly: false,
+                                responseFormat: undefined,
+                            }))
+                            : {
+                                plan: await this.runPhase("architect", () => planner.plan(context, {
+                                    contextManager: this.options.contextManager,
+                                    laneId: architectLaneId,
+                                    instructionHint: revisionHint,
+                                    responseFormat: undefined,
+                                })),
+                                raw: "",
+                                warnings: [],
+                            };
+                        const revisedWarnings = uniqueStrings([...(revisedPlanResult.warnings ?? [])]);
+                        const revisedPlanQuality = assessPlanQualityGate(request, revisedPlanResult.plan, context);
+                        const revisedBlocking = collectBlockingPlanQualityReasons(revisedPlanQuality);
+                        await logPhaseArtifact("architect", "output", {
+                            source: "architect_review_retry_revision",
+                            review,
+                            instruction_hint: revisionHint,
+                            plan_hint: null,
+                            raw_output: revisedPlanResult.raw ?? "",
+                            normalized_output: revisedPlanResult.plan,
+                            warnings: revisedWarnings,
+                            quality_gate: revisedPlanQuality,
+                        });
+                        if (this.options.logger) {
+                            await this.options.logger.log("architect_revision_result", {
+                                source: "architect_review_retry",
+                                reason: "architect_review_retry",
+                                warnings: revisedWarnings,
+                                quality_ok: revisedPlanQuality.ok,
+                                quality_reasons: revisedPlanQuality.reasons,
+                            });
+                        }
+                        if (revisedPlanResult.request) {
+                            builderNote = reviewFixes.length > 0
+                                ? `Architect review requested fixes: ${reviewFixes.join("; ")}`
+                                : "Architect review requested changes. Provide a corrected output.";
+                            await logRetryDecision({
+                                phase: toRuntimePhase("architect_review"),
+                                reason_code: "architect_review_retry",
+                                disposition: "retry",
+                                attempt: attempts,
+                                max_attempts: this.options.maxRetries + 1,
+                                details: reviewFixes,
+                            });
+                            continue;
+                        }
+                        if (revisedBlocking.length > 0) {
+                            criticResult = {
+                                status: "FAIL",
+                                reasons: [
+                                    "architect_review_retry_revision_failed",
+                                    ...revisedBlocking,
+                                ],
+                                retryable: false,
+                            };
+                            break;
+                        }
+                        plan = revisedPlanResult.plan;
+                        builderNote = reviewFixes.length > 0
+                            ? `Architect review requested fixes: ${reviewFixes.join("; ")}`
+                            : "Architect review requested changes. Provide a corrected output.";
+                        await logRetryDecision({
+                            phase: toRuntimePhase("architect_review"),
+                            reason_code: "architect_review_retry",
+                            disposition: "retry",
+                            attempt: attempts,
+                            max_attempts: this.options.maxRetries + 1,
+                            details: reviewFixes,
+                        });
+                        continue;
+                    }
+                    if (reviewRetryActionable) {
+                        criticResult = {
+                            status: "FAIL",
+                            reasons: ["architect_review_failed", ...review.feedback],
+                            retryable: false,
+                        };
+                        await logRetryDecision({
+                            phase: toRuntimePhase("architect_review"),
+                            reason_code: "architect_review_retry_exhausted",
+                            disposition: "terminate",
+                            attempt: attempts,
+                            max_attempts: this.options.maxRetries + 1,
+                            details: review.feedback,
+                        });
+                        break;
+                    }
+                }
+                const builderSemantic = assessBuilderSemanticAlignment(request, plan, built.finalMessage.content);
+                await logPhaseArtifact("architect_review", "semantic_guard", {
+                    assessment: builderSemantic,
+                    review_status: review.status,
+                    review_reasons: review.reasons ?? [],
+                });
+                if (this.options.logger) {
+                    await this.options.logger.log("architect_review_semantic_guard", {
+                        ok: builderSemantic.ok,
+                        score: builderSemantic.score,
+                        reasons: builderSemantic.reasons,
+                        matches: builderSemantic.matches,
+                        target_signals: builderSemantic.targetSignals,
+                        source: builderSemantic.source,
+                    });
+                }
+                if (!builderSemantic.ok) {
+                    if (attempts <= this.options.maxRetries) {
+                        builderNote =
+                            `Semantic guard requested fixes: ${builderSemantic.reasons.join("; ")}. ` +
+                                `Ensure output directly addresses request anchors (${builderSemantic.anchors.slice(0, 6).join(", ")}) ` +
+                                `and concrete plan targets (${plan.target_files.join(", ")}).`;
+                        await logRetryDecision({
+                            phase: toRuntimePhase("architect_review"),
+                            reason_code: "semantic_guard_retry",
+                            disposition: "retry",
+                            attempt: attempts,
+                            max_attempts: this.options.maxRetries + 1,
+                            details: builderSemantic.reasons,
+                        });
+                        continue;
+                    }
+                    criticResult = {
+                        status: "FAIL",
+                        reasons: ["architect_review_semantic_guard_failed", ...builderSemantic.reasons],
+                        retryable: false,
+                    };
+                    await logRetryDecision({
+                        phase: toRuntimePhase("architect_review"),
+                        reason_code: "semantic_guard_retry_exhausted",
+                        disposition: "terminate",
+                        attempt: attempts,
+                        max_attempts: this.options.maxRetries + 1,
+                        details: builderSemantic.reasons,
+                    });
+                    break;
+                }
+            }
+            const touchedAfter = this.options.getTouchedFiles?.() ?? touchedBefore;
+            const touchedBeforeSet = new Set(touchedBefore);
+            const touchedDelta = touchedAfter.filter((file) => !touchedBeforeSet.has(file));
+            const touchedFromBuilder = built.touchedFiles ?? [];
+            const touchedFiles = uniqueStrings([...touchedFromBuilder, ...touchedDelta]);
+            const effectiveTouchedFiles = touchedFiles.length > 0 ? touchedFiles : undefined;
+            await logPhaseArtifact("critic", "input", {
+                plan,
+                builder_output: built.finalMessage.content,
+                touched_files: effectiveTouchedFiles ?? [],
+            });
+            let criticRefreshes = 0;
+            while (true) {
+                const criticAllowedPaths = Array.from(new Set([...(plan.target_files ?? []), ...(plan.create_files ?? [])]));
+                const criticReadOnlyPaths = context.read_only_paths ?? [];
+                criticResult = await this.runPhase("critic", () => this.options.criticEvaluator.evaluate(plan, built.finalMessage.content, effectiveTouchedFiles, {
+                    contextManager: this.options.contextManager,
+                    laneId: criticLaneId,
+                    allowedPaths: criticAllowedPaths,
+                    readOnlyPaths: criticReadOnlyPaths,
+                    allowProtocolRequest: true,
+                    logger: this.options.logger,
+                    verificationPolicyName: this.options.verificationPolicyName,
+                    minimumVerificationChecks: this.options.minimumVerificationChecks,
+                    enforceHighConfidence: this.options.enforceVerificationHighConfidence,
+                }));
+                if (criticResult.request && criticRefreshes < maxContextRefreshes) {
+                    const response = await this.options.contextAssembler.fulfillAgentRequest(criticResult.request);
+                    await appendCriticHistory(formatCodaliResponse(response));
+                    if (this.options.logger) {
+                        await this.options.logger.log("critic_request_fulfilled", {
+                            request_id: criticResult.request.request_id,
+                            results: response.results.length,
+                            warnings: response.meta?.warnings ?? [],
+                        });
+                    }
+                    criticRefreshes += 1;
+                    continue;
+                }
+                break;
+            }
+            await logPhaseArtifact("critic", "output", criticResult);
+            if (this.options.logger) {
+                const verificationReport = criticResult.report?.verification ?? criticResult.verification;
+                if (verificationReport) {
+                    await this.options.logger.writePhaseArtifact("verify", "verification_report", verificationReport);
+                    if (typeof this.options.logger.logVerificationReport === "function") {
+                        await this.options.logger.logVerificationReport(verificationReport);
+                    }
+                }
+                await this.options.logger.log("critic_output", {
+                    status: criticResult.status,
+                    guardrail: criticResult.report?.guardrail ?? criticResult.guardrail ?? null,
+                    verification: verificationReport
+                        ? {
+                            outcome: verificationReport.outcome,
+                            reason_codes: verificationReport.reason_codes,
+                            high_confidence: criticResult.report?.high_confidence
+                                ?? criticResult.high_confidence
+                                ?? false,
+                        }
+                        : null,
+                });
+            }
+            const verificationReport = criticResult.report?.verification ?? criticResult.verification;
+            if (criticResult.status === "PASS"
+                && verificationReport?.policy.enforce_high_confidence
+                && verificationReport.outcome !== "verified_passed") {
+                const gateReasons = [
+                    "verification_high_confidence_gate_blocked",
+                    ...verificationReport.reason_codes.map((code) => `verification_${code}`),
+                ];
+                criticResult = {
+                    ...criticResult,
+                    status: "FAIL",
+                    reasons: uniqueStrings(gateReasons),
+                    retryable: false,
+                    high_confidence: false,
+                    report: {
+                        status: "FAIL",
+                        reasons: uniqueStrings(gateReasons),
+                        suggested_fixes: [
+                            "Run at least one concrete verification check that passes before accepting high-confidence completion.",
+                        ],
+                        touched_files: criticResult.report?.touched_files,
+                        plan_targets: criticResult.report?.plan_targets,
+                        alignment_evidence: criticResult.report?.alignment_evidence,
+                        guardrail: criticResult.report?.guardrail ?? criticResult.guardrail,
+                        high_confidence: false,
+                        verification: verificationReport,
+                    },
+                };
+                if (this.options.logger) {
+                    await this.options.logger.log("verification_high_confidence_gate", {
+                        status: "blocked",
+                        outcome: verificationReport.outcome,
+                        reason_codes: verificationReport.reason_codes,
+                        policy: verificationReport.policy,
+                    });
+                }
+            }
+            this.emitStatus("done", `critic result: ${criticResult.status}`);
+            await logLaneSummary("critic", criticLaneId);
+            if (criticResult.status === "PASS")
+                break;
+            await appendArchitectHistory(formatCodaliResponse(buildCriticResponse(criticResult)));
+            if (criticResult.retryable && attempts <= this.options.maxRetries) {
+                builderNote = criticResult.reasons.length
+                    ? `Critic failed: ${criticResult.reasons.join("; ")}`
+                    : "Critic failed. Provide a corrected output.";
+                await logRetryDecision({
+                    phase: toRuntimePhase("critic"),
+                    reason_code: "critic_retryable_failure",
+                    disposition: "retry",
+                    attempt: attempts,
+                    max_attempts: this.options.maxRetries + 1,
+                    details: criticResult.reasons,
+                });
+                continue;
+            }
+            if (!criticResult.retryable) {
+                await logRetryDecision({
+                    phase: toRuntimePhase("critic"),
+                    reason_code: "critic_non_retryable_failure",
+                    disposition: "terminate",
+                    attempt: attempts,
+                    max_attempts: this.options.maxRetries + 1,
+                    details: criticResult.reasons,
+                });
+                break;
+            }
+        }
+        if (!builderResult || !criticResult) {
+            throw new Error("SmartPipeline failed to produce results");
+        }
+        const preferences = context.preferences_detected ?? [];
+        if (criticResult.status === "FAIL") {
+            await this.options.memoryWriteback.persist({
+                failures: attempts,
+                maxRetries: this.options.maxRetries,
+                lesson: criticResult.reasons.join("; "),
+                preferences: preferences.length ? preferences : undefined,
+            });
+        }
+        else if (preferences.length) {
+            await this.options.memoryWriteback.persist({
+                failures: 0,
+                maxRetries: this.options.maxRetries,
+                lesson: "",
+                preferences,
+            });
+        }
+        if (this.phaseTracker.current === "verify" || this.phaseTracker.current === "answer") {
+            await this.runPhase("answer", async () => undefined);
+        }
+        return {
+            context,
+            research: researchPhase,
+            plan,
+            builderResult,
+            criticResult,
+            verification: criticResult.report?.verification ?? criticResult.verification,
+            attempts,
+            contextRefreshTerminationReason,
+            phaseTrace: [...this.phaseTracker.trace],
+        };
+    }
+    async runPhase(phase, fn) {
+        try {
+            this.transitionPhase(phase);
+        }
+        catch (error) {
+            if (this.options.logger && error instanceof RuntimePhaseTransitionError) {
+                await this.options.logger.log("phase_transition_error", { ...error.metadata });
+                await this.options.logger.writePhaseArtifact(phase, "summary", {
+                    status: "failed",
+                    reason_code: error.metadata.code,
+                    phase,
+                    started_at_ms: Date.now(),
+                    ended_at_ms: Date.now(),
+                    duration_ms: 0,
+                    error_class: error.name,
+                    error_message: error.message,
+                    phase_trace: error.metadata.phase_trace,
+                });
+            }
+            throw error;
+        }
+        const startedAt = Date.now();
+        this.emitStatus(this.phaseStatus(phase), `${phase}: start`);
+        if (this.options.logger) {
+            await this.options.logger.log("phase_start", { phase });
+        }
+        try {
+            const result = await fn();
+            const endedAt = Date.now();
+            const warnings = extractPhaseWarnings(phase, result);
+            const usage = extractPhaseUsage(result);
+            if (this.options.logger) {
+                await this.options.logger.log("phase_end", { phase, duration_ms: endedAt - startedAt });
+                await this.options.logger.writePhaseArtifact(phase, "summary", {
+                    status: "completed",
+                    phase,
+                    started_at_ms: startedAt,
+                    ended_at_ms: endedAt,
+                    duration_ms: endedAt - startedAt,
+                    warnings,
+                    usage,
+                });
+            }
+            this.emitStatus("done", `${phase}: done`);
+            return result;
+        }
+        catch (error) {
+            const endedAt = Date.now();
+            const errorWarnings = asStringArray(asObject(error)?.warnings);
+            if (this.options.logger) {
+                await this.options.logger.log("phase_end", {
+                    phase,
+                    duration_ms: endedAt - startedAt,
+                    error: error instanceof Error ? error.message : String(error),
+                    reason_code: error instanceof RuntimePhaseTransitionError ? error.metadata.code : undefined,
+                });
+                await this.options.logger.writePhaseArtifact(phase, "summary", {
+                    status: "failed",
+                    phase,
+                    started_at_ms: startedAt,
+                    ended_at_ms: endedAt,
+                    duration_ms: endedAt - startedAt,
+                    error_class: error instanceof Error ? error.name : "UnknownError",
+                    error_message: error instanceof Error ? error.message : String(error),
+                    reason_code: error instanceof RuntimePhaseTransitionError ? error.metadata.code : "phase_execution_error",
+                    warnings: errorWarnings,
+                });
+            }
+            this.emitStatus("done", `${phase}: failed`);
+            throw error;
+        }
+    }
+    emitStatus(phase, message) {
+        this.options.onEvent?.({ type: "status", phase, message });
+    }
+    phaseStatus(phase) {
+        if (phase === "builder")
+            return "executing";
+        if (phase === "critic")
+            return "thinking";
+        if (phase === "librarian" || phase === "architect")
+            return "thinking";
+        return "thinking";
+    }
+}