@agentbridge1/cli 0.0.7 → 0.0.9

package/dist/mcp/agentbridge-mcp.js

@@ -2980,7 +2980,7 @@ var require_compile = __commonJS({
       const schOrFunc = root.refs[ref];
       if (schOrFunc)
         return schOrFunc;
-      let _sch = resolve2.call(this, root, ref);
+      let _sch = resolve3.call(this, root, ref);
       if (_sch === void 0) {
         const schema = (_a = root.localRefs) === null || _a === void 0 ? void 0 : _a[ref];
         const { schemaId } = this.opts;
@@ -3007,7 +3007,7 @@ var require_compile = __commonJS({
     function sameSchemaEnv(s1, s2) {
       return s1.schema === s2.schema && s1.root === s2.root && s1.baseId === s2.baseId;
     }
-    function resolve2(root, ref) {
+    function resolve3(root, ref) {
       let sch;
       while (typeof (sch = this.refs[ref]) == "string")
         ref = sch;
@@ -3582,7 +3582,7 @@ var require_fast_uri = __commonJS({
       }
       return uri;
     }
-    function resolve2(baseURI, relativeURI, options) {
+    function resolve3(baseURI, relativeURI, options) {
       const schemelessOptions = options ? Object.assign({ scheme: "null" }, options) : { scheme: "null" };
       const resolved = resolveComponent(parse3(baseURI, schemelessOptions), parse3(relativeURI, schemelessOptions), schemelessOptions, true);
       schemelessOptions.skipEscape = true;
@@ -3809,7 +3809,7 @@ var require_fast_uri = __commonJS({
     var fastUri = {
       SCHEMES,
       normalize,
-      resolve: resolve2,
+      resolve: resolve3,
       resolveComponent,
       equal,
       serialize,
@@ -18892,7 +18892,7 @@ var Protocol = class {
           return;
         }
         const pollInterval = task2.pollInterval ?? this._options?.defaultTaskPollInterval ?? 1e3;
-        await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+        await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
         options?.signal?.throwIfAborted();
       }
     } catch (error2) {
@@ -18909,7 +18909,7 @@ var Protocol = class {
    */
   request(request, resultSchema, options) {
     const { relatedRequestId, resumptionToken, onresumptiontoken, task, relatedTask } = options ?? {};
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       const earlyReject = (error2) => {
         reject(error2);
       };
@@ -18987,7 +18987,7 @@ var Protocol = class {
           if (!parseResult.success) {
             reject(parseResult.error);
           } else {
-            resolve2(parseResult.data);
+            resolve3(parseResult.data);
           }
         } catch (error2) {
           reject(error2);
@@ -19248,12 +19248,12 @@ var Protocol = class {
       }
     } catch {
     }
-    return new Promise((resolve2, reject) => {
+    return new Promise((resolve3, reject) => {
       if (signal.aborted) {
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
         return;
       }
-      const timeoutId = setTimeout(resolve2, interval);
+      const timeoutId = setTimeout(resolve3, interval);
       signal.addEventListener("abort", () => {
         clearTimeout(timeoutId);
         reject(new McpError(ErrorCode.InvalidRequest, "Request cancelled"));
@@ -20353,7 +20353,7 @@ var McpServer = class {
     let task = createTaskResult.task;
     const pollInterval = task.pollInterval ?? 5e3;
     while (task.status !== "completed" && task.status !== "failed" && task.status !== "cancelled") {
-      await new Promise((resolve2) => setTimeout(resolve2, pollInterval));
+      await new Promise((resolve3) => setTimeout(resolve3, pollInterval));
       const updatedTask = await extra.taskStore.getTask(taskId);
       if (!updatedTask) {
         throw new McpError(ErrorCode.InternalError, `Task ${taskId} not found during polling`);
@@ -21002,20 +21002,161 @@ var StdioServerTransport = class {
     this.onclose?.();
   }
   send(message) {
-    return new Promise((resolve2) => {
+    return new Promise((resolve3) => {
       const json = serializeMessage(message);
       if (this._stdout.write(json)) {
-        resolve2();
+        resolve3();
       } else {
-        this._stdout.once("drain", resolve2);
+        this._stdout.once("drain", resolve3);
       }
     });
   }
 };
 
+// ../mcp/agentbridge-mcp.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path2 = require("node:path");
+
 // src/session.ts
 var import_node_child_process2 = require("node:child_process");
 
+// src/intent-parser.ts
+var ACTIONS = ["fix", "add", "update", "refactor", "remove", "migrate", "rename", "revert", "delete", "implement", "improve", "patch"];
+var DOMAIN_KEYWORD_MAP = {
+  auth: ["auth", "login", "logout", "session", "token", "oauth", "jwt", "password", "signin", "signup", "sign-in", "sign-up", "register", "credential", "permission", "role"],
+  database: ["database", "db", "schema", "migration", "migrate", "prisma", "sql", "query", "table", "column", "index", "model", "seed", "orm"],
+  payments: ["payment", "payments", "billing", "stripe", "invoice", "subscription", "checkout", "webhook"],
+  api: ["api", "endpoint", "route", "handler", "controller", "request", "response", "rest", "graphql"],
+  ui: ["ui", "style", "css", "component", "page", "layout", "copy", "design", "render", "display", "view", "frontend", "html", "template"],
+  mcp: ["mcp", "agentbridge", "cursor", "rules"],
+  tests: ["test", "tests", "spec", "vitest", "jest", "coverage", "proof"]
+};
+var SYMPTOMS = {
+  "401": ["401", "unauthorized", "unauthenticated"],
+  "403": ["403", "forbidden"],
+  "404": ["404", "not found", "notfound"],
+  "500": ["500", "internal server error", "server error"],
+  "null": ["null", "undefined", "nan", "nil"],
+  "crash": ["crash", "crashes", "crashed", "exception", "throws", "throw"],
+  "loop": ["loop", "infinite loop", "recursion"],
+  "hang": ["hang", "hangs", "timeout", "deadlock"],
+  "slow": ["slow", "performance", "latency", "memory leak", "memory"],
+  "duplicate": ["duplicate", "duplicated", "twice"],
+  "missing": ["missing", "not showing", "not found"]
+};
+var ROUTE_RE = /(?<!\w)(\/[a-zA-Z0-9_-]+(?:\/[a-zA-Z0-9_:_-]+)*)/g;
+var FILE_RE = /\b([A-Za-z][A-Za-z0-9_-]*\.[a-z]{2,4})\b/g;
+var PASCAL_RE = /\b([A-Z][a-z]+(?:[A-Z][a-z]*)+)\b/g;
+var CAMEL_FN_RE = /\b([a-z][a-z0-9]*(?:[A-Z][a-z0-9]*)+)\b/g;
+var QUOTED_RE = /"([^"]+)"|'([^']+)'/g;
+function detectDomain(lower) {
+  for (const [domain, keywords] of Object.entries(DOMAIN_KEYWORD_MAP)) {
+    if (keywords.some((kw) => lower.includes(kw))) return domain;
+  }
+  return null;
+}
+function detectAction(lower) {
+  for (const action of ACTIONS) {
+    if (lower.startsWith(action) || lower.includes(` ${action} `)) return action;
+  }
+  return null;
+}
+function detectSymptom(lower) {
+  for (const [symptom, patterns] of Object.entries(SYMPTOMS)) {
+    if (patterns.some((p) => lower.includes(p))) return symptom;
+  }
+  return null;
+}
+function extractTargets(raw) {
+  const targets = /* @__PURE__ */ new Set();
+  for (const m of raw.matchAll(QUOTED_RE)) {
+    const phrase = m[1] ?? m[2];
+    if (phrase) targets.add(phrase.trim());
+  }
+  for (const m of raw.matchAll(ROUTE_RE)) {
+    targets.add(m[1]);
+  }
+  for (const m of raw.matchAll(FILE_RE)) {
+    targets.add(m[1]);
+  }
+  for (const m of raw.matchAll(PASCAL_RE)) {
+    targets.add(m[1]);
+  }
+  for (const m of raw.matchAll(CAMEL_FN_RE)) {
+    if (m[1].length <= 40) targets.add(m[1]);
+  }
+  return [...targets];
+}
+function inferLayers(domain, targets, symptom, action, rawLower) {
+  const layers = [];
+  const hasRoute = targets.some((t) => t.startsWith("/"));
+  const hasMigration = action === "migrate" || targets.some((t) => t.toLowerCase().includes("migration"));
+  if (domain === "auth") {
+    if (symptom === "401" || symptom === "403") layers.push("route_handler", "auth_middleware");
+    else if (hasRoute) layers.push("route_handler", "auth_middleware");
+    else layers.push("auth_middleware");
+  }
+  if (domain === "api") {
+    if (hasRoute) layers.push("route_handler");
+    else layers.push("route_handler");
+  }
+  if (domain === "database") {
+    if (hasMigration) layers.push("schema", "migration_file");
+    else layers.push("model", "query");
+  }
+  if (domain === "ui") {
+    layers.push("component", "view");
+  }
+  if (domain === "payments") {
+    if (targets.some((t) => t.toLowerCase().includes("webhook")) || rawLower.includes("webhook")) {
+      layers.push("webhook_handler");
+    } else {
+      layers.push("billing_handler");
+    }
+  }
+  if (domain === "mcp") {
+    layers.push("mcp_server", "config");
+  }
+  return layers;
+}
+function parseIntent(raw) {
+  if (!raw?.trim()) {
+    return { raw: raw ?? "", domain: null, targets: [], symptom: null, action: null, affected_layer: [] };
+  }
+  const lower = raw.toLowerCase();
+  const domain = detectDomain(lower);
+  const action = detectAction(lower);
+  const symptom = detectSymptom(lower);
+  const targets = extractTargets(raw);
+  const affected_layer = inferLayers(domain, targets, symptom, action, lower);
+  return { raw, domain, targets, symptom, action, affected_layer };
+}
+function buildTaskSpecificCriteria(parsed) {
+  const extra = [];
+  const routeTargets = parsed.targets.filter((t) => t.startsWith("/"));
+  const fileTargets = parsed.targets.filter((t) => t.includes("."));
+  const namedTargets = parsed.targets.filter((t) => !t.startsWith("/") && !t.includes("."));
+  if (routeTargets.length > 0 && parsed.domain === "auth" && parsed.symptom) {
+    extra.push(`The ${routeTargets[0]} route handler or its auth middleware chain is updated to address the ${parsed.symptom}.`);
+  } else if (routeTargets.length > 0 && parsed.domain === "api") {
+    extra.push(`The ${routeTargets[0]} endpoint handler is updated as intended.`);
+  } else if (routeTargets.length > 0) {
+    extra.push(`Changes are focused on the ${routeTargets[0]} route.`);
+  } else if (fileTargets.length > 0) {
+    extra.push(`Changes are focused on ${fileTargets[0]}.`);
+  } else if (namedTargets.length > 0) {
+    extra.push(`Changes are focused on ${namedTargets[0]}.`);
+  }
+  if (parsed.symptom && routeTargets.length > 0) {
+    extra.push(`Proof exists for the ${parsed.symptom} behavior on ${routeTargets[0]}.`);
+  } else if (parsed.symptom) {
+    extra.push(`Proof exists that the ${parsed.symptom} condition is resolved.`);
+  } else if (parsed.action && parsed.domain) {
+    extra.push(`Proof exists that the ${parsed.action} to the ${parsed.domain} layer is correct.`);
+  }
+  return extra;
+}
+
 // src/session-state.ts
 var import_node_fs2 = require("node:fs");
 var import_node_path = require("node:path");
@@ -21058,6 +21199,20 @@ function computeFileFingerprints(paths) {
 }
 
 // src/local-proof.ts
+function normalizePath2(path) {
+  return path.trim().replaceAll("\\", "/");
+}
+function isProofNoiseFile(file) {
+  const normalized = normalizePath2(file);
+  const lower = normalized.toLowerCase();
+  if (lower === "agentbridge.md" || lower === ".cursor" || lower.startsWith(".cursor/")) {
+    return true;
+  }
+  if (/\.timestamp-\d+-[a-z0-9]+\.mjs$/i.test(normalized)) {
+    return true;
+  }
+  return false;
+}
 function isLocalVerificationRun(value) {
   if (typeof value !== "object" || value === null) return false;
   const row = value;
@@ -21080,6 +21235,12 @@ function isLocalVerificationRun(value) {
 }
 
 // src/session-state.ts
+function isActiveLocalSession(state) {
+  if (!state) return false;
+  if (state.status === "closed") return false;
+  if (!state.id || state.id === "none") return false;
+  return true;
+}
 function resolveRepoRoot() {
   return process.env.AGENTBRIDGE_REPO_ROOT?.trim() || process.cwd();
 }
@@ -21155,6 +21316,15 @@ function isLocalSessionState(value) {
   if (value.updatedAt !== void 0 && typeof value.updatedAt !== "string") return false;
   if (value.closedAt !== void 0 && typeof value.closedAt !== "string") return false;
   if (value.claimedPaths !== void 0 && !isStringArray(value.claimedPaths)) return false;
+  if (value.createdBy !== void 0 && value.createdBy !== "user_start" && value.createdBy !== "agent_hello") {
+    return false;
+  }
+  if (value.contractProfiles !== void 0 && !isStringArray(value.contractProfiles)) return false;
+  if (value.expectedSurfaces !== void 0 && !isStringArray(value.expectedSurfaces)) return false;
+  if (value.expectedFileAreas !== void 0 && !isStringArray(value.expectedFileAreas)) return false;
+  if (value.completionCriteria !== void 0 && !isStringArray(value.completionCriteria)) return false;
+  if (value.proofNeeded !== void 0 && !isStringArray(value.proofNeeded)) return false;
+  if (value.riskyOmissions !== void 0 && !isStringArray(value.riskyOmissions)) return false;
   if (value.lastLocalVerificationRun !== void 0 && !isLocalVerificationRun(value.lastLocalVerificationRun)) {
     return false;
   }
@@ -21223,14 +21393,304 @@ function writeSessionState(state) {
   }
   (0, import_node_fs2.renameSync)(tempPath, path);
 }
+function clearSessionState() {
+  writeSessionState({
+    id: "none",
+    agentId: "none",
+    laneDomain: null,
+    status: "closed",
+    closeReason: "completed",
+    changedFiles: [],
+    crossings: [],
+    approvals: [],
+    domains: [],
+    createdAt: (/* @__PURE__ */ new Date(0)).toISOString()
+  });
+}
+
+// src/contract-intelligence.ts
+var MCP_RULE_PROFILE = "mcp_rules_config_install";
+var AUTH_PROFILE = "auth_login_session";
+var DB_PROFILE = "database_schema_migration";
+var UI_PROFILE = "ui_style_copy";
+var API_PROFILE = "api_endpoint";
+var TEST_PROFILE = "tests";
+var PAYMENTS_PROFILE = "payments_webhooks";
+var GENERIC_PROFILE = "generic";
+function unique(values) {
+  return [...new Set(values.map((value) => value.trim()).filter(Boolean))];
+}
+function matchIntent(intent, keywords) {
+  const lower = intent.toLowerCase();
+  return keywords.some((keyword) => lower.includes(keyword));
+}
+function detectProfiles(intent) {
+  const profiles = [];
+  if (matchIntent(intent, ["mcp"]) && matchIntent(intent, ["rule", "rules", "install", "setup", "config", "configuration"])) {
+    profiles.push(MCP_RULE_PROFILE);
+  }
+  if (matchIntent(intent, ["auth", "login", "session", "token", "oauth"])) {
+    profiles.push(AUTH_PROFILE);
+  }
+  if (matchIntent(intent, ["database", "db", "schema", "migration", "prisma", "sql"])) {
+    profiles.push(DB_PROFILE);
+  }
+  if (matchIntent(intent, ["ui", "style", "css", "copy", "layout", "component"])) {
+    profiles.push(UI_PROFILE);
+  }
+  if (matchIntent(intent, ["api", "endpoint", "route", "handler", "controller"])) {
+    profiles.push(API_PROFILE);
+  }
+  if (matchIntent(intent, ["test", "tests", "vitest", "jest", "proof"])) {
+    profiles.push(TEST_PROFILE);
+  }
+  if (matchIntent(intent, ["payment", "payments", "billing", "stripe", "webhook"])) {
+    profiles.push(PAYMENTS_PROFILE);
+  }
+  return profiles.length > 0 ? profiles : [GENERIC_PROFILE];
+}
+function profileBlueprint(profile) {
+  switch (profile) {
+    case MCP_RULE_PROFILE:
+      return {
+        expectedSurfaces: ["mcp", "rules_installation", "configuration_flow", "tests_or_manual_proof"],
+        expectedFileAreas: [
+          "mcp/**",
+          "mcp/agentbridge-mcp.ts",
+          "AGENTBRIDGE.md",
+          ".cursor/rules/**",
+          "cli/src/mcp-config.ts",
+          "cli/src/commands/setup-mcp.ts"
+        ],
+        completionCriteria: [
+          "MCP configuration path triggers AgentBridge rule installation.",
+          "Rules are created or updated in the expected Cursor rules location.",
+          "Existing rules/config are preserved or safely updated.",
+          "Re-running MCP configuration is idempotent and does not duplicate rules.",
+          "Proof exists that MCP configuration causes rules to be installed."
+        ],
+        proofNeeded: [
+          "Run MCP setup/configuration flow in a clean repo.",
+          "Confirm the AgentBridge Cursor rules file is created.",
+          "Run setup/configuration again to confirm idempotency.",
+          "Record test/manual proof output."
+        ],
+        riskyOmissions: [
+          "MCP server file changed but no install trigger wired to the configuration path.",
+          "Rules are installed only in local mode or only in server mode.",
+          "Existing Cursor rules are overwritten.",
+          "No idempotency check.",
+          "No proof that the auto-install behavior actually runs."
+        ],
+        contractProfiles: [MCP_RULE_PROFILE]
+      };
+    case AUTH_PROFILE:
+      return {
+        expectedSurfaces: ["auth", "session", "tests_or_manual_proof"],
+        expectedFileAreas: ["auth/**", "src/**/auth/**", "src/**/session/**", "middleware/**"],
+        completionCriteria: [
+          "Authentication/session flow handling is updated where intended.",
+          "Authorization boundaries remain explicit and unchanged outside scope.",
+          "Proof exists for the auth/session behavior change."
+        ],
+        proofNeeded: ["Run auth/session flow tests or a reproducible manual proof."],
+        riskyOmissions: [
+          "Auth logic changed without session or middleware checks.",
+          "No proof of login/session behavior."
+        ],
+        contractProfiles: [AUTH_PROFILE]
+      };
+    case DB_PROFILE:
+      return {
+        expectedSurfaces: ["database", "schema_migration", "tests_or_manual_proof"],
+        expectedFileAreas: ["prisma/**", "migrations/**", "src/**/db/**", "src/**/database/**"],
+        completionCriteria: [
+          "Schema/data-layer changes are applied in intended files.",
+          "Migration or compatibility impact is accounted for.",
+          "Proof exists for migration/query behavior."
+        ],
+        proofNeeded: ["Run migration/database verification command and capture output."],
+        riskyOmissions: [
+          "Schema changed without migration/compatibility proof.",
+          "No evidence of migration/query validation."
+        ],
+        contractProfiles: [DB_PROFILE]
+      };
+    case UI_PROFILE:
+      return {
+        expectedSurfaces: ["ui", "copy_or_style", "tests_or_manual_proof"],
+        expectedFileAreas: ["src/**/components/**", "src/**/pages/**", "src/**/*.css", "src/**/*.html"],
+        completionCriteria: [
+          "UI/copy/style surface for the contract is updated.",
+          "Unrelated UI areas are not changed unintentionally.",
+          "Proof exists for the visible behavior change."
+        ],
+        proofNeeded: ["Record manual verification steps (or visual/tests) for UI outcome."],
+        riskyOmissions: [
+          "UI files changed without a clear visible proof.",
+          "Broad style changes without scope evidence."
+        ],
+        contractProfiles: [UI_PROFILE]
+      };
+    case API_PROFILE:
+      return {
+        expectedSurfaces: ["api", "endpoint_logic", "tests_or_manual_proof"],
+        expectedFileAreas: ["src/**/routes/**", "src/**/api/**", "src/**/controllers/**"],
+        completionCriteria: [
+          "Target API/endpoint behavior is changed in the correct surface.",
+          "Request/response behavior is evidenced.",
+          "Proof exists for endpoint behavior."
+        ],
+        proofNeeded: ["Run endpoint tests or reproducible request/response proof."],
+        riskyOmissions: [
+          "Endpoint files changed without request/response evidence.",
+          "No proof for API behavior change."
+        ],
+        contractProfiles: [API_PROFILE]
+      };
+    case TEST_PROFILE:
+      return {
+        expectedSurfaces: ["tests", "proof"],
+        expectedFileAreas: ["**/*.test.ts", "**/*.spec.ts", "tests/**"],
+        completionCriteria: [
+          "Test/proof artifacts relevant to the contract are updated.",
+          "Test execution evidence is recorded."
+        ],
+        proofNeeded: ["Run tests and record command + result output."],
+        riskyOmissions: ["Tests changed but no execution proof recorded."],
+        contractProfiles: [TEST_PROFILE]
+      };
+    case PAYMENTS_PROFILE:
+      return {
+        expectedSurfaces: ["payments", "webhooks", "tests_or_manual_proof"],
+        expectedFileAreas: ["src/**/billing/**", "src/**/payments/**", "src/**/webhooks/**"],
+        completionCriteria: [
+          "Payments/webhook handling logic is updated in scope.",
+          "Critical payment side effects are evidenced.",
+          "Proof exists for payment/webhook behavior."
+        ],
+        proofNeeded: ["Run payment/webhook verification flow and capture output."],
+        riskyOmissions: [
+          "Webhook/payment logic changed without behavior proof.",
+          "No idempotency/effect validation for financial flows."
+        ],
+        contractProfiles: [PAYMENTS_PROFILE]
+      };
+    default:
+      return {
+        expectedSurfaces: ["implementation_surface", "tests_or_manual_proof"],
+        expectedFileAreas: ["**"],
+        completionCriteria: [
+          "Files changed align with the declared contract intent.",
+          "Proof exists for the intended behavior change."
+        ],
+        proofNeeded: ["Run relevant tests or provide manual proof output."],
+        riskyOmissions: ["Code changed without proof linked to the declared intent."],
+        contractProfiles: [GENERIC_PROFILE]
+      };
+  }
+}
+function buildContractIntelligence(intent, createdBy) {
+  const normalizedIntent = intent?.trim() ?? "";
+  const profiles = detectProfiles(normalizedIntent);
+  const combined = profiles.map((profile) => profileBlueprint(profile));
+  const baseCompletionCriteria = unique(combined.flatMap((item) => item.completionCriteria));
+  const parsed = parseIntent(normalizedIntent);
+  const taskCriteria = buildTaskSpecificCriteria(parsed);
+  const firstTask = taskCriteria[0];
+  const lastTask = taskCriteria[1];
+  const completionCriteria = unique([
+    ...firstTask ? [firstTask] : [],
+    ...baseCompletionCriteria.filter((c) => !c.toLowerCase().startsWith("proof")),
+    ...lastTask ? [lastTask] : [],
+    ...baseCompletionCriteria.filter((c) => c.toLowerCase().startsWith("proof"))
+  ]);
+  return {
+    expectedSurfaces: unique(combined.flatMap((item) => item.expectedSurfaces)),
+    expectedFileAreas: unique(combined.flatMap((item) => item.expectedFileAreas)),
+    completionCriteria,
+    proofNeeded: unique(combined.flatMap((item) => item.proofNeeded)),
+    riskyOmissions: unique(combined.flatMap((item) => item.riskyOmissions)),
+    contractProfiles: unique(combined.flatMap((item) => item.contractProfiles)),
+    createdBy
+  };
+}
+function localSessionToContractIntelligence(session) {
+  if (session.completionCriteria?.length && session.contractProfiles?.length) {
+    return {
+      contractProfiles: session.contractProfiles,
+      completionCriteria: session.completionCriteria,
+      proofNeeded: session.proofNeeded ?? [],
+      riskyOmissions: session.riskyOmissions ?? [],
+      expectedSurfaces: session.expectedSurfaces ?? [],
+      expectedFileAreas: session.expectedFileAreas ?? [],
+      createdBy: session.createdBy ?? "agent_hello"
+    };
+  }
+  return buildContractIntelligence(session.intent, session.createdBy ?? "agent_hello");
+}
+function sessionNeedsContractBackfill(session) {
+  return !session.completionCriteria?.length || !session.contractProfiles?.length;
+}
+function ensureSessionContractIntelligence(session) {
+  if (!sessionNeedsContractBackfill(session)) {
+    return session;
+  }
+  const createdBy = session.createdBy ?? (session.agentId?.trim() === "local" ? "user_start" : "agent_hello");
+  const contract = buildContractIntelligence(session.intent?.trim(), createdBy);
+  const updated = {
+    ...session,
+    createdBy,
+    contractProfiles: contract.contractProfiles,
+    expectedSurfaces: contract.expectedSurfaces,
+    expectedFileAreas: contract.expectedFileAreas,
+    completionCriteria: contract.completionCriteria,
+    proofNeeded: contract.proofNeeded,
+    riskyOmissions: contract.riskyOmissions
+  };
+  writeSessionState(updated);
+  return updated;
+}
+function buildProofRequiredCommands(contract) {
+  if (contract.contractProfiles.includes(MCP_RULE_PROFILE)) {
+    return [
+      "agentbridge verify npm run setup-mcp -- --local",
+      "agentbridge verify npm run setup-mcp -- --local  (run again to confirm idempotency)"
+    ];
+  }
+  if (contract.contractProfiles.includes(DB_PROFILE)) {
+    return [
+      "agentbridge verify npx prisma migrate status",
+      "agentbridge verify npm test"
+    ];
+  }
+  if (contract.contractProfiles.includes(AUTH_PROFILE) || contract.contractProfiles.includes(API_PROFILE) || contract.contractProfiles.includes(UI_PROFILE) || contract.contractProfiles.includes(TEST_PROFILE) || contract.contractProfiles.includes(PAYMENTS_PROFILE)) {
+    return ["agentbridge verify npm test"];
+  }
+  return ["agentbridge verify npm test"];
+}
+function buildLocalHelloPayload(session) {
+  const contract = localSessionToContractIntelligence(session);
+  const scopeSource = session.createdBy ?? (session.agentId?.trim() === "local" ? "user_start" : "agent_hello");
+  return {
+    contract: {
+      id: session.id,
+      intent: session.intent?.trim() ?? null,
+      created_by: scopeSource
+    },
+    done_checklist: contract.completionCriteria.slice(0, 4),
+    proof_required: buildProofRequiredCommands(contract),
+    warnings: contract.riskyOmissions.slice(0, 2)
+  };
+}
 
 // src/git-status.ts
 var import_node_child_process = require("node:child_process");
-function normalizePath2(path) {
+function normalizePath3(path) {
   return path.trim().replaceAll("\\", "/");
 }
 function isAgentbridgeLocalPath(path) {
-  const normalized = normalizePath2(path);
+  const normalized = normalizePath3(path);
   return normalized === ".agentbridge" || normalized.startsWith(".agentbridge/");
 }
 function isRenameOrCopy(xy) {
@@ -21246,25 +21706,28 @@ function parseGitStatusPorcelainZ(raw) {
     const payload = token.slice(3);
     if (!payload) continue;
     if (isRenameOrCopy(xy)) {
-      const originalPath = normalizePath2(payload);
-      const renamedTo = normalizePath2(tokens[idx + 1] ?? "");
+      const originalPath = normalizePath3(payload);
+      const renamedTo = normalizePath3(tokens[idx + 1] ?? "");
       if (renamedTo.length > 0) {
         entries.push({ xy, path: renamedTo, originalPath });
       }
       idx += 1;
       continue;
     }
-    entries.push({ xy, path: normalizePath2(payload) });
+    entries.push({ xy, path: normalizePath3(payload) });
   }
   return entries;
 }
+function isSupervisionRelevantPath(path) {
+  return !isAgentbridgeLocalPath(path) && !isProofNoiseFile(path);
+}
 function collectChangedFilesFromStatusEntries(entries) {
   const files = /* @__PURE__ */ 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);
     }
   }
@@ -21313,6 +21776,45 @@ function captureLocalSessionBaseline() {
     fingerprintsAtStart
   };
 }
+function openLocalSession(input) {
+  const claimedPaths = [...new Set((input.claimedPaths ?? []).map((path) => path.trim()).filter(Boolean))];
+  const baseline = captureLocalSessionBaseline();
+  const now = baseline.startedAt;
+  const createdBy = input.createdBy ?? (input.agentId?.trim() === "local" ? "user_start" : "agent_hello");
+  const contract = buildContractIntelligence(input.intent?.trim(), createdBy);
+  const state = {
+    id: `local_${Date.now().toString(36)}`,
+    agentId: input.agentId?.trim() || "local",
+    laneDomain: input.laneDomain,
+    intent: input.intent?.trim() || void 0,
+    createdBy,
+    contractProfiles: contract.contractProfiles,
+    expectedSurfaces: contract.expectedSurfaces,
+    expectedFileAreas: contract.expectedFileAreas,
+    completionCriteria: contract.completionCriteria,
+    proofNeeded: contract.proofNeeded,
+    riskyOmissions: contract.riskyOmissions,
+    mode: input.mode,
+    changeRequestId: input.changeRequestId,
+    claimedPaths,
+    status: "active",
+    changedFiles: [],
+    crossings: [],
+    approvals: [],
+    domains: input.domains,
+    serverSessionId: input.serverSessionId,
+    pendingHandoffToAgent: input.pendingHandoffToAgent,
+    pendingHandoffDomain: input.pendingHandoffDomain,
+    createdAt: now,
+    updatedAt: now,
+    startedAt: baseline.startedAt,
+    gitHead: baseline.gitHead,
+    dirtyFilesAtStart: baseline.dirtyFilesAtStart,
+    fingerprintsAtStart: baseline.fingerprintsAtStart
+  };
+  writeSessionState(state);
+  return state;
+}
 
 // src/local-session-mirror.ts
 function uniquePaths(paths) {
@@ -21523,6 +22025,475 @@ function mirrorMcpToolSuccess(toolName, args, json) {
   mirrorMcpLifecycleEvent(patch);
 }
 
+// src/error-catalog.ts
+var CATALOG = {
+  PROJECT_ACCESS_NOT_MEMBER: {
+    code: "PROJECT_ACCESS_NOT_MEMBER",
+    category: "PROJECT_ACCESS_ERROR",
+    title: "Project access denied.",
+    what: "This API key is valid but the agent is not a member of this project.",
+    why: "AgentBridge cannot read or mutate work state without project membership.",
+    next: "Use a key for this project or add this agent to the room."
+  },
+  PROJECT_ACCESS_UNAUTHORIZED: {
+    code: "PROJECT_ACCESS_UNAUTHORIZED",
+    category: "AUTH_ERROR",
+    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: "Run `agentbridge room exit`, set a fresh AGENTBRIDGE_API_KEY, then `agentbridge connect`."
+  },
+  PROJECT_ACCESS_NOT_FOUND: {
+    code: "PROJECT_ACCESS_NOT_FOUND",
+    category: "PROJECT_ACCESS_ERROR",
+    title: "Project not found.",
+    what: "The configured project ID does not exist in this API environment.",
+    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",
+    title: "Active agent could not be resolved.",
+    what: "Configured activeAgentId could not be resolved in this project.",
+    why: "Start and watch need a WorkIdentity that exists in the current room.",
+    next: "Run `agentbridge identity list` and update with `agentbridge use <agent-id>`."
+  },
+  WORK_CONTEXT_NO_CURRENT_SESSION: {
+    code: "WORK_CONTEXT_NO_CURRENT_SESSION",
+    category: "WORK_CONTEXT_ERROR",
+    title: "No active tracked work session.",
+    what: "No active tracked work session was found for this command.",
+    why: "Proof, verify, accept, and handoff require a bound work session.",
+    next: "Run `agentbridge watch` beside Cursor for live supervision, or `agentbridge verify -- <test command>` to record proof.",
+    blocksAcceptance: true
+  },
+  WORK_CONTEXT_BINDING_REQUIRED: {
+    code: "WORK_CONTEXT_BINDING_REQUIRED",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Work session binding required.",
+    what: "This command needs a linked local/server work session.",
+    why: "The CLI and server must agree on the active change request and session.",
+    next: 'Run `agentbridge watch --allow-dirty` for default review, or `agentbridge watch --task "<task>" --scope "<path>"` for strict mode.',
+    blocksAcceptance: true
+  },
+  PROOF_STALE_AFTER_CHANGE: {
+    code: "PROOF_STALE_AFTER_CHANGE",
+    category: "PROOF_STALE_ERROR",
+    title: "Proof is stale.",
+    what: "Verification passed earlier, but scoped files changed afterward.",
+    why: "Acceptance requires proof that matches the current tree.",
+    next: "Rerun `agentbridge verify -- <command>`.",
+    blocksAcceptance: true
+  },
+  SCOPE_DRIFT_OUT_OF_SCOPE_FILE: {
+    code: "SCOPE_DRIFT_OUT_OF_SCOPE_FILE",
+    category: "SCOPE_DRIFT_ERROR",
+    title: "Scope drift detected.",
+    what: "The agent changed a file outside the declared scope.",
+    why: "Out-of-scope edits are not safe to trust until reviewed or rescoped.",
+    next: 'Options: (1) revert the out-of-scope file, (2) widen strict scope via `agentbridge watch --task "<work>" --scope "<wider-path>"`, or (3) split into a separate task.',
+    blocksAcceptance: true
+  },
+  HANDOFF_REQUIRED: {
+    code: "HANDOFF_REQUIRED",
+    category: "HANDOFF_ERROR",
+    title: "Handoff required.",
+    what: "Acceptance is blocked until a handoff is recorded for this session.",
+    why: "Cross-boundary work must be explicitly handed off before close.",
+    next: "Run `agentbridge handoff` with a summary, then retry accept.",
+    blocksAcceptance: true
+  },
+  ACCEPTANCE_BLOCKED: {
+    code: "ACCEPTANCE_BLOCKED",
+    category: "ACCEPTANCE_ERROR",
+    title: "Acceptance blocked by protocol rules.",
+    what: "Server checks rejected acceptance due to missing handoff, proof, or scope alignment.",
+    why: "The acceptance contract was not fully satisfied.",
+    next: "Run `agentbridge watch --once` to see current blocking issues, resolve each one, then retry `agentbridge accept`.",
+    blocksAcceptance: true
+  },
+  MEMORY_SUGGEST_NO_SESSION: {
+    code: "MEMORY_SUGGEST_NO_SESSION",
+    category: "MEMORY_ERROR",
+    title: "No accepted session for memory suggest.",
+    what: "Memory suggest could not find an accepted session to summarize.",
+    why: "Memory packets are generated from completed, accepted work.",
+    next: "Complete and accept a session first, then rerun `agentbridge memory suggest`."
+  },
+  CONFIG_INCOMPLETE: {
+    code: "CONFIG_INCOMPLETE",
+    category: "CONFIG_ERROR",
+    title: "Configuration incomplete.",
+    what: "Project ID, API key, or base URL is missing from config and environment.",
+    why: "AgentBridge cannot call the server without connection settings.",
+    next: "Run `agentbridge init` or set AGENTBRIDGE_PROJECT_ID / AGENTBRIDGE_API_KEY."
+  },
+  IDENTITY_NO_ACTIVE_AGENT: {
+    code: "IDENTITY_NO_ACTIVE_AGENT",
+    category: "IDENTITY_ERROR",
+    title: "No active agent configured.",
+    what: "activeAgentId is not set in .agentbridge/config.json.",
+    why: "Watch and start need a WorkIdentity selected for this repo.",
+    next: "Run `agentbridge identity list` then `agentbridge use <agent-id>`."
+  },
+  CONFIG_NO_DOMAIN_MAP: {
+    code: "CONFIG_NO_DOMAIN_MAP",
+    category: "CONFIG_ERROR",
+    title: "Domain map missing.",
+    what: "No recovered domain map was found in .agentbridge/config.json.",
+    why: "Watch uses domain boundaries to enforce scoped file tracking.",
+    next: "Run `agentbridge init` to recover domains for this repo."
+  },
+  AUTH_LOGIN_FAILED: {
+    code: "AUTH_LOGIN_FAILED",
+    category: "AUTH_ERROR",
+    title: "Sign in failed.",
+    what: "Authentication could not be completed.",
+    why: "You cannot open rooms without a valid session.",
+    next: "Return to login and try again, or contact your admin if auth is disabled."
+  },
+  NETWORK_UNREACHABLE: {
+    code: "NETWORK_UNREACHABLE",
+    category: "NETWORK_ERROR",
+    title: "Network error.",
+    what: "The CLI could not reach the AgentBridge API.",
+    why: "Without network access, local commands cannot sync work state.",
+    next: "Check AGENTBRIDGE_BASE_URL and network connectivity, then rerun `agentbridge doctor`."
+  },
+  SERVER_ERROR: {
+    code: "SERVER_ERROR",
+    category: "SERVER_ERROR",
+    title: "Server error.",
+    what: "The AgentBridge server failed while handling the request.",
+    why: "The action could not complete until the server recovers.",
+    next: "Retry shortly. If it persists, run `agentbridge doctor` and check server logs."
+  },
+  UNKNOWN_RUNTIME_ERROR: {
+    code: "UNKNOWN_RUNTIME_ERROR",
+    category: "UNKNOWN_ERROR",
+    title: "Command failed.",
+    what: "The command could not be completed due to an unexpected local/runtime error.",
+    why: "AgentBridge could not classify this failure.",
+    next: "Run `agentbridge doctor` with AGENTBRIDGE_DEBUG=1 and retry."
+  },
+  START_SUMMARY_REQUIRED: {
+    code: "START_SUMMARY_REQUIRED",
+    category: "START_ERROR",
+    title: "Summary required.",
+    what: "Start requires a non-empty --summary describing the work.",
+    why: "Change requests and work sessions need a human-readable intent.",
+    next: 'Run `agentbridge start --summary "<work>" --scope "<path>"`.'
+  },
+  START_SCOPE_REQUIRED: {
+    code: "START_SCOPE_REQUIRED",
+    category: "START_ERROR",
+    title: "Scope required.",
+    what: "Start requires a non-empty --scope path or glob.",
+    why: "Scoped work must declare which files this session may touch.",
+    next: 'Run `agentbridge start --summary "<work>" --scope "<path>"`.'
+  },
+  START_MISSING_ACTIVE_AGENT: {
+    code: "START_MISSING_ACTIVE_AGENT",
+    category: "IDENTITY_ERROR",
+    title: "No active agent configured.",
+    what: "Neither activeAgentId nor --agent was provided for strict tracked start.",
+    why: "Strict tracked work (--summary/--scope, --resume, or --change-request) must bind to a WorkIdentity in this project.",
+    next: [
+      "For strict tracked work: run `agentbridge identity list` then `agentbridge use <agent-id>`, or pass --agent.",
+      "For room-level watching only: run `agentbridge start` with no strict flags."
+    ].join("\n")
+  },
+  START_EXECUTION_SURFACE_REQUIRED: {
+    code: "START_EXECUTION_SURFACE_REQUIRED",
+    category: "CONFIG_ERROR",
+    title: "Execution surface missing.",
+    what: "No executionSurfaceId is saved in .agentbridge/config.json.",
+    why: "The server needs a stable execution surface to open a tracked session.",
+    next: [
+      "Run:",
+      "  agentbridge connect --project <project-id> --api-key <key> --api-base-url <url>",
+      "Then:",
+      "  agentbridge doctor",
+      "If this continues, AgentBridge could not create an AgentConnection/execution surface for this project."
+    ].join("\n")
+  },
+  START_AGENT_INVALID: {
+    code: "START_AGENT_INVALID",
+    category: "IDENTITY_ERROR",
+    title: "Agent could not be resolved.",
+    what: "The --agent value does not match any WorkIdentity in this project.",
+    why: "Start cannot open scoped work without a valid project agent.",
+    next: 'Run `agentbridge identity list` and retry with `--agent "<valid-agent-id>"`.'
+  },
+  START_IDENTITY_MISMATCH: {
+    code: "START_IDENTITY_MISMATCH",
+    category: "IDENTITY_ERROR",
+    title: "Agent identity mismatch.",
+    what: "The resolved agent is not authorized for this API key's WorkIdentity.",
+    why: "Start must run under the same WorkIdentity as the API key.",
+    next: "Use an API key bound to that agent, or pick an agent your key owns."
+  },
+  START_CALLER_IDENTITY_UNRESOLVED: {
+    code: "START_CALLER_IDENTITY_UNRESOLVED",
+    category: "IDENTITY_ERROR",
+    title: "Caller identity unresolved.",
+    what: "The API key could not be mapped to a WorkIdentity in this project.",
+    why: "Start requires a resolvable caller WorkIdentity from the server.",
+    next: "Run `agentbridge doctor` and verify this key is an AgentConnection key."
+  },
+  START_DOMAIN_UNRESOLVED: {
+    code: "START_DOMAIN_UNRESOLVED",
+    category: "START_ERROR",
+    title: "Domain could not be inferred.",
+    what: "No domain could be inferred from scope or active identity.",
+    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",
+    title: "Domain owner unresolved.",
+    what: "The change request or session policy requires an owner WorkIdentity that is not assigned.",
+    why: "The server will not open a tracked session without domain ownership.",
+    next: "Ensure this project has a domain owner for the scope, or pass --domain."
+  },
+  START_CR_OWNERSHIP_MISMATCH: {
+    code: "START_CR_OWNERSHIP_MISMATCH",
+    category: "START_ERROR",
+    title: "Tracked task belongs to another connected agent.",
+    what: "AgentBridge found an old tracked task owned by a different connected agent.",
+    why: "AgentBridge will not let one connected agent automatically take over another agent's tracked work.",
+    next: "Run `agentbridge watch` for live supervision, or switch back to the original connected agent if you intend to resume old tracked work."
+  },
+  START_CR_NOT_EXECUTABLE: {
+    code: "START_CR_NOT_EXECUTABLE",
+    category: "START_ERROR",
+    title: "Change request not executable.",
+    what: "The change request is in a terminal or incompatible lifecycle state.",
+    why: "Only draft/scoped/assigned/ready_for_session CRs can start scoped work.",
+    next: "Pick another change request or create a new one with start."
+  },
+  START_SESSION_OPEN_FAILED: {
+    code: "START_SESSION_OPEN_FAILED",
+    category: "START_ERROR",
+    title: "Session could not be opened.",
+    what: "A change request was prepared but no work session could be opened.",
+    why: "Watch and verify require a server-backed session linked to the CR.",
+    next: "Run `agentbridge watch --change-request <id>` or inspect `agentbridge session list`."
+  },
+  START_LOCAL_SESSION_WRITE_FAILED: {
+    code: "START_LOCAL_SESSION_WRITE_FAILED",
+    category: "START_ERROR",
+    title: "Local session write failed.",
+    what: "The server session opened but local session state could not be saved.",
+    why: "Watch and verify rely on .agentbridge/session state on disk.",
+    next: "Check repo permissions under .agentbridge/ and retry start."
+  },
+  VERIFY_COMMAND_REQUIRED: {
+    code: "VERIFY_COMMAND_REQUIRED",
+    category: "PROOF_ERROR",
+    title: "Verification command required.",
+    what: "Verify requires a shell command after `--`.",
+    why: "Proof must record the output of a concrete verification command.",
+    next: "Run `agentbridge verify -- npm test` (or your project command).",
+    blocksAcceptance: true
+  },
+  VERIFY_COMMAND_FAILED: {
+    code: "VERIFY_COMMAND_FAILED",
+    category: "PROOF_ERROR",
+    title: "Verification command failed.",
+    what: "The verification command exited with a non-zero status.",
+    why: "Failed proof blocks acceptance until tests or checks pass.",
+    next: "Fix the command failure, then rerun `agentbridge verify -- <command>`.",
+    blocksAcceptance: true
+  },
+  PROOF_MISSING: {
+    code: "PROOF_MISSING",
+    category: "PROOF_ERROR",
+    title: "Required proof missing.",
+    what: "Acceptance checks report missing verification evidence.",
+    why: "Acceptance requires recorded proof for this work session.",
+    next: "Run `agentbridge verify -- <command>` then `agentbridge check`.",
+    blocksAcceptance: true
+  },
+  PROOF_TOO_WEAK: {
+    code: "PROOF_TOO_WEAK",
+    category: "PROOF_ERROR",
+    title: "Proof too weak.",
+    what: "Verification ran, but proof strength is below what this change requires.",
+    why: "High-risk or source changes need stronger proof than file-existence checks.",
+    next: "Rerun with a stronger command from proof guidance (e.g. `agentbridge verify -- npm test`).",
+    blocksAcceptance: true
+  },
+  PROOF_NOT_RELEVANT: {
+    code: "PROOF_NOT_RELEVANT",
+    category: "PROOF_ERROR",
+    title: "Proof not relevant.",
+    what: "Recorded proof does not cover the files or impact of this change.",
+    why: "Proof must match the changed files \u2014 unrelated passing tests do not count.",
+    next: "Rerun verification scoped to the changed files listed in the acceptance report.",
+    blocksAcceptance: true
+  },
+  PROOF_IMPACT_COVERAGE_GAP: {
+    code: "PROOF_IMPACT_COVERAGE_GAP",
+    category: "PROOF_ERROR",
+    title: "Proof impact coverage gap.",
+    what: "Proof exists but does not cover required impact areas for this work type.",
+    why: "Some change profiles require broader verification than a single lightweight check.",
+    next: "Run the minimum commands listed under proof guidance in `agentbridge check`.",
+    blocksAcceptance: true
+  },
+  PROOF_EVIDENCE_NOT_RECORDED: {
+    code: "PROOF_EVIDENCE_NOT_RECORDED",
+    category: "PROOF_ERROR",
+    title: "Proof not recorded.",
+    what: "Verification could not be recorded on the server.",
+    why: "Without a verification run, acceptance cannot proceed.",
+    next: "Retry verify after confirming network access and session binding.",
+    blocksAcceptance: true
+  },
+  SESSION_ID_REQUIRED: {
+    code: "SESSION_ID_REQUIRED",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Session id required.",
+    what: "Session inspect requires a work session id argument.",
+    why: "The command must know which server session to load.",
+    next: "Run `agentbridge session inspect <work-session-id>`."
+  },
+  SESSION_ABANDON_REASON_REQUIRED: {
+    code: "SESSION_ABANDON_REASON_REQUIRED",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Abandon reason too short.",
+    what: "Session abandon requires --reason with at least 8 characters.",
+    why: "Abandon is audited and must explain why the session stopped.",
+    next: 'Run `agentbridge session abandon --reason "<why stopping>"`.'
+  },
+  SESSION_NO_TARGET: {
+    code: "SESSION_NO_TARGET",
+    category: "WORK_CONTEXT_ERROR",
+    title: "No session to abandon.",
+    what: "No --session id was passed and no local session is linked.",
+    why: "Abandon must target a specific work session.",
+    next: "Pass --session <id> or link a session via `agentbridge watch`."
+  },
+  WORK_CONTEXT_SESSION_ALREADY_TERMINAL: {
+    code: "WORK_CONTEXT_SESSION_ALREADY_TERMINAL",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Session already closed.",
+    what: "The linked work session is closed or terminal.",
+    why: "Proof and acceptance cannot attach to a finished session.",
+    next: 'Run `agentbridge session abandon --reason "session closed"` and start fresh.',
+    blocksAcceptance: true
+  },
+  ACCEPTANCE_ALREADY_CLOSED: {
+    code: "ACCEPTANCE_ALREADY_CLOSED",
+    category: "ACCEPTANCE_ERROR",
+    title: "Work already closed.",
+    what: "This change request or session is already in a terminal acceptance state.",
+    why: "Accept and verify cannot mutate closed work.",
+    next: "Run `agentbridge watch --allow-dirty` to review new coding work.",
+    blocksAcceptance: true
+  },
+  WORK_CONTEXT_SESSION_CR_MISMATCH: {
+    code: "WORK_CONTEXT_SESSION_CR_MISMATCH",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Session change-request mismatch.",
+    what: "Local session points at a different change request than requested.",
+    why: "Proof or acceptance could attach to the wrong work.",
+    next: "Fix activeChangeRequestId or abandon the stale local session.",
+    blocksAcceptance: true
+  },
+  WORK_CONTEXT_STALE_LOCAL_SESSION: {
+    code: "WORK_CONTEXT_STALE_LOCAL_SESSION",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Stale local session.",
+    what: "Local session id no longer exists on the server.",
+    why: "Watch and verify would track orphaned state.",
+    next: "Local session state has been cleared. Run `agentbridge watch --allow-dirty` to review current work.",
+    blocksAcceptance: true
+  },
+  WORK_CONTEXT_SCOPE_MISMATCH: {
+    code: "WORK_CONTEXT_SCOPE_MISMATCH",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Session scope or task mismatch.",
+    what: "The active session was started with a different task or scope than requested.",
+    why: "Resuming the wrong session would silently corrupt proof and scope boundaries.",
+    next: 'Finish or abandon the current session (`agentbridge session abandon --reason "..."`) then rerun `agentbridge watch --task "<task>" --scope "<path>"`.',
+    blocksAcceptance: true
+  },
+  WORK_CONTEXT_AMBIGUOUS_SESSIONS: {
+    code: "WORK_CONTEXT_AMBIGUOUS_SESSIONS",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Ambiguous active sessions.",
+    what: "Multiple active sessions match this change request.",
+    why: "The CLI cannot pick a single current session safely.",
+    next: 'Run `agentbridge session abandon --session <id> --reason "duplicate"`.',
+    blocksAcceptance: true
+  },
+  WORK_CONTEXT_OTHER_ACTIVE_SESSIONS: {
+    code: "WORK_CONTEXT_OTHER_ACTIVE_SESSIONS",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Other active sessions exist.",
+    what: "No current session is bound, but other active sessions exist on the server.",
+    why: "Verify and accept must not attach to the wrong session silently.",
+    next: "Run `agentbridge session list --active` to identify the correct session, then `agentbridge watch --change-request <cr-id>` to bind it explicitly.",
+    blocksAcceptance: true
+  },
+  SESSION_SERVER_MISSING: {
+    code: "SESSION_SERVER_MISSING",
+    category: "WORK_CONTEXT_ERROR",
+    title: "Session not found on server.",
+    what: "The requested work session id does not exist in this project.",
+    why: "Inspect and abandon require a valid server session.",
+    next: "Run `agentbridge session list` and pick a current id."
+  }
+};
+
+// src/intent-validation.ts
+var 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));
+}
+
 // ../mcp/config.ts
 function required2(name) {
   const v = process.env[name];
@@ -21536,9 +22507,23 @@ function required2(name) {
 function loadMcpConfig() {
   const raw = process.env.AGENTBRIDGE_BASE_URL ?? process.env.PUBLIC_BASE_URL ?? "http://127.0.0.1:3000";
   const baseUrl = raw.replace(/\/+$/, "");
+  const projectId = process.env.AGENTBRIDGE_PROJECT_ID?.trim() || void 0;
+  const localOnly = !projectId;
+  if (localOnly) {
+    return {
+      baseUrl,
+      apiKey: process.env.AGENTBRIDGE_API_KEY?.trim() || "",
+      projectId: void 0,
+      agentId: process.env.AGENTBRIDGE_AGENT_ID?.trim() || void 0,
+      localOnly: true
+    };
+  }
   return {
     baseUrl,
-    apiKey: required2("AGENTBRIDGE_API_KEY")
+    apiKey: required2("AGENTBRIDGE_API_KEY"),
+    projectId,
+    agentId: process.env.AGENTBRIDGE_AGENT_ID?.trim() || void 0,
+    localOnly: false
   };
 }
 
@@ -21599,6 +22584,84 @@ function toolJson(data) {
     ]
   };
 }
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function needsRulesAutoInstall(hello) {
+  return isRecord2(hello) && hello.rules_status === "not_installed";
+}
+function formatUnknownError(err) {
+  if (err instanceof Error) return err.message;
+  return String(err);
+}
+async function autoInstallRulesForProject(cfg, projectId) {
+  const installPath = `/v1/dev/projects/${encodeURIComponent(projectId)}/rules`;
+  const installRes = await bridgeJson(cfg, "GET", installPath);
+  if (!installRes.ok) {
+    return {
+      status: "failed",
+      step: "install_agentbridge_rules",
+      error: formatHttpFailure(installPath, installRes.status, installRes.text, installRes.json)
+    };
+  }
+  if (!isRecord2(installRes.json) || !Array.isArray(installRes.json.files)) {
+    return {
+      status: "failed",
+      step: "install_agentbridge_rules",
+      error: "Rules payload is missing a valid files[] list."
+    };
+  }
+  const repoRoot = process.env.AGENTBRIDGE_REPO_ROOT?.trim() || process.cwd();
+  const writtenFiles = [];
+  try {
+    for (const file of installRes.json.files) {
+      if (!isRecord2(file) || typeof file.path !== "string" || typeof file.content !== "string") {
+        throw new Error("Invalid rules file entry in server response.");
+      }
+      const absolutePath = (0, import_node_path2.resolve)(repoRoot, file.path);
+      (0, import_node_fs3.mkdirSync)((0, import_node_path2.dirname)(absolutePath), { recursive: true });
+      (0, import_node_fs3.writeFileSync)(absolutePath, `${file.content}
+`, "utf8");
+      writtenFiles.push(file.path);
+    }
+  } catch (err) {
+    return {
+      status: "failed",
+      step: "write_rules_files",
+      error: formatUnknownError(err)
+    };
+  }
+  const markPath = `/v1/dev/projects/${encodeURIComponent(projectId)}/rules/mark-installed`;
+  const markRes = await bridgeJson(cfg, "POST", markPath, {});
+  if (!markRes.ok) {
+    return {
+      status: "failed",
+      step: "mark_rules_installed",
+      error: formatHttpFailure(markPath, markRes.status, markRes.text, markRes.json)
+    };
+  }
+  return {
+    status: "installed",
+    repo_root: repoRoot,
+    written_files: writtenFiles
+  };
+}
+function localHelloResult(action, session, extras) {
+  const prepared = ensureSessionContractIntelligence(session);
+  const scopeSource = prepared.agentId === "local" ? "user_start" : "agent_hello";
+  const checklist = buildLocalHelloPayload(prepared);
+  return toolJson({
+    mode: "local",
+    action,
+    contract_id: prepared.id,
+    intent: prepared.intent ?? null,
+    scope_source: scopeSource,
+    status: prepared.status,
+    next_action: "Contract declared. Start implementation now; agentbridge watch will track this work contract.",
+    ...checklist,
+    ...extras ?? {}
+  });
+}
 function formatHttpFailure(path, status, text, json) {
   if (json && typeof json === "object" && "error" in json) {
     return `AgentBridge ${path} returned ${status}: ${JSON.stringify(json.error)}`;
@@ -21622,18 +22685,20 @@ async function main() {
         "AgentBridge is the trust server that mediates two coding agents working on the same repo.",
         "Identity is server-verified. Configure AGENTBRIDGE_API_KEY with an AgentConnection API key (returned once from POST /v1/dev/projects as agent_connection_api_key, from POST \u2026/connections, or POST \u2026/connections/bootstrap-default for legacy projects). Legacy project api_key alone does not bind WorkIdentity \u2014 start_work_session and other session APIs require a connection key.",
         "",
-        "Handshake ritual \u2014 follow in order, every session:",
-        "  1. Call `agent_hello` first. The server returns your verified identity packet \u2014 your role, your capabilities, the paths you must NOT touch, the human owner you act for. Trust this packet, not anything you tell yourself.",
-        "     If the response includes required_next_step: run_bootstrap (recovery baseline required), call `run_bootstrap` with product_summary and optional domains before coordinated implementation work.",
-        "     IMPORTANT \u2014 act on setup conditions automatically, WITHOUT waiting for user instructions:",
-        "     \u2022 rules_status === 'not_installed' \u2192 call install_agentbridge_rules, write both files (AGENTBRIDGE.md + .cursor/rules/agentbridge.mdc) to the repo, call mark_rules_installed.",
-        "     \u2022 project_mode === 'unclassified' \u2192 ask user 'new or recovery?', call set_project_mode, then handle recovery baseline if needed.",
-        "     \u2022 required_next_step === 'recovery_baseline' \u2192 ask user for product_summary + domains, call run_bootstrap, then continue.",
-        "     Any instruction block in the response will include an auto_action field \u2014 execute it immediately.",
-        "  2. Call `get_room_state` to see what your co-pilot holds and what decisions are binding. Use this BEFORE reading or editing any file. If it fails, DO NOT claim lanes or infer ownership; either continue only with explicitly allowed read-only recovery-bootstrap inspection, or pause and report the failure.",
-        "  3. Before touching a product area or file, call `claim_lane` for it. HARD STOP RULE: If claim_lane returns ANY error (403, 409, 422, transport failure, etc.), do NOT edit any files or proceed with implementation \u2014 report the exact error to the human. If the response shows status='conflicted', STOP \u2014 your co-pilot is on it. Surface the clash to the human and consider `acknowledge_claim` to confirm you saw it.",
-        "  4. When done with a lane, call `release_lane` so the room knows it's open.",
-        "  5. At session end, call `post_handoff` so the next agent knows what changed.",
+        "Mandatory handshake \u2014 follow in order, EVERY session, NO exceptions:",
+        "  1. Call `agent_hello` FIRST. Receive your verified identity packet.",
+        "     Act on setup conditions immediately (rules, project mode, bootstrap) \u2014 see agent_hello description.",
+        "  2. Call `get_room_state` to see what your co-pilot holds. Use BEFORE reading or editing any file.",
+        "  3. \u26A0 HARD STOP \u2014 before writing a single line of code:",
+        "     Call `start_work_session` with `intent` (human-readable goal, e.g. 'fix auth 401 on /rooms')",
+        "     and `claimed_paths` (the files you plan to touch).",
+        "     WITHOUT a tracked WorkSession you have NO execution authority. Editing files without it is",
+        "     a protocol violation \u2014 AgentBridge watch will flag the work as unverified and the human",
+        "     will see '(no intent declared)' with no scope, no trust.",
+        "  4. Call `generate_authority_packet` to receive your full execution surface.",
+        "  5. Call `claim_lane` for every file/area before touching it.",
+        "  6. Call `release_lane` when done with each lane.",
+        "  7. Call `post_handoff` at session end.",
         "",
         "Use `get_live_wire` any time to read the project's chronological event log.",
         "Use `request_context` to ask your co-pilot a question. Use `reserve_file` to request an approval-gated lock.",
@@ -21654,9 +22719,11 @@ async function main() {
   server.registerTool(
     "agent_hello",
     {
-      description: "Identify yourself to the trust server and receive your verified identity packet.\n\nOPERATING LOOP (Phase 5.5 \u2014 read this carefully):\n  1. Call agent_hello FIRST every session.\n  2. Inspect the response's `active_sessions` array:\n       \u2022 0 sessions  \u2192 there is no active tracked job (internal WorkSession) for this connection. Stop and ask the human to start a job before issuing any controlled call.\n       \u2022 1 session   \u2192 that is your active tracked job. Use its work_session_id for everything below.\n       \u2022 2+ sessions \u2192 DO NOT GUESS. The response sets selected_session_required=true. Ask the human which session to use, or call select_work_session to confirm.\n  3. Call generate_authority_packet(project_id, work_session_id) to receive the full tracked-job authority packet (WorkIdentity, ExecutionSurface, allowed/blocked domains, scope_snapshot, out_of_scope_snapshot, risk_level).\n  4. Pass work_session_id on EVERY controlled call: claim_lane, release_lane, post_handoff, close_work_session, check_close_readiness.\n  5. Respect `session_required_for_implementation=true` (a tracked job is required before this agent can edit files). If `active_sessions` is empty, do not perform implementation edits.\n\nAUTHORITY MODEL:\n  \u2022 Cursor / Claude Code / etc. are ExecutionSurfaces. They are NOT the agent identity.\n  \u2022 The accountable identity is the WorkIdentity (e.g. 'Auth Agent').\n  \u2022 A WorkIdentity is granted only by an active tracked job (WorkSession record) bound to your AgentConnection.\n  \u2022 You cannot self-declare authority. The server resolves your role from that WorkSession.\n\nIdentity packet shapes:\n  \u2022 NEW (AgentConnection key): `work_identity` packet with WorkIdentity, ExecutionSurface, domain, capabilities, blocked_domains.\n  \u2022 LEGACY (Agent API key): `verified` packet with role, capabilities, blocked_paths.\n\nRECOVERY MODE \u2014 when you're working on an existing unstructured codebase:\n  \u2022 If the project's `project_mode` is 'recovery' and `recoveryStatus` is 'active' or 'stabilising',\n    the response includes a `recovery_brief` block.\n  \u2022 If you are NEW to this project (no prior completed sessions), `recovery_brief` includes:\n      - `product_summary`: what the codebase does\n      - `known_domains`: list of domain names with trap counts\n      - `known_traps`: flat list of ALL traps across domains \u2014 READ BEFORE TOUCHING ANYTHING\n      - `recommended_first_action`: what to do first\n      - `warning`: 'This is a recovery project. Treat all domain boundaries as fragile.'\n  \u2022 If you have prior sessions, `recovery_brief` is abbreviated with `recommended_first_action: 'continue_with_memory'`.\n  \u2022 If `recoveryStatus === 'archived'`, the response signals `recovery_archived: true` \u2014 treat as a normal V1 project.\n  \u2022 If `required_next_step` is `run_bootstrap` (or `recovery_status` is `baseline_required`), call `run_bootstrap` with `product_summary` and optional `domains` \u2014 same payload as POST /v1/dev/projects/:id/bootstrap.\n\nAUTOMATIC SETUP \u2014 do not wait for user instructions when any of these apply:\n  \u2022 `rules_status === 'not_installed'` \u2192 call install_agentbridge_rules, write AGENTBRIDGE.md and .cursor/rules/agentbridge.mdc to the repo, call mark_rules_installed.\n  \u2022 `project_mode === 'unclassified'` or `required_next_step === 'classify_project_mode'` \u2192 ask user new/recovery, call set_project_mode.\n  \u2022 `required_next_step === 'recovery_baseline'` \u2192 ask user for summary + domains, call run_bootstrap.\n  When setup is required, the instruction block includes an `auto_action` string \u2014 execute it immediately.\n\nSTARTUP FLOW \u2014 call in order on every new chat:\n  1. agent_hello            \u2192 receive identity + check for setup conditions\n  2. get_project_packet     \u2192 receive compact project context (product summary, domain counts, charter, risks)\n  3. resolve_work_context   \u2192 structured next step from durable state (sessions, approvals, CRs, paths, LIP); NL classifier is last resort only\n  4. get_domain_packet      \u2192 load detailed domain context for the resolved domain(s) (traps, risks, owned paths)\n  5. get_last_implementation_packet \u2192 durable post-close implementation memory (what changed, files, risks, learned_after)\n  6. inspect repo files targeted to those domains / the packet\n  7. start_work_session + generate_authority_packet ONLY before editing files\n\nagent_hello does NOT return full product memory \u2014 call get_project_packet for startup context.\nPrefer resolve_work_context before classify_task_domain when the user's intent is vague or continuation-style.\nFor regressions after recent work, do not begin by summarising chat history. Load the Last Implementation Packet first (get_last_implementation_packet).",
+      description: "Call agent_hello at the start of every session.\n\nLOCAL MODE (no AGENTBRIDGE_PROJECT_ID configured):\n  - If a contract already exists: returns it. No arguments needed.\n  - If no contract exists: pass intent with what you are about to do.\n    agent_hello({ intent: \"Fix auth 401 on /rooms endpoint\" })\n  - agentbridge watch in the terminal tracks the contract and prints a verdict.\n  - Do not call start_work_session, claim_lane, or generate_authority_packet in local mode.\n\nSERVER MODE (AGENTBRIDGE_PROJECT_ID configured):\nIdentify yourself to the trust server and receive your verified identity packet.\n\nOPERATING LOOP (Phase 5.5 \u2014 read this carefully):\n  1. Call agent_hello FIRST every session.\n  2. Inspect the response's `active_sessions` array:\n       \u2022 0 sessions  \u2192 \u26A0 HARD STOP. You have NO execution authority.\n         DO NOT read files, DO NOT write code, DO NOT run commands.\n         You MUST call `start_work_session` NOW with:\n           - `intent`: a human-readable description of what the user asked for\n             (e.g. 'fix the 401 auth error on /rooms', 'add dark mode toggle')\n           - `claimed_paths`: the files/directories you plan to touch\n         Without this, AgentBridge watch will report '(no intent declared)' and\n         flag all your changes as UNVERIFIED. The human loses all trust visibility.\n       \u2022 1 session   \u2192 that is your active tracked job. Use its work_session_id for everything below.\n       \u2022 2+ sessions \u2192 DO NOT GUESS. The response sets selected_session_required=true. Ask the human which session to use, or call select_work_session to confirm.\n  3. Call generate_authority_packet(project_id, work_session_id) to receive the full tracked-job authority packet (WorkIdentity, ExecutionSurface, allowed/blocked domains, scope_snapshot, out_of_scope_snapshot, risk_level).\n  4. Pass work_session_id on EVERY controlled call: claim_lane, release_lane, post_handoff, close_work_session, check_close_readiness.\n  5. Respect `session_required_for_implementation=true` (a tracked job is required before this agent can edit files). If `active_sessions` is empty, do not perform implementation edits.\n\nAUTHORITY MODEL:\n  \u2022 Cursor / Claude Code / etc. are ExecutionSurfaces. They are NOT the agent identity.\n  \u2022 The accountable identity is the WorkIdentity (e.g. 'Auth Agent').\n  \u2022 A WorkIdentity is granted only by an active tracked job (WorkSession record) bound to your AgentConnection.\n  \u2022 You cannot self-declare authority. The server resolves your role from that WorkSession.\n\nIdentity packet shapes:\n  \u2022 NEW (AgentConnection key): `work_identity` packet with WorkIdentity, ExecutionSurface, domain, capabilities, blocked_domains.\n  \u2022 LEGACY (Agent API key): `verified` packet with role, capabilities, blocked_paths.\n\nRECOVERY MODE \u2014 when you're working on an existing unstructured codebase:\n  \u2022 If the project's `project_mode` is 'recovery' and `recoveryStatus` is 'active' or 'stabilising',\n    the response includes a `recovery_brief` block.\n  \u2022 If you are NEW to this project (no prior completed sessions), `recovery_brief` includes:\n      - `product_summary`: what the codebase does\n      - `known_domains`: list of domain names with trap counts\n      - `known_traps`: flat list of ALL traps across domains \u2014 READ BEFORE TOUCHING ANYTHING\n      - `recommended_first_action`: what to do first\n      - `warning`: 'This is a recovery project. Treat all domain boundaries as fragile.'\n  \u2022 If you have prior sessions, `recovery_brief` is abbreviated with `recommended_first_action: 'continue_with_memory'`.\n  \u2022 If `recoveryStatus === 'archived'`, the response signals `recovery_archived: true` \u2014 treat as a normal V1 project.\n  \u2022 If `required_next_step` is `run_bootstrap` (or `recovery_status` is `baseline_required`), call `run_bootstrap` with `product_summary` and optional `domains` \u2014 same payload as POST /v1/dev/projects/:id/bootstrap.\n\nAUTOMATIC SETUP \u2014 do not wait for user instructions when any of these apply:\n  \u2022 `rules_status === 'not_installed'` \u2192 call install_agentbridge_rules, write AGENTBRIDGE.md and .cursor/rules/agentbridge.mdc to the repo, call mark_rules_installed.\n  \u2022 `project_mode === 'unclassified'` or `required_next_step === 'classify_project_mode'` \u2192 ask user new/recovery, call set_project_mode.\n  \u2022 `required_next_step === 'recovery_baseline'` \u2192 ask user for summary + domains, call run_bootstrap.\n  When setup is required, the instruction block includes an `auto_action` string \u2014 execute it immediately.\n\nSTARTUP FLOW \u2014 call in order on every new chat:\n  1. agent_hello            \u2192 receive identity + check for setup conditions\n  2. get_project_packet     \u2192 receive compact project context (product summary, domain counts, charter, risks)\n  3. resolve_work_context   \u2192 structured next step from durable state (sessions, approvals, CRs, paths, LIP); NL classifier is last resort only\n  4. get_domain_packet      \u2192 load detailed domain context for the resolved domain(s)\n  5. get_last_implementation_packet \u2192 durable post-close implementation memory\n  6. \u26A0 start_work_session  \u2192 REQUIRED before ANY file edit. Declare intent + claimed_paths.\n                              This is NOT optional. Without it, agentbridge watch cannot verify\n                              your work and will report all changes as UNVERIFIED SCOPE UNKNOWN.\n                              intent   = the user's goal in plain English (copy it verbatim if possible)\n                              claimed_paths = the files/dirs you plan to modify\n  7. generate_authority_packet \u2192 receive full execution authority\n  8. inspect + implement\n\nagent_hello does NOT return full product memory \u2014 call get_project_packet for startup context.\nPrefer resolve_work_context before classify_task_domain when the user's intent is vague or continuation-style.\nFor regressions after recent work, do not begin by summarising chat history. Load the Last Implementation Packet first (get_last_implementation_packet).",
       inputSchema: {
-        project_id: external_exports.string().min(1).describe("Project / handshake id (hnd_\u2026)"),
+        project_id: external_exports.string().min(1).optional().describe(
+          "Project / handshake id (hnd_\u2026). Optional when AGENTBRIDGE_PROJECT_ID env var is set \u2014 the server uses it automatically."
+        ),
         tool_type: external_exports.enum([
           "cursor",
           "claude_code",
@@ -21678,11 +22745,68 @@ async function main() {
         ),
         work_session_id: external_exports.string().optional().describe(
           "Phase 5: if you have an active tracked job (ws_\u2026), pass it here. The response will include an active_session block with brief_summary and next_action hint. Follow up with generate_authority_packet to receive the full authority packet."
+        ),
+        intent: external_exports.string().max(500).optional().describe(
+          "LOCAL MODE: declare the work contract before editing files (e.g. 'Fix auth 401 on /rooms endpoint'). Required when no active contract exists."
         )
       }
     },
     async (args) => {
-      const path = `/v1/dev/projects/${encodeURIComponent(args.project_id)}/hello`;
+      if (cfg.localOnly) {
+        const existing = readSessionState();
+        const declaredIntent = args.intent?.trim() || args.note?.trim();
+        if (isActiveLocalSession(existing)) {
+          if (existing.agentId === "local") {
+            return localHelloResult("reuse", existing, {
+              scope_locked: true
+            });
+          }
+          const currentIntent = existing.intent?.trim();
+          if (!declaredIntent || declaredIntent === currentIntent) {
+            return localHelloResult("reuse", existing);
+          }
+          const canReplace = existing.changedFiles.length === 0 && existing.crossings.length === 0 && existing.approvals.length === 0;
+          if (!canReplace) {
+            return toolError(
+              `A different AgentBridge contract is already active.
+
+Current contract: ${currentIntent ?? "(unknown intent)"}
+Close the current contract in watch, then call agent_hello again with your new intent.`
+            );
+          }
+          clearSessionState();
+          const replaced = openLocalSession({
+            agentId: "mcp",
+            laneDomain: null,
+            intent: declaredIntent,
+            domains: [],
+            mode: "local_supervision"
+          });
+          return localHelloResult("replaced", replaced, {
+            replaced_contract_id: existing.id
+          });
+        }
+        if (!declaredIntent || isVagueIntent(declaredIntent)) {
+          return toolError(
+            'No active AgentBridge contract.\n\nAgent must declare a concrete scope before editing files:\n  agent_hello({ intent: "Fix auth 401 on /rooms endpoint" })\n\nOr run in a terminal: agentbridge start "Fix auth 401 on /rooms endpoint"'
+          );
+        }
+        const session = openLocalSession({
+          agentId: "mcp",
+          laneDomain: null,
+          intent: declaredIntent,
+          domains: [],
+          mode: "local_supervision"
+        });
+        return localHelloResult("created", session);
+      }
+      const resolvedProjectId = args.project_id ?? cfg.projectId;
+      if (!resolvedProjectId) {
+        return toolError(
+          "project_id is required. Pass it as an argument or set AGENTBRIDGE_PROJECT_ID in the MCP server environment."
+        );
+      }
+      const path = `/v1/dev/projects/${encodeURIComponent(resolvedProjectId)}/hello`;
       const body = {};
       if (args.tool_type !== void 0) body.tool_type = args.tool_type;
       if (args.capabilities_advert !== void 0)
@@ -21692,7 +22816,20 @@ async function main() {
       const res = await bridgeJson(cfg, "POST", path, body);
       if (!res.ok)
         return toolError(formatHttpFailure(path, res.status, res.text, res.json));
-      return toolJson(res.json);
+      if (!needsRulesAutoInstall(res.json)) {
+        return toolJson(res.json);
+      }
+      const autoRulesInstall = await autoInstallRulesForProject(cfg, resolvedProjectId);
+      if (isRecord2(res.json)) {
+        return toolJson({
+          ...res.json,
+          auto_rules_install: autoRulesInstall
+        });
+      }
+      return toolJson({
+        hello: res.json,
+        auto_rules_install: autoRulesInstall
+      });
     }
   );
   server.registerTool(