cclaw-cli 0.48.31 → 0.48.33

package/dist/content/ideate-frames.d.ts

@@ -0,0 +1,31 @@
+export type IdeateFrameId = "pain-friction" | "inversion" | "assumption-break" | "leverage" | "cross-domain-analogy" | "constraint-flip";
+export interface IdeateFrame {
+    id: IdeateFrameId;
+    label: string;
+    prompt: string;
+    examplePatterns: string[];
+}
+export interface IdeateFrameDispatchInput {
+    focus: string;
+    mode: "repo-grounded" | "elsewhere-software" | "elsewhere-non-software";
+    signalSummary: string[];
+}
+export interface IdeateFrameDispatchPlanEntry {
+    frameId: IdeateFrameId;
+    label: string;
+    prompt: string;
+}
+export interface IdeateCandidateDraft {
+    title: string;
+    evidencePath: string;
+    summary: string;
+    frameId: IdeateFrameId;
+}
+export interface IdeateCandidateMerged extends Omit<IdeateCandidateDraft, "frameId"> {
+    frameIds: IdeateFrameId[];
+}
+export declare const DEFAULT_IDEATE_FRAME_IDS: readonly IdeateFrameId[];
+export declare const IDEATE_FRAMES: readonly IdeateFrame[];
+export declare function resolveIdeateFrames(frameIds?: readonly IdeateFrameId[]): IdeateFrame[];
+export declare function buildIdeateFrameDispatchPlan(input: IdeateFrameDispatchInput, frameIds?: readonly IdeateFrameId[]): IdeateFrameDispatchPlanEntry[];
+export declare function dedupeIdeateCandidates(drafts: readonly IdeateCandidateDraft[]): IdeateCandidateMerged[];

package/dist/content/ideate-frames.js

