brainclaw 0.19.2

package/dist/core/brainclaw-version.js

@@ -0,0 +1,433 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { BrainclawLocalReleaseManifestSchema, } from './schema.js';
+export const DEFAULT_LOCAL_RELEASES_DIR = '.releases';
+export const DEFAULT_LOCAL_RELEASE_MANIFEST_PATH = `${DEFAULT_LOCAL_RELEASES_DIR}/brainclaw-local.json`;
+const SEMVER_RE = /^v?(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/;
+let cachedCliVersion;
+export function getInstalledBrainclawVersion() {
+    if (cachedCliVersion) {
+        return cachedCliVersion;
+    }
+    const packageJsonPath = findOwnPackageJson();
+    if (!packageJsonPath) {
+        cachedCliVersion = '0.0.0';
+        return cachedCliVersion;
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        cachedCliVersion = typeof parsed.version === 'string' && parsed.version.trim().length > 0
+            ? parsed.version.trim()
+            : '0.0.0';
+    }
+    catch {
+        cachedCliVersion = '0.0.0';
+    }
+    return cachedCliVersion;
+}
+export function assessBrainclawVersion(config) {
+    const cliVersion = getInstalledBrainclawVersion();
+    const minimumVersion = normalizeConfiguredVersion(config?.minimum_brainclaw_version);
+    const recommendedVersion = normalizeConfiguredVersion(config?.recommended_brainclaw_version);
+    const upgradeMessage = config?.brainclaw_upgrade_message?.trim() || null;
+    const upgradeCommand = config?.brainclaw_upgrade_command?.trim() || null;
+    const invalidFields = [
+        minimumVersion ? undefined : invalidField('minimum_brainclaw_version', config?.minimum_brainclaw_version),
+        recommendedVersion ? undefined : invalidField('recommended_brainclaw_version', config?.recommended_brainclaw_version),
+    ].filter((value) => Boolean(value));
+    if (invalidFields.length > 0) {
+        return {
+            cli_version: cliVersion,
+            minimum_brainclaw_version: minimumVersion,
+            recommended_brainclaw_version: recommendedVersion,
+            upgrade_message: upgradeMessage,
+            upgrade_command: upgradeCommand,
+            target_version: recommendedVersion ?? minimumVersion,
+            status: 'invalid_config',
+            message: `Invalid Brainclaw version policy in config.yaml: ${invalidFields.join(', ')}`,
+        };
+    }
+    if (minimumVersion && compareVersions(cliVersion, minimumVersion) < 0) {
+        return {
+            cli_version: cliVersion,
+            minimum_brainclaw_version: minimumVersion,
+            recommended_brainclaw_version: recommendedVersion,
+            upgrade_message: upgradeMessage,
+            upgrade_command: upgradeCommand,
+            target_version: recommendedVersion ?? minimumVersion,
+            status: 'upgrade_required',
+            message: `Installed brainclaw ${cliVersion} is older than the required minimum ${minimumVersion}.`,
+        };
+    }
+    if (recommendedVersion && compareVersions(cliVersion, recommendedVersion) < 0) {
+        return {
+            cli_version: cliVersion,
+            minimum_brainclaw_version: minimumVersion,
+            recommended_brainclaw_version: recommendedVersion,
+            upgrade_message: upgradeMessage,
+            upgrade_command: upgradeCommand,
+            target_version: recommendedVersion,
+            status: 'update_available',
+            message: `Installed brainclaw ${cliVersion} is older than the project recommendation ${recommendedVersion}.`,
+        };
+    }
+    const message = minimumVersion || recommendedVersion
+        ? `Installed brainclaw ${cliVersion} satisfies the project version policy.`
+        : `Installed brainclaw ${cliVersion}; no project-specific version policy is configured.`;
+    return {
+        cli_version: cliVersion,
+        minimum_brainclaw_version: minimumVersion,
+        recommended_brainclaw_version: recommendedVersion,
+        upgrade_message: upgradeMessage,
+        upgrade_command: upgradeCommand,
+        target_version: recommendedVersion ?? minimumVersion,
+        status: 'ok',
+        message,
+    };
+}
+export function checkBrainclawInstallableUpdate(config, cwd) {
+    const source = config?.brainclaw_update_source;
+    if (!source) {
+        return {
+            checked: false,
+            source_type: null,
+            source_description: null,
+            latest_installable_version: null,
+            artifact_path: null,
+            install_command: null,
+            release_notes: null,
+            status: 'not_configured',
+            message: 'No installable update source is configured for this project.',
+        };
+    }
+    if (source.type === 'npm') {
+        const packageName = source.package_name?.trim() || 'brainclaw';
+        const distTag = source.dist_tag?.trim() || 'latest';
+        return {
+            checked: false,
+            source_type: 'npm',
+            source_description: `${packageName}@${distTag}`,
+            latest_installable_version: null,
+            artifact_path: null,
+            install_command: null,
+            release_notes: null,
+            status: 'unsupported_source',
+            message: 'The npm update source is modeled in config but is not implemented yet in this build.',
+        };
+    }
+    const manifestPath = source.manifest_path.trim();
+    if (manifestPath.length === 0) {
+        return {
+            checked: false,
+            source_type: 'local-pack',
+            source_description: null,
+            latest_installable_version: null,
+            artifact_path: null,
+            install_command: null,
+            release_notes: null,
+            status: 'invalid_config',
+            message: 'brainclaw_update_source.manifest_path must not be empty.',
+        };
+    }
+    const resolvedManifestPath = path.isAbsolute(manifestPath)
+        ? manifestPath
+        : path.resolve(cwd, manifestPath);
+    if (!fs.existsSync(resolvedManifestPath)) {
+        return {
+            checked: true,
+            source_type: 'local-pack',
+            source_description: resolvedManifestPath,
+            latest_installable_version: null,
+            artifact_path: null,
+            install_command: null,
+            release_notes: null,
+            status: 'check_failed',
+            message: `The configured local-pack manifest was not found: ${resolvedManifestPath}`,
+        };
+    }
+    try {
+        const parsed = JSON.parse(fs.readFileSync(resolvedManifestPath, 'utf-8'));
+        const manifest = BrainclawLocalReleaseManifestSchema.parse(parsed);
+        const latestVersion = normalizeConfiguredVersion(manifest.latest_installable_version);
+        if (!latestVersion) {
+            return {
+                checked: true,
+                source_type: 'local-pack',
+                source_description: resolvedManifestPath,
+                latest_installable_version: null,
+                artifact_path: null,
+                install_command: null,
+                release_notes: manifest.release_notes?.trim() || config?.brainclaw_upgrade_message?.trim() || null,
+                status: 'check_failed',
+                message: `The local-pack manifest has an invalid latest_installable_version: ${manifest.latest_installable_version}`,
+            };
+        }
+        const artifactPath = manifest.artifact_path
+            ? resolveManifestArtifactPath(manifest.artifact_path, resolvedManifestPath)
+            : null;
+        const installCommand = manifest.install_command?.trim()
+            || (artifactPath ? `npm install -g "${artifactPath}"` : config?.brainclaw_upgrade_command?.trim() || null);
+        const releaseNotes = manifest.release_notes?.trim() || config?.brainclaw_upgrade_message?.trim() || null;
+        const installedVersion = getInstalledBrainclawVersion();
+        if (compareVersions(installedVersion, latestVersion) < 0) {
+            return {
+                checked: true,
+                source_type: 'local-pack',
+                source_description: resolvedManifestPath,
+                latest_installable_version: latestVersion,
+                artifact_path: artifactPath,
+                install_command: installCommand,
+                release_notes: releaseNotes,
+                status: 'update_available',
+                message: `A newer installable brainclaw build is available: ${latestVersion} (installed ${installedVersion}).`,
+            };
+        }
+        return {
+            checked: true,
+            source_type: 'local-pack',
+            source_description: resolvedManifestPath,
+            latest_installable_version: latestVersion,
+            artifact_path: artifactPath,
+            install_command: installCommand,
+            release_notes: releaseNotes,
+            status: 'up_to_date',
+            message: `Installed brainclaw ${installedVersion} is up to date for the configured local-pack channel.`,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            checked: true,
+            source_type: 'local-pack',
+            source_description: resolvedManifestPath,
+            latest_installable_version: null,
+            artifact_path: null,
+            install_command: null,
+            release_notes: null,
+            status: 'check_failed',
+            message: `Failed to read the configured local-pack manifest: ${message}`,
+        };
+    }
+}
+export function publishLocalBrainclawRelease(cwd, options = {}) {
+    const workspacePackage = readWorkspaceBrainclawPackage(cwd);
+    const outputDir = path.resolve(cwd, options.outputDir ?? DEFAULT_LOCAL_RELEASES_DIR);
+    const manifestPath = path.resolve(cwd, options.manifestPath ?? DEFAULT_LOCAL_RELEASE_MANIFEST_PATH);
+    fs.mkdirSync(outputDir, { recursive: true });
+    fs.mkdirSync(path.dirname(manifestPath), { recursive: true });
+    const packResult = spawnSync(resolveNpmCommand(), resolveNpmPackArgs(outputDir), {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 120000,
+    });
+    if (packResult.error) {
+        throw new Error(`Failed to run npm pack: ${packResult.error.message}`);
+    }
+    if (packResult.status !== 0) {
+        throw new Error(firstNonEmptyLine(packResult.stderr) ?? firstNonEmptyLine(packResult.stdout) ?? 'npm pack failed');
+    }
+    const artifactFilename = parsePackedFilename(packResult.stdout);
+    if (!artifactFilename) {
+        throw new Error('npm pack did not report the generated tarball filename.');
+    }
+    const artifactAbsolutePath = path.join(outputDir, artifactFilename);
+    if (!fs.existsSync(artifactAbsolutePath)) {
+        throw new Error(`npm pack reported ${artifactFilename}, but the tarball was not found in ${outputDir}.`);
+    }
+    const manifestArtifactPath = toManifestRelativePath(path.relative(path.dirname(manifestPath), artifactAbsolutePath));
+    const projectArtifactPath = toManifestRelativePath(path.relative(cwd, artifactAbsolutePath));
+    const projectManifestPath = toPortablePath(path.relative(cwd, manifestPath));
+    const installCommand = `npm install -g "${projectArtifactPath}"`;
+    const releaseNotes = options.releaseNotes?.trim() || null;
+    const manifest = BrainclawLocalReleaseManifestSchema.parse({
+        version: 1,
+        channel: 'local-pack',
+        package_name: workspacePackage.name,
+        latest_installable_version: workspacePackage.version,
+        published_at: new Date().toISOString(),
+        artifact_path: manifestArtifactPath,
+        install_command: installCommand,
+        release_notes: releaseNotes ?? undefined,
+    });
+    fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, 'utf-8');
+    return {
+        package_name: workspacePackage.name,
+        workspace_version: workspacePackage.version,
+        manifest_path: projectManifestPath,
+        artifact_path: projectArtifactPath,
+        install_command: installCommand,
+        release_notes: releaseNotes,
+    };
+}
+function resolveNpmCommand() {
+    return process.platform === 'win32' ? (process.env.ComSpec?.trim() || 'cmd.exe') : 'npm';
+}
+function resolveNpmPackArgs(outputDir) {
+    if (process.platform === 'win32') {
+        return ['/d', '/s', '/c', 'npm', 'pack', '--json', '--pack-destination', outputDir];
+    }
+    return ['pack', '--json', '--pack-destination', outputDir];
+}
+function findOwnPackageJson() {
+    let currentDir = path.dirname(fileURLToPath(import.meta.url));
+    while (true) {
+        const candidate = path.join(currentDir, 'package.json');
+        if (fs.existsSync(candidate)) {
+            try {
+                const parsed = JSON.parse(fs.readFileSync(candidate, 'utf-8'));
+                if (parsed.name === 'brainclaw') {
+                    return candidate;
+                }
+            }
+            catch {
+                // Ignore malformed package.json while walking upward.
+            }
+        }
+        const parent = path.dirname(currentDir);
+        if (parent === currentDir) {
+            return undefined;
+        }
+        currentDir = parent;
+    }
+}
+function resolveManifestArtifactPath(artifactPath, manifestPath) {
+    if (path.isAbsolute(artifactPath)) {
+        return artifactPath;
+    }
+    return path.resolve(path.dirname(manifestPath), artifactPath);
+}
+function readWorkspaceBrainclawPackage(cwd) {
+    const packageJsonPath = path.join(cwd, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        throw new Error('Local Brainclaw release publishing requires a package.json in the current workspace.');
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        throw new Error(`Failed to read package.json: ${message}`);
+    }
+    const name = typeof parsed.name === 'string' ? parsed.name.trim() : '';
+    const version = typeof parsed.version === 'string' ? parsed.version.trim() : '';
+    if (name !== 'brainclaw') {
+        throw new Error(`Local release publishing is only supported from the brainclaw workspace; found package name "${name || '<missing>'}".`);
+    }
+    if (!parseVersion(version)) {
+        throw new Error(`package.json version must be a valid semver string; found "${version || '<missing>'}".`);
+    }
+    return { name, version };
+}
+function parsePackedFilename(stdout) {
+    try {
+        const parsed = JSON.parse(stdout);
+        const filename = parsed[0]?.filename;
+        return typeof filename === 'string' && filename.trim().length > 0 ? filename.trim() : undefined;
+    }
+    catch {
+        return firstNonEmptyLine(stdout);
+    }
+}
+function firstNonEmptyLine(value) {
+    return value
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find(Boolean);
+}
+function toManifestRelativePath(value) {
+    const portable = toPortablePath(value);
+    if (portable.startsWith('./') || portable.startsWith('../')) {
+        return portable;
+    }
+    return `./${portable}`;
+}
+function toPortablePath(value) {
+    return value.replace(/\\/g, '/');
+}
+function normalizeConfiguredVersion(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+        return null;
+    }
+    return parseVersion(trimmed) ? trimmed : null;
+}
+function invalidField(fieldName, rawValue) {
+    if (!rawValue || rawValue.trim().length === 0) {
+        return undefined;
+    }
+    return parseVersion(rawValue.trim()) ? undefined : `${fieldName}=${rawValue.trim()}`;
+}
+function parseVersion(value) {
+    const match = value.match(SEMVER_RE);
+    if (!match) {
+        return undefined;
+    }
+    return {
+        major: Number.parseInt(match[1], 10),
+        minor: Number.parseInt(match[2], 10),
+        patch: Number.parseInt(match[3], 10),
+        prerelease: match[4] ? match[4].split('.') : [],
+    };
+}
+function compareVersions(left, right) {
+    const parsedLeft = parseVersion(left);
+    const parsedRight = parseVersion(right);
+    if (!parsedLeft || !parsedRight) {
+        return 0;
+    }
+    if (parsedLeft.major !== parsedRight.major) {
+        return parsedLeft.major - parsedRight.major;
+    }
+    if (parsedLeft.minor !== parsedRight.minor) {
+        return parsedLeft.minor - parsedRight.minor;
+    }
+    if (parsedLeft.patch !== parsedRight.patch) {
+        return parsedLeft.patch - parsedRight.patch;
+    }
+    return comparePrerelease(parsedLeft.prerelease, parsedRight.prerelease);
+}
+function comparePrerelease(left, right) {
+    if (left.length === 0 && right.length === 0) {
+        return 0;
+    }
+    if (left.length === 0) {
+        return 1;
+    }
+    if (right.length === 0) {
+        return -1;
+    }
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart === undefined) {
+            return -1;
+        }
+        if (rightPart === undefined) {
+            return 1;
+        }
+        if (leftPart === rightPart) {
+            continue;
+        }
+        const leftNumber = /^\d+$/.test(leftPart) ? Number.parseInt(leftPart, 10) : undefined;
+        const rightNumber = /^\d+$/.test(rightPart) ? Number.parseInt(rightPart, 10) : undefined;
+        if (leftNumber !== undefined && rightNumber !== undefined) {
+            return leftNumber - rightNumber;
+        }
+        if (leftNumber !== undefined) {
+            return -1;
+        }
+        if (rightNumber !== undefined) {
+            return 1;
+        }
+        return leftPart.localeCompare(rightPart);
+    }
+    return 0;
+}
+//# sourceMappingURL=brainclaw-version.js.map

