@agentbridge1/cli 0.0.6 → 0.0.8

package/dist/config.js

@@ -1,9 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_API_BASE_URL = exports.CONFIG_PATH = exports.CONFIG_DIR = void 0;
+exports.ROOM_CONNECTION_KEYS = exports.DEFAULT_API_BASE_URL = exports.CONFIG_PATH = exports.CONFIG_DIR = void 0;
 exports.readConfig = readConfig;
 exports.writeConfig = writeConfig;
 exports.updateConfig = updateConfig;
+exports.clearRoomConnection = clearRoomConnection;
 exports.contextFromConfig = contextFromConfig;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -30,6 +31,35 @@ function updateConfig(partial) {
     writeConfig(next);
     return next;
 }
+/** Config keys that bind this repo to a cloud room / execution surface. */
+exports.ROOM_CONNECTION_KEYS = [
+    "projectId",
+    "apiKey",
+    "activeAgentId",
+    "executionSurfaceId",
+    "activeChangeRequestId",
+    "lastAcceptedSessionId",
+    "lastAcceptedAt",
+];
+function clearRoomConnection() {
+    const current = readConfig();
+    const clearedKeys = [];
+    const next = { ...current };
+    for (const key of exports.ROOM_CONNECTION_KEYS) {
+        if (next[key] !== undefined) {
+            clearedKeys.push(key);
+            delete next[key];
+        }
+    }
+    if (clearedKeys.length > 0) {
+        writeConfig(next);
+    }
+    return {
+        clearedKeys,
+        previousProjectId: current.projectId,
+        hadApiKey: Boolean(current.apiKey),
+    };
+}
 function contextFromConfig() {
     const cfg = readConfig();
     const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ??

package/dist/contract-verdict.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectOutOfScopeFiles = detectOutOfScopeFiles;
+exports.renderContractVerdict = renderContractVerdict;
+const domain_resolution_1 = require("./domain-resolution");
+const local_proof_1 = require("./local-proof");
+const INTENT_STOP_WORDS = new Set([
+    "a",
+    "an",
+    "the",
+    "on",
+    "in",
+    "to",
+    "for",
+    "and",
+    "or",
+    "of",
+    "fix",
+    "add",
+    "update",
+    "change",
+    "make",
+    "with",
+    "from",
+    "into",
+    "by",
+    "at",
+    "is",
+    "are",
+    "be",
+    "do",
+    "does",
+    "did",
+    "was",
+    "were",
+    "it",
+    "its",
+    "this",
+    "that",
+    "endpoint",
+    "bug",
+    "issue",
+    "error",
+]);
+function normalizePath(path) {
+    return path.trim().replaceAll("\\", "/");
+}
+function intentKeywords(intent) {
+    return intent
+        .toLowerCase()
+        .split(/[^a-z0-9]+/)
+        .map((word) => word.trim())
+        .filter((word) => word.length >= 3 && !INTENT_STOP_WORDS.has(word));
+}
+function fileMatchesIntentKeywords(file, keywords) {
+    if (keywords.length === 0)
+        return true;
+    const lower = normalizePath(file).toLowerCase();
+    return keywords.some((keyword) => lower.includes(keyword));
+}
+function fileMatchesClaimedPaths(file, claimedPaths) {
+    if (claimedPaths.length === 0)
+        return true;
+    const normalized = normalizePath(file);
+    return claimedPaths.some((pattern) => {
+        const trimmed = normalizePath(pattern);
+        if (!trimmed)
+            return false;
+        if (trimmed.endsWith("/**")) {
+            const prefix = trimmed.slice(0, -3);
+            return normalized === prefix || normalized.startsWith(`${prefix}/`);
+        }
+        if (trimmed.endsWith("/*")) {
+            const prefix = trimmed.slice(0, -2);
+            const slash = normalized.lastIndexOf("/");
+            const dir = slash >= 0 ? normalized.slice(0, slash) : "";
+            return dir === prefix;
+        }
+        return normalized === trimmed || normalized.startsWith(`${trimmed}/`);
+    });
+}
+function detectOutOfScopeFiles(changedFiles, session, domains) {
+    const meaningful = changedFiles
+        .map(normalizePath)
+        .filter((file) => file.length > 0 && !(0, local_proof_1.isProofNoiseFile)(file));
+    if (meaningful.length === 0)
+        return [];
+    const claimedPaths = session?.claimedPaths ?? [];
+    if (claimedPaths.length > 0) {
+        return meaningful.filter((file) => !fileMatchesClaimedPaths(file, claimedPaths));
+    }
+    const intent = session?.intent?.trim() ?? "";
+    if (!intent)
+        return [];
+    const keywords = intentKeywords(intent);
+    if (keywords.length === 0)
+        return [];
+    const outOfScope = [];
+    for (const file of meaningful) {
+        if (fileMatchesIntentKeywords(file, keywords))
+            continue;
+        if (domains.length > 0) {
+            const domain = (0, domain_resolution_1.resolveDomainForFile)(file, domains).domain;
+            if (domain && keywords.some((keyword) => domain.toLowerCase().includes(keyword))) {
+                continue;
+            }
+        }
+        outOfScope.push(file);
+    }
+    return outOfScope;
+}
+function renderContractVerdict(session, changedFiles, proofRun, domains = []) {
+    const intent = session?.intent?.trim() || "(no intent declared)";
+    const meaningfulFiles = changedFiles
+        .map(normalizePath)
+        .filter((file) => file.length > 0 && !(0, local_proof_1.isProofNoiseFile)(file));
+    const outOfScope = detectOutOfScopeFiles(meaningfulFiles, session, domains);
+    const missing = [];
+    if (!session?.intent?.trim()) {
+        missing.push("No contract intent was recorded.");
+    }
+    if (meaningfulFiles.length === 0) {
+        missing.push("No files changed since the contract baseline.");
+    }
+    if (!proofRun) {
+        missing.push("No proof/test run was recorded.");
+    }
+    else if (proofRun.status === "failed") {
+        missing.push(`Proof failed: ${proofRun.command} (exit ${proofRun.exitCode}).`);
+    }
+    let nextStep = "Contract looks complete. Commit when ready.";
+    if (missing.length > 0 && outOfScope.length > 0) {
+        nextStep =
+            "Review out-of-scope files, run the relevant tests, then decide whether to accept or revert the extra changes.";
+    }
+    else if (missing.some((item) => item.includes("proof"))) {
+        nextStep = "Run the relevant test command so AgentBridge can record proof for this contract.";
+    }
+    else if (outOfScope.length > 0) {
+        nextStep =
+            "Ask the agent to justify the out-of-scope files, or revert them before accepting the work.";
+    }
+    else if (meaningfulFiles.length === 0) {
+        nextStep = "No work was recorded. Start a new contract when you are ready to implement.";
+    }
+    const lines = [
+        "AgentBridge Contract Verdict",
+        "─────────────────────────────────────────",
+        "",
+        "Here's what the contract was:",
+        `  ${intent}`,
+        "",
+        "Here's what the agent changed:",
+    ];
+    if (meaningfulFiles.length === 0) {
+        lines.push("  No files changed.");
+    }
+    else {
+        for (const file of meaningfulFiles) {
+            lines.push(`  - ${file}`);
+        }
+    }
+    lines.push("", "Here's what appears missing:");
+    if (missing.length === 0) {
+        lines.push("  Nothing obvious from this contract check.");
+    }
+    else {
+        for (const item of missing) {
+            lines.push(`  - ${item}`);
+        }
+    }
+    lines.push("", "Here's where the work drifted out of scope:");
+    if (outOfScope.length === 0) {
+        lines.push("  No out-of-scope files detected.");
+    }
+    else {
+        for (const file of outOfScope) {
+            const reason = session?.intent?.trim()
+                ? `${file} was changed, but the contract was about ${session.intent.trim()}.`
+                : `${file} was changed outside the declared contract.`;
+            lines.push(`  - ${reason}`);
+        }
+    }
+    lines.push("", "Here's the next step:", `  ${nextStep}`, "");
+    return lines.join("\n");
+}

package/dist/error-catalog.js

@@ -20,7 +20,7 @@ const CATALOG = {
         title: "Authentication failed.",
         what: "The API key was missing, invalid, or rejected by the server.",
         why: "AgentBridge cannot reach project APIs without valid credentials.",
-        next: "Verify AGENTBRIDGE_API_KEY and rerun `agentbridge doctor`.",
+        next: "Run `agentbridge room exit`, set a fresh AGENTBRIDGE_API_KEY, then `agentbridge connect`.",
     },
     PROJECT_ACCESS_NOT_FOUND: {
         code: "PROJECT_ACCESS_NOT_FOUND",
@@ -30,6 +30,19 @@ const CATALOG = {
         why: "Commands target the wrong room or environment.",
         next: "Verify AGENTBRIDGE_PROJECT_ID and rerun `agentbridge init --project <id>`.",
     },
+    CONNECT_EXECUTION_SURFACE_MISSING: {
+        code: "CONNECT_EXECUTION_SURFACE_MISSING",
+        category: "IDENTITY_ERROR",
+        title: "Connection incomplete.",
+        what: "Project access was verified, but this key is not bound to an AgentConnection execution surface.",
+        why: "Connect requires a room connection key that resolves to work_identity on /hello.",
+        next: [
+            "In the AgentBridge dashboard, open this room and rotate the API key (or create a new room).",
+            "Update AGENTBRIDGE_API_KEY or .agentbridge/config.json with the new key.",
+            "Run: agentbridge connect --project <project-id> --api-key <new-key>",
+            "Connect does not create or rotate keys automatically.",
+        ].join("\n"),
+    },
     IDENTITY_ACTIVE_AGENT_STALE: {
         code: "IDENTITY_ACTIVE_AGENT_STALE",
         category: "IDENTITY_ERROR",
@@ -229,6 +242,22 @@ const CATALOG = {
         why: "Scoped work must target a recovered domain lane.",
         next: 'Pass `--domain "<domain>"` with start, or run `agentbridge init`.',
     },
+    START_LANE_CLAIM_CONFIRM_REQUIRED: {
+        code: "START_LANE_CLAIM_CONFIRM_REQUIRED",
+        category: "START_ERROR",
+        title: "Lane claim needs explicit confirmation.",
+        what: "Start inferred a domain with medium confidence.",
+        why: "Production-safe lane claim requires explicit confirmation when scope-to-domain mapping is ambiguous.",
+        next: 'Rerun with `--confirm-domain` or pass an explicit `--domain "<domain>"`.',
+    },
+    START_LANE_CLAIM_LOW_CONFIDENCE: {
+        code: "START_LANE_CLAIM_LOW_CONFIDENCE",
+        category: "START_ERROR",
+        title: "Lane claim confidence too low.",
+        what: "AgentBridge could not confidently bind this work to a single domain lane.",
+        why: "A wrong lane claim undermines scope enforcement and ownership attribution.",
+        next: 'Pass explicit `--domain "<domain>"` and tighter `--scope "<path>"`, then rerun start.',
+    },
     START_OWNER_UNRESOLVED: {
         code: "START_OWNER_UNRESOLVED",
         category: "START_ERROR",

package/dist/git-status.js

@@ -7,6 +7,7 @@ exports.repoDirtySnapshotFromGitStatus = repoDirtySnapshotFromGitStatus;
 exports.getBranchName = getBranchName;
 exports.getDirtyWorkingTreeFiles = getDirtyWorkingTreeFiles;
 const node_child_process_1 = require("node:child_process");
+const local_proof_1 = require("./local-proof");
 function normalizePath(path) {
     return path.trim().replaceAll("\\", "/");
 }
@@ -41,13 +42,16 @@ function parseGitStatusPorcelainZ(raw) {
     }
     return entries;
 }
+function isSupervisionRelevantPath(path) {
+    return !isAgentbridgeLocalPath(path) && !(0, local_proof_1.isProofNoiseFile)(path);
+}
 function collectChangedFilesFromStatusEntries(entries) {
     const files = new Set();
     for (const entry of entries) {
-        if (entry.path && !isAgentbridgeLocalPath(entry.path)) {
+        if (entry.path && isSupervisionRelevantPath(entry.path)) {
             files.add(entry.path);
         }
-        if (entry.originalPath && !isAgentbridgeLocalPath(entry.originalPath)) {
+        if (entry.originalPath && isSupervisionRelevantPath(entry.originalPath)) {
             files.add(entry.originalPath);
         }
     }

package/dist/index.js

@@ -25,11 +25,13 @@ const memory_1 = require("./commands/memory");
 const session_1 = require("./commands/session");
 const handshake_1 = require("./commands/handshake");
 const connect_1 = require("./commands/connect");
+const room_1 = require("./commands/room");
 const setup_mcp_1 = require("./commands/setup-mcp");
 const bug_1 = require("./commands/bug");
 const autopilot_1 = require("./commands/autopilot");
 const attention_1 = require("./commands/attention");
 const recover_1 = require("./commands/recover");
+const install_rules_1 = require("./commands/install-rules");
 const proof_guidance_1 = require("./commands/proof-guidance");
 const node_path_1 = require("node:path");
 const node_child_process_1 = require("node:child_process");
@@ -41,6 +43,10 @@ const COMMAND_HELP = {
     connect: "  agentbridge connect [--project <id>] [--api-key <key>] [--api-base-url <url>] [--agent <id>]\n" +
         "    Save credentials and verify connection to your AgentBridge project.\n" +
         "    Credentials can also come from AGENTBRIDGE_PROJECT_ID / AGENTBRIDGE_API_KEY env vars.\n",
+    room: "  agentbridge room exit [--keep-session] [--json]\n" +
+        "    Clear saved room credentials from .agentbridge/config.json (no server call).\n" +
+        "    Use when API keys are rejected or you need to connect to a different project.\n" +
+        "    Preserves domain recovery data from init/recover.\n",
     recover: "  agentbridge recover [--force]\n" +
         "    Recover project context so AI agents do not start blind.\n" +
         "    Shows project name, domains, and known context.\n",
@@ -49,11 +55,11 @@ const COMMAND_HELP = {
         "    Run `agentbridge connect` first to save credentials.\n",
     use: "  agentbridge use <agent-id>\n" +
         "    Set the active agent identity used by `watch` and `start`.\n",
-    start: "  agentbridge start [\"intent\"] [--details] [--yes]\n" +
+    start: "  agentbridge start [\"intent\"] [--details] [--yes] [--confirm-domain]\n" +
         "    Open or close a task checkpoint (not the live watcher).\n" +
         "    For live supervision beside Cursor, run `agentbridge watch`.\n" +
         "    Record proof: `agentbridge verify -- <test command>`.\n",
-    watch: "  agentbridge watch [--allow-dirty] [--once] [--daemon] [--details] [--task \"<summary>\"] [--scope \"<path>\"]\n" +
+    watch: "  agentbridge watch [--allow-dirty] [--once] [--daemon] [--details] [--confirm-domain] [--task \"<summary>\"] [--scope \"<path>\"]\n" +
         "    Primary live supervision command — run beside Cursor while the agent codes.\n" +
         "    Shows MCP-declared intent and disk changes; warns on scope drift.\n" +
         "    No --task or --scope required for normal use.\n" +
@@ -62,8 +68,9 @@ const COMMAND_HELP = {
         "    --once            Run one supervision pass and exit.\n" +
         "    --daemon          Non-interactive mode: skip prompts, auto-deny domain crossings.\n" +
         "    --change-request / --execution-surface  Advanced session binding.\n",
-    "setup-mcp": "  agentbridge setup-mcp [--editor cursor|windsurf|vscode]\n" +
-        "    Print the MCP server configuration snippet to add to your editor.\n",
+    "setup-mcp": "  agentbridge setup-mcp [--local] [--editor cursor|windsurf|vscode]\n" +
+        "    --local           Write local-first MCP config (no API keys) to .cursor/mcp.json\n" +
+        "    Print or write the MCP server configuration for your editor.\n",
     mcp: "  agentbridge mcp\n" +
         "    Start the AgentBridge MCP stdio server.\n",
     status: "  agentbridge status [--repair] [--json]\n    Show current work session status.\n",
@@ -89,6 +96,9 @@ const COMMAND_HELP = {
         "    Manage domain memory packets.\n",
     version: "  agentbridge version\n    Print CLI version.\n",
     doctor: "  agentbridge doctor\n    Run config and connectivity diagnostics.\n",
+    "install-rules": "  agentbridge install-rules [--project <id>] [--api-key <key>] [--api-base-url <url>]\n" +
+        "    Fetch server protocol rules for the connected project, write AGENTBRIDGE.md and\n" +
+        "    .cursor/rules/agentbridge.mdc, and mark rules installed on the server.\n",
     "precommit-check": "  agentbridge precommit-check\n    Git pre-commit hook: block commits that violate domain boundaries.\n",
     bug: "  agentbridge bug report --title \"<text>\" --severity P0|P1|P2|P3 --category <CATEGORY> \\\n" +
         "    [--found-in dogfood,production,...] --observed \"<text>\" --expected \"<text>\" \\\n" +
@@ -118,6 +128,8 @@ function usage(command, opts) {
         "Setup:",
         "  agentbridge doctor               Check connection and repo readiness",
         "  agentbridge connect              Save credentials (cloud projects)",
+        "  agentbridge room exit            Clear stale room credentials (no server call)",
+        "  agentbridge install-rules        Install server protocol rules in this repo",
         "",
         "Advanced commands:",
         "  start --task ... --scope ...     Strict scoped session (both flags required)",
@@ -263,12 +275,36 @@ async function main() {
         });
         return;
     }
+    if (command === "room") {
+        const sub = positional[0] ?? "";
+        if (sub === "exit") {
+            (0, room_1.runRoomExit)({
+                keepSession: flags["--keep-session"] === "true",
+                json: flags["--json"] === "true",
+            });
+            return;
+        }
+        process.stderr.write("Usage: agentbridge room exit [--keep-session] [--json]\n");
+        process.exit(3);
+        return;
+    }
+    if (command === "install-rules") {
+        await (0, install_rules_1.runInstallRules)({
+            projectId,
+            apiKey,
+            apiBaseUrl,
+        });
+        return;
+    }
     if (command === "recover") {
         await (0, recover_1.runRecover)({ force: Boolean(flags["--force"]) });
         return;
     }
     if (command === "setup-mcp") {
-        await (0, setup_mcp_1.runSetupMcp)({ editor: flags["--editor"] });
+        await (0, setup_mcp_1.runSetupMcp)({
+            editor: flags["--editor"],
+            local: flags["--local"] === "true",
+        });
         return;
     }
     if (command === "mcp") {
@@ -340,6 +376,7 @@ async function main() {
             daemon: flags["--daemon"] === "true",
             once: flags["--once"] === "true",
             details: flags["--details"] === "true",
+            confirmDomain: flags["--confirm-domain"] === "true",
         });
         return;
     }
@@ -359,6 +396,7 @@ async function main() {
             resume: flags["--resume"] === "true",
             details: flags["--details"] === "true",
             confirmClose: flags["--yes"] === "true",
+            confirmDomain: flags["--confirm-domain"] === "true",
         });
         return;
     }

package/dist/init.js

@@ -597,6 +597,16 @@ async function runBootstrapRecovery(ctx, opts = {}) {
         const existingBootstrap = refsToBootstrapDomains(opts.reconcilePlan.existingActive);
         bootstrapPayload.domains = (0, recovery_reconcile_1.mergeBootstrapDomainEntries)(opts.reconcilePlan, candidateBootstrap, existingBootstrap);
     }
+    if (process.env.AGENTBRIDGE_DEBUG_HTTP === "1") {
+        const payloadDomains = Array.isArray(bootstrapPayload.domains)
+            ? bootstrapPayload.domains
+            : [];
+        const mappedPathCount = payloadDomains.reduce((count, domain) => {
+            const paths = domain.files && domain.files.length > 0 ? domain.files : domain.pathPatterns;
+            return count + (Array.isArray(paths) ? paths.length : 0);
+        }, 0);
+        process.stderr.write(`[agentbridge:recover] bootstrap POST project=${ctx.projectId} domains=${payloadDomains.length} mapped_paths=${mappedPathCount} product_summary_len=${String(bootstrapPayload.product_summary ?? "").length}\n`);
+    }
     await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/bootstrap`, bootstrapPayload);
     const payloadDomains = Array.isArray(bootstrapPayload.domains)
         ? bootstrapPayload.domains

package/dist/intent-validation.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isVagueIntent = isVagueIntent;
+exports.validateIntent = validateIntent;
+const errors_1 = require("./errors");
+const VAGUE_PHRASES = [
+    "working on project",
+    "making changes",
+    "updating files",
+    "fix stuff",
+    "general work",
+];
+function isVagueIntent(intent) {
+    const lower = intent.trim().toLowerCase();
+    if (!lower)
+        return true;
+    if (lower.split(/\s+/).length < 4)
+        return true;
+    return VAGUE_PHRASES.some((phrase) => lower.includes(phrase));
+}
+function validateIntent(intent) {
+    const trimmed = intent.trim();
+    if (!trimmed) {
+        throw (0, errors_1.catalogCliError)("START_SUMMARY_REQUIRED", {
+            what: "A work contract intent is required.",
+            next: 'Run: agentbridge start "Fix auth 401 on /rooms endpoint"',
+        });
+    }
+    if (isVagueIntent(trimmed)) {
+        throw (0, errors_1.catalogCliError)("START_SUMMARY_REQUIRED", {
+            what: "Intent is too vague for a work contract.",
+            why: "AgentBridge needs a specific goal to compare against file changes.",
+            next: 'Use a concrete intent, e.g. agentbridge start "Fix auth 401 on /rooms endpoint"',
+        });
+    }
+    return trimmed;
+}

package/dist/local-proof.js

@@ -11,10 +11,18 @@ function normalizePath(path) {
     return path.trim().replaceAll("\\", "/");
 }
 function isProofNoiseFile(file) {
-    const normalized = normalizePath(file).toLowerCase();
-    return (normalized === "agentbridge.md" ||
-        normalized === ".cursor" ||
-        normalized.startsWith(".cursor/"));
+    const normalized = normalizePath(file);
+    const lower = normalized.toLowerCase();
+    if (lower === "agentbridge.md" ||
+        lower === ".cursor" ||
+        lower.startsWith(".cursor/")) {
+        return true;
+    }
+    // Vite ephemeral config bundles (e.g. vite.config.ts.timestamp-1781442511868-*.mjs)
+    if (/\.timestamp-\d+-[a-z0-9]+\.mjs$/i.test(normalized)) {
+        return true;
+    }
+    return false;
 }
 function normalizeProofMatchingFileSet(files) {
     return [...new Set(files.map(normalizePath).filter((file) => file.length > 0 && !isProofNoiseFile(file)))].sort();