@@ -0,0 +1,140 @@
+const FRAME_REGISTRY = {
+    "pain-friction": {
+        id: "pain-friction",
+        label: "pain/friction",
+        prompt: "Find repeated friction in the repo workflow. Prioritize changes that eliminate recurring toil, fragile handoffs, or repeated manual recovery.",
+        examplePatterns: [
+            "Repeated TODO/FIXME hotspots in one subsystem",
+            "Flows that require manual retries or ad-hoc scripts",
+            "Developer loops slowed by avoidable boilerplate"
+        ]
+    },
+    inversion: {
+        id: "inversion",
+        label: "inversion",
+        prompt: "Invert a dominant assumption in the current implementation (e.g., push vs pull, synchronous vs queued, implicit vs explicit) and evaluate upside.",
+        examplePatterns: [
+            "Replace optimistic assumptions with fail-closed defaults",
+            "Switch from post-facto checks to pre-flight validation",
+            "Move from global policy to module-local contracts"
+        ]
+    },
+    "assumption-break": {
+        id: "assumption-break",
+        label: "assumption-break",
+        prompt: "List assumptions that might be false in production. Generate ideas that remain correct even when those assumptions fail.",
+        examplePatterns: [
+            "Edge paths currently treated as impossible",
+            "Implicit coupling between modules with no explicit contract",
+            "Latency, scale, or environment assumptions baked into logic"
+        ]
+    },
+    leverage: {
+        id: "leverage",
+        label: "leverage",
+        prompt: "Target interventions with asymmetric payoff: one change that improves multiple stages, teams, or failure classes at once.",
+        examplePatterns: [
+            "A shared helper replacing duplicated logic in many files",
+            "One lint/gate that blocks an entire class of regressions",
+            "A protocol update that improves multiple stage outputs"
+        ]
+    },
+    "cross-domain-analogy": {
+        id: "cross-domain-analogy",
+        label: "cross-domain analogy",
+        prompt: "Borrow a proven pattern from another domain and adapt it to this repo. Keep it concrete and grounded in local constraints.",
+        examplePatterns: [
+            "Apply SRE-style error budgets to planning artifacts",
+            "Use security threat-model thinking for reliability design",
+            "Import CI release-train discipline into stage completion gates"
+        ]
+    },
+    "constraint-flip": {
+        id: "constraint-flip",
+        label: "constraint-flip",
+        prompt: "Flip one assumed constraint (time, team size, risk tolerance, compatibility) and derive better options under the new boundary.",
+        examplePatterns: [
+            "Assume near-zero migration window and redesign rollout",
+            "Assume one maintainer and optimize for low operational burden",
+            "Assume strict auditability and remove ambiguous behaviors"
+        ]
+    }
+};
+export const DEFAULT_IDEATE_FRAME_IDS = Object.freeze([
+    "pain-friction",
+    "inversion",
+    "assumption-break",
+    "leverage",
+    "cross-domain-analogy",
+    "constraint-flip"
+]);
+export const IDEATE_FRAMES = Object.freeze(DEFAULT_IDEATE_FRAME_IDS.map((id) => FRAME_REGISTRY[id]));
+export function resolveIdeateFrames(frameIds) {
+    if (!frameIds || frameIds.length === 0) {
+        return [...IDEATE_FRAMES];
+    }
+    const seen = new Set();
+    const resolved = [];
+    for (const rawId of frameIds) {
+        if (!DEFAULT_IDEATE_FRAME_IDS.includes(rawId)) {
+            throw new Error(`Unknown ideate frame id: ${rawId}`);
+        }
+        if (seen.has(rawId))
+            continue;
+        seen.add(rawId);
+        resolved.push(FRAME_REGISTRY[rawId]);
+    }
+    return resolved;
+}
+export function buildIdeateFrameDispatchPlan(input, frameIds) {
+    const signalBlock = input.signalSummary.length > 0
+        ? input.signalSummary.map((line) => `- ${line}`).join("\n")
+        : "- no pre-scan signals captured yet";
+    return resolveIdeateFrames(frameIds).map((frame) => ({
+        frameId: frame.id,
+        label: frame.label,
+        prompt: [
+            `Frame: ${frame.label} (${frame.id})`,
+            `Mode: ${input.mode}`,
+            `Focus: ${input.focus || "open-ended scan"}`,
+            "",
+            "Signal summary:",
+            signalBlock,
+            "",
+            `Frame prompt: ${frame.prompt}`,
+            "",
+            "Generate 3-5 concrete candidates with repo-grounded evidence."
+        ].join("\n")
+    }));
+}
+function normalizeCandidateKey(title, evidencePath) {
+    const normalizedTitle = title.trim().toLowerCase().replace(/[^a-z0-9]+/gu, " ").trim();
+    const normalizedEvidence = evidencePath
+        .trim()
+        .toLowerCase()
+        .replace(/\\/gu, "/");
+    return `${normalizedTitle}::${normalizedEvidence}`;
+}
+export function dedupeIdeateCandidates(drafts) {
+    const merged = new Map();
+    for (const draft of drafts) {
+        const key = normalizeCandidateKey(draft.title, draft.evidencePath);
+        const existing = merged.get(key);
+        if (!existing) {
+            merged.set(key, {
+                title: draft.title,
+                evidencePath: draft.evidencePath,
+                summary: draft.summary,
+                frameIds: [draft.frameId]
+            });
+            continue;
+        }
+        if (!existing.frameIds.includes(draft.frameId)) {
+            existing.frameIds.push(draft.frameId);
+        }
+        if (draft.summary.length > existing.summary.length) {
+            existing.summary = draft.summary;
+        }
+    }
+    return [...merged.values()];
+}

package/dist/content/ideate-ranking.d.ts

