cclaw-cli 7.7.1 → 8.1.1

package/dist/internal/advance-stage/parsers.js

@@ -1,357 +0,0 @@
-import { FLOW_STAGES } from "../../types.js";
-import { isDiscoveryMode, isFlowTrack } from "../../flow-state.js";
-import { isFlowStageValue, parseCsv, parseEvidenceByGate, unique } from "./helpers.js";
-export function parseAdvanceStageArgs(tokens) {
-    const [stageRaw, ...flagTokens] = tokens;
-    if (!isFlowStageValue(stageRaw)) {
-        throw new Error(`internal advance-stage requires a stage positional argument (${FLOW_STAGES.join(", ")}).`);
-    }
-    let evidenceJson;
-    let passed = [];
-    let waiveDelegations = [];
-    let waiverReason;
-    let acceptProactiveWaiver = false;
-    let acceptProactiveWaiverReason;
-    let acceptProactiveWaiverToken;
-    let skipQuestions = false;
-    let quiet = false;
-    let json = false;
-    for (let i = 0; i < flagTokens.length; i += 1) {
-        const token = flagTokens[i];
-        const nextToken = flagTokens[i + 1];
-        if (token === "--json") {
-            json = true;
-            continue;
-        }
-        if (token === "--quiet") {
-            quiet = true;
-            continue;
-        }
-        if (token === "--evidence-json") {
-            if (!nextToken || nextToken.startsWith("--")) {
-                throw new Error("--evidence-json requires a JSON object value.");
-            }
-            evidenceJson = nextToken;
-            i += 1;
-            continue;
-        }
-        if (token.startsWith("--evidence-json=")) {
-            evidenceJson = token.slice("--evidence-json=".length);
-            continue;
-        }
-        if (token === "--passed") {
-            if (!nextToken || nextToken.startsWith("--")) {
-                throw new Error("--passed requires a comma-separated gate list.");
-            }
-            passed = [...passed, ...parseCsv(nextToken)];
-            i += 1;
-            continue;
-        }
-        if (token.startsWith("--passed=")) {
-            passed = [...passed, ...parseCsv(token.slice("--passed=".length))];
-            continue;
-        }
-        if (token === "--waive-delegation") {
-            if (!nextToken || nextToken.startsWith("--")) {
-                throw new Error("--waive-delegation requires a comma-separated agent list.");
-            }
-            waiveDelegations = [...waiveDelegations, ...parseCsv(nextToken)];
-            i += 1;
-            continue;
-        }
-        if (token.startsWith("--waive-delegation=")) {
-            waiveDelegations = [
-                ...waiveDelegations,
-                ...parseCsv(token.slice("--waive-delegation=".length))
-            ];
-            continue;
-        }
-        if (token === "--waiver-reason") {
-            if (!nextToken || nextToken.startsWith("--")) {
-                throw new Error("--waiver-reason requires a text value.");
-            }
-            waiverReason = nextToken.trim();
-            i += 1;
-            continue;
-        }
-        if (token.startsWith("--waiver-reason=")) {
-            waiverReason = token.slice("--waiver-reason=".length).trim();
-            continue;
-        }
-        if (token === "--accept-proactive-waiver") {
-            acceptProactiveWaiver = true;
-            continue;
-        }
-        if (token.startsWith("--accept-proactive-waiver=")) {
-            acceptProactiveWaiver = true;
-            acceptProactiveWaiverToken = token.slice("--accept-proactive-waiver=".length).trim();
-            continue;
-        }
-        if (token === "--skip-questions") {
-            skipQuestions = true;
-            continue;
-        }
-        if (token === "--accept-proactive-waiver-reason") {
-            if (!nextToken || nextToken.startsWith("--")) {
-                throw new Error("--accept-proactive-waiver-reason requires a text value.");
-            }
-            acceptProactiveWaiverReason = nextToken.trim();
-            i += 1;
-            continue;
-        }
-        if (token.startsWith("--accept-proactive-waiver-reason=")) {
-            acceptProactiveWaiverReason = token.slice("--accept-proactive-waiver-reason=".length).trim();
-            continue;
-        }
-        throw new Error(`Unknown flag for internal advance-stage: ${token}`);
-    }
-    return {
-        stage: stageRaw,
-        passedGateIds: unique(passed),
-        evidenceByGate: parseEvidenceByGate(evidenceJson),
-        waiveDelegations: unique(waiveDelegations),
-        waiverReason,
-        acceptProactiveWaiver,
-        acceptProactiveWaiverReason,
-        acceptProactiveWaiverToken,
-        skipQuestions,
-        quiet,
-        json
-    };
-}
-export function parseVerifyFlowStateDiffArgs(tokens) {
-    let afterJson;
-    let afterFile;
-    let quiet = false;
-    for (const token of tokens) {
-        if (token === "--quiet") {
-            quiet = true;
-            continue;
-        }
-        if (token.startsWith("--after-json=")) {
-            afterJson = token.replace("--after-json=", "");
-            continue;
-        }
-        if (token.startsWith("--after-file=")) {
-            afterFile = token.replace("--after-file=", "");
-            continue;
-        }
-        throw new Error(`Unknown flag for internal verify-flow-state-diff: ${token}`);
-    }
-    if (!afterJson && !afterFile) {
-        throw new Error("internal verify-flow-state-diff requires --after-json=<json> or --after-file=<path>.");
-    }
-    return { afterJson, afterFile, quiet };
-}
-export function parseVerifyCurrentStateArgs(tokens) {
-    let quiet = false;
-    for (const token of tokens) {
-        if (token === "--quiet") {
-            quiet = true;
-            continue;
-        }
-        throw new Error(`Unknown flag for internal verify-current-state: ${token}`);
-    }
-    return { quiet };
-}
-export function parseRewindArgs(tokens) {
-    let quiet = false;
-    let json = false;
-    const positional = [];
-    for (let i = 0; i < tokens.length; i += 1) {
-        const token = tokens[i];
-        const nextToken = tokens[i + 1];
-        if (token === "--quiet") {
-            quiet = true;
-            continue;
-        }
-        if (token === "--json") {
-            json = true;
-            continue;
-        }
-        if (token === "--ack") {
-            if (!nextToken || nextToken.startsWith("--")) {
-                throw new Error("--ack requires a stage value.");
-            }
-            if (!isFlowStageValue(nextToken)) {
-                throw new Error(`--ack stage must be one of: ${FLOW_STAGES.join(", ")}.`);
-            }
-            i += 1;
-            return { mode: "ack", targetStage: nextToken, quiet, json };
-        }
-        if (token.startsWith("--ack=")) {
-            const stage = token.slice("--ack=".length);
-            if (!isFlowStageValue(stage)) {
-                throw new Error(`--ack stage must be one of: ${FLOW_STAGES.join(", ")}.`);
-            }
-            return { mode: "ack", targetStage: stage, quiet, json };
-        }
-        positional.push(token);
-    }
-    const [targetStage, ...reasonParts] = positional;
-    if (!isFlowStageValue(targetStage)) {
-        throw new Error(`internal rewind requires a target stage (${FLOW_STAGES.join(", ")}) or --ack <stage>.`);
-    }
-    const reason = reasonParts.join(" ").trim();
-    if (reason.length === 0) {
-        throw new Error('internal rewind requires a reason, for example: cclaw internal rewind tdd "review_blocked_by_critical".');
-    }
-    return { mode: "rewind", targetStage, reason, quiet, json };
-}
-export function parseHookArgs(tokens) {
-    const [hookName, ...rest] = tokens;
-    const normalizedHook = typeof hookName === "string" ? hookName.trim() : "";
-    if (normalizedHook.length === 0) {
-        throw new Error("internal hook requires a hook name: cclaw internal hook <name>.");
-    }
-    if (rest.length > 0) {
-        throw new Error(`Unknown arguments for internal hook: ${rest.join(" ")}`);
-    }
-    return { hookName: normalizedHook };
-}
-export function parseStartFlowArgs(tokens) {
-    let track;
-    let discoveryMode = "guided";
-    let className;
-    let prompt;
-    let reason;
-    let stack;
-    let forceReset = false;
-    let reclassify = false;
-    let quiet = false;
-    let fromIdeaArtifact;
-    let fromIdeaCandidateId;
-    for (let i = 0; i < tokens.length; i += 1) {
-        const token = tokens[i];
-        const nextToken = tokens[i + 1];
-        const readValue = (flag) => {
-            if (token.startsWith(`${flag}=`))
-                return token.slice(flag.length + 1);
-            if (token === flag && nextToken && !nextToken.startsWith("--")) {
-                i += 1;
-                return nextToken;
-            }
-            throw new Error(`${flag} requires a value.`);
-        };
-        if (token === "--quiet") {
-            quiet = true;
-            continue;
-        }
-        if (token === "--force-reset") {
-            forceReset = true;
-            continue;
-        }
-        if (token === "--reclassify") {
-            reclassify = true;
-            continue;
-        }
-        if (token === "--track" || token.startsWith("--track=")) {
-            const raw = readValue("--track").trim();
-            if (!isFlowTrack(raw)) {
-                throw new Error(`--track must be one of: standard, medium, quick.`);
-            }
-            track = raw;
-            continue;
-        }
-        if (token === "--discovery-mode" || token.startsWith("--discovery-mode=")) {
-            const raw = readValue("--discovery-mode").trim();
-            const normalized = raw.toLowerCase();
-            if (!isDiscoveryMode(normalized)) {
-                throw new Error(`--discovery-mode must be one of: lean, guided, deep.`);
-            }
-            discoveryMode = normalized;
-            continue;
-        }
-        if (token === "--class" || token.startsWith("--class=")) {
-            className = readValue("--class").trim();
-            continue;
-        }
-        if (token === "--prompt" || token.startsWith("--prompt=")) {
-            prompt = readValue("--prompt").trim();
-            continue;
-        }
-        if (token === "--reason" || token.startsWith("--reason=")) {
-            reason = readValue("--reason").trim();
-            continue;
-        }
-        if (token === "--stack" || token.startsWith("--stack=")) {
-            stack = readValue("--stack").trim();
-            continue;
-        }
-        if (token === "--from-idea-artifact" || token.startsWith("--from-idea-artifact=")) {
-            const raw = readValue("--from-idea-artifact").trim();
-            fromIdeaArtifact = raw.length > 0 ? raw : undefined;
-            continue;
-        }
-        if (token === "--from-idea-candidate" || token.startsWith("--from-idea-candidate=")) {
-            const raw = readValue("--from-idea-candidate").trim();
-            fromIdeaCandidateId = raw.length > 0 ? raw : undefined;
-            continue;
-        }
-        throw new Error(`Unknown flag for internal start-flow: ${token}`);
-    }
-    if (!track) {
-        throw new Error("internal start-flow requires --track=<standard|medium|quick>.");
-    }
-    if (fromIdeaCandidateId && !fromIdeaArtifact) {
-        throw new Error("--from-idea-candidate requires --from-idea-artifact=<path> to be set as well.");
-    }
-    return {
-        track,
-        discoveryMode,
-        className,
-        prompt,
-        reason,
-        stack,
-        forceReset,
-        reclassify,
-        quiet,
-        fromIdeaArtifact,
-        fromIdeaCandidateId
-    };
-}
-export function parseCancelRunArgs(tokens) {
-    let reason;
-    let disposition = "cancelled";
-    let name;
-    let quiet = false;
-    for (let i = 0; i < tokens.length; i += 1) {
-        const token = tokens[i];
-        const nextToken = tokens[i + 1];
-        const readValue = (flag) => {
-            if (token.startsWith(`${flag}=`))
-                return token.slice(flag.length + 1);
-            if (token === flag && nextToken && !nextToken.startsWith("--")) {
-                i += 1;
-                return nextToken;
-            }
-            throw new Error(`${flag} requires a value.`);
-        };
-        if (token === "--quiet") {
-            quiet = true;
-            continue;
-        }
-        if (token === "--reason" || token.startsWith("--reason=")) {
-            reason = readValue("--reason").trim();
-            continue;
-        }
-        if (token === "--name" || token.startsWith("--name=")) {
-            const raw = readValue("--name").trim();
-            name = raw.length > 0 ? raw : undefined;
-            continue;
-        }
-        if (token === "--disposition" || token.startsWith("--disposition=")) {
-            const raw = readValue("--disposition").trim();
-            if (raw !== "cancelled" && raw !== "abandoned") {
-                throw new Error("--disposition must be cancelled or abandoned.");
-            }
-            disposition = raw;
-            continue;
-        }
-        throw new Error(`Unknown flag for internal cancel-run: ${token}`);
-    }
-    if (!reason || reason.length === 0) {
-        throw new Error("internal cancel-run requires --reason=<text>.");
-    }
-    return { reason, disposition, name, quiet };
-}