package/dist/core/candidates.js

@@ -0,0 +1,137 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { CandidateSchema } from './schema.js';
+import { resolveEntityDir } from './io.js';
+import { nowISO, getNextShortLabel } from './ids.js';
+import { JsonStore } from './json-store.js';
+function inboxDir(cwd, mode = 'read') {
+    return resolveEntityDir('inbox', cwd ?? process.cwd(), mode);
+}
+function acceptedDir(cwd, mode = 'read') {
+    return resolveEntityDir('inbox/accepted', cwd ?? process.cwd(), mode);
+}
+function rejectedDir(cwd, mode = 'read') {
+    return resolveEntityDir('inbox/rejected', cwd ?? process.cwd(), mode);
+}
+export function ensureInboxDirs(cwd) {
+    for (const dir of [inboxDir(cwd, 'write'), acceptedDir(cwd, 'write'), rejectedDir(cwd, 'write')]) {
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+}
+function candidateStore(dest = 'pending', cwd) {
+    const dir = dest === 'accepted'
+        ? acceptedDir(cwd)
+        : dest === 'rejected'
+            ? rejectedDir(cwd)
+            : inboxDir(cwd);
+    return new JsonStore({
+        dirPath: dir,
+        documentType: 'candidate',
+        getId: (candidate) => candidate.id,
+        sort: (a, b) => a.created_at.localeCompare(b.created_at),
+    });
+}
+export function saveCandidate(candidate, cwd) {
+    ensureInboxDirs(cwd);
+    candidateStore('pending', cwd).save(CandidateSchema.parse(candidate));
+}
+export function loadCandidate(id, cwd) {
+    return candidateStore('pending', cwd).load(id);
+}
+export function updateCandidate(candidate, cwd) {
+    saveCandidate(candidate, cwd);
+}
+export function listCandidates(status, cwd) {
+    const candidates = candidateStore('pending', cwd).list();
+    return status ? candidates.filter((candidate) => candidate.status === status) : candidates;
+}
+export function archiveCandidate(candidate, dest, cwd) {
+    ensureInboxDirs(cwd);
+    candidateStore(dest, cwd).save(CandidateSchema.parse(candidate));
+    candidateStore('pending', cwd).delete(candidate.id);
+}
+export function listArchivedCandidates(dest, cwd) {
+    return candidateStore(dest, cwd).list();
+}
+export function deleteArchivedCandidate(id, dest, cwd) {
+    const dir = dest === 'accepted' ? acceptedDir(cwd) : rejectedDir(cwd);
+    const filepath = path.join(dir, `${id}.json`);
+    if (fs.existsSync(filepath)) {
+        fs.unlinkSync(filepath);
+        return true;
+    }
+    return false;
+}
+export function addCandidateStar(id, by, cwd) {
+    const candidate = loadCandidate(id, cwd);
+    if (candidate.status !== 'pending') {
+        throw new Error(`Candidate '${id}' is already ${candidate.status}.`);
+    }
+    const actor = by.trim();
+    if (!actor) {
+        throw new Error('Star actor must not be empty.');
+    }
+    if (candidate.starred_by.includes(actor)) {
+        return { candidate, added: false };
+    }
+    candidate.starred_by = [...candidate.starred_by, actor].sort((a, b) => a.localeCompare(b));
+    candidate.star_count = candidate.starred_by.length;
+    candidate.last_starred_at = nowISO();
+    updateCandidate(candidate, cwd);
+    return { candidate, added: true };
+}
+export function addCandidateUse(id, by, context, cwd) {
+    const candidate = loadCandidate(id, cwd);
+    if (candidate.status !== 'pending') {
+        throw new Error(`Candidate '${id}' is already ${candidate.status}.`);
+    }
+    const actor = by.trim();
+    const usageContext = context.trim();
+    if (!actor) {
+        throw new Error('Usage actor must not be empty.');
+    }
+    if (!usageContext) {
+        throw new Error('Usage context must not be empty.');
+    }
+    const exists = candidate.usage_events.some((event) => event.by === actor && event.context === usageContext);
+    if (exists) {
+        return { candidate, added: false };
+    }
+    candidate.usage_events = [
+        ...candidate.usage_events,
+        { by: actor, context: usageContext, created_at: nowISO() },
+    ].sort((a, b) => a.created_at.localeCompare(b.created_at));
+    candidate.usage_count = candidate.usage_events.length;
+    candidate.last_used_at = nowISO();
+    updateCandidate(candidate, cwd);
+    return { candidate, added: true };
+}
+export function generateCandidateId() {
+    const rand = crypto.randomBytes(4).toString('hex');
+    return `cnd_${rand}`;
+}
+/** Generate both a hash candidate ID and a short label (e.g. `cnd#47`). */
+export function generateCandidateIdWithLabel(cwd) {
+    const rand = crypto.randomBytes(4).toString('hex');
+    const id = `cnd_${rand}`;
+    const short_label = getNextShortLabel('cnd', cwd);
+    return { id, short_label };
+}
+/**
+ * Resolve a candidate alias (`cnd#47`) or hash ID to the canonical hash ID.
+ * Searches pending inbox only — use `resolveArchivedIdOrAlias` for historical items.
+ */
+export function resolveIdOrAlias(input, cwd) {
+    if (!/^[a-z]+#\d+$/.test(input))
+        return input;
+    const candidates = listCandidates(undefined, cwd);
+    const found = candidates.find(c => c.short_label === input);
+    if (!found) {
+        throw new Error(`No pending candidate found with alias '${input}'.`);
+    }
+    return found.id;
+}
+//# sourceMappingURL=candidates.js.map

package/dist/core/circuit-breaker.js

@@ -0,0 +1,118 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { listArchivedCandidates } from './candidates.js';
+import { loadConfig } from './config.js';
+import { memoryDir } from './io.js';
+import { withLock } from './lock.js';
+const OVERRIDES_FILE = '.circuit-breaker-overrides.json';
+function overridesPath(cwd) {
+    return path.join(memoryDir(cwd), OVERRIDES_FILE);
+}
+function readOverrides(cwd) {
+    const fp = overridesPath(cwd);
+    try {
+        return JSON.parse(fs.readFileSync(fp, 'utf-8'));
+    }
+    catch {
+        return {};
+    }
+}
+/** Record a manual reset for a given agent key (resets the rolling window for that agent). */
+export function resetCircuitBreaker(agentKey, cwd) {
+    const fp = overridesPath(cwd);
+    withLock(fp, () => {
+        const overrides = readOverrides(cwd);
+        overrides[agentKey.trim().toLowerCase()] = new Date().toISOString();
+        fs.writeFileSync(fp, JSON.stringify(overrides, null, 2), 'utf-8');
+    });
+}
+/**
+ * Check circuit-breaker state for a single agent.
+ * Counts accepted rejections in the rolling window and compares to threshold.
+ */
+export function checkCircuitBreaker(agentNameOrId, cwd) {
+    const config = loadConfig(cwd);
+    const threshold = config.reflective_memory?.circuit_breaker_threshold ?? 5;
+    const windowDays = config.reflective_memory?.circuit_breaker_window_days ?? 7;
+    const windowMs = windowDays * 24 * 60 * 60 * 1000;
+    const key = agentNameOrId.trim().toLowerCase();
+    // Honour manual reset: if a reset was recorded more recently than the window start, use it
+    const overrides = readOverrides(cwd);
+    const resetAt = overrides[key] ? new Date(overrides[key]) : null;
+    const windowStart = resetAt
+        ? new Date(Math.max(Date.now() - windowMs, resetAt.getTime()))
+        : new Date(Date.now() - windowMs);
+    const rejected = listArchivedCandidates('rejected', cwd);
+    const recentRejections = rejected.filter((c) => {
+        const matchesAgent = (c.author_id?.trim().toLowerCase() === key) ||
+            (c.author.trim().toLowerCase() === key);
+        if (!matchesAgent)
+            return false;
+        const resolvedAt = c.resolved_at ?? c.created_at;
+        return new Date(resolvedAt) >= windowStart;
+    });
+    return {
+        tripped: recentRejections.length >= threshold,
+        agent_key: key,
+        rejection_count: recentRejections.length,
+        threshold,
+        window_days: windowDays,
+        window_start: windowStart.toISOString(),
+    };
+}
+/**
+ * Build a snapshot of circuit-breaker state for all agents that have
+ * any recent rejection activity. Agents with no activity are omitted.
+ */
+export function buildCircuitBreakerSnapshot(cwd) {
+    const config = loadConfig(cwd);
+    const threshold = config.reflective_memory?.circuit_breaker_threshold ?? 5;
+    const windowDays = config.reflective_memory?.circuit_breaker_window_days ?? 7;
+    const windowMs = windowDays * 24 * 60 * 60 * 1000;
+    const overrides = readOverrides(cwd);
+    const rejected = listArchivedCandidates('rejected', cwd);
+    const agentCounts = new Map();
+    for (const c of rejected) {
+        const key = (c.author_id?.trim().toLowerCase() ?? c.author.trim().toLowerCase());
+        const resetAt = overrides[key] ? new Date(overrides[key]) : null;
+        const windowStart = resetAt
+            ? new Date(Math.max(Date.now() - windowMs, resetAt.getTime()))
+            : new Date(Date.now() - windowMs);
+        const resolvedAt = c.resolved_at ?? c.created_at;
+        if (new Date(resolvedAt) < windowStart)
+            continue;
+        const existing = agentCounts.get(key);
+        if (existing) {
+            existing.count++;
+        }
+        else {
+            agentCounts.set(key, { name: c.author, id: c.author_id, count: 1, windowStart });
+        }
+    }
+    const tripped = [];
+    const clear = [];
+    for (const [key, data] of agentCounts.entries()) {
+        const status = {
+            tripped: data.count >= threshold,
+            agent_key: key,
+            rejection_count: data.count,
+            threshold,
+            window_days: windowDays,
+            window_start: data.windowStart.toISOString(),
+        };
+        if (status.tripped) {
+            tripped.push(status);
+        }
+        else {
+            clear.push(status);
+        }
+    }
+    return {
+        checked_at: new Date().toISOString(),
+        window_days: windowDays,
+        threshold,
+        tripped_agents: tripped,
+        clear_agents: clear,
+    };
+}
+//# sourceMappingURL=circuit-breaker.js.map