@agentbridge1/cli 0.0.5 → 0.0.7

package/dist/mcp-runtime.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveMcpRuntime = resolveMcpRuntime;
+exports.isMcpRuntimeAvailable = isMcpRuntimeAvailable;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+/** Resolve MCP stdio entrypoint relative to `cli/dist` (index.js directory). */
+function resolveMcpRuntime(cliDistDir) {
+    const bundled = (0, node_path_1.resolve)(cliDistDir, "mcp", "agentbridge-mcp.js");
+    if ((0, node_fs_1.existsSync)(bundled)) {
+        return {
+            mode: "bundled",
+            path: bundled,
+            command: process.execPath,
+            args: [bundled],
+        };
+    }
+    const devTs = (0, node_path_1.resolve)(cliDistDir, "..", "..", "mcp", "agentbridge-mcp.ts");
+    if ((0, node_fs_1.existsSync)(devTs)) {
+        return {
+            mode: "dev",
+            path: devTs,
+            command: "npx",
+            args: ["tsx", devTs],
+        };
+    }
+    return null;
+}
+function isMcpRuntimeAvailable(cliDistDir) {
+    return resolveMcpRuntime(cliDistDir) !== null;
+}

package/dist/preflight-changed-files.js

@@ -1,5 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.isPostStartWorkFile = isPostStartWorkFile;
+exports.computeCurrentWorkFiles = computeCurrentWorkFiles;
 exports.repoDirtySnapshot = repoDirtySnapshot;
 exports.preflightSyncChangedFiles = preflightSyncChangedFiles;
 const claimed_paths_1 = require("./claimed-paths");
@@ -7,6 +9,26 @@ const file_fingerprints_1 = require("./file-fingerprints");
 const git_status_1 = require("./git-status");
 const session_state_1 = require("./session-state");
 const server_sync_1 = require("./server-sync");
+/** True when a git-dirty file is genuinely new work within this session (not baseline-only). */
+function isPostStartWorkFile(file, dirtyAtStart, fingerprintsAtStart) {
+    if (!dirtyAtStart.has(file))
+        return true;
+    const fps = (0, file_fingerprints_1.computeFileFingerprints)([file]);
+    const current = fps[0];
+    if (!current?.exists) {
+        return fingerprintsAtStart[file] !== undefined;
+    }
+    const currentFp = current.sha256 ?? current.mtimeMs?.toString() ?? "";
+    const baseFp = fingerprintsAtStart[file];
+    return baseFp === undefined || currentFp !== baseFp;
+}
+/** Files dirty now that count as supervised work after session baseline. */
+function computeCurrentWorkFiles(state, dirtyNow) {
+    const dirty = normalizeChangedFiles(dirtyNow ?? repoDirtySnapshot());
+    const dirtyAtStart = new Set(state.dirtyFilesAtStart ?? []);
+    const fingerprintsAtStart = state.fingerprintsAtStart ?? {};
+    return dirty.filter((file) => isPostStartWorkFile(file, dirtyAtStart, fingerprintsAtStart));
+}
 function normalizeChangedFiles(files) {
     return [...new Set(files.map((file) => file.trim()).filter((file) => file.length > 0))].sort();
 }