package/dist/internal/advance-stage/proactive-delegation-trace.d.ts

@@ -1,24 +0,0 @@
-import { type StageAutoSubagentDispatch } from "../../content/stage-schema.js";
-import type { DiscoveryMode, FlowStage } from "../../types.js";
-import type { RepoSignals } from "../../flow-state.js";
-export interface ProactiveDelegationTraceResult {
-    missingRules: StageAutoSubagentDispatch[];
-}
-/**
- * Ensure every proactive dispatch rule for the stage has a ledger row for the
- * active run, or an explicit user-flag waiver.
- *
- * Lean/guided discovery on brainstorm/scope/design keeps only proactive rules
- * marked `essentialAcrossModes` (researcher today) so external research stays
- * auditable without requiring every discretionary proactive lens. Deep
- * discovery evaluates the full proactive matrix.
- */
-export declare function ensureProactiveDelegationTrace(projectRoot: string, stage: FlowStage, options: {
-    acceptWaiver: boolean;
-    waiverReason?: string;
-    approvalToken?: string;
-    approvalReason?: string;
-    approvalIssuedAt?: string;
-    discoveryMode: DiscoveryMode;
-    repoSignals?: RepoSignals;
-}): Promise<ProactiveDelegationTraceResult>;

package/dist/internal/advance-stage/proactive-delegation-trace.js

