cclaw-cli 7.7.1 → 8.1.1

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

@@ -1,108 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_ROOT } from "../../constants.js";
-import { ensureDir } from "../../fs-utils.js";
-import { readFlowState, writeFlowState } from "../../runs.js";
-import { TRACK_STAGES } from "../../types.js";
-export function rewindLogPath(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "state", "rewind-log.jsonl");
-}
-export function rewindId(date = new Date()) {
-    return `rewind-${date.getTime().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
-}
-export function stagesInvalidatedByRewind(current, targetStage) {
-    const ordered = TRACK_STAGES[current.track];
-    const targetIndex = ordered.indexOf(targetStage);
-    const currentIndex = ordered.indexOf(current.currentStage);
-    if (targetIndex < 0 || currentIndex < 0 || targetIndex > currentIndex) {
-        return [];
-    }
-    return ordered.slice(targetIndex, currentIndex + 1);
-}
-export async function appendRewindLog(projectRoot, payload) {
-    const logPath = rewindLogPath(projectRoot);
-    await ensureDir(path.dirname(logPath));
-    await fs.appendFile(logPath, `${JSON.stringify(payload)}\n`, "utf8");
-}
-export async function runRewind(projectRoot, args, io) {
-    const current = await readFlowState(projectRoot);
-    const now = new Date().toISOString();
-    if (args.mode === "ack") {
-        const marker = current.staleStages[args.targetStage];
-        if (!marker) {
-            io.stderr.write(`cclaw internal rewind: no stale marker exists for "${args.targetStage}".\n`);
-            return 1;
-        }
-        if (current.currentStage !== args.targetStage) {
-            io.stderr.write(`cclaw internal rewind: cannot ack "${args.targetStage}" while currentStage is "${current.currentStage}". Re-run the stale stage before acknowledging it.\n`);
-            return 1;
-        }
-        const staleStages = { ...current.staleStages };
-        delete staleStages[args.targetStage];
-        const nextState = { ...current, staleStages };
-        await writeFlowState(projectRoot, nextState, { writerSubsystem: "rewind-ack" });
-        const payload = {
-            ok: true,
-            command: "rewind",
-            action: "ack",
-            stage: args.targetStage,
-            acknowledgedAt: now,
-            rewindId: marker.rewindId
-        };
-        await appendRewindLog(projectRoot, payload);
-        if (!args.quiet) {
-            io.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-        }
-        return 0;
-    }
-    const invalidatedStages = stagesInvalidatedByRewind(current, args.targetStage);
-    if (invalidatedStages.length === 0) {
-        io.stderr.write(`cclaw internal rewind: target "${args.targetStage}" is not an earlier or current stage on track "${current.track}" from "${current.currentStage}".\n`);
-        return 1;
-    }
-    const id = rewindId();
-    const completedInvalidated = new Set(invalidatedStages);
-    const staleStages = { ...current.staleStages };
-    for (const stage of invalidatedStages) {
-        staleStages[stage] = {
-            rewindId: id,
-            reason: args.reason ?? "rewind",
-            markedAt: now
-        };
-    }
-    const record = {
-        id,
-        fromStage: current.currentStage,
-        toStage: args.targetStage,
-        reason: args.reason ?? "rewind",
-        timestamp: now,
-        invalidatedStages
-    };
-    const nextState = {
-        ...current,
-        currentStage: args.targetStage,
-        completedStages: current.completedStages.filter((stage) => !completedInvalidated.has(stage)),
-        staleStages,
-        rewinds: [...current.rewinds, record]
-    };
-    await writeFlowState(projectRoot, nextState, { writerSubsystem: "rewind" });
-    const payload = {
-        ok: true,
-        command: "rewind",
-        action: "rewind",
-        rewind: record,
-        currentStage: nextState.currentStage,
-        completedStages: nextState.completedStages,
-        staleStages: Object.keys(nextState.staleStages),
-        nextActions: [
-            `Re-run ${args.targetStage} stage work and update its artifact evidence.`,
-            `Then run cclaw internal rewind --ack ${args.targetStage}.`,
-            "Continue with /cc after the stale marker is acknowledged."
-        ]
-    };
-    await appendRewindLog(projectRoot, payload);
-    if (!args.quiet) {
-        io.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-    }
-    return 0;
-}

package/dist/internal/advance-stage/start-flow.d.ts

@@ -1,13 +0,0 @@
-import { type FlowState, type RepoSignals } from "../../flow-state.js";
-import type { StartFlowArgs } from "./parsers.js";
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-/** One-pass repo snapshot (max ~200 files, skips `node_modules`/`.git`). */
-export declare function collectRepoSignals(projectRoot: string): Promise<RepoSignals>;
-export declare function discoverStartFlowContext(projectRoot: string): Promise<string[]>;
-export declare function appendIdeaArtifact(projectRoot: string, args: StartFlowArgs, previous?: FlowState): Promise<void>;
-export declare function runStartFlow(projectRoot: string, args: StartFlowArgs, io: InternalIo): Promise<number>;
-export {};

package/dist/internal/advance-stage/start-flow.js

@@ -1,241 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_ROOT } from "../../constants.js";
-import { createInitialFlowState } from "../../flow-state.js";
-import { readFlowState, writeFlowState } from "../../runs.js";
-import { listExistingFiles, listFilesUnder, pathExists } from "./helpers.js";
-import { STACK_DISCOVERY_DIR_MARKERS, STACK_DISCOVERY_MARKERS, loadStackAdapter } from "../../stack-detection.js";
-import { TRACK_STAGES } from "../../types.js";
-import { buildValidationReport } from "./advance.js";
-import { carriedCompletedStageCatalog, completedStageClosureEvidenceIssues, firstIncompleteStageForTrack } from "./verify.js";
-function resolveTaskClass(className, fallback) {
-    if (className === "software-standard" || className === "software-trivial" || className === "software-bugfix") {
-        return className;
-    }
-    return fallback;
-}
-const REPO_SIGNAL_SKIP_DIRS = new Set(["node_modules", ".git"]);
-/** One-pass repo snapshot (max ~200 files, skips `node_modules`/`.git`). */
-export async function collectRepoSignals(projectRoot) {
-    const capturedAt = new Date().toISOString();
-    const cap = 200;
-    let fileCount = 0;
-    async function visit(absDir, depth) {
-        if (fileCount >= cap)
-            return;
-        let entries;
-        try {
-            entries = await fs.readdir(absDir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const ent of entries) {
-            if (fileCount >= cap)
-                return;
-            const name = ent.name;
-            if (REPO_SIGNAL_SKIP_DIRS.has(name))
-                continue;
-            const abs = path.join(absDir, name);
-            if (ent.isFile()) {
-                fileCount += 1;
-                continue;
-            }
-            if (ent.isDirectory() && depth < 1) {
-                await visit(abs, depth + 1);
-            }
-        }
-    }
-    let hasReadme = false;
-    let hasPackageManifest = false;
-    for (const fname of ["README.md", "readme.md", "Readme.md"]) {
-        try {
-            const st = await fs.stat(path.join(projectRoot, fname));
-            if (st.isFile())
-                hasReadme = true;
-        }
-        catch {
-            // ignore
-        }
-    }
-    // 7.6.0 — manifest detection now routes through the stack-adapter
-    // contract instead of hardcoding `package.json` / `pyproject.toml` /
-    // `Cargo.toml`. Adapters that declare manifestGlobs probe their
-    // declared paths; the unknown adapter is a no-op.
-    const stackAdapter = await loadStackAdapter(projectRoot);
-    for (const manifestGlob of stackAdapter.manifestGlobs) {
-        if (manifestGlob.includes("*"))
-            continue;
-        try {
-            const st = await fs.stat(path.join(projectRoot, manifestGlob));
-            if (st.isFile()) {
-                hasPackageManifest = true;
-                break;
-            }
-        }
-        catch {
-            // ignore
-        }
-    }
-    try {
-        await visit(projectRoot, 0);
-    }
-    catch {
-        fileCount = Math.min(fileCount, cap);
-    }
-    return { fileCount, hasReadme, hasPackageManifest, capturedAt };
-}
-export async function discoverStartFlowContext(projectRoot) {
-    const lines = [];
-    const seedFiles = (await listFilesUnder(projectRoot, path.join(RUNTIME_ROOT, "seeds"), 10))
-        .filter((relPath) => /^\.cclaw\/seeds\/SEED-.*\.md$/u.test(relPath));
-    lines.push(seedFiles.length > 0
-        ? `- Seed shelf scanned: ${seedFiles.join(", ")}.`
-        : "- Seed shelf scanned: no `.cclaw/seeds/SEED-*.md` files found.");
-    const originDirs = ["docs/prd", "docs/rfcs", "docs/adr", "docs/design", "specs", "prd", "rfc", "design"];
-    const originRootFiles = ["PRD.md", "SPEC.md", "DESIGN.md", "REQUIREMENTS.md", "ROADMAP.md"];
-    const originFiles = [
-        ...(await listExistingFiles(projectRoot, originRootFiles)),
-        ...(await Promise.all(originDirs.map((dir) => listFilesUnder(projectRoot, dir, 6)))).flat()
-    ].slice(0, 20);
-    lines.push(originFiles.length > 0
-        ? `- Origin docs scanned: found ${originFiles.join(", ")}.`
-        : "- Origin docs scanned: no PRD/RFC/ADR/design/spec files found in configured locations.");
-    const stackMarkers = await listExistingFiles(projectRoot, [...STACK_DISCOVERY_MARKERS]);
-    for (const markerDir of STACK_DISCOVERY_DIR_MARKERS) {
-        if (await pathExists(projectRoot, markerDir)) {
-            stackMarkers.push(`${markerDir}/`);
-        }
-    }
-    lines.push(stackMarkers.length > 0
-        ? `- Stack markers scanned: found ${stackMarkers.join(", ")}.`
-        : "- Stack markers scanned: no root stack markers found.");
-    return lines;
-}
-export async function appendIdeaArtifact(projectRoot, args, previous) {
-    const artifactPath = path.join(projectRoot, RUNTIME_ROOT, "artifacts", "00-idea.md");
-    await fs.mkdir(path.dirname(artifactPath), { recursive: true });
-    const now = new Date().toISOString();
-    if (args.reclassify) {
-        const entry = [
-            "",
-            `Reclassification: ${now}`,
-            `- From: ${previous?.track ?? "unknown"}`,
-            `- To: ${args.track}`,
-            `- Class: ${args.className || "unspecified"}`,
-            `- Discovery mode: ${args.discoveryMode}`,
-            `- Reason: ${args.reason || "unspecified"}`
-        ].join("\n") + "\n";
-        await fs.appendFile(artifactPath, entry, "utf8");
-        return;
-    }
-    const discoveredContext = await discoverStartFlowContext(projectRoot);
-    const body = [
-        "# Idea",
-        `Class: ${args.className || "unspecified"}`,
-        `Track: ${args.track}${args.reason ? ` (${args.reason})` : ""}`,
-        `Discovery mode: ${args.discoveryMode}`,
-        `Stack: ${args.stack || "unknown"}`,
-        "",
-        "## User prompt",
-        args.prompt || "(not provided)",
-        "",
-        "## Discovered context",
-        ...discoveredContext
-    ].join("\n") + "\n";
-    await fs.writeFile(artifactPath, body, "utf8");
-}
-export async function runStartFlow(projectRoot, args, io) {
-    const current = await readFlowState(projectRoot);
-    const hasProgress = current.completedStages.length > 0;
-    if (!args.reclassify && hasProgress && !args.forceReset) {
-        io.stderr.write("cclaw internal start-flow: refusing to reset an active flow with completed stages without --force-reset. Ask the user before resetting.\n");
-        return 1;
-    }
-    const nextTaskClass = resolveTaskClass(args.className, current.taskClass);
-    let nextState;
-    if (args.reclassify) {
-        const completedInNewTrack = current.completedStages.filter((stage) => TRACK_STAGES[args.track].includes(stage));
-        const fresh = createInitialFlowState({ activeRunId: current.activeRunId, track: args.track, discoveryMode: args.discoveryMode });
-        const stageGateCatalog = { ...fresh.stageGateCatalog };
-        const guardEvidence = {};
-        for (const stage of completedInNewTrack) {
-            const carried = carriedCompletedStageCatalog(current, fresh, stage);
-            stageGateCatalog[stage] = carried.catalog;
-            Object.assign(guardEvidence, carried.evidence);
-        }
-        nextState = {
-            ...fresh,
-            ...(nextTaskClass !== undefined ? { taskClass: nextTaskClass } : {}),
-            completedStages: completedInNewTrack,
-            currentStage: firstIncompleteStageForTrack(args.track, completedInNewTrack),
-            guardEvidence,
-            stageGateCatalog,
-            rewinds: current.rewinds,
-            staleStages: current.staleStages
-        };
-        const validation = await buildValidationReport(projectRoot, nextState);
-        const evidenceIssues = completedStageClosureEvidenceIssues(nextState);
-        if (!validation.completedStages.ok || evidenceIssues.length > 0) {
-            io.stderr.write("cclaw internal start-flow: reclassification would leave completed stages without valid gate closure.\n");
-            const issues = [...validation.completedStages.issues, ...evidenceIssues];
-            if (issues.length > 0) {
-                io.stderr.write(`- completed-stage closure issues: ${issues.join(" | ")}\n`);
-            }
-            return 1;
-        }
-    }
-    else {
-        nextState = createInitialFlowState({ track: args.track, discoveryMode: args.discoveryMode });
-        if (nextTaskClass !== undefined) {
-            nextState = { ...nextState, taskClass: nextTaskClass };
-        }
-    }
-    if (args.fromIdeaArtifact) {
-        const existingHints = nextState.interactionHints ?? {};
-        const existingBrainstorm = existingHints.brainstorm ?? {};
-        nextState.interactionHints = {
-            ...existingHints,
-            brainstorm: {
-                ...existingBrainstorm,
-                fromIdeaArtifact: args.fromIdeaArtifact,
-                ...(args.fromIdeaCandidateId ? { fromIdeaCandidateId: args.fromIdeaCandidateId } : {}),
-                recordedAt: new Date().toISOString()
-            }
-        };
-    }
-    const repoSignals = await collectRepoSignals(projectRoot);
-    nextState = { ...nextState, repoSignals };
-    await writeFlowState(projectRoot, nextState, {
-        allowReset: true,
-        writerSubsystem: "start-flow"
-    });
-    await appendIdeaArtifact(projectRoot, args, current);
-    const successPayload = {
-        ok: true,
-        command: "start-flow",
-        reclassify: args.reclassify,
-        track: nextState.track,
-        discoveryMode: nextState.discoveryMode,
-        taskClass: nextState.taskClass ?? null,
-        currentStage: nextState.currentStage,
-        skippedStages: nextState.skippedStages,
-        activeRunId: nextState.activeRunId,
-        repoSignals
-    };
-    if (args.quiet) {
-        io.stdout.write(`${JSON.stringify({
-            ok: true,
-            command: "start-flow",
-            track: successPayload.track,
-            discoveryMode: successPayload.discoveryMode,
-            currentStage: successPayload.currentStage,
-            activeRunId: successPayload.activeRunId,
-            repoSignals: successPayload.repoSignals
-        })}\n`);
-    }
-    else {
-        io.stdout.write(`${JSON.stringify(successPayload, null, 2)}\n`);
-    }
-    return 0;
-}

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

@@ -1,21 +0,0 @@
-import { type FlowState, type StageGateState } from "../../flow-state.js";
-import { type FlowStage, type FlowTrack } from "../../types.js";
-import type { VerifyCurrentStateArgs, VerifyFlowStateDiffArgs } from "./parsers.js";
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-export declare function runVerifyFlowStateDiff(projectRoot: string, args: VerifyFlowStateDiffArgs, io: InternalIo): Promise<number>;
-export declare function runVerifyCurrentState(projectRoot: string, args: VerifyCurrentStateArgs, io: InternalIo): Promise<number>;
-export declare function firstIncompleteStageForTrack(track: FlowTrack, completedStages: FlowStage[]): FlowStage;
-export declare function carriedCompletedStageCatalog(current: FlowState, fresh: FlowState, stage: FlowStage): {
-    catalog: StageGateState;
-    evidence: Record<string, string>;
-};
-export declare function completedStageClosureEvidenceIssues(flowState: FlowState): string[];
-export declare function pathExists(projectRoot: string, relPath: string): Promise<boolean>;
-export declare function listExistingFiles(projectRoot: string, relPaths: string[]): Promise<string[]>;
-export declare function listFilesUnder(projectRoot: string, relDir: string, limit?: number): Promise<string[]>;
-export declare function discoverStartFlowContext(projectRoot: string): Promise<string[]>;
-export {};

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

@@ -1,185 +0,0 @@
-import path from "node:path";
-import { RUNTIME_ROOT } from "../../constants.js";
-import { stageSchema } from "../../content/stage-schema.js";
-import { readFlowState } from "../../runs.js";
-import { TRACK_STAGES } from "../../types.js";
-import { STACK_DISCOVERY_DIR_MARKERS, STACK_DISCOVERY_MARKERS } from "../../stack-detection.js";
-import { coerceCandidateFlowState } from "./flow-state-coercion.js";
-import { buildValidationReport } from "./advance.js";
-import fs from "node:fs/promises";
-export async function runVerifyFlowStateDiff(projectRoot, args, io) {
-    let raw = args.afterJson;
-    if (!raw && args.afterFile) {
-        raw = await fs.readFile(args.afterFile, "utf8");
-    }
-    if (!raw) {
-        io.stderr.write("cclaw internal verify-flow-state-diff: no candidate state payload.\n");
-        return 1;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(raw);
-    }
-    catch (err) {
-        io.stderr.write(`cclaw internal verify-flow-state-diff: invalid JSON payload (${err instanceof Error ? err.message : String(err)}).\n`);
-        return 1;
-    }
-    const current = await readFlowState(projectRoot);
-    const candidate = coerceCandidateFlowState(parsed, current);
-    const validation = await buildValidationReport(projectRoot, candidate);
-    if (!args.quiet) {
-        io.stdout.write(`${JSON.stringify(validation, null, 2)}\n`);
-    }
-    if (!validation.ok) {
-        io.stderr.write(`cclaw internal verify-flow-state-diff: candidate state is invalid for stage "${validation.stage}".\n`);
-    }
-    return validation.ok ? 0 : 1;
-}
-export async function runVerifyCurrentState(projectRoot, args, io) {
-    const current = await readFlowState(projectRoot);
-    const validation = await buildValidationReport(projectRoot, current);
-    if (!args.quiet) {
-        io.stdout.write(`${JSON.stringify(validation, null, 2)}\n`);
-    }
-    if (!validation.ok) {
-        const unmetDelegations = validation.delegation.missing.length + validation.delegation.missingEvidence.length;
-        const gatesWithoutEvidence = validation.gates.issues.filter((issue) => issue.includes("missing guardEvidence entry")).length;
-        io.stderr.write(`cclaw: current stage has ${unmetDelegations} unmet mandatory delegations and ${gatesWithoutEvidence} gates without evidence.\n`);
-        io.stderr.write(`cclaw internal verify-current-state: unresolved stage constraints for "${validation.stage}".\n`);
-    }
-    return validation.ok ? 0 : 1;
-}
-export function firstIncompleteStageForTrack(track, completedStages) {
-    const completed = new Set(completedStages);
-    const stages = TRACK_STAGES[track];
-    return stages.find((stage) => !completed.has(stage)) ?? stages[stages.length - 1] ?? "brainstorm";
-}
-export function carriedCompletedStageCatalog(current, fresh, stage) {
-    const previousCatalog = current.stageGateCatalog[stage];
-    const freshCatalog = fresh.stageGateCatalog[stage];
-    const allowed = new Set([...freshCatalog.required, ...freshCatalog.recommended]);
-    const previousPassed = new Set(previousCatalog.passed.filter((gateId) => allowed.has(gateId)));
-    const previousBlocked = new Set(previousCatalog.blocked.filter((gateId) => allowed.has(gateId)));
-    const orderedAllowed = [...freshCatalog.required, ...freshCatalog.recommended];
-    const evidence = {};
-    const passed = orderedAllowed.filter((gateId) => {
-        if (!previousPassed.has(gateId))
-            return false;
-        const note = current.guardEvidence[gateId];
-        if (typeof note !== "string" || note.trim().length === 0)
-            return false;
-        evidence[gateId] = note.trim();
-        return true;
-    });
-    const passedSet = new Set(passed);
-    return {
-        catalog: {
-            required: [...freshCatalog.required],
-            recommended: [...freshCatalog.recommended],
-            conditional: [],
-            triggered: [],
-            passed,
-            blocked: orderedAllowed.filter((gateId) => previousBlocked.has(gateId) && !passedSet.has(gateId))
-        },
-        evidence
-    };
-}
-export function completedStageClosureEvidenceIssues(flowState) {
-    const issues = [];
-    for (const stage of flowState.completedStages) {
-        const schema = stageSchema(stage, flowState.track, flowState.discoveryMode, flowState.taskClass ?? null);
-        const catalog = flowState.stageGateCatalog[stage];
-        const required = schema.requiredGates
-            .filter((gate) => gate.tier === "required")
-            .map((gate) => gate.id);
-        for (const gateId of required) {
-            if (!catalog.passed.includes(gateId))
-                continue;
-            const note = flowState.guardEvidence[gateId];
-            if (typeof note !== "string" || note.trim().length === 0) {
-                issues.push(`completed stage "${stage}" passed gate "${gateId}" is missing guardEvidence.`);
-            }
-        }
-    }
-    return issues;
-}
-export async function pathExists(projectRoot, relPath) {
-    try {
-        await fs.stat(path.join(projectRoot, relPath));
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export async function listExistingFiles(projectRoot, relPaths) {
-    const matches = [];
-    for (const relPath of relPaths) {
-        try {
-            const stat = await fs.stat(path.join(projectRoot, relPath));
-            if (stat.isFile())
-                matches.push(relPath);
-        }
-        catch {
-            // continue
-        }
-    }
-    return matches;
-}
-export async function listFilesUnder(projectRoot, relDir, limit = 20) {
-    const root = path.join(projectRoot, relDir);
-    const out = [];
-    async function walk(absDir) {
-        if (out.length >= limit)
-            return;
-        let entries;
-        try {
-            entries = await fs.readdir(absDir, { withFileTypes: true });
-        }
-        catch {
-            return;
-        }
-        for (const entry of entries) {
-            if (out.length >= limit)
-                return;
-            if (entry.name.startsWith("."))
-                continue;
-            const abs = path.join(absDir, entry.name);
-            if (entry.isDirectory()) {
-                await walk(abs);
-            }
-            else if (entry.isFile()) {
-                out.push(path.relative(projectRoot, abs).split(path.sep).join("/"));
-            }
-        }
-    }
-    await walk(root);
-    return out;
-}
-export async function discoverStartFlowContext(projectRoot) {
-    const lines = [];
-    const seedFiles = (await listFilesUnder(projectRoot, path.join(RUNTIME_ROOT, "seeds"), 10))
-        .filter((relPath) => /^\.cclaw\/seeds\/SEED-.*\.md$/u.test(relPath));
-    lines.push(seedFiles.length > 0
-        ? `- Seed shelf scanned: ${seedFiles.join(", ")}.`
-        : "- Seed shelf scanned: no `.cclaw/seeds/SEED-*.md` files found.");
-    const originDirs = ["docs/prd", "docs/rfcs", "docs/adr", "docs/design", "specs", "prd", "rfc", "design"];
-    const originRootFiles = ["PRD.md", "SPEC.md", "DESIGN.md", "REQUIREMENTS.md", "ROADMAP.md"];
-    const originFiles = [
-        ...(await listExistingFiles(projectRoot, originRootFiles)),
-        ...(await Promise.all(originDirs.map((dir) => listFilesUnder(projectRoot, dir, 6)))).flat()
-    ].slice(0, 20);
-    lines.push(originFiles.length > 0
-        ? `- Origin docs scanned: found ${originFiles.join(", ")}.`
-        : "- Origin docs scanned: no PRD/RFC/ADR/design/spec files found in configured locations.");
-    const stackMarkers = await listExistingFiles(projectRoot, [...STACK_DISCOVERY_MARKERS]);
-    for (const markerDir of STACK_DISCOVERY_DIR_MARKERS) {
-        if (await pathExists(projectRoot, markerDir)) {
-            stackMarkers.push(`${markerDir}/`);
-        }
-    }
-    lines.push(stackMarkers.length > 0
-        ? `- Stack markers scanned: found ${stackMarkers.join(", ")}.`
-        : "- Stack markers scanned: no root stack markers found.");
-    return lines;
-}

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

@@ -1,7 +0,0 @@
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-export declare function runInternalCommand(projectRoot: string, argv: string[], io: InternalIo): Promise<number>;
-export {};