cclaw-cli 7.7.1 → 8.1.1

package/dist/internal/advance-stage.js

@@ -1,138 +0,0 @@
-import { runEnvelopeValidateCommand } from "./envelope-validate.js";
-import { runTddRedEvidenceCommand } from "./tdd-red-evidence.js";
-import { runTddLoopStatusCommand } from "./tdd-loop-status.js";
-import { runEarlyLoopStatusCommand } from "./early-loop-status.js";
-import { runCompoundReadinessCommand } from "./compound-readiness.js";
-import { runRuntimeIntegrityCommand } from "./runtime-integrity.js";
-import { runAdvanceStage } from "./advance-stage/advance.js";
-import { runStartFlow } from "./advance-stage/start-flow.js";
-import { runCancelRun } from "./advance-stage/cancel-run.js";
-import { runRewind } from "./advance-stage/rewind.js";
-import { runVerifyFlowStateDiff, runVerifyCurrentState } from "./advance-stage/verify.js";
-import { runHookCommand } from "./advance-stage/hook.js";
-import { parseAdvanceStageArgs, parseCancelRunArgs, parseHookArgs, parseRewindArgs, parseStartFlowArgs, parseVerifyCurrentStateArgs, parseVerifyFlowStateDiffArgs } from "./advance-stage/parsers.js";
-import { parseFlowStateRepairArgs, runFlowStateRepair } from "./flow-state-repair.js";
-import { parseWaiverGrantArgs, runWaiverGrant } from "./waiver-grant.js";
-import { FlowStateGuardMismatchError, verifyFlowStateGuard } from "../run-persistence.js";
-import { DelegationTimestampError, DispatchCapError, DispatchClaimedPathProtectedError, DispatchDuplicateError, DispatchOverlapError, SliceAlreadyClosedError } from "../delegation.js";
-import { parsePlanSplitWavesArgs, runPlanSplitWaves } from "./plan-split-waves.js";
-import { runWaveStatusCommand } from "./wave-status.js";
-import { runCohesionContractCommand } from "./cohesion-contract-stub.js";
-import { runSliceCommitCommand } from "./slice-commit.js";
-/**
- * Subcommands that mutate or consult flow-state.json via the CLI runtime.
- * They all require the sha256 sidecar to match before continuing so a
- * manual edit hard-blocks with exit code 2 (same contract as the inline
- * hook checks).
- */
-const GUARD_ENFORCED_SUBCOMMANDS = new Set([
-    "advance-stage",
-    "start-flow",
-    "cancel-run",
-    "rewind",
-    "verify-flow-state-diff",
-    "verify-current-state"
-]);
-export async function runInternalCommand(projectRoot, argv, io) {
-    const [subcommand, ...tokens] = argv;
-    if (!subcommand) {
-        io.stderr.write("cclaw internal requires a subcommand: advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | slice-commit | flow-state-repair | waiver-grant | plan-split-waves | wave-status | cohesion-contract\n");
-        return 1;
-    }
-    try {
-        if (GUARD_ENFORCED_SUBCOMMANDS.has(subcommand)) {
-            await verifyFlowStateGuard(projectRoot);
-        }
-        if (subcommand === "advance-stage") {
-            return await runAdvanceStage(projectRoot, parseAdvanceStageArgs(tokens), io);
-        }
-        if (subcommand === "start-flow") {
-            return await runStartFlow(projectRoot, parseStartFlowArgs(tokens), io);
-        }
-        if (subcommand === "cancel-run") {
-            return await runCancelRun(projectRoot, parseCancelRunArgs(tokens), io);
-        }
-        if (subcommand === "rewind") {
-            return await runRewind(projectRoot, parseRewindArgs(tokens), io);
-        }
-        if (subcommand === "verify-flow-state-diff") {
-            return await runVerifyFlowStateDiff(projectRoot, parseVerifyFlowStateDiffArgs(tokens), io);
-        }
-        if (subcommand === "verify-current-state") {
-            return await runVerifyCurrentState(projectRoot, parseVerifyCurrentStateArgs(tokens), io);
-        }
-        if (subcommand === "envelope-validate") {
-            return await runEnvelopeValidateCommand(projectRoot, tokens, io);
-        }
-        if (subcommand === "tdd-red-evidence") {
-            return await runTddRedEvidenceCommand(projectRoot, tokens, io);
-        }
-        if (subcommand === "tdd-loop-status") {
-            return await runTddLoopStatusCommand(projectRoot, tokens, io);
-        }
-        if (subcommand === "early-loop-status") {
-            return await runEarlyLoopStatusCommand(projectRoot, tokens, io);
-        }
-        if (subcommand === "compound-readiness") {
-            return await runCompoundReadinessCommand(projectRoot, tokens, io);
-        }
-        if (subcommand === "runtime-integrity") {
-            return await runRuntimeIntegrityCommand(projectRoot, tokens, io);
-        }
-        if (subcommand === "hook") {
-            return await runHookCommand(projectRoot, parseHookArgs(tokens), io);
-        }
-        if (subcommand === "slice-commit") {
-            return await runSliceCommitCommand(projectRoot, tokens, io);
-        }
-        if (subcommand === "flow-state-repair") {
-            return await runFlowStateRepair(projectRoot, parseFlowStateRepairArgs(tokens), io);
-        }
-        if (subcommand === "waiver-grant") {
-            return await runWaiverGrant(projectRoot, parseWaiverGrantArgs(tokens), io);
-        }
-        if (subcommand === "plan-split-waves") {
-            return await runPlanSplitWaves(projectRoot, parsePlanSplitWavesArgs(tokens), io);
-        }
-        if (subcommand === "wave-status") {
-            return await runWaveStatusCommand(projectRoot, tokens, io);
-        }
-        if (subcommand === "cohesion-contract") {
-            return await runCohesionContractCommand(projectRoot, tokens, io);
-        }
-        io.stderr.write(`Unknown internal subcommand: ${subcommand}. Expected advance-stage | start-flow | cancel-run | rewind | verify-flow-state-diff | verify-current-state | envelope-validate | tdd-red-evidence | tdd-loop-status | early-loop-status | compound-readiness | runtime-integrity | hook | slice-commit | flow-state-repair | waiver-grant | plan-split-waves | wave-status | cohesion-contract\n`);
-        return 1;
-    }
-    catch (err) {
-        if (err instanceof FlowStateGuardMismatchError) {
-            io.stderr.write(`cclaw internal ${subcommand}: ${err.message}\n`);
-            return 2;
-        }
-        if (err instanceof DelegationTimestampError) {
-            io.stderr.write(`error: delegation_timestamp_non_monotonic — ${err.field}: ${err.actual} < ${err.priorBound}\n`);
-            return 2;
-        }
-        if (err instanceof DispatchDuplicateError) {
-            io.stderr.write(`error: dispatch_duplicate — ${err.message}\n`);
-            return 2;
-        }
-        if (err instanceof DispatchOverlapError) {
-            io.stderr.write(`error: dispatch_overlap — ${err.message}\n`);
-            return 2;
-        }
-        if (err instanceof DispatchClaimedPathProtectedError) {
-            io.stderr.write(`error: dispatch_claimed_path_protected — ${err.message}\n`);
-            return 2;
-        }
-        if (err instanceof SliceAlreadyClosedError) {
-            io.stderr.write(`error: slice_already_closed — ${err.message}\n`);
-            return 2;
-        }
-        if (err instanceof DispatchCapError) {
-            io.stderr.write(`error: dispatch_cap — ${err.message}\n`);
-            return 2;
-        }
-        io.stderr.write(`cclaw internal ${subcommand} failed: ${err instanceof Error ? err.message : String(err)}\n`);
-        return 1;
-    }
-}

