@agentbridge1/cli 0.0.7 → 0.0.8

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

@@ -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

@@ -55,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" +
@@ -68,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",
@@ -300,7 +301,10 @@ async function main() {
         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") {
@@ -372,6 +376,7 @@ async function main() {
             daemon: flags["--daemon"] === "true",
             once: flags["--once"] === "true",
             details: flags["--details"] === "true",
+            confirmDomain: flags["--confirm-domain"] === "true",
         });
         return;
     }
@@ -391,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/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();