@@ -1,56 +0,0 @@
-import { appendDelegation, readDelegationLedger } from "../../delegation.js";
-import { stageAutoSubagentDispatch } from "../../content/stage-schema.js";
-function isEarlyElicitationStage(stage) {
-    return stage === "brainstorm" || stage === "scope" || stage === "design";
-}
-function proactiveRulesForDiscoveryMode(stage, discoveryMode) {
-    const proactiveRules = stageAutoSubagentDispatch(stage).filter((rule) => rule.mode === "proactive");
-    if (isEarlyElicitationStage(stage) && (discoveryMode === "lean" || discoveryMode === "guided")) {
-        return proactiveRules.filter((rule) => rule.essentialAcrossModes === true);
-    }
-    return proactiveRules;
-}
-/**
- * Ensure every proactive dispatch rule for the stage has a ledger row for the
- * active run, or an explicit user-flag waiver.
- *
- * Lean/guided discovery on brainstorm/scope/design keeps only proactive rules
- * marked `essentialAcrossModes` (researcher today) so external research stays
- * auditable without requiring every discretionary proactive lens. Deep
- * discovery evaluates the full proactive matrix.
- */
-export async function ensureProactiveDelegationTrace(projectRoot, stage, options) {
-    void options.repoSignals;
-    const proactiveRules = proactiveRulesForDiscoveryMode(stage, options.discoveryMode);
-    if (proactiveRules.length === 0)
-        return { missingRules: [] };
-    const ledger = await readDelegationLedger(projectRoot);
-    const currentRunEntries = ledger.entries.filter((entry) => entry.runId === ledger.runId);
-    const missingRules = proactiveRules.filter((rule) => !currentRunEntries.some((entry) => entry.stage === stage && entry.agent === rule.agent && entry.mode === "proactive"));
-    if (missingRules.length === 0)
-        return { missingRules: [] };
-    if (!options.acceptWaiver)
-        return { missingRules };
-    const approvalToken = options.approvalToken?.trim();
-    const approvalReason = options.approvalReason?.trim();
-    const waiverReason = options.waiverReason?.trim() ||
-        approvalReason ||
-        "accepted via --accept-proactive-waiver";
-    for (const rule of missingRules) {
-        await appendDelegation(projectRoot, {
-            stage,
-            agent: rule.agent,
-            mode: "proactive",
-            status: "waived",
-            waiverReason,
-            acceptedBy: "user-flag",
-            conditionTrigger: rule.when,
-            skill: rule.skill,
-            ...(approvalToken ? { approvalToken } : {}),
-            ...(approvalReason ? { approvalReason } : {}),
-            ...(options.approvalIssuedAt ? { approvalIssuedAt: options.approvalIssuedAt } : {}),
-            ts: new Date().toISOString()
-        });
-    }
-    return { missingRules: [] };
-}