package/dist/internal/cohesion-contract-stub.d.ts

@@ -1,24 +0,0 @@
-import type { Writable } from "node:stream";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-export interface CohesionContractArgs {
-    stub: boolean;
-    force: boolean;
-    reason: string | null;
-}
-export declare function parseCohesionContractArgs(tokens: string[]): CohesionContractArgs | null;
-/**
- * Scaffold a minimal cohesion-contract pair (`cohesion-contract.{md,json}`)
- * so authors have a starting point when a multi-slice wave needs cross-slice
- * cohesion documentation. The stub seeds `sharedTypes`, `touchpoints`, and
- * `slices` from the active run delegation ledger and carries
- * `status.verdict: "scaffold"` so reviewers know to fill in the real content
- * before treating it as authoritative.
- *
- * Refuses to overwrite an existing contract unless `--force` is passed; the
- * existing file is treated as authored work.
- */
-export declare function runCohesionContractCommand(projectRoot: string, tokens: string[], io: InternalIo): Promise<number>;
-export {};

package/dist/internal/cohesion-contract-stub.js

@@ -1,148 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_ROOT } from "../constants.js";
-import { writeFileSafe } from "../fs-utils.js";
-import { readDelegationLedger, isParallelTddSliceWorker } from "../delegation.js";
-import { compareSliceIds } from "../util/slice-id.js";
-export function parseCohesionContractArgs(tokens) {
-    const args = { stub: false, force: false, reason: null };
-    for (const token of tokens) {
-        if (token === "--stub") {
-            args.stub = true;
-            continue;
-        }
-        if (token === "--force") {
-            args.force = true;
-            continue;
-        }
-        if (token.startsWith("--reason=")) {
-            const raw = token.slice("--reason=".length).trim();
-            if (raw.length > 0)
-                args.reason = raw;
-            continue;
-        }
-        return null;
-    }
-    if (!args.stub)
-        return null;
-    return args;
-}
-/**
- * Scaffold a minimal cohesion-contract pair (`cohesion-contract.{md,json}`)
- * so authors have a starting point when a multi-slice wave needs cross-slice
- * cohesion documentation. The stub seeds `sharedTypes`, `touchpoints`, and
- * `slices` from the active run delegation ledger and carries
- * `status.verdict: "scaffold"` so reviewers know to fill in the real content
- * before treating it as authoritative.
- *
- * Refuses to overwrite an existing contract unless `--force` is passed; the
- * existing file is treated as authored work.
- */
-export async function runCohesionContractCommand(projectRoot, tokens, io) {
-    const parsed = parseCohesionContractArgs(tokens);
-    if (!parsed) {
-        io.stderr.write("cclaw internal cohesion-contract: usage: --stub [--force] [--reason=\"<short>\"]\n");
-        return 1;
-    }
-    const artifactsDir = path.join(projectRoot, RUNTIME_ROOT, "artifacts");
-    const mdPath = path.join(artifactsDir, "cohesion-contract.md");
-    const jsonPath = path.join(artifactsDir, "cohesion-contract.json");
-    if (!parsed.force) {
-        const mdExists = await fileExists(mdPath);
-        const jsonExists = await fileExists(jsonPath);
-        if (mdExists || jsonExists) {
-            io.stderr.write("cclaw internal cohesion-contract: existing cohesion-contract.{md,json} present; pass --force to overwrite.\n");
-            return 1;
-        }
-    }
-    const ledger = await readDelegationLedger(projectRoot).catch(() => null);
-    const sliceIds = collectSliceIds(ledger?.entries ?? []);
-    const reasonNote = parsed.reason
-        ? `Reason: ${parsed.reason}`
-        : "Reason: scaffold for a multi-slice wave that needs cohesion documentation.";
-    const md = [
-        "# Cohesion Contract",
-        "",
-        "_Scaffold generated by `cclaw-cli internal cohesion-contract --stub`._",
-        "_Status: `scaffold` — replace placeholders with real cross-slice data before review._",
-        "",
-        `${reasonNote}`,
-        "",
-        "## Shared Types & Interfaces",
-        "| Symbol | Path | Signature | Owner slice |",
-        "|---|---|---|---|",
-        "| (none recorded) | (none) | (none) | (n/a) |",
-        "",
-        "## Naming Conventions",
-        "- Stub: per-slice modules continue to follow the existing repo conventions.",
-        "",
-        "## Invariants",
-        "- Stub: no cross-slice invariants asserted; treat each slice as independent until upgraded.",
-        "",
-        "## Integration Touchpoints",
-        "| From slice | To slice | Surface | Integration test name |",
-        "|---|---|---|---|",
-        "| (none recorded) | (n/a) | (n/a) | (n/a) |",
-        "",
-        "## Behavior Specifications per Slice",
-        sliceIds.length === 0
-            ? "- (none recorded)"
-            : sliceIds
-                .map((sid) => `### Slice ${sid}\n- Behavior: see \`tdd-slices/${sid}.md\` (if present).`)
-                .join("\n\n"),
-        "",
-        "## Status",
-        "| Slice | Implemented | Tests pass | Cohesion verified |",
-        "|---|---|---|---|",
-        sliceIds.length === 0
-            ? "| (none) | n/a | n/a | n/a |"
-            : sliceIds.map((sid) => `| ${sid} | yes | yes | advisory |`).join("\n"),
-        ""
-    ].join("\n");
-    const jsonStub = {
-        version: 1,
-        sharedTypes: [],
-        touchpoints: [],
-        slices: sliceIds.map((sid) => ({
-            sliceId: sid,
-            description: `Scaffold entry for ${sid}; replace with real behavior summary.`,
-            implemented: true,
-            testsPass: true,
-            cohesionVerified: false
-        })),
-        status: {
-            verdict: "scaffold",
-            generatedBy: "cclaw-cli internal cohesion-contract --stub",
-            reason: parsed.reason ?? "scaffold for a multi-slice wave"
-        }
-    };
-    await writeFileSafe(mdPath, md);
-    await writeFileSafe(jsonPath, `${JSON.stringify(jsonStub, null, 2)}\n`);
-    io.stdout.write(`cclaw: cohesion-contract scaffold written (${sliceIds.length} slice(s) referenced). ` +
-        "Status: scaffold — replace placeholders with real cross-slice data.\n");
-    return 0;
-}
-async function fileExists(filePath) {
-    try {
-        await fs.access(filePath);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function collectSliceIds(entries) {
-    const set = new Set();
-    for (const entry of entries) {
-        if (!isParallelTddSliceWorker(entry.agent ?? ""))
-            continue;
-        if (entry.status !== "completed")
-            continue;
-        if (typeof entry.sliceId !== "string")
-            continue;
-        if (entry.sliceId.length === 0)
-            continue;
-        set.add(entry.sliceId);
-    }
-    return [...set].sort(compareSliceIds);
-}

package/dist/internal/compound-readiness.d.ts

@@ -1,23 +0,0 @@
-import type { Writable } from "node:stream";
-import { type CompoundReadiness } from "../knowledge-store.js";
-interface InternalIo {
-    stdout: Writable;
-    stderr: Writable;
-}
-/**
- * Count archived runs as sub-directories under `.cclaw/archive/`. Missing
- * dir / ENOENT is interpreted as zero — callers should NOT conflate
- * that with "unknown" (undefined); we only return undefined on
- * unexpected errors so the caller can choose to skip the relaxation
- * rather than guess a number.
- */
-export declare function countArchivedRunsSafely(projectRoot: string): Promise<number | undefined>;
-/**
- * Compact one-liner for bootstrap surfaces.
- *
- * Example: `Compound readiness: clusters=12, ready=2 (critical=1)`.
- * When `ready === 0`, emit `Compound readiness: no candidates`.
- */
-export declare function formatCompoundReadinessLine(status: CompoundReadiness): string;
-export declare function runCompoundReadinessCommand(projectRoot: string, argv: string[], io: InternalIo): Promise<number>;
-export {};

package/dist/internal/compound-readiness.js

@@ -1,102 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { RUNTIME_ROOT } from "../constants.js";
-import { writeFileSafe } from "../fs-utils.js";
-import { computeCompoundReadiness, readKnowledgeSafely } from "../knowledge-store.js";
-function parseArgs(tokens) {
-    const args = { json: false, quiet: false, write: true };
-    for (let i = 0; i < tokens.length; i += 1) {
-        const token = tokens[i];
-        if (token === "--json")
-            args.json = true;
-        else if (token === "--quiet")
-            args.quiet = true;
-        else if (token === "--no-write")
-            args.write = false;
-        else if (token === "--write")
-            args.write = true;
-        else if (token === "--threshold") {
-            const value = tokens[i + 1];
-            if (!value)
-                throw new Error("--threshold requires a numeric value");
-            // Strict: reject "2abc", "2.9", "-1", "" — parseInt would silently
-            // accept the first two and produce surprising behavior.
-            if (!/^\d+$/u.test(value)) {
-                throw new Error(`--threshold must be a positive integer, got ${value}`);
-            }
-            const parsed = Number.parseInt(value, 10);
-            if (!Number.isInteger(parsed) || parsed < 1) {
-                throw new Error(`--threshold must be a positive integer, got ${value}`);
-            }
-            args.threshold = parsed;
-            i += 1;
-        }
-        else {
-            throw new Error(`Unknown compound-readiness flag: ${token}`);
-        }
-    }
-    return args;
-}
-function stateDir(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "state");
-}
-function archiveRunsDir(projectRoot) {
-    return path.join(projectRoot, RUNTIME_ROOT, "archive");
-}
-/**
- * Count archived runs as sub-directories under `.cclaw/archive/`. Missing
- * dir / ENOENT is interpreted as zero — callers should NOT conflate
- * that with "unknown" (undefined); we only return undefined on
- * unexpected errors so the caller can choose to skip the relaxation
- * rather than guess a number.
- */
-export async function countArchivedRunsSafely(projectRoot) {
-    const dir = archiveRunsDir(projectRoot);
-    try {
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        return entries.filter((entry) => entry.isDirectory()).length;
-    }
-    catch (error) {
-        const code = error?.code;
-        if (code === "ENOENT")
-            return 0;
-        return undefined;
-    }
-}
-/**
- * Compact one-liner for bootstrap surfaces.
- *
- * Example: `Compound readiness: clusters=12, ready=2 (critical=1)`.
- * When `ready === 0`, emit `Compound readiness: no candidates`.
- */
-export function formatCompoundReadinessLine(status) {
-    if (status.readyCount === 0) {
-        return `Compound readiness: no candidates (clusters=${status.clusterCount}, threshold=${status.threshold})`;
-    }
-    const critical = status.ready.filter((cluster) => cluster.severity === "critical").length;
-    const criticalSuffix = critical > 0 ? ` (critical=${critical})` : "";
-    return `Compound readiness: clusters=${status.clusterCount}, ready=${status.readyCount}${criticalSuffix}`;
-}
-export async function runCompoundReadinessCommand(projectRoot, argv, io) {
-    const args = parseArgs(argv);
-    const threshold = args.threshold;
-    const archivedRunsCount = await countArchivedRunsSafely(projectRoot);
-    const { entries } = await readKnowledgeSafely(projectRoot, { lockAware: true });
-    const status = computeCompoundReadiness(entries, {
-        ...(typeof threshold === "number" ? { threshold } : {}),
-        ...(typeof archivedRunsCount === "number" ? { archivedRunsCount } : {})
-    });
-    if (args.write) {
-        const target = path.join(stateDir(projectRoot), "compound-readiness.json");
-        await writeFileSafe(target, `${JSON.stringify(status, null, 2)}\n`);
-    }
-    if (!args.quiet) {
-        if (args.json) {
-            io.stdout.write(`${JSON.stringify(status, null, 2)}\n`);
-        }
-        else {
-            io.stdout.write(`${formatCompoundReadinessLine(status)}\n`);
-        }
-    }
-    return 0;
-}

package/dist/internal/detect-public-api-changes.d.ts

@@ -1,5 +0,0 @@
-export interface PublicApiChangeDetection {
-    triggered: boolean;
-    changedFiles: string[];
-}
-export declare function detectPublicApiChanges(projectRoot: string): Promise<PublicApiChangeDetection>;

package/dist/internal/detect-public-api-changes.js

@@ -1,45 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-const PUBLIC_SURFACE_PATH_PATTERNS = [
-    /(^|\/)(cli|types?|config)\.[cm]?[jt]s$/iu,
-    /(^|\/)(openapi|swagger|schema)(\/|[-_.])/iu,
-    /(^|\/)(api|commands?|flags?)(\/|[-_.])/iu,
-    /(^|\/)(package|tsconfig)\.json$/iu
-];
-async function resolveDiffBase(projectRoot) {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD~1"], {
-            cwd: projectRoot
-        });
-        const base = stdout.trim();
-        return base.length > 0 ? base : null;
-    }
-    catch {
-        return null;
-    }
-}
-export async function detectPublicApiChanges(projectRoot) {
-    const base = await resolveDiffBase(projectRoot);
-    if (!base) {
-        return { triggered: false, changedFiles: [] };
-    }
-    try {
-        const range = `${base}..HEAD`;
-        const { stdout } = await execFileAsync("git", ["diff", "--name-only", range], {
-            cwd: projectRoot
-        });
-        const changedFiles = stdout
-            .split(/\r?\n/gu)
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0)
-            .filter((filePath) => PUBLIC_SURFACE_PATH_PATTERNS.some((pattern) => pattern.test(filePath)));
-        return {
-            triggered: changedFiles.length > 0,
-            changedFiles
-        };
-    }
-    catch {
-        return { triggered: false, changedFiles: [] };
-    }
-}

