cclaw-cli 0.48.1 → 0.48.3

package/dist/install.js

@@ -178,15 +178,15 @@ async function ensureStructure(projectRoot) {
         await ensureDir(path.join(projectRoot, dir));
     }
 }
-async function writeCommandContracts(projectRoot) {
-    for (const stage of FLOW_STAGES) {
-        await writeFileSafe(runtimePath(projectRoot, "commands", `${stage}.md`), stageCommandContract(stage));
-    }
+async function writeCommandContracts(projectRoot, track = "standard") {
+    await Promise.all(FLOW_STAGES.map(async (stage) => {
+        await writeFileSafe(runtimePath(projectRoot, "commands", `${stage}.md`), stageCommandContract(stage, track));
+    }));
 }
 async function writeArtifactTemplates(projectRoot) {
-    for (const [fileName, content] of Object.entries(ARTIFACT_TEMPLATES)) {
+    await Promise.all(Object.entries(ARTIFACT_TEMPLATES).map(async ([fileName, content]) => {
         await writeFileSafe(runtimePath(projectRoot, "templates", fileName), content);
-    }
+    }));
 }
 /**
  * Seed the `.cclaw/evals/` scaffold. Only writes files that do not already
@@ -699,7 +699,7 @@ async function writeHooks(projectRoot, config) {
 async function ensureKnowledgeStore(projectRoot) {
     const storePath = runtimePath(projectRoot, "knowledge.jsonl");
     if (!(await exists(storePath))) {
-        await writeFileSafe(storePath, "");
+        await writeFileSafe(storePath, "", { mode: 0o600 });
     }
     const legacyMdPath = runtimePath(projectRoot, "knowledge.md");
     if (await exists(legacyMdPath)) {
@@ -874,7 +874,7 @@ async function ensureSessionStateFiles(projectRoot) {
     }
     const activityPath = path.join(stateDir, "stage-activity.jsonl");
     if (!(await exists(activityPath))) {
-        await writeFileSafe(activityPath, "");
+        await writeFileSafe(activityPath, "", { mode: 0o600 });
     }
     const checkpointPath = path.join(stateDir, "checkpoint.json");
     if (!(await exists(checkpointPath))) {
@@ -887,7 +887,7 @@ async function ensureSessionStateFiles(projectRoot) {
             blockers: [],
             timestamp: new Date().toISOString()
         };
-        await writeFileSafe(checkpointPath, `${JSON.stringify(initialCheckpoint, null, 2)}\n`);
+        await writeFileSafe(checkpointPath, `${JSON.stringify(initialCheckpoint, null, 2)}\n`, { mode: 0o600 });
     }
     const suggestionMemoryPath = path.join(stateDir, "suggestion-memory.json");
     if (!(await exists(suggestionMemoryPath))) {
@@ -897,11 +897,11 @@ async function ensureSessionStateFiles(projectRoot) {
             lastSuggestedStage: "",
             lastSuggestedAt: ""
         };
-        await writeFileSafe(suggestionMemoryPath, `${JSON.stringify(suggestionMemory, null, 2)}\n`);
+        await writeFileSafe(suggestionMemoryPath, `${JSON.stringify(suggestionMemory, null, 2)}\n`, { mode: 0o600 });
     }
     const contextModePath = path.join(stateDir, "context-mode.json");
     if (!(await exists(contextModePath))) {
-        await writeFileSafe(contextModePath, `${JSON.stringify(createInitialContextModeState(), null, 2)}\n`);
+        await writeFileSafe(contextModePath, `${JSON.stringify(createInitialContextModeState(), null, 2)}\n`, { mode: 0o600 });
     }
     const knowledgeDigestPath = path.join(stateDir, "knowledge-digest.md");
     if (!(await exists(knowledgeDigestPath))) {
@@ -909,18 +909,18 @@ async function ensureSessionStateFiles(projectRoot) {
     }
     const tddCycleLogPath = path.join(stateDir, "tdd-cycle-log.jsonl");
     if (!(await exists(tddCycleLogPath))) {
-        await writeFileSafe(tddCycleLogPath, "");
+        await writeFileSafe(tddCycleLogPath, "", { mode: 0o600 });
     }
     const reconciliationNoticesPath = path.join(stateDir, "reconciliation-notices.json");
     if (!(await exists(reconciliationNoticesPath))) {
-        await writeFileSafe(reconciliationNoticesPath, `${JSON.stringify({ schemaVersion: 1, notices: [] }, null, 2)}\n`);
+        await writeFileSafe(reconciliationNoticesPath, `${JSON.stringify({ schemaVersion: 1, notices: [] }, null, 2)}\n`, { mode: 0o600 });
     }
     const flowSnapshotPath = path.join(stateDir, "flow-state.snapshot.json");
     if (!(await exists(flowSnapshotPath))) {
         await writeFileSafe(flowSnapshotPath, `${JSON.stringify({
             capturedAt: new Date().toISOString(),
             state: flow
-        }, null, 2)}\n`);
+        }, null, 2)}\n`, { mode: 0o600 });
     }
 }
 async function writeRulebook(projectRoot) {
@@ -977,8 +977,8 @@ async function writeState(projectRoot, config, forceReset = false) {
     if (!forceReset && (await exists(statePath))) {
         return;
     }
-    const state = createInitialFlowState("active", config.defaultTrack ?? "standard");
-    await writeFileSafe(statePath, `${JSON.stringify(state, null, 2)}\n`);
+    const state = createInitialFlowState({ track: config.defaultTrack ?? "standard" });
+    await writeFileSafe(statePath, `${JSON.stringify(state, null, 2)}\n`, { mode: 0o600 });
 }
 async function writeAdapterManifest(projectRoot, harnesses) {
     const manifest = {
@@ -1198,13 +1198,15 @@ async function materializeRuntime(projectRoot, config, forceStateReset) {
     await ensureStructure(projectRoot);
     await cleanLegacyArtifacts(projectRoot);
     await cleanStaleFiles(projectRoot);
-    await writeCommandContracts(projectRoot);
-    await writeUtilityCommands(projectRoot, config);
-    await writeSkills(projectRoot, config);
-    await writeContextModes(projectRoot);
-    await writeArtifactTemplates(projectRoot);
-    await writeEvalScaffold(projectRoot);
-    await writeRulebook(projectRoot);
+    await Promise.all([
+        writeCommandContracts(projectRoot, config.defaultTrack ?? "standard"),
+        writeUtilityCommands(projectRoot, config),
+        writeSkills(projectRoot, config),
+        writeContextModes(projectRoot),
+        writeArtifactTemplates(projectRoot),
+        writeEvalScaffold(projectRoot),
+        writeRulebook(projectRoot)
+    ]);
     await writeState(projectRoot, config, forceStateReset);
     await ensureRunSystem(projectRoot, { createIfMissing: false });
     await ensureSessionStateFiles(projectRoot);

package/dist/internal/advance-stage.js

@@ -1,22 +1,51 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import { RUNTIME_ROOT } from "../constants.js";
+import { RUNTIME_ROOT, SHIP_FINALIZATION_MODES } from "../constants.js";
 import { stageSchema } from "../content/stage-schema.js";
 import { appendDelegation, checkMandatoryDelegations } from "../delegation.js";
 import { readActiveFeature } from "../feature-system.js";
 import { verifyCompletedStagesGateClosure, verifyCurrentStageGateEvidence } from "../gate-evidence.js";
 import { extractMarkdownSectionBody, parseLearningsSection } from "../artifact-linter.js";
-import { isFlowTrack, nextStage } from "../flow-state.js";
+import { getAvailableTransitions, getTransitionGuards, isFlowTrack } from "../flow-state.js";
 import { appendKnowledge } from "../knowledge-store.js";
 import { readFlowState, writeFlowState } from "../runs.js";
 import { FLOW_STAGES } from "../types.js";
 function unique(values) {
     return [...new Set(values)];
 }
+function resolveSuccessorTransition(stage, track, transitionTargets, satisfiedGuards, selectedTransitionGuards) {
+    const natural = transitionTargets[0] ?? null;
+    const specialTargets = transitionTargets.filter((target) => target !== natural);
+    for (const target of specialTargets) {
+        const guards = getTransitionGuards(stage, target, track);
+        if (guards.length === 0)
+            continue;
+        const selectedSpecial = guards.some((guard) => selectedTransitionGuards.has(guard));
+        if (!selectedSpecial)
+            continue;
+        if (guards.every((guard) => satisfiedGuards.has(guard))) {
+            return target;
+        }
+    }
+    if (natural) {
+        const guards = getTransitionGuards(stage, natural, track);
+        if (guards.every((guard) => satisfiedGuards.has(guard))) {
+            return natural;
+        }
+    }
+    for (const target of specialTargets) {
+        const guards = getTransitionGuards(stage, target, track);
+        if (guards.every((guard) => satisfiedGuards.has(guard))) {
+            return target;
+        }
+    }
+    return natural;
+}
 const TEST_COMMAND_HINT_PATTERN = /\b(?:npm test|pnpm test|yarn test|bun test|vitest|jest|pytest|go test|cargo test|mvn test|gradle test|dotnet test)\b/iu;
 const SHA_WITH_LABEL_PATTERN = /\b(?:sha|commit)(?:\s*[:=]|\s+)\s*[0-9a-f]{7,40}\b/iu;
 const PASS_STATUS_PATTERN = /\b(?:pass|passed|green|ok)\b/iu;
-const SHIP_FINALIZATION_MODE_PATTERN = /\bFINALIZE_(?:MERGE_LOCAL|OPEN_PR|QUEUE|HANDOFF|SKIP)\b/u;
+const SHIP_FINALIZATION_MODE_PATTERN = new RegExp(`\\b(?:${SHIP_FINALIZATION_MODES.join("|")})\\b`, "u");
+const SHIP_FINALIZATION_MODE_HINT = SHIP_FINALIZATION_MODES.join(", ");
 // 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
@@ -36,7 +65,7 @@ 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 `FINALIZE_MERGE_LOCAL`, `FINALIZE_OPEN_PR`, `FINALIZE_HANDOFF`, `FINALIZE_QUEUE`, or `FINALIZE_SKIP`).";
+            return `must name the finalization mode that ran (for example ${SHIP_FINALIZATION_MODE_HINT}).`;
         }
         return null;
     }
@@ -395,11 +424,18 @@ async function runAdvanceStage(projectRoot, args, io) {
     const requiredGateIds = schema.requiredGates
         .filter((gate) => gate.tier === "required")
         .map((gate) => gate.id);
+    const transitionTargets = getAvailableTransitions(args.stage, flowState.track).map((rule) => rule.to);
     const allowedGateIds = new Set(schema.requiredGates.map((gate) => gate.id));
+    const transitionGuardIds = new Set(transitionTargets
+        .flatMap((target) => getTransitionGuards(args.stage, target, flowState.track))
+        .filter((guardId) => !allowedGateIds.has(guardId)));
+    const selectableGateIds = new Set([...allowedGateIds, ...transitionGuardIds]);
     const selectedGateIds = args.passedGateIds.length > 0
-        ? args.passedGateIds.filter((gateId) => allowedGateIds.has(gateId))
+        ? args.passedGateIds.filter((gateId) => selectableGateIds.has(gateId))
         : requiredGateIds;
-    const missingRequired = requiredGateIds.filter((gateId) => !selectedGateIds.includes(gateId));
+    const selectedGateIdSet = new Set(selectedGateIds);
+    const selectedTransitionGuards = selectedGateIds.filter((gateId) => transitionGuardIds.has(gateId));
+    const missingRequired = requiredGateIds.filter((gateId) => !selectedGateIdSet.has(gateId));
     if (missingRequired.length > 0) {
         io.stderr.write(`cclaw internal advance-stage: required gates not selected as passed: ${missingRequired.join(", ")}.\n`);
         return 1;
@@ -429,14 +465,16 @@ async function runAdvanceStage(projectRoot, args, io) {
     }
     const catalog = flowState.stageGateCatalog[args.stage];
     const nextPassed = unique([...catalog.passed, ...selectedGateIds]).filter((gateId) => allowedGateIds.has(gateId));
-    const nextBlocked = unique(catalog.blocked.filter((gateId) => !nextPassed.includes(gateId))).filter((gateId) => allowedGateIds.has(gateId));
+    const nextPassedSet = new Set(nextPassed);
+    const nextBlocked = unique(catalog.blocked.filter((gateId) => !nextPassedSet.has(gateId))).filter((gateId) => allowedGateIds.has(gateId));
     const conditional = new Set(catalog.conditional);
     const nextTriggered = unique([
         ...catalog.triggered.filter((gateId) => conditional.has(gateId)),
         ...nextPassed.filter((gateId) => conditional.has(gateId)),
         ...nextBlocked.filter((gateId) => conditional.has(gateId))
     ]);
-    const missingGuardEvidence = nextPassed.filter((gateId) => {
+    const guardEvidenceGateIds = unique([...nextPassed, ...selectedTransitionGuards]);
+    const missingGuardEvidence = guardEvidenceGateIds.filter((gateId) => {
         const existing = flowState.guardEvidence[gateId];
         if (typeof existing === "string" && existing.trim().length > 0) {
             return false;
@@ -464,7 +502,7 @@ async function runAdvanceStage(projectRoot, args, io) {
         return 1;
     }
     const nextGuardEvidence = { ...flowState.guardEvidence };
-    for (const gateId of nextPassed) {
+    for (const gateId of guardEvidenceGateIds) {
         const provided = args.evidenceByGate[gateId];
         if (typeof provided === "string" && provided.trim().length > 0) {
             nextGuardEvidence[gateId] = provided.trim();
@@ -508,7 +546,8 @@ async function runAdvanceStage(projectRoot, args, io) {
         io.stderr.write(`cclaw internal advance-stage: learnings harvest failed for "${schema.artifactFile}". ${learningsHarvest.details}\n`);
         return 1;
     }
-    const successor = nextStage(args.stage, flowState.track);
+    const satisfiedGuards = new Set([...nextPassed, ...selectedTransitionGuards]);
+    const successor = resolveSuccessorTransition(args.stage, flowState.track, transitionTargets, satisfiedGuards, new Set(selectedTransitionGuards));
     const completedStages = flowState.completedStages.includes(args.stage)
         ? [...flowState.completedStages]
         : [...flowState.completedStages, args.stage];

package/dist/knowledge-store.d.ts

@@ -58,9 +58,17 @@ export interface AppendKnowledgeResult {
     errors: string[];
     appendedEntries: KnowledgeEntry[];
 }
+export interface ReadKnowledgeOptions {
+    lockAware?: boolean;
+}
+export interface ReadKnowledgeResult {
+    entries: KnowledgeEntry[];
+    malformedLines: number;
+}
 export declare function validateKnowledgeEntry(entry: unknown): {
     ok: boolean;
     errors: string[];
 };
 export declare function materializeKnowledgeEntry(seed: KnowledgeSeedEntry, defaults?: AppendKnowledgeDefaults): KnowledgeEntry;
+export declare function readKnowledgeSafely(projectRoot: string, options?: ReadKnowledgeOptions): Promise<ReadKnowledgeResult>;
 export declare function appendKnowledge(projectRoot: string, seeds: KnowledgeSeedEntry[], defaults?: AppendKnowledgeDefaults): Promise<AppendKnowledgeResult>;

package/dist/knowledge-store.js

@@ -66,8 +66,78 @@ function dedupeKey(entry) {
         entry.severity === undefined ? "none" : entry.severity
     ].join("|");
 }
+function emptyKnowledgeSnapshot() {
+    return {
+        lines: [],
+        entries: [],
+        malformedLines: 0,
+        keyToIndex: new Map(),
+        entryByIndex: new Map()
+    };
+}
+function parseKnowledgeSnapshot(raw) {
+    const lines = stripBom(raw).split(/\r?\n/u);
+    const entries = [];
+    const keyToIndex = new Map();
+    const entryByIndex = new Map();
+    let malformedLines = 0;
+    for (let i = 0; i < lines.length; i += 1) {
+        const trimmed = lines[i].trim();
+        if (trimmed.length === 0)
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            const validated = validateKnowledgeEntry(parsed);
+            if (!validated.ok) {
+                malformedLines += 1;
+                continue;
+            }
+            const entry = parsed;
+            entries.push(entry);
+            const key = dedupeKey(entry);
+            if (!keyToIndex.has(key)) {
+                keyToIndex.set(key, i);
+            }
+            entryByIndex.set(i, entry);
+        }
+        catch {
+            malformedLines += 1;
+        }
+    }
+    return {
+        lines,
+        entries,
+        malformedLines,
+        keyToIndex,
+        entryByIndex
+    };
+}
+async function readKnowledgeSnapshot(filePath) {
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        return parseKnowledgeSnapshot(raw);
+    }
+    catch (error) {
+        const code = error?.code;
+        if (code === "ENOENT") {
+            return emptyKnowledgeSnapshot();
+        }
+        throw error;
+    }
+}
+function mergeKnowledgeOccurrence(target, incoming) {
+    const mergedFrequency = target.frequency + Math.max(1, incoming.frequency);
+    const mergedLastSeen = target.last_seen_ts >= incoming.last_seen_ts
+        ? target.last_seen_ts
+        : incoming.last_seen_ts;
+    return {
+        ...target,
+        frequency: mergedFrequency,
+        last_seen_ts: mergedLastSeen
+    };
+}
 function isIsoUtcTimestamp(value) {
-    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/u.test(value);
+    return /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/u.test(value);
 }
 function isNullableString(value) {
     return value === null || typeof value === "string";
@@ -176,29 +246,19 @@ export function materializeKnowledgeEntry(seed, defaults = {}) {
     }
     return entry;
 }
-async function readExistingKnowledgeKeys(filePath) {
-    const keys = new Set();
-    try {
-        const raw = stripBom(await fs.readFile(filePath, "utf8"));
-        const lines = raw.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
-        for (const line of lines) {
-            try {
-                const parsed = JSON.parse(line);
-                const validated = validateKnowledgeEntry(parsed);
-                if (!validated.ok)
-                    continue;
-                const entry = parsed;
-                keys.add(dedupeKey(entry));
-            }
-            catch {
-                // Ignore malformed historical lines for dedupe indexing.
-            }
-        }
-    }
-    catch {
-        // Missing file is fine — treat as empty store.
+export async function readKnowledgeSafely(projectRoot, options = {}) {
+    const filePath = knowledgePath(projectRoot);
+    const read = async () => {
+        const snapshot = await readKnowledgeSnapshot(filePath);
+        return {
+            entries: snapshot.entries,
+            malformedLines: snapshot.malformedLines
+        };
+    };
+    if (options.lockAware === false) {
+        return read();
     }
-    return keys;
+    return withDirectoryLock(knowledgeLockPath(projectRoot), read);
 }
 export async function appendKnowledge(projectRoot, seeds, defaults = {}) {
     if (seeds.length === 0) {
@@ -221,22 +281,42 @@ export async function appendKnowledge(projectRoot, seeds, defaults = {}) {
     const appendedEntries = [];
     await withDirectoryLock(knowledgeLockPath(projectRoot), async () => {
         await fs.mkdir(path.dirname(filePath), { recursive: true });
-        const existingKeys = await readExistingKnowledgeKeys(filePath);
-        const batchKeys = new Set();
-        const linesToAppend = [];
+        const snapshot = await readKnowledgeSnapshot(filePath);
+        const updatedByIndex = new Map();
+        const batchEntries = new Map();
         for (const entry of materialized) {
             const key = dedupeKey(entry);
-            if (existingKeys.has(key) || batchKeys.has(key)) {
+            const existingIndex = snapshot.keyToIndex.get(key);
+            if (existingIndex !== undefined) {
                 skippedDuplicates += 1;
+                const base = updatedByIndex.get(existingIndex) ?? snapshot.entryByIndex.get(existingIndex);
+                if (base) {
+                    updatedByIndex.set(existingIndex, mergeKnowledgeOccurrence(base, entry));
+                }
                 continue;
             }
-            batchKeys.add(key);
-            existingKeys.add(key);
-            appendedEntries.push(entry);
-            linesToAppend.push(JSON.stringify(entry));
+            const existingBatchEntry = batchEntries.get(key);
+            if (existingBatchEntry) {
+                skippedDuplicates += 1;
+                batchEntries.set(key, mergeKnowledgeOccurrence(existingBatchEntry, entry));
+                continue;
+            }
+            batchEntries.set(key, { ...entry });
+        }
+        appendedEntries.push(...batchEntries.values());
+        if (updatedByIndex.size === 0 && batchEntries.size === 0) {
+            return;
         }
-        if (linesToAppend.length > 0) {
-            await fs.appendFile(filePath, `${linesToAppend.join("\n")}\n`, "utf8");
+        const rewrittenLines = snapshot.lines.map((line, index) => {
+            const updated = updatedByIndex.get(index);
+            return updated ? JSON.stringify(updated) : line;
+        }).filter((line) => line.trim().length > 0);
+        const linesToWrite = [
+            ...rewrittenLines,
+            ...Array.from(batchEntries.values(), (entry) => JSON.stringify(entry))
+        ];
+        if (linesToWrite.length > 0) {
+            await fs.writeFile(filePath, `${linesToWrite.join("\n")}\n`, "utf8");
         }
     });
     return {

package/dist/retro-gate.js

@@ -2,6 +2,7 @@ import fs from "node:fs/promises";
 import path from "node:path";
 import { RUNTIME_ROOT } from "./constants.js";
 import { exists, stripBom } from "./fs-utils.js";
+import { readKnowledgeSafely } from "./knowledge-store.js";
 function activeArtifactsPath(projectRoot) {
     return path.join(projectRoot, RUNTIME_ROOT, "artifacts");
 }
@@ -61,35 +62,44 @@ export async function evaluateRetroGate(projectRoot, state) {
         }
     }
     const shouldFallbackScan = compoundEntries <= 0 && (windowStartMs !== null || windowEndMs !== null);
-    const knowledgeFile = path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
-    if (shouldFallbackScan && (await exists(knowledgeFile))) {
+    if (shouldFallbackScan) {
+        const countIfEligible = (parsed) => {
+            if (parsed.type !== "compound") {
+                return 0;
+            }
+            const created = typeof parsed.created === "string" ? parseIsoTimestamp(parsed.created) : null;
+            if (created === null || !inInclusiveWindow(created, windowStartMs, windowEndMs)) {
+                return 0;
+            }
+            const source = typeof parsed.source === "string"
+                ? parsed.source.trim().toLowerCase()
+                : null;
+            const legacyRetroStage = parsed.stage === "retro";
+            return source === "retro" || legacyRetroStage ? 1 : 0;
+        };
         try {
-            const raw = stripBom(await fs.readFile(knowledgeFile, "utf8"));
+            const knowledgeFile = path.join(projectRoot, RUNTIME_ROOT, "knowledge.jsonl");
+            const { entries } = await readKnowledgeSafely(projectRoot);
             compoundEntries = 0;
-            for (const line of raw.split(/\r?\n/)) {
-                const trimmed = line.trim();
-                if (!trimmed)
-                    continue;
-                try {
-                    const parsed = JSON.parse(trimmed);
-                    if (parsed.type !== "compound") {
-                        continue;
-                    }
-                    const created = typeof parsed.created === "string" ? parseIsoTimestamp(parsed.created) : null;
-                    if (created === null || !inInclusiveWindow(created, windowStartMs, windowEndMs)) {
+            for (const parsed of entries) {
+                compoundEntries += countIfEligible(parsed);
+            }
+            // Backward compatibility for historical/hand-edited rows that don't pass
+            // strict knowledge schema validation but still carry retro evidence.
+            if (compoundEntries === 0 && (await exists(knowledgeFile))) {
+                const raw = stripBom(await fs.readFile(knowledgeFile, "utf8"));
+                for (const line of raw.split(/\r?\n/)) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
                         continue;
+                    try {
+                        const parsed = JSON.parse(trimmed);
+                        compoundEntries += countIfEligible(parsed);
                     }
-                    const source = typeof parsed.source === "string"
-                        ? parsed.source.trim().toLowerCase()
-                        : null;
-                    const legacyRetroStage = parsed.stage === "retro";
-                    if (source === "retro" || legacyRetroStage) {
-                        compoundEntries += 1;
+                    catch {
+                        // ignore malformed lines for retro gate calculation
                     }
                 }
-                catch {
-                    // ignore malformed lines for retro gate calculation
-                }
             }
         }
         catch {