@@ -49,21 +71,6 @@ async function preflightSyncChangedFiles(ctx) {
     // acquire new content within the session.
     const dirtyAtStart = new Set(state.dirtyFilesAtStart ?? []);
     const startFingerprints = state.fingerprintsAtStart ?? {};
-    /** True when a git-dirty file is genuinely new work within this session. */
-    function isNewWorkFile(file) {
-        if (!dirtyAtStart.has(file))
-            return true; // wasn't dirty at start → always new work
-        // Was dirty at start – only include if content changed since start
-        const fps = (0, file_fingerprints_1.computeFileFingerprints)([file]);
-        const current = fps[0];
-        if (!current?.exists) {
-            // File now missing. Treat as new work only when it previously existed at start.
-            return startFingerprints[file] !== undefined;
-        }
-        const currentFp = current.sha256 ?? current.mtimeMs?.toString() ?? "";
-        const baseFp = startFingerprints[file];
-        return baseFp === undefined || currentFp !== baseFp;
-    }
     const watchOnlyFiles = watchFiles.filter((file) => !gitFileSet.has(file));
     const watchOnlyFingerprints = (0, file_fingerprints_1.computeFileFingerprints)(watchOnlyFiles);
     const activeWatchOnlyFiles = watchOnlyFingerprints
@@ -72,9 +79,9 @@ async function preflightSyncChangedFiles(ctx) {
     const merged = normalizeChangedFiles([
         ...watchFiles.filter((file) => gitFileSet.has(file)),
         ...activeWatchOnlyFiles,
-        ...gitFiles.filter((file) => isNewWorkFile(file) &&
+        ...gitFiles.filter((file) => isPostStartWorkFile(file, dirtyAtStart, startFingerprints) &&
             (claimedPaths.length === 0 || (0, claimed_paths_1.fileWithinClaimedPaths)(file, claimedPaths))),
-        ...gitFiles.filter((file) => isNewWorkFile(file) &&
+        ...gitFiles.filter((file) => isPostStartWorkFile(file, dirtyAtStart, startFingerprints) &&
             claimedPaths.length > 0 &&
             !(0, claimed_paths_1.fileWithinClaimedPaths)(file, claimedPaths)),
     ]);

package/dist/proof-obligations.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.obligationBlocksAtRollout = obligationBlocksAtRollout;
+exports.getBlockingObligations = getBlockingObligations;
+exports.primaryBlockingObligation = primaryBlockingObligation;
+exports.resolveProofBlockingErrorCode = resolveProofBlockingErrorCode;
+exports.minimumCommandsForReport = minimumCommandsForReport;
+exports.buildObligationSuggestedPrompt = buildObligationSuggestedPrompt;
+exports.renderProofObligationSection = renderProofObligationSection;
+exports.renderProofObligationErrorLines = renderProofObligationErrorLines;
+exports.buildWatchBlockingIssueFromObligation = buildWatchBlockingIssueFromObligation;
+const error_catalog_1 = require("./error-catalog");
+const OBLIGATION_CODE_PRIORITY = [
+    "PROOF_TOO_WEAK",
+    "PROOF_NOT_RELEVANT",
+    "PROOF_IMPACT_COVERAGE_GAP",
+];
+function obligationBlocksAtRollout(obligation) {
+    return (obligation.status === "unsatisfied" &&
+        obligation.rollout_stage !== undefined &&
+        obligation.rollout_stage !== "warn_only");
+}
+function getBlockingObligations(report) {
+    return (report.obligation_set ?? []).filter(obligationBlocksAtRollout);
+}
+function primaryBlockingObligation(report) {
+    const blocking = getBlockingObligations(report);
+    if (blocking.length === 0)
+        return null;
+    for (const code of OBLIGATION_CODE_PRIORITY) {
+        const match = blocking.find((obligation) => obligation.code === code);
+        if (match)
+            return match;
+    }
+    return blocking[0] ?? null;
+}
+function resolveProofBlockingErrorCode(report) {
+    const primary = primaryBlockingObligation(report);
+    if (primary?.code)
+        return primary.code;
+    if (report.decision === "needs_proof")
+        return "PROOF_MISSING";
+    if (report.decision === "stale_evidence")
+        return "PROOF_STALE_AFTER_CHANGE";
+    return null;
+}
+function uniqueCommands(values) {
+    return [...new Set(values.map((value) => value.trim()).filter((value) => value.length > 0))];
+}
+function minimumCommandsForReport(report, obligation) {
+    const fromObligation = obligation?.recommended_commands ?? [];
+    const fromGuidance = report.proof_guidance?.minimum_commands ?? [];
+    const fromBlocking = getBlockingObligations(report).flatMap((item) => item.recommended_commands ?? []);
+    return uniqueCommands([...fromObligation, ...fromGuidance, ...fromBlocking]);
+}
+function buildObligationSuggestedPrompt(input) {
+    const { obligation, report } = input;
+    const files = obligation.applies_to_files.length > 0 ? obligation.applies_to_files : report.changed_files;
+    const commands = minimumCommandsForReport(report, obligation);
+    const unacceptable = report.proof_guidance?.unacceptable_commands ?? [];
+    const lines = [
+        obligation.requirement ??
+            `Proof obligation ${obligation.code ?? obligation.source} is unsatisfied.`,
+        obligation.code === "PROOF_TOO_WEAK" && unacceptable.length > 0
+            ? `These commands are too weak for this change: ${unacceptable.join(", ")}`
+            : "",
+        commands.length > 0
+            ? `Run one of these minimum commands:\n${commands.map((command) => `- ${command}`).join("\n")}`
+            : "Run a stronger verification command that covers the changed files.",
+        files.length > 0 ? `Files: ${files.join(", ")}` : "",
+    ].filter((line) => line.length > 0);
+    return lines.join("\n");
+}
+function renderProofObligationSection(report) {
+    const obligations = report.obligation_set ?? [];
+    if (obligations.length === 0 && !report.proof_guidance)
+        return [];
+    const lines = ["Proof obligations:"];
+    if (obligations.length === 0) {
+        lines.push("  - none");
+    }
+    else {
+        for (const obligation of obligations) {
+            const label = obligation.code ?? obligation.source;
+            const rollout = obligation.rollout_stage ? ` (${obligation.rollout_stage})` : "";
+            lines.push(`  - [${obligation.status}] ${label}${rollout}`);
+            if (obligation.requirement) {
+                lines.push(`    requirement: ${obligation.requirement}`);
+            }
+            if (obligation.recommended_commands && obligation.recommended_commands.length > 0) {
+                for (const command of obligation.recommended_commands) {
+                    lines.push(`    run: ${command}`);
+                }
+            }
+        }
+    }
+    if (report.proof_guidance) {
+        lines.push(`Proof guidance: ${report.proof_guidance.reason}`);
+        if (report.proof_guidance.minimum_commands.length > 0) {
+            lines.push("Minimum commands:");
+            for (const command of report.proof_guidance.minimum_commands) {
+                lines.push(`  - ${command}`);
+            }
+        }
+        if (report.proof_guidance.unacceptable_commands.length > 0) {
+            lines.push("Unacceptable (too weak):");
+            for (const command of report.proof_guidance.unacceptable_commands) {
+                lines.push(`  - ${command}`);
+            }
+        }
+    }
+    return lines;
+}
+function renderProofObligationErrorLines(report) {
+    const code = resolveProofBlockingErrorCode(report);
+    if (!code || code === "PROOF_MISSING" || code === "PROOF_STALE_AFTER_CHANGE") {
+        return [];
+    }
+    const obligation = primaryBlockingObligation(report);
+    const entry = (0, error_catalog_1.catalogEntryForCode)(code);
+    const commands = minimumCommandsForReport(report, obligation);
+    const lines = [`✗ Error code: ${code}`];
+    lines.push(`  What happened: ${entry?.what ?? "A proof obligation is unsatisfied."}`);
+    lines.push(`  Why it matters: ${entry?.why ?? "Acceptance requires proof that matches this risk profile."}`);
+    if (obligation?.requirement) {
+        lines.push(`  Obligation: ${obligation.requirement}`);
+    }
+    if (commands.length > 0) {
+        lines.push("  Minimum commands:");
+        for (const command of commands) {
+            lines.push(`    - ${command}`);
+        }
+    }
+    else if (entry?.next) {
+        lines.push(`  Next action: ${entry.next}`);
+    }
+    return lines;
+}
+function buildWatchBlockingIssueFromObligation(report, obligation) {
+    const code = obligation.code ?? "PROOF_MISSING";
+    const entry = (0, error_catalog_1.catalogEntryForCode)(code);
+    const files = [
+        ...new Set(obligation.applies_to_files.length > 0 ? obligation.applies_to_files : report.changed_files),
+    ];
+    const commands = minimumCommandsForReport(report, obligation);
+    const nextAction = commands[0] ?? entry?.next ?? "Run a stronger verification command for the changed files.";
+    return {
+        errorCode: code,
+        whatHappened: entry?.what ?? obligation.requirement ?? "A proof obligation is unsatisfied.",
+        whyItMatters: entry?.why ?? "Acceptance requires proof that matches this change profile.",
+        files,
+        suggestedPrompt: buildObligationSuggestedPrompt({ obligation, report }),
+        nextAction,
+    };
+}

package/dist/recovery-reconcile.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeDomainKey = normalizeDomainKey;
+exports.isGenericGeneralDomain = isGenericGeneralDomain;
+exports.activeDomainsFromPacket = activeDomainsFromPacket;
+exports.packetDomainsToRefs = packetDomainsToRefs;
+exports.isLoneGenericGeneral = isLoneGenericGeneral;
+exports.hasMeaningfulDomainMap = hasMeaningfulDomainMap;
+exports.assessRecoveryQuality = assessRecoveryQuality;
+exports.buildReconcilePlan = buildReconcilePlan;
+exports.mergeBootstrapDomainEntries = mergeBootstrapDomainEntries;
+exports.recoveryQualityLabel = recoveryQualityLabel;
+exports.recoveryBaselineRequired = recoveryBaselineRequired;
+exports.recoveryIsBasicPacket = recoveryIsBasicPacket;
+function normalizeDomainKey(name) {
+    return name
+        .trim()
+        .toLowerCase()
+        .replace(/[\s-]+/g, "_")
+        .replace(/[^a-z0-9_]/g, "");
+}
+function isGenericGeneralDomain(name) {
+    const key = normalizeDomainKey(name);
+    return key === "general" || key === "misc";
+}
+function activeDomainsFromPacket(packet) {
+    return (packet?.domains_summary ?? []).filter((d) => d.state !== "retired");
+}
+function packetDomainsToRefs(packet, configDomains = []) {
+    const active = activeDomainsFromPacket(packet);
+    const configByKey = new Map(configDomains.map((d) => [normalizeDomainKey(d.domain), d.pathPatterns]));
+    return active.map((d) => ({
+        name: d.domain_name,
+        pathPatterns: configByKey.get(normalizeDomainKey(d.domain_name)) ?? [],
+    }));
+}
+function isLoneGenericGeneral(domains) {
+    if (domains.length !== 1)
+        return false;
+    return isGenericGeneralDomain(domains[0]?.name ?? "");
+}
+function hasMeaningfulDomainMap(domains) {
+    const nonGeneric = domains.filter((d) => !isGenericGeneralDomain(d.name));
+    return nonGeneric.length >= 2 || (nonGeneric.length === 1 && domains.length >= 1 && !isLoneGenericGeneral(domains));
+}
+function domainMapsEqual(a, b) {
+    const keysA = new Set(a.map((d) => normalizeDomainKey(d.name)));
+    const keysB = new Set(b.map((d) => normalizeDomainKey(d.name)));
+    if (keysA.size !== keysB.size)
+        return false;
+    for (const key of keysA) {
+        if (!keysB.has(key))
+            return false;
+    }
+    return true;
+}
+function assessRecoveryQuality(input) {
+    const { packet, existingActive, candidates, rulesInstalled } = input;
+    const status = packet?.recovery_status ?? null;
+    if (!packet ||
+        status === "baseline_required" ||
+        status === "pending" ||
+        status === null ||
+        existingActive.length === 0) {
+        return "missing";
+    }
+    if (isLoneGenericGeneral(existingActive)) {
+        const scanHasSpecific = candidates.some((d) => !isGenericGeneralDomain(d.name));
+        if (scanHasSpecific) {
+            return "stale";
+        }
+        return "basic";
+    }
+    const candidateNonGeneric = candidates.filter((d) => !isGenericGeneralDomain(d.name));
+    const existingNonGeneric = existingActive.filter((d) => !isGenericGeneralDomain(d.name));
+    if (existingNonGeneric.length === 0 && candidateNonGeneric.length > 0) {
+        return "stale";
+    }
+    const candidateKeys = new Set(candidates.map((d) => normalizeDomainKey(d.name)));
+    const existingKeys = new Set(existingActive.map((d) => normalizeDomainKey(d.name)));
+    const missingFromStored = candidateNonGeneric.filter((c) => !existingKeys.has(normalizeDomainKey(c.name)));
+    const orphanStored = existingNonGeneric.filter((e) => !candidateKeys.has(normalizeDomainKey(e.name)));
+    if (missingFromStored.length > 0 && existingNonGeneric.length > 0) {
+        return orphanStored.length > 0 ? "mismatch" : "stale";
+    }
+    if (!hasMeaningfulDomainMap(existingActive)) {
+        return "basic";
+    }
+    const hasCharter = Boolean(packet.charter_summary?.purpose?.trim());
+    if (!hasCharter || rulesInstalled === false) {
+        return "needs_review";
+    }
+    if (domainMapsEqual(existingActive, candidates)) {
+        return "complete";
+    }
+    if (missingFromStored.length > 0) {
+        return "stale";
+    }
+    return "complete";
+}
+function buildReconcilePlan(input) {
+    const { existingActive, candidates, mode, packet, rulesInstalled } = input;
+    const existingByKey = new Map(existingActive.map((d) => [normalizeDomainKey(d.name), d]));
+    const candidateByKey = new Map(candidates.map((d) => [normalizeDomainKey(d.name), d]));
+    const toAdd = candidates.filter((c) => !existingByKey.has(normalizeDomainKey(c.name)));
+    const unchanged = existingActive.filter((e) => candidateByKey.has(normalizeDomainKey(e.name)));
+    let toRetire = [];
+    let toPreserve = [];
+    if (mode === "force") {
+        toRetire = existingActive.filter((e) => !candidateByKey.has(normalizeDomainKey(e.name)));
+        toPreserve = [];
+    }
+    else {
+        const upgradingFromGeneral = isLoneGenericGeneral(existingActive) &&
+            candidates.some((c) => !isGenericGeneralDomain(c.name));
+        if (upgradingFromGeneral) {
+            toRetire = existingActive.filter((e) => isGenericGeneralDomain(e.name));
+            toPreserve = existingActive.filter((e) => !isGenericGeneralDomain(e.name));
+        }
+        else {
+            toPreserve = existingActive.filter((e) => !toAdd.some((a) => normalizeDomainKey(a.name) === normalizeDomainKey(e.name)));
+        }
+    }
+    const hasChanges = toAdd.length > 0 ||
+        toRetire.length > 0 ||
+        (mode === "force" && !domainMapsEqual(existingActive, candidates));
+    const quality = assessRecoveryQuality({
+        packet,
+        existingActive,
+        candidates,
+        rulesInstalled,
+    });
+    return {
+        mode,
+        candidates,
+        existingActive,
+        toAdd,
+        toPreserve,
+        toRetire,
+        unchanged,
+        hasChanges,
+        quality,
+    };
+}
+function mergeBootstrapDomainEntries(plan, candidateEntries, existingEntries) {
+    const byKey = new Map();
+    const addEntry = (entry) => {
+        const name = typeof entry.name === "string" ? entry.name : "";
+        if (!name)
+            return;
+        byKey.set(normalizeDomainKey(name), entry);
+    };
+    if (plan.mode === "force") {
+        for (const entry of candidateEntries)
+            addEntry(entry);
+        return Array.from(byKey.values());
+    }
+    for (const entry of existingEntries)
+        addEntry(entry);
+    for (const entry of candidateEntries)
+        addEntry(entry);
+    if (plan.toRetire.some((d) => isGenericGeneralDomain(d.name)) &&
+        plan.toAdd.some((d) => !isGenericGeneralDomain(d.name))) {
+        byKey.delete("general");
+        byKey.delete("misc");
+    }
+    return Array.from(byKey.values());
+}
+function recoveryQualityLabel(quality) {
+    return quality;
+}
+function recoveryBaselineRequired(packet) {
+    if (!packet || packet.project_mode !== "recovery")
+        return false;
+    const status = packet.recovery_status ?? null;
+    return status === "baseline_required" || status === "pending" || status === null;
+}
+function recoveryIsBasicPacket(packet) {
+    const active = packetDomainsToRefs(packet);
+    if (active.length === 0)
+        return false;
+    return isLoneGenericGeneral(active) || !hasMeaningfulDomainMap(active);
+}

package/dist/rules-sync.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROTOCOL_RULES_MARKER = exports.LOCAL_RULES_HEADER = void 0;
+exports.rulesArtifactPaths = rulesArtifactPaths;
+exports.extractProjectIdFromRulesText = extractProjectIdFromRulesText;
+exports.classifyRulesFormat = classifyRulesFormat;
+exports.analyzeRulesArtifacts = analyzeRulesArtifacts;
+exports.fetchProjectRules = fetchProjectRules;
+exports.writeRulesFiles = writeRulesFiles;
+exports.markProjectRulesInstalled = markProjectRulesInstalled;
+exports.extractProjectNameFromRulesResponse = extractProjectNameFromRulesResponse;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const http_1 = require("./http");
+exports.LOCAL_RULES_HEADER = "# AgentBridge Local Rules";
+exports.PROTOCOL_RULES_MARKER = "This repo is coordinated through AgentBridge";
+function rulesArtifactPaths(workspaceRoot) {
+    return {
+        rulesMarkdownPath: (0, node_path_1.resolve)(workspaceRoot, "AGENTBRIDGE.md"),
+        rulesMdcPath: (0, node_path_1.resolve)(workspaceRoot, ".cursor", "rules", "agentbridge.mdc"),
+    };
+}
+function extractProjectIdFromRulesText(content) {
+    const markdownMatch = content.match(/\*\*Project ID:\*\*\s*`([^`]+)`/);
+    if (markdownMatch?.[1]) {
+        return markdownMatch[1].trim();
+    }
+    const inlineMatch = content.match(/project ID:\s*`([^`]+)`/i);
+    if (inlineMatch?.[1]) {
+        return inlineMatch[1].trim();
+    }
+    return null;
+}
+function classifyRulesFormat(markdownContent, mdcContent) {
+    const md = markdownContent ?? "";
+    const mdc = mdcContent ?? "";
+    if (!md.trim() && !mdc.trim()) {
+        return "missing";
+    }
+    if (md.startsWith(exports.LOCAL_RULES_HEADER) || mdc.includes("Recovered domains:")) {
+        return "local";
+    }
+    if (md.includes(exports.PROTOCOL_RULES_MARKER) ||
+        mdc.includes("AgentBridge Protocol Rules") ||
+        mdc.includes("AgentBridge protocol rules")) {
+        return "protocol";
+    }
+    return "unknown";
+}
+function readOptionalFile(path) {
+    if (!(0, node_fs_1.existsSync)(path))
+        return null;
+    return (0, node_fs_1.readFileSync)(path, "utf8");
+}
+function analyzeRulesArtifacts(workspaceRoot, expectedProjectId) {
+    const paths = rulesArtifactPaths(workspaceRoot);
+    const markdownContent = readOptionalFile(paths.rulesMarkdownPath);
+    const mdcContent = readOptionalFile(paths.rulesMdcPath);
+    const filesPresent = markdownContent !== null && mdcContent !== null;
+    const format = classifyRulesFormat(markdownContent, mdcContent);
+    const projectIds = new Set();
+    if (markdownContent) {
+        const id = extractProjectIdFromRulesText(markdownContent);
+        if (id)
+            projectIds.add(id);
+    }
+    if (mdcContent) {
+        const id = extractProjectIdFromRulesText(mdcContent);
+        if (id)
+            projectIds.add(id);
+    }
+    const issues = [];
+    let projectIdInRepo = null;
+    if (projectIds.size === 1) {
+        projectIdInRepo = [...projectIds][0] ?? null;
+    }
+    else if (projectIds.size > 1) {
+        issues.push("AGENTBRIDGE.md and .cursor/rules/agentbridge.mdc reference different project IDs.");
+        projectIdInRepo = [...projectIds][0] ?? null;
+    }
+    else if (filesPresent) {
+        issues.push("Rules files are present but no project ID could be parsed.");
+    }
+    let projectIdMatchesConfig = null;
+    if (expectedProjectId) {
+        if (projectIdInRepo) {
+            projectIdMatchesConfig = projectIdInRepo === expectedProjectId;
+            if (!projectIdMatchesConfig) {
+                issues.push(`Rules reference project ${projectIdInRepo}, but configured project is ${expectedProjectId}.`);
+            }
+        }
+        else if (filesPresent) {
+            projectIdMatchesConfig = false;
+        }
+    }
+    if (!filesPresent) {
+        issues.push("Missing AGENTBRIDGE.md or .cursor/rules/agentbridge.mdc.");
+    }
+    else if (format === "local") {
+        issues.push("Rules are in local watch format (from agentbridge init), not server protocol rules.");
+    }
+    else if (format === "unknown") {
+        issues.push("Rules files exist but do not match the expected AgentBridge protocol format.");
+    }
+    const protocolRulesValid = filesPresent &&
+        format === "protocol" &&
+        (projectIdMatchesConfig ?? true) &&
+        issues.length === 0;
+    return {
+        paths,
+        filesPresent,
+        format,
+        projectIdInRepo,
+        projectIdMatchesConfig,
+        protocolRulesValid,
+        issues,
+    };
+}
+async function fetchProjectRules(ctx) {
+    return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/rules`);
+}
+function writeRulesFiles(workspaceRoot, files) {
+    for (const file of files) {
+        const fullPath = (0, node_path_1.resolve)(workspaceRoot, file.path);
+        (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(fullPath), { recursive: true });
+        (0, node_fs_1.writeFileSync)(fullPath, file.content, "utf8");
+    }
+}
+async function markProjectRulesInstalled(ctx) {
+    return (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/rules/mark-installed`, {});
+}
+function extractProjectNameFromRulesResponse(files) {
+    const markdown = files.find((file) => file.path === "AGENTBRIDGE.md")?.content;
+    if (!markdown)
+        return null;
+    const match = markdown.match(/^# AgentBridge — (.+)$/m);
+    return match?.[1]?.trim() ?? null;
+}

package/dist/server-sync.js

@@ -12,6 +12,7 @@ exports.postObservedDiff = postObservedDiff;
 exports.postScopedApproval = postScopedApproval;
 exports.closeServerSession = closeServerSession;
 exports.fetchAcceptanceCheck = fetchAcceptanceCheck;
+exports.fetchAgentProofGuidance = fetchAgentProofGuidance;
 exports.reviewOnceForWatch = reviewOnceForWatch;
 exports.isWatchFastPathUnavailable = isWatchFastPathUnavailable;
 exports.fetchMemorySuggestion = fetchMemorySuggestion;
@@ -252,6 +253,29 @@ async function fetchAcceptanceCheck(ctx, options) {
     const query = queryParams.toString();
     return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/current/acceptance-check${query ? `?${query}` : ""}`);
 }
+async function fetchAgentProofGuidance(ctx, options) {
+    const rolloutParams = new URLSearchParams();
+    if (options?.rolloutProofTooWeak) {
+        rolloutParams.set("rollout_proof_too_weak", options.rolloutProofTooWeak);
+    }
+    if (options?.rolloutProofNotRelevant) {
+        rolloutParams.set("rollout_proof_not_relevant", options.rolloutProofNotRelevant);
+    }
+    if (options?.rolloutImpactCoverageGap) {
+        rolloutParams.set("rollout_impact_coverage_gap", options.rolloutImpactCoverageGap);
+    }
+    const rolloutSuffix = rolloutParams.toString();
+    if (options?.workSessionId) {
+        const qs = rolloutSuffix ? `?${rolloutSuffix}` : "";
+        return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/${encodeURIComponent(options.workSessionId)}/proof-guidance${qs}`);
+    }
+    const queryParams = new URLSearchParams(rolloutParams);
+    if (options?.changeRequestId && options.changeRequestId.trim().length > 0) {
+        queryParams.set("change_request_id", options.changeRequestId);
+    }
+    const query = queryParams.toString();
+    return (0, http_1.getJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/work-sessions/current/proof-guidance${query ? `?${query}` : ""}`);
+}
 /**
  * One-shot Agent Watch review fast path. Collapses cold-create / resume +
  * observed-diff sync + acceptance check into a single bounded server call.