package/dist/internal/detect-supply-chain-changes.d.ts

@@ -1,6 +0,0 @@
-export interface SupplyChainChangeDetection {
-    triggered: boolean;
-    changedFiles: string[];
-    reasons: string[];
-}
-export declare function detectSupplyChainChanges(projectRoot: string): Promise<SupplyChainChangeDetection>;

package/dist/internal/detect-supply-chain-changes.js

@@ -1,138 +0,0 @@
-import { execFile } from "node:child_process";
-import { promisify } from "node:util";
-const execFileAsync = promisify(execFile);
-const WORKFLOW_PATH = /(^|\/)\.github\/workflows\//u;
-const CURSOR_CONFIG_PATH = /(^|\/)\.cursor\//u;
-const PACKAGE_JSON_PATH = /(^|\/)package\.json$/u;
-const SUPPLY_CHAIN_DEP_KEYS = [
-    "dependencies",
-    "devDependencies",
-    "peerDependencies",
-    "optionalDependencies"
-];
-async function resolveDiffBase(projectRoot) {
-    try {
-        const { stdout } = await execFileAsync("git", ["rev-parse", "HEAD~1"], {
-            cwd: projectRoot
-        });
-        const base = stdout.trim();
-        return base.length > 0 ? base : null;
-    }
-    catch {
-        return null;
-    }
-}
-async function readFileAtRev(projectRoot, rev, filePath) {
-    try {
-        const { stdout } = await execFileAsync("git", ["show", `${rev}:${filePath}`], {
-            cwd: projectRoot,
-            maxBuffer: 32 * 1024 * 1024
-        });
-        return stdout;
-    }
-    catch {
-        return null;
-    }
-}
-function dependencyMapsDiffer(before, after) {
-    const beforeKeys = before ? Object.keys(before).sort() : [];
-    const afterKeys = after ? Object.keys(after).sort() : [];
-    if (beforeKeys.length !== afterKeys.length)
-        return true;
-    for (let i = 0; i < beforeKeys.length; i += 1) {
-        if (beforeKeys[i] !== afterKeys[i])
-            return true;
-        const k = beforeKeys[i];
-        if (before[k] !== after[k]) {
-            return true;
-        }
-    }
-    return false;
-}
-async function packageJsonHasDependencyDiff(projectRoot, base, filePath) {
-    const beforeRaw = await readFileAtRev(projectRoot, base, filePath);
-    const afterRaw = await readFileAtRev(projectRoot, "HEAD", filePath);
-    // If either side is missing or unparseable, treat as changed (be conservative).
-    if (beforeRaw === null || afterRaw === null)
-        return true;
-    let beforeJson;
-    let afterJson;
-    try {
-        beforeJson = JSON.parse(beforeRaw);
-    }
-    catch {
-        return true;
-    }
-    try {
-        afterJson = JSON.parse(afterRaw);
-    }
-    catch {
-        return true;
-    }
-    const beforeObj = beforeJson !== null && typeof beforeJson === "object"
-        ? beforeJson
-        : {};
-    const afterObj = afterJson !== null && typeof afterJson === "object"
-        ? afterJson
-        : {};
-    for (const key of SUPPLY_CHAIN_DEP_KEYS) {
-        const beforeMap = (beforeObj[key] !== null && typeof beforeObj[key] === "object")
-            ? beforeObj[key]
-            : undefined;
-        const afterMap = (afterObj[key] !== null && typeof afterObj[key] === "object")
-            ? afterObj[key]
-            : undefined;
-        if (dependencyMapsDiffer(beforeMap, afterMap)) {
-            return true;
-        }
-    }
-    return false;
-}
-export async function detectSupplyChainChanges(projectRoot) {
-    const base = await resolveDiffBase(projectRoot);
-    if (!base) {
-        return { triggered: false, changedFiles: [], reasons: [] };
-    }
-    let changed = [];
-    try {
-        const range = `${base}..HEAD`;
-        const { stdout } = await execFileAsync("git", ["diff", "--name-only", range], {
-            cwd: projectRoot
-        });
-        changed = stdout
-            .split(/\r?\n/gu)
-            .map((line) => line.trim())
-            .filter((line) => line.length > 0);
-    }
-    catch {
-        return { triggered: false, changedFiles: [], reasons: [] };
-    }
-    const matchedFiles = [];
-    const reasons = [];
-    for (const filePath of changed) {
-        if (WORKFLOW_PATH.test(filePath)) {
-            matchedFiles.push(filePath);
-            reasons.push(`.github/workflows changed: ${filePath}`);
-            continue;
-        }
-        if (CURSOR_CONFIG_PATH.test(filePath)) {
-            matchedFiles.push(filePath);
-            reasons.push(`.cursor config changed: ${filePath}`);
-            continue;
-        }
-        if (PACKAGE_JSON_PATH.test(filePath)) {
-            // Only flag when supply-chain dependency keys differ.
-            const depDiffers = await packageJsonHasDependencyDiff(projectRoot, base, filePath);
-            if (depDiffers) {
-                matchedFiles.push(filePath);
-                reasons.push(`${filePath} dependencies/devDependencies/peerDependencies/optionalDependencies changed`);
-            }
-            continue;
-        }
-    }
-    return {
-        triggered: matchedFiles.length > 0,
-        changedFiles: matchedFiles,
-        reasons
-    };
-}

package/dist/internal/early-loop-status.d.ts

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