package/dist/internal/advance-stage/review-loop.d.ts

@@ -1,16 +0,0 @@
-import type { FlowStage } from "../../types.js";
-export declare const AUTO_REVIEW_LOOP_GATE_BY_STAGE: Partial<Record<FlowStage, string>>;
-/**
- * exact JSON shape that gate-evidence validators
- * accept for a review-loop envelope. The error messages emitted by
- * `validateReviewLoopGateEvidence` always include this example so the
- * agent never has to guess where `stage` lives (top-level of the
- * envelope, NOT inside `payload`). Keep `stage`/`targetScore`/etc. in
- * the order shown so a copy-paste from the error survives.
- */
-export declare function reviewLoopEnvelopeExample(stage: "scope" | "design"): string;
-export declare function pickReviewLoopEnvelope(value: unknown): Record<string, unknown> | null;
-export declare function validateReviewLoopGateEvidence(stage: "scope" | "design", evidence: string): string | null;
-export declare function validateUserApprovalEvidence(evidence: string): string | null;
-export declare function validateGateEvidenceShape(projectRoot: string, stage: FlowStage, gateId: string, evidence: string): Promise<string | null>;
-export declare function reviewLoopArtifactFixHint(stage: FlowStage, gateId: string): string;

package/dist/internal/advance-stage/review-loop.js