@@ -0,0 +1,25 @@
+export type IdeateImpact = "high" | "medium" | "low";
+export type IdeateEffort = "s" | "m" | "l";
+export type IdeateConfidence = "high" | "medium" | "low";
+export interface IdeateCandidateEvaluationInput {
+    id: string;
+    title: string;
+    impact: IdeateImpact;
+    effort: IdeateEffort;
+    confidence: IdeateConfidence;
+    rationaleStrength: number;
+    counterArgumentStrength: number;
+}
+export interface IdeateCandidateEvaluation extends IdeateCandidateEvaluationInput {
+    disposition: "survivor" | "critiqued-out";
+    rankingScore: number;
+}
+export interface IdeateRankingResult {
+    survivors: IdeateCandidateEvaluation[];
+    critiquedOut: IdeateCandidateEvaluation[];
+    recommendationId: string | null;
+}
+export declare function isCritiquedOut(rationaleStrength: number, counterArgumentStrength: number): boolean;
+export declare function scoreIdeateCandidate(impact: IdeateImpact, effort: IdeateEffort, confidence: IdeateConfidence): number;
+export declare function evaluateIdeateCandidate(input: IdeateCandidateEvaluationInput): IdeateCandidateEvaluation;
+export declare function rankIdeateCandidates(inputs: readonly IdeateCandidateEvaluationInput[], maxSurvivors?: number): IdeateRankingResult;

package/dist/content/ideate-ranking.js

@@ -0,0 +1,65 @@
+const IMPACT_POINTS = {
+    high: 9,
+    medium: 6,
+    low: 3
+};
+const EFFORT_COST = {
+    s: 1,
+    m: 2,
+    l: 3
+};
+const CONFIDENCE_MULTIPLIER = {
+    high: 1,
+    medium: 0.75,
+    low: 0.5
+};
+function clampStrength(value) {
+    if (!Number.isFinite(value))
+        return 0;
+    if (value < 0)
+        return 0;
+    if (value > 1)
+        return 1;
+    return value;
+}
+export function isCritiquedOut(rationaleStrength, counterArgumentStrength) {
+    return clampStrength(counterArgumentStrength) > clampStrength(rationaleStrength);
+}
+export function scoreIdeateCandidate(impact, effort, confidence) {
+    const raw = (IMPACT_POINTS[impact] / EFFORT_COST[effort]) * CONFIDENCE_MULTIPLIER[confidence];
+    return Number(raw.toFixed(3));
+}
+export function evaluateIdeateCandidate(input) {
+    const disposition = isCritiquedOut(input.rationaleStrength, input.counterArgumentStrength)
+        ? "critiqued-out"
+        : "survivor";
+    return {
+        ...input,
+        disposition,
+        rankingScore: scoreIdeateCandidate(input.impact, input.effort, input.confidence)
+    };
+}
+export function rankIdeateCandidates(inputs, maxSurvivors = 10) {
+    const evaluated = inputs.map(evaluateIdeateCandidate);
+    const survivors = evaluated
+        .filter((candidate) => candidate.disposition === "survivor")
+        .sort((left, right) => {
+        if (right.rankingScore !== left.rankingScore) {
+            return right.rankingScore - left.rankingScore;
+        }
+        if (right.rationaleStrength !== left.rationaleStrength) {
+            return right.rationaleStrength - left.rationaleStrength;
+        }
+        return left.id.localeCompare(right.id);
+    })
+        .slice(0, Math.max(0, maxSurvivors));
+    const survivorIds = new Set(survivors.map((candidate) => candidate.id));
+    const critiquedOut = evaluated
+        .filter((candidate) => candidate.disposition === "critiqued-out" || !survivorIds.has(candidate.id))
+        .sort((left, right) => left.id.localeCompare(right.id));
+    return {
+        survivors,
+        critiquedOut,
+        recommendationId: survivors[0]?.id ?? null
+    };
+}

package/dist/content/node-hooks.js

@@ -1,6 +1,7 @@
 import { DEFAULT_COMPOUND_RECURRENCE_THRESHOLD } from "../config.js";
 import { RUNTIME_ROOT } from "../constants.js";
 import { SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD, SMALL_PROJECT_RECURRENCE_THRESHOLD } from "../knowledge-store.js";
+import { HOOK_INLINE_SHARED_HELPERS, COMPOUND_READINESS_INLINE_SOURCE, RALPH_LOOP_INLINE_SOURCE } from "./hook-inline-snippets.js";
 function normalizePatterns(patterns, fallback) {
     if (!patterns || patterns.length === 0)
         return [...fallback];
@@ -1451,203 +1452,14 @@ async function handlePromptGuard(runtime) {
   return 0;
 }
 
-function normalizeCompoundLastUpdatedAt(date) {
-  return date.toISOString().replace(/\\.\\d{3}Z$/u, "Z");
-}
-
-// Count archived runs as sub-directories under \`.cclaw/runs/\`. Missing
-// dir returns 0; unexpected errors return undefined so the caller can
-// skip the small-project relaxation rather than guess.
-async function countArchivedRunsInline(root) {
-  const dir = path.join(root, RUNTIME_ROOT, "runs");
-  try {
-    const entries = await fs.readdir(dir, { withFileTypes: true });
-    return entries.filter((entry) => entry.isDirectory()).length;
-  } catch (error) {
-    const code = error && typeof error === "object" && "code" in error ? error.code : null;
-    if (code === "ENOENT") return 0;
-    return undefined;
-  }
-}
-
-// Mirrors src/knowledge-store.ts::computeCompoundReadiness — kept inline so
-// SessionStart can refresh compound-readiness.json without the CLI binary.
-// Any schema change must update src/knowledge-store.ts::computeCompoundReadiness
-// and src/internal/compound-readiness.ts in lockstep. Parity is enforced by
-// tests/unit/ralph-loop-parity.test.ts.
-async function computeCompoundReadinessInline(root, options) {
-  const filePath = path.join(root, RUNTIME_ROOT, "knowledge.jsonl");
-  // Caller may supply pre-read raw to avoid double-reading knowledge.jsonl.
-  const raw = typeof (options && options.prereadRaw) === "string"
-    ? options.prereadRaw
-    : await readTextFile(filePath, "");
-  const baseThresholdRaw = options && options.threshold;
-  const baseThreshold = Number.isInteger(baseThresholdRaw) && baseThresholdRaw >= 1
-    ? baseThresholdRaw
-    : COMPOUND_RECURRENCE_THRESHOLD;
-  const archivedRunsCount =
-    typeof (options && options.archivedRunsCount) === "number" &&
-    Number.isFinite(options.archivedRunsCount) &&
-    options.archivedRunsCount >= 0
-      ? Math.floor(options.archivedRunsCount)
-      : undefined;
-  const smallProjectRelaxationApplied =
-    archivedRunsCount !== undefined &&
-    archivedRunsCount < SMALL_PROJECT_ARCHIVE_RUNS_THRESHOLD &&
-    baseThreshold > SMALL_PROJECT_RECURRENCE_THRESHOLD;
-  const threshold = smallProjectRelaxationApplied
-    ? SMALL_PROJECT_RECURRENCE_THRESHOLD
-    : baseThreshold;
-  const maxReady = Number.isInteger(options && options.maxReady) && options.maxReady >= 1
-    ? options.maxReady
-    : 10;
-  const normalize = (value) => String(value == null ? "" : value).trim().replace(/\\s+/gu, " ").toLowerCase();
-  const severityWeight = (sev) => {
-    if (sev === "critical") return 3;
-    if (sev === "important") return 2;
-    if (sev === "suggestion") return 1;
-    return 0;
-  };
-  const buckets = new Map();
-  for (const rawLine of raw.split(/\\r?\\n/gu)) {
-    const line = rawLine.trim();
-    if (line.length === 0) continue;
-    let row;
-    try { row = JSON.parse(line); } catch { continue; }
-    if (!row || typeof row !== "object" || Array.isArray(row)) continue;
-    if (row.maturity === "lifted-to-enforcement") continue;
-    const type = typeof row.type === "string" ? row.type : "";
-    const trigger = typeof row.trigger === "string" ? row.trigger : "";
-    const action = typeof row.action === "string" ? row.action : "";
-    if (type.length === 0 || trigger.length === 0 || action.length === 0) continue;
-    const key = type + "||" + normalize(trigger) + "||" + normalize(action);
-    const frequency = Number.isInteger(row.frequency) && row.frequency > 0 ? Math.floor(row.frequency) : 1;
-    const lastSeen = typeof row.last_seen_ts === "string" ? row.last_seen_ts : "";
-    let bucket = buckets.get(key);
-    if (!bucket) {
-      bucket = {
-        trigger,
-        action,
-        recurrence: frequency,
-        entryCount: 1,
-        severity: typeof row.severity === "string" ? row.severity : undefined,
-        lastSeenTs: lastSeen,
-        types: new Set([type]),
-        maturity: new Set([typeof row.maturity === "string" ? row.maturity : "raw"])
-      };
-      buckets.set(key, bucket);
-      continue;
-    }
-    bucket.recurrence += frequency;
-    bucket.entryCount += 1;
-    bucket.types.add(type);
-    bucket.maturity.add(typeof row.maturity === "string" ? row.maturity : "raw");
-    if (row.severity === "critical") {
-      bucket.severity = "critical";
-    } else if (row.severity === "important" && bucket.severity !== "critical") {
-      bucket.severity = "important";
-    }
-    if (lastSeen && Date.parse(lastSeen) > Date.parse(bucket.lastSeenTs || "0")) {
-      bucket.lastSeenTs = lastSeen;
-    }
-  }
-  const ready = [];
-  for (const bucket of buckets.values()) {
-    const criticalOverride = bucket.severity === "critical";
-    const meetsRecurrence = bucket.recurrence >= threshold;
-    if (!criticalOverride && !meetsRecurrence) continue;
-    ready.push({
-      trigger: bucket.trigger,
-      action: bucket.action,
-      recurrence: bucket.recurrence,
-      entryCount: bucket.entryCount,
-      qualification: criticalOverride && !meetsRecurrence ? "critical_override" : "recurrence",
-      ...(bucket.severity ? { severity: bucket.severity } : {}),
-      lastSeenTs: bucket.lastSeenTs,
-      types: Array.from(bucket.types).sort(),
-      maturity: Array.from(bucket.maturity).sort()
-    });
-  }
-  ready.sort((a, b) => {
-    const sevDiff = severityWeight(b.severity) - severityWeight(a.severity);
-    if (sevDiff !== 0) return sevDiff;
-    if (b.recurrence !== a.recurrence) return b.recurrence - a.recurrence;
-    const recencyDiff = Date.parse(b.lastSeenTs || "0") - Date.parse(a.lastSeenTs || "0");
-    if (!Number.isNaN(recencyDiff) && recencyDiff !== 0) return recencyDiff;
-    return String(a.trigger).localeCompare(String(b.trigger));
-  });
-  return {
-    schemaVersion: 2,
-    threshold,
-    baseThreshold,
-    ...(archivedRunsCount !== undefined ? { archivedRunsCount } : {}),
-    smallProjectRelaxationApplied,
-    clusterCount: buckets.size,
-    readyCount: ready.length,
-    ready: ready.slice(0, maxReady),
-    lastUpdatedAt: normalizeCompoundLastUpdatedAt(new Date())
-  };
-}
-
-// Mirrors src/tdd-cycle.ts::computeRalphLoopStatus — kept inline so the
-// SessionStart hook can write ralph-loop.json without depending on the CLI
-// binary being installed globally. Any schema change must update both copies.
-async function computeRalphLoopStatusInline(stateDir, runId) {
-  const filePath = path.join(stateDir, "tdd-cycle-log.jsonl");
-  const raw = await readTextFile(filePath, "");
-  const sliceMap = new Map();
-  const acClosed = new Set();
-  const redOpenSlices = [];
-  let loopIteration = 0;
-  for (const rawLine of raw.split(/\\r?\\n/gu)) {
-    const line = rawLine.trim();
-    if (line.length === 0) continue;
-    let row;
-    try { row = JSON.parse(line); } catch { continue; }
-    if (!row || typeof row !== "object" || Array.isArray(row)) continue;
-    const rowRun = typeof row.runId === "string" && row.runId.length > 0 ? row.runId : runId;
-    if (rowRun !== runId) continue;
-    const slice = typeof row.slice === "string" && row.slice.length > 0 ? row.slice : "S-unknown";
-    let state = sliceMap.get(slice);
-    if (!state) {
-      state = { slice, redCount: 0, greenCount: 0, refactorCount: 0, redOpen: false, acIds: [] };
-      sliceMap.set(slice, state);
-    }
-    const exitCode = typeof row.exitCode === "number" ? row.exitCode : undefined;
-    if (row.phase === "red") {
-      state.redCount += 1;
-      if (exitCode !== undefined && exitCode !== 0) state.redOpen = true;
-    } else if (row.phase === "green") {
-      state.greenCount += 1;
-      state.redOpen = false;
-      loopIteration += 1;
-      if (Array.isArray(row.acIds)) {
-        for (const acId of row.acIds) {
-          if (typeof acId !== "string" || acId.length === 0) continue;
-          acClosed.add(acId);
-          if (!state.acIds.includes(acId)) state.acIds.push(acId);
-        }
-      }
-    } else if (row.phase === "refactor") {
-      state.refactorCount += 1;
-    }
-  }
-  for (const state of sliceMap.values()) {
-    if (state.redOpen) redOpenSlices.push(state.slice);
-  }
-  const slices = Array.from(sliceMap.values()).sort((a, b) => a.slice.localeCompare(b.slice, "en"));
-  return {
-    schemaVersion: 1,
-    runId,
-    loopIteration,
-    redOpen: redOpenSlices.length > 0,
-    redOpenSlices,
-    acClosed: Array.from(acClosed).sort(),
-    sliceCount: slices.length,
-    slices,
-    lastUpdatedAt: new Date().toISOString()
-  };
-}
+// Inline mirrors of canonical CLI computations (compound-readiness,
+// ralph-loop) are factored into src/content/hook-inline-snippets.ts so
+// this 2000+-line file no longer owns their bodies. Each snippet carries
+// an explicit "mirrors X, parity enforced by Y" comment in the snippets
+// module. Parity is enforced by tests/unit/ralph-loop-parity.test.ts.
+${HOOK_INLINE_SHARED_HELPERS}
+${COMPOUND_READINESS_INLINE_SOURCE}
+${RALPH_LOOP_INLINE_SOURCE}
 
 async function hasFailingRedEvidenceForPath(stateDir, runId, rawPath) {
   const cycleRaw = await readTextFile(path.join(stateDir, "tdd-cycle-log.jsonl"), "");

package/dist/content/review-loop.d.ts

@@ -0,0 +1,192 @@
+import type { FlowStage } from "../types.js";
+import type { SkillEnvelope } from "./stage-schema.js";
+export declare const REVIEW_LOOP_STAGES: readonly ["scope", "design"];
+export type ReviewLoopStage = (typeof REVIEW_LOOP_STAGES)[number];
+export declare const REVIEW_LOOP_DEFAULT_MAX_ITERATIONS = 3;
+export declare const REVIEW_LOOP_DEFAULT_TARGET_SCORE = 0.8;
+export type ReviewFindingSeverity = "critical" | "important" | "suggestion";
+export type ReviewLoopStopReason = "quality_threshold_met" | "max_iterations_reached" | "user_opt_out";
+export interface ReviewLoopDimension {
+    id: string;
+    label: string;
+    weight: number;
+    guidance: string;
+}
+export interface ReviewLoopDimensionScore {
+    dimensionId: string;
+    score: number;
+    weight?: number;
+    rationale?: string;
+}
+export interface ReviewFinding {
+    id: string;
+    dimensionId: string;
+    severity: ReviewFindingSeverity;
+    summary: string;
+    evidence?: string;
+    recommendation?: string;
+}
+export interface ReviewLoopBudget {
+    maxIterations?: number;
+    targetScore?: number;
+}
+export interface ReviewLoopIterationSummary {
+    iteration: number;
+    qualityScore: number;
+    findingsCount: number;
+}
+export interface ReviewLoopInput {
+    artifactPath: string;
+    stage: ReviewLoopStage;
+    checklist?: readonly ReviewLoopDimension[];
+    priorIterations?: ReadonlyArray<ReviewLoopIterationSummary>;
+    budget?: ReviewLoopBudget;
+}
+export interface ReviewLoopDispatchRequest {
+    stage: ReviewLoopStage;
+    artifactPath: string;
+    checklist: readonly ReviewLoopDimension[];
+    priorIterations: ReadonlyArray<ReviewLoopIterationSummary>;
+    iteration: number;
+    budget: Required<ReviewLoopBudget>;
+}
+export interface ReviewLoopIterationResult {
+    qualityScore: number;
+    findings: ReviewFinding[];
+    iteration: number;
+    shouldContinue: boolean;
+    dimensionScores: ReviewLoopDimensionScore[];
+}
+export interface ReviewLoopEnvelope {
+    type: "review-loop";
+    version: "1";
+    stage: ReviewLoopStage;
+    artifactPath: string;
+    targetScore: number;
+    maxIterations: number;
+    stopReason: ReviewLoopStopReason;
+    iterations: ReviewLoopIterationSummary[];
+}
+export interface ReviewLoopRunResult {
+    iterations: ReviewLoopIterationResult[];
+    qualityScore: number;
+    stopReason: ReviewLoopStopReason;
+    envelope: ReviewLoopEnvelope;
+}
+export type ReviewLoopDispatcher = (request: ReviewLoopDispatchRequest) => Promise<unknown>;
+export interface ReviewLoopDispatchAdapterRequest {
+    request: ReviewLoopDispatchRequest;
+    prompt: string;
+    responseSchema: string;
+}
+export type ReviewLoopDispatchAdapter = (payload: ReviewLoopDispatchAdapterRequest) => Promise<unknown>;
+export interface ReviewLoopSecondOpinionPolicy {
+    enabled?: boolean;
+    scoreDeltaThreshold?: number;
+    modelLabel?: string;
+}
+export interface ReviewLoopSecondOpinionMeta {
+    enabled: boolean;
+    modelLabel?: string;
+    primaryScore: number;
+    secondOpinionScore: number;
+    scoreDelta: number;
+    threshold: number;
+}
+export type ReviewLoopApplyFindings = (iteration: ReviewLoopIterationResult) => Promise<void> | void;
+export interface RunReviewLoopOptions {
+    dispatcher: ReviewLoopDispatcher;
+    applyFindings: ReviewLoopApplyFindings;
+    shouldOptOut?: () => boolean;
+    emitEnvelope?: (envelope: ReviewLoopEnvelope) => void;
+}
+export declare const REVIEW_LOOP_CHECKLISTS: {
+    readonly scope: readonly [{
+        readonly id: "premise_fit";
+        readonly label: "Premise fit";
+        readonly weight: 1;
+        readonly guidance: "Does the scope contract solve the actual user/problem framing without drifting into adjacent asks?";
+    }, {
+        readonly id: "alternatives_coverage";
+        readonly label: "Alternatives coverage";
+        readonly weight: 1;
+        readonly guidance: "Are meaningful alternatives compared with explicit trade-offs and one clear recommendation?";
+    }, {
+        readonly id: "error_rescue_registry";
+        readonly label: "Error and rescue coverage";
+        readonly weight: 1;
+        readonly guidance: "Does each scoped capability define failure mode, detection signal, and fallback/rescue behavior?";
+    }, {
+        readonly id: "scope_creep_risk";
+        readonly label: "Scope-creep risk";
+        readonly weight: 1;
+        readonly guidance: "Are in/out boundaries explicit and protected against silent expansion/reduction language?";
+    }, {
+        readonly id: "completion_status_fidelity";
+        readonly label: "Completion status fidelity";
+        readonly weight: 1;
+        readonly guidance: "Does the completion dashboard honestly report unresolved risks, decision count, and stop reason?";
+    }];
+    readonly design: readonly [{
+        readonly id: "architecture_fit";
+        readonly label: "Architecture fit";
+        readonly weight: 1;
+        readonly guidance: "Do architecture boundaries and diagrams align with scope and real blast-radius code?";
+    }, {
+        readonly id: "failure_mode_coverage";
+        readonly label: "Failure-mode coverage";
+        readonly weight: 1;
+        readonly guidance: "Does the failure-mode table capture method/exception/rescue/user-visible impact for critical paths?";
+    }, {
+        readonly id: "test_coverage_realism";
+        readonly label: "Test coverage realism";
+        readonly weight: 1;
+        readonly guidance: "Is the proposed test split realistic (unit/integration/e2e) with explicit gap handling?";
+    }, {
+        readonly id: "performance_budget";
+        readonly label: "Performance budget";
+        readonly weight: 1;
+        readonly guidance: "Are critical metrics, thresholds, and measurement methods concrete and enforceable?";
+    }, {
+        readonly id: "observability_adequacy";
+        readonly label: "Observability adequacy";
+        readonly weight: 1;
+        readonly guidance: "Can on-call trace a failure from user symptom to root cause via logs/metrics/traces/alerts?";
+    }];
+};
+export declare function buildOutsideVoiceReviewPrompt(request: ReviewLoopDispatchRequest): string;
+export declare function createOutsideVoiceDispatcher(adapter: ReviewLoopDispatchAdapter): ReviewLoopDispatcher;
+export declare function parseReviewLoopDispatcherResult(raw: unknown, checklist: readonly ReviewLoopDimension[]): {
+    findings: ReviewFinding[];
+    dimensionScores: ReviewLoopDimensionScore[];
+};
+export declare function mergeSecondOpinionResults(primaryRaw: unknown, secondOpinionRaw: unknown, checklist: readonly ReviewLoopDimension[], policy?: ReviewLoopSecondOpinionPolicy): {
+    findings: ReviewFinding[];
+    dimensionScores: ReviewLoopDimensionScore[];
+    secondOpinion: ReviewLoopSecondOpinionMeta;
+};
+export declare function createSecondOpinionDispatcher(args: {
+    primary: ReviewLoopDispatcher;
+    secondOpinion?: ReviewLoopDispatcher;
+    policy?: ReviewLoopSecondOpinionPolicy;
+}): ReviewLoopDispatcher;
+export declare function aggregateQualityScore(scores: readonly ReviewLoopDimensionScore[], checklist: readonly ReviewLoopDimension[]): number;
+export declare function runReviewLoopIteration(input: ReviewLoopInput & {
+    iteration: number;
+}, dispatcher: ReviewLoopDispatcher): Promise<ReviewLoopIterationResult>;
+export declare function buildReviewLoopEnvelope(args: {
+    stage: ReviewLoopStage;
+    artifactPath: string;
+    targetScore: number;
+    maxIterations: number;
+    stopReason: ReviewLoopStopReason;
+    iterations: ReadonlyArray<ReviewLoopIterationSummary>;
+}): ReviewLoopEnvelope;
+export declare function renderReviewLoopHeader(envelope: ReviewLoopEnvelope): string;
+export declare function upsertReviewLoopHeader(markdown: string, envelope: ReviewLoopEnvelope): string;
+export declare function renderReviewLoopSummarySection(envelope: ReviewLoopEnvelope): string;
+export declare function upsertReviewLoopSummary(markdown: string, envelope: ReviewLoopEnvelope): string;
+export declare function extractReviewLoopEnvelopeFromArtifact(markdown: string, stage: ReviewLoopStage, artifactPath: string): ReviewLoopEnvelope | null;
+export declare function toSkillEnvelope(envelope: ReviewLoopEnvelope, emittedAt?: string, agent?: string): SkillEnvelope;
+export declare function runReviewLoop(input: ReviewLoopInput, options: RunReviewLoopOptions): Promise<ReviewLoopRunResult>;
+export declare function isReviewLoopStage(stage: FlowStage): stage is ReviewLoopStage;