@@ -1,199 +0,0 @@
-import { SHIP_FINALIZATION_MODES } from "../../constants.js";
-import { validateTddVerificationEvidence } from "../../tdd-verification-evidence.js";
-import { asRecord } from "./helpers.js";
-export const AUTO_REVIEW_LOOP_GATE_BY_STAGE = {
-    design: "design_architecture_locked"
-};
-const SHIP_FINALIZATION_MODE_PATTERN = new RegExp(`\\b(?:${SHIP_FINALIZATION_MODES.join("|")})\\b`, "u");
-const SHIP_FINALIZATION_MODE_HINT = SHIP_FINALIZATION_MODES.join(", ");
-const REVIEW_LOOP_STOP_REASONS = new Set([
-    "quality_threshold_met",
-    "max_iterations_reached",
-    "user_opt_out"
-]);
-/**
- * exact JSON shape that gate-evidence validators
- * accept for a review-loop envelope. The error messages emitted by
- * `validateReviewLoopGateEvidence` always include this example so the
- * agent never has to guess where `stage` lives (top-level of the
- * envelope, NOT inside `payload`). Keep `stage`/`targetScore`/etc. in
- * the order shown so a copy-paste from the error survives.
- */
-export function reviewLoopEnvelopeExample(stage) {
-    return JSON.stringify({
-        type: "review-loop",
-        stage,
-        targetScore: 0.8,
-        maxIterations: 3,
-        stopReason: "quality_threshold_met",
-        iterations: [{ iteration: 1, qualityScore: 0.8, findingsCount: 0 }]
-    });
-}
-function reviewLoopEnvelopeShapeHint(stage) {
-    return (`Expected envelope: ${reviewLoopEnvelopeExample(stage)}` +
-        " (top-level keys: type, stage, targetScore, maxIterations, stopReason, iterations[]). " +
-        "Stage MUST be at the top level — not inside payload.");
-}
-export function pickReviewLoopEnvelope(value) {
-    const direct = asRecord(value);
-    if (!direct)
-        return null;
-    if (direct.type === "review-loop")
-        return direct;
-    const payload = asRecord(direct.payload);
-    if (payload?.type === "review-loop")
-        return payload;
-    const nested = asRecord(direct.reviewLoop);
-    if (nested?.type === "review-loop")
-        return nested;
-    return null;
-}
-export function validateReviewLoopGateEvidence(stage, evidence) {
-    let parsed;
-    try {
-        parsed = JSON.parse(evidence);
-    }
-    catch {
-        return ("must be JSON containing a review-loop envelope (`type: \"review-loop\"`) in top-level, `payload`, or `reviewLoop`. " +
-            reviewLoopEnvelopeShapeHint(stage));
-    }
-    const envelope = pickReviewLoopEnvelope(parsed);
-    if (!envelope) {
-        return ("must include a review-loop envelope (`type: \"review-loop\"`) in top-level, `payload`, or `reviewLoop`. " +
-            reviewLoopEnvelopeShapeHint(stage));
-    }
-    if (envelope.stage !== stage) {
-        return (`review-loop envelope stage must be "${stage}" at the top level of the envelope, not inside payload. ` +
-            reviewLoopEnvelopeShapeHint(stage));
-    }
-    const targetScore = envelope.targetScore;
-    if (typeof targetScore !== "number" || Number.isNaN(targetScore) || targetScore < 0 || targetScore > 1) {
-        return "review-loop targetScore must be a number between 0 and 1.";
-    }
-    const maxIterations = envelope.maxIterations;
-    if (typeof maxIterations !== "number" ||
-        Number.isNaN(maxIterations) ||
-        !Number.isInteger(maxIterations) ||
-        maxIterations < 1) {
-        return "review-loop maxIterations must be an integer >= 1.";
-    }
-    if (typeof envelope.stopReason !== "string" || !REVIEW_LOOP_STOP_REASONS.has(envelope.stopReason)) {
-        return "review-loop stopReason must be one of quality_threshold_met, max_iterations_reached, user_opt_out.";
-    }
-    const rows = envelope.iterations;
-    if (!Array.isArray(rows) || rows.length === 0) {
-        return "review-loop iterations must be a non-empty array.";
-    }
-    if (rows.length > maxIterations) {
-        return "review-loop iterations count cannot exceed maxIterations.";
-    }
-    let prevScore = -Infinity;
-    let reachedTarget = false;
-    for (let index = 0; index < rows.length; index++) {
-        const row = asRecord(rows[index]);
-        if (!row) {
-            return `review-loop iterations[${index}] must be an object.`;
-        }
-        const iteration = row.iteration;
-        const qualityScore = row.qualityScore;
-        const findingsCount = row.findingsCount;
-        if (typeof iteration !== "number" ||
-            Number.isNaN(iteration) ||
-            !Number.isInteger(iteration) ||
-            iteration < 1) {
-            return `review-loop iterations[${index}].iteration must be an integer >= 1.`;
-        }
-        if (typeof qualityScore !== "number" ||
-            Number.isNaN(qualityScore) ||
-            qualityScore < 0 ||
-            qualityScore > 1) {
-            return `review-loop iterations[${index}].qualityScore must be between 0 and 1.`;
-        }
-        if (typeof findingsCount !== "number" ||
-            Number.isNaN(findingsCount) ||
-            !Number.isInteger(findingsCount) ||
-            findingsCount < 0) {
-            return `review-loop iterations[${index}].findingsCount must be an integer >= 0.`;
-        }
-        if (qualityScore + Number.EPSILON < prevScore) {
-            return "review-loop qualityScore must be monotonic non-decreasing across iterations.";
-        }
-        if (qualityScore >= targetScore) {
-            reachedTarget = true;
-        }
-        prevScore = qualityScore;
-    }
-    if (envelope.stopReason === "quality_threshold_met" && !reachedTarget) {
-        return "review-loop stopReason is quality_threshold_met but no iteration reached targetScore.";
-    }
-    if (envelope.stopReason === "max_iterations_reached" && rows.length < maxIterations) {
-        return "review-loop stopReason is max_iterations_reached but iterations are below maxIterations.";
-    }
-    return null;
-}
-export function validateUserApprovalEvidence(evidence) {
-    const normalized = evidence.trim();
-    if (normalized.length === 0) {
-        return "must cite explicit user approval.";
-    }
-    const reviewLoopEnvelope = (() => {
-        try {
-            return pickReviewLoopEnvelope(JSON.parse(normalized));
-        }
-        catch {
-            return null;
-        }
-    })();
-    if (reviewLoopEnvelope) {
-        return "must cite explicit user approval; review-loop evidence is outside-voice evidence, not user approval.";
-    }
-    if (/\b(?:approved|approval|user approved|confirmed|accepted|yes|ok)\b/iu.test(normalized)) {
-        return null;
-    }
-    if (/\b(?:утвержд(?:аю|ено|ен|ена)|подтвержд(?:аю|ено|ен|ена)|соглас(?:ен|на|овано)|да|ок|принято)\b/iu.test(normalized)) {
-        return null;
-    }
-    return "must cite explicit user approval (for example `user approved the scope contract` or `пользователь утвердил scope`).";
-}
-// Per-gate validators keyed by `${stage}:${gateId}`. Returning a non-null
-// string surfaces the reason as an `advance-stage` failure so evidence is
-// guaranteed to carry the structural breadcrumbs downstream tooling
-// expects. Previously only `tdd:tdd_verified_before_complete` was checked.
-const GATE_EVIDENCE_VALIDATORS = {
-    "ship:ship_finalization_executed": (evidence) => {
-        if (!SHIP_FINALIZATION_MODE_PATTERN.test(evidence)) {
-            return `must name the finalization mode that ran (for example ${SHIP_FINALIZATION_MODE_HINT}).`;
-        }
-        return null;
-    },
-    "scope:scope_user_approved": (evidence) => validateUserApprovalEvidence(evidence),
-    "design:design_architecture_locked": (evidence) => validateReviewLoopGateEvidence("design", evidence)
-};
-export async function validateGateEvidenceShape(projectRoot, stage, gateId, evidence) {
-    const normalized = evidence.trim();
-    if (stage === "tdd" && gateId === "tdd_verified_before_complete") {
-        const result = await validateTddVerificationEvidence(projectRoot, normalized);
-        return result.ok ? null : result.issues.join(" ");
-    }
-    const validator = GATE_EVIDENCE_VALIDATORS[`${stage}:${gateId}`];
-    if (!validator)
-        return null;
-    return validator(normalized);
-}
-export function reviewLoopArtifactFixHint(stage, gateId) {
-    if (AUTO_REVIEW_LOOP_GATE_BY_STAGE[stage] !== gateId)
-        return "";
-    // the consistent flow is "include the gate in
-    // --passed AND let stage-complete auto-hydrate evidence from the
-    // artifact". An older hint told agents to omit the gate from
-    // --evidence-json, but they then hit
-    // `missing --evidence-json entries for passed gates: <gateId>`
-    // because hydration only runs when --evidence-json is also present
-    // OR when an artifact section yields a parseable envelope. The new
-    // hint tells the agent to:
-    //   1. Add the artifact section (so hydration succeeds), AND
-    //   2. Include the gate in --passed.
-    // No --evidence-json entry is required in that case.
-    const stageReviewSection = stage === "scope" ? "Scope Outside Voice Loop" : "Design Outside Voice Loop";
-    return (` Fix in two steps: (1) Add a \`## ${stageReviewSection}\` table to the artifact with rows like \`| 1 | 0.80 | 0 |\` plus \`- Stop reason: quality_threshold_met\`, \`- Target score: 0.80\`, and \`- Max iterations: 3\`. (2) Re-run \`stage-complete ${stage} --passed=...,${gateId},...\` — stage-complete will auto-hydrate the envelope from the artifact, so you do NOT need to pass --evidence-json for ${gateId}.`);
-}

package/dist/internal/advance-stage/rewind.d.ts

@@ -1,14 +0,0 @@
-import { type FlowState } from "../../flow-state.js";
-import { type FlowStage } from "../../types.js";
-import type { RewindArgs } from "./parsers.js";
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-export declare function rewindLogPath(projectRoot: string): string;
-export declare function rewindId(date?: Date): string;
-export declare function stagesInvalidatedByRewind(current: FlowState, targetStage: FlowStage): FlowStage[];
-export declare function appendRewindLog(projectRoot: string, payload: Record<string, unknown>): Promise<void>;
-export declare function runRewind(projectRoot: string, args: RewindArgs, io: InternalIo): Promise<number>;
-export {};