@agentbridge1/cli 0.0.1

package/dist/watch-packet-handshake.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderHandshakeRefusalBlock = renderHandshakeRefusalBlock;
+exports.applyHandshakeRefusal = applyHandshakeRefusal;
+exports.renderProjectPacketBanner = renderProjectPacketBanner;
+exports.renderProjectPacketOneLiner = renderProjectPacketOneLiner;
+exports.renderDomainPacketBanner = renderDomainPacketBanner;
+function renderHandshakeRefusalBlock(file, crossingDomain) {
+    const domainLabel = crossingDomain ?? "unknown";
+    return [
+        `✋ Edit refused: "${file}" is in domain "${domainLabel}" which requires a cross-domain`,
+        "   work permit (AgentHandshake) before you can claim it.",
+        "",
+        "   Create the permit, then re-edit:",
+        "     agentbridge handshake create \\",
+        `       --domain "${domainLabel}" \\`,
+        '       --action "<≥20 char description of what you intend to change>" \\',
+        '       --reason "<≥20 char rationale>"',
+        "",
+        "   Watch will surface the file change again on your next save once the handshake",
+        "   is requested. Acceptance will remain blocked until the handshake is resolved",
+        "   (status: resolved by target, or acknowledged with explicit close approval).",
+    ].join("\n");
+}
+function applyHandshakeRefusal(state, file, outcome, revertFile) {
+    const crossing = state.crossings.find((c) => c.file === file);
+    if (crossing) {
+        crossing.status = "pending_handshake";
+        if (outcome.crossingDomain) {
+            crossing.domain = outcome.crossingDomain;
+        }
+    }
+    state.changedFiles = state.changedFiles.filter((changed) => changed !== file);
+    revertFile(file);
+}
+function renderProjectPacketBanner(packet, cfgDomains = []) {
+    const tierByDomain = new Map(cfgDomains.map((d) => [d.domain, d.tier]));
+    const ownerByDomain = new Map(cfgDomains.map((d) => [d.domain, d.ownerAgentId]));
+    const mode = packet.project_mode ?? "unknown";
+    const charter = packet.charter_summary?.purpose?.slice(0, 80) ?? "none";
+    const lines = [
+        `Project packet (recovery_mode: ${mode}, charter: ${charter}):`,
+        `  Domains (${packet.domains_summary.length}):`,
+    ];
+    for (const domain of packet.domains_summary.slice(0, 8)) {
+        const tier = tierByDomain.get(domain.domain_name) ?? "unknown";
+        const owner = ownerByDomain.get(domain.domain_name) ?? domain.label ?? "unknown";
+        const freshness = domain.freshness?.staleness ?? "unknown";
+        lines.push(`    - ${domain.domain_name}: tier=${tier}, owner=${owner}, freshness=${freshness}`);
+    }
+    const invariants = packet.global_rules?.length ?? 0;
+    const risks = packet.global_open_risks?.length ?? 0;
+    lines.push(`  Known invariants: ${invariants}; Open risks: ${risks}`);
+    return lines.join("\n");
+}
+function renderProjectPacketOneLiner(packet) {
+    return `Project packet: ${packet.domains_summary.length} domains, mode=${packet.project_mode ?? "unknown"}`;
+}
+function renderDomainPacketBanner(entry) {
+    const lines = [
+        `Domain packet (${entry.domain_name}):`,
+        `  Known traps: ${entry.known_traps.length}; Owned paths: ${entry.owned_paths.length}`,
+    ];
+    for (const trap of entry.known_traps.slice(0, 3)) {
+        lines.push(`    - trap: ${trap}`);
+    }
+    for (const risk of entry.open_risks.slice(0, 3)) {
+        lines.push(`    - risk: ${risk}`);
+    }
+    return lines.join("\n");
+}

package/dist/watcher.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shouldIgnorePath = shouldIgnorePath;
+exports.startWatcher = startWatcher;
+const chokidar_1 = __importDefault(require("chokidar"));
+const IGNORED_SEGMENTS = [
+    "/.git/",
+    "/node_modules/",
+    "/.agentbridge/",
+    "/.agents/",
+    "/.cursor/",
+    "/dist/",
+    "/build/",
+    "/.next/",
+    "/coverage/",
+    "/.turbo/",
+    "/.cache/",
+    "/DerivedData/",
+    "/logs/",
+    "/tmp/",
+    "/temp/",
+    "/.tmp/",
+];
+function shouldIgnorePath(targetPath) {
+    const normalized = targetPath.replace(/\\/g, "/");
+    if (normalized.startsWith(".") && !normalized.startsWith("./src/")) {
+        return true;
+    }
+    return IGNORED_SEGMENTS.some((segment) => normalized.includes(segment));
+}
+function startWatcher(root, onChange) {
+    const watcher = chokidar_1.default.watch(root, {
+        ignoreInitial: true,
+        ignored: [
+            "**/.git/**",
+            "**/node_modules/**",
+            "**/.agentbridge/**",
+            "**/.agents/**",
+            "**/.cursor/**",
+            "**/dist/**",
+            "**/build/**",
+            "**/.next/**",
+            "**/coverage/**",
+            "**/.turbo/**",
+            "**/.cache/**",
+            "**/DerivedData/**",
+            "**/logs/**",
+            "**/tmp/**",
+            "**/temp/**",
+            (targetPath) => shouldIgnorePath(String(targetPath)),
+        ],
+    });
+    watcher.on("add", (path) => onChange(path));
+    watcher.on("change", (path) => onChange(path));
+    watcher.on("unlink", (path) => onChange(path));
+    return () => {
+        void watcher.close();
+    };
+}

package/dist/work-context-resolver.js

@@ -0,0 +1,412 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NON_TERMINAL_SESSION_STATUSES = void 0;
+exports.resolveEffectiveChangeRequestId = resolveEffectiveChangeRequestId;
+exports.isNonTerminalSessionStatus = isNonTerminalSessionStatus;
+exports.resolveWorkContext = resolveWorkContext;
+exports.requireWorkContextBinding = requireWorkContextBinding;
+exports.renderWorkContextGuidance = renderWorkContextGuidance;
+exports.renderWorkContextLines = renderWorkContextLines;
+exports.findSingleActiveSessionForChangeRequest = findSingleActiveSessionForChangeRequest;
+const config_1 = require("./config");
+const errors_1 = require("./errors");
+const error_catalog_1 = require("./error-catalog");
+const http_1 = require("./http");
+const session_state_1 = require("./session-state");
+const server_sync_1 = require("./server-sync");
+/** Non-terminal work-session statuses (matches server acceptance-check resolver). */
+exports.NON_TERMINAL_SESSION_STATUSES = new Set([
+    "active",
+    "blocked",
+    "pending_boundary_approval",
+    "blocked_closed",
+]);
+function resolveEffectiveChangeRequestContext(override, useConfigActiveChangeRequestId = true) {
+    const fromOverride = override?.trim();
+    if (fromOverride)
+        return { changeRequestId: fromOverride, source: "explicit CR" };
+    const fromEnv = process.env.AGENTBRIDGE_CHANGE_REQUEST_ID?.trim();
+    if (fromEnv)
+        return { changeRequestId: fromEnv, source: "explicit CR" };
+    if (useConfigActiveChangeRequestId) {
+        const cfg = (0, config_1.readConfig)();
+        const fromConfig = cfg.activeChangeRequestId?.trim();
+        if (fromConfig)
+            return { changeRequestId: fromConfig, source: "activeChangeRequestId" };
+    }
+    return { changeRequestId: null, source: "none" };
+}
+function resolveEffectiveChangeRequestId(override, useConfigActiveChangeRequestId = true) {
+    return resolveEffectiveChangeRequestContext(override, useConfigActiveChangeRequestId)
+        .changeRequestId;
+}
+function isNonTerminalSessionStatus(status) {
+    return exports.NON_TERMINAL_SESSION_STATUSES.has(status);
+}
+function terminalMessage(status) {
+    if (status === "closed")
+        return "Work session is closed.";
+    if (status === "cancelled")
+        return "Work session was cancelled.";
+    return `Work session is not active (status: ${status}).`;
+}
+async function loadActiveSessions(ctx) {
+    const sessions = await (0, server_sync_1.listWorkSessions)(ctx, { status: "all" });
+    return sessions.filter((s) => isNonTerminalSessionStatus(s.status));
+}
+async function tryBindSession(ctx, sessionId, requestedCr, skipAcceptanceFetch = false) {
+    let report;
+    let sessionStatus;
+    let sessionCr;
+    try {
+        const session = await (0, server_sync_1.getWorkSession)(ctx, sessionId);
+        sessionStatus = session.status;
+        sessionCr = session.change_request_id?.trim() ?? null;
+        if (!skipAcceptanceFetch) {
+            report = await (0, server_sync_1.fetchAcceptanceCheck)(ctx, { workSessionId: sessionId });
+            sessionCr = report.change_request_id?.trim() ?? null;
+        }
+    }
+    catch (err) {
+        if (err instanceof http_1.CliHttpError && err.status === 404) {
+            return { ok: false, reason: "missing" };
+        }
+        throw err;
+    }
+    if (!isNonTerminalSessionStatus(sessionStatus)) {
+        return { ok: false, reason: "terminal", status: sessionStatus, report };
+    }
+    if (requestedCr && sessionCr && sessionCr !== requestedCr) {
+        return { ok: false, reason: "mismatch", report };
+    }
+    return {
+        ok: true,
+        binding: {
+            workSessionId: skipAcceptanceFetch ? sessionId : report.work_session_id,
+            changeRequestId: sessionCr,
+            ...(report ? { report } : {}),
+        },
+    };
+}
+function partitionByCr(active, requestedCr) {
+    if (!requestedCr) {
+        return { onRequestedCr: active, other: [] };
+    }
+    const onRequestedCr = active.filter((s) => (s.change_request_id?.trim() ?? null) === requestedCr);
+    const other = active.filter((s) => (s.change_request_id?.trim() ?? null) !== requestedCr);
+    return { onRequestedCr, other };
+}
+/**
+ * Strict work-context resolution. Never binds to an unrelated active session.
+ */
+async function resolveWorkContext(ctx, options = {}) {
+    const useConfigCr = options.useConfigActiveChangeRequestId !== false;
+    const skipAcceptanceFetch = options.skipAcceptanceFetchInBind === true;
+    const resolvedCrContext = resolveEffectiveChangeRequestContext(options.changeRequestId, useConfigCr);
+    const requestedCr = resolvedCrContext.changeRequestId;
+    const preferredId = options.preferredWorkSessionId?.trim() ?? null;
+    const local = (0, session_state_1.readSessionState)();
+    const localId = local?.serverSessionId?.trim() ?? null;
+    let usedServerCurrentForCr = false;
+    const withDiagnostics = (resolution) => ({
+        ...resolution,
+        diagnostics: {
+            localSessionId: localId,
+            resolvedSessionId: resolution.resolvedServerSessionId,
+            resolvedChangeRequestId: resolution.resolvedChangeRequestId,
+            usedConfigActiveChangeRequestId: resolvedCrContext.source === "activeChangeRequestId",
+            usedServerCurrentForCr,
+        },
+    });
+    if (preferredId) {
+        const attempt = await tryBindSession(ctx, preferredId, requestedCr, skipAcceptanceFetch);
+        if (attempt.ok) {
+            return withDiagnostics({
+                state: "current_session_resolved",
+                contextSource: "explicit session",
+                requestedChangeRequestId: requestedCr,
+                binding: attempt.binding,
+                ambiguousSessions: [],
+                otherActiveSessions: [],
+                localServerSessionId: localId,
+                resolvedServerSessionId: attempt.binding.workSessionId,
+                resolvedChangeRequestId: attempt.binding.changeRequestId,
+                message: `Bound to work session ${preferredId}.`,
+            });
+        }
+        if (attempt.reason === "missing") {
+            return withDiagnostics({
+                state: "stale_orphan_session_detected",
+                contextSource: "explicit session",
+                requestedChangeRequestId: requestedCr,
+                binding: null,
+                ambiguousSessions: [],
+                otherActiveSessions: [],
+                localServerSessionId: preferredId,
+                resolvedServerSessionId: null,
+                resolvedChangeRequestId: null,
+                message: `Work session ${preferredId} was not found on the server.`,
+            });
+        }
+        return withDiagnostics({
+            state: attempt.reason === "mismatch" ? "mismatch" : "current_session_closed",
+            contextSource: "explicit session",
+            requestedChangeRequestId: requestedCr,
+            binding: null,
+            ambiguousSessions: [],
+            otherActiveSessions: [],
+            localServerSessionId: preferredId,
+            resolvedServerSessionId: attempt.report?.work_session_id ?? preferredId,
+            resolvedChangeRequestId: attempt.report?.change_request_id?.trim() ?? null,
+            message: attempt.reason === "mismatch"
+                ? `Work session ${preferredId} does not match the requested change request.`
+                : terminalMessage(attempt.status ?? "closed"),
+        });
+    }
+    const contextSource = localId
+        ? "local session"
+        : resolvedCrContext.source;
+    if (localId) {
+        const attempt = await tryBindSession(ctx, localId, requestedCr, skipAcceptanceFetch);
+        if (attempt.ok) {
+            let otherActiveSessions = [];
+            if (options.includeOtherActiveSessions) {
+                const active = await loadActiveSessions(ctx);
+                otherActiveSessions = active.filter((s) => s.id !== attempt.binding.workSessionId);
+            }
+            return withDiagnostics({
+                state: "current_session_resolved",
+                contextSource,
+                requestedChangeRequestId: requestedCr,
+                binding: attempt.binding,
+                ambiguousSessions: [],
+                otherActiveSessions,
+                localServerSessionId: localId,
+                resolvedServerSessionId: attempt.binding.workSessionId,
+                resolvedChangeRequestId: attempt.binding.changeRequestId,
+                message: "Bound to local tracked work session.",
+            });
+        }
+        if (attempt.reason === "mismatch") {
+            const active = await loadActiveSessions(ctx);
+            const { other } = partitionByCr(active, requestedCr);
+            return withDiagnostics({
+                state: "mismatch",
+                contextSource,
+                requestedChangeRequestId: requestedCr,
+                binding: null,
+                ambiguousSessions: [],
+                otherActiveSessions: other,
+                localServerSessionId: localId,
+                resolvedServerSessionId: attempt.report?.work_session_id ?? localId,
+                resolvedChangeRequestId: attempt.report?.change_request_id?.trim() ?? null,
+                message: requestedCr
+                    ? `Local session ${localId} belongs to change request ${attempt.report?.change_request_id ?? "none"}, not ${requestedCr}.`
+                    : `Local session ${localId} does not match the requested change request context.`,
+            });
+        }
+        if (attempt.reason === "terminal") {
+            return withDiagnostics({
+                state: "current_session_closed",
+                contextSource,
+                requestedChangeRequestId: requestedCr,
+                binding: null,
+                ambiguousSessions: [],
+                otherActiveSessions: [],
+                localServerSessionId: localId,
+                resolvedServerSessionId: localId,
+                resolvedChangeRequestId: attempt.report?.change_request_id?.trim() ?? null,
+                message: terminalMessage(attempt.status ?? "closed"),
+            });
+        }
+        return withDiagnostics({
+            state: "stale_orphan_session_detected",
+            contextSource,
+            requestedChangeRequestId: requestedCr,
+            binding: null,
+            ambiguousSessions: [],
+            otherActiveSessions: [],
+            localServerSessionId: localId,
+            resolvedServerSessionId: null,
+            resolvedChangeRequestId: null,
+            message: `Local session ${localId} was not found on the server. Clear local state with agentbridge session abandon or start a new watch session.`,
+        });
+    }
+    const active = await loadActiveSessions(ctx);
+    const { onRequestedCr, other } = partitionByCr(active, requestedCr);
+    if (requestedCr && onRequestedCr.length > 1) {
+        return withDiagnostics({
+            state: "ambiguous_active_sessions",
+            contextSource,
+            requestedChangeRequestId: requestedCr,
+            binding: null,
+            ambiguousSessions: onRequestedCr,
+            otherActiveSessions: other,
+            localServerSessionId: null,
+            resolvedServerSessionId: null,
+            resolvedChangeRequestId: null,
+            message: `Multiple active work sessions match change request ${requestedCr}. Use agentbridge session list and session abandon to clean up.`,
+        });
+    }
+    if (requestedCr && onRequestedCr.length === 1 && options.allowServerCurrentForCr) {
+        const attempt = await tryBindSession(ctx, onRequestedCr[0].id, requestedCr, skipAcceptanceFetch);
+        if (attempt.ok) {
+            usedServerCurrentForCr = true;
+            return withDiagnostics({
+                state: "current_session_resolved",
+                contextSource,
+                requestedChangeRequestId: requestedCr,
+                binding: attempt.binding,
+                ambiguousSessions: [],
+                otherActiveSessions: other,
+                localServerSessionId: null,
+                resolvedServerSessionId: attempt.binding.workSessionId,
+                resolvedChangeRequestId: attempt.binding.changeRequestId,
+                message: "Bound to the single active server session for this change request.",
+            });
+        }
+    }
+    if (other.length > 0 ||
+        (requestedCr && onRequestedCr.length === 1) ||
+        (!requestedCr && onRequestedCr.length > 0)) {
+        const parts = [];
+        if (requestedCr && onRequestedCr.length === 1) {
+            parts.push(`An active server session exists for ${requestedCr} but is not linked locally.`);
+            parts.push("Run agentbridge watch with --change-request to bind, or use session inspect.");
+        }
+        else if (!requestedCr && onRequestedCr.length > 0) {
+            parts.push("Other active work sessions exist on the server but none are linked locally.");
+        }
+        else if (other.length > 0) {
+            parts.push("Other active work sessions exist on the server but none are linked locally.");
+        }
+        return withDiagnostics({
+            state: other.length > 0 || (!requestedCr && onRequestedCr.length > 0)
+                ? "other_active_sessions_exist"
+                : "no_current_session",
+            contextSource,
+            requestedChangeRequestId: requestedCr,
+            binding: null,
+            ambiguousSessions: [],
+            otherActiveSessions: requestedCr ? [...onRequestedCr, ...other] : onRequestedCr,
+            localServerSessionId: null,
+            resolvedServerSessionId: null,
+            resolvedChangeRequestId: null,
+            message: parts.join(" "),
+        });
+    }
+    return withDiagnostics({
+        state: "no_current_session",
+        contextSource,
+        requestedChangeRequestId: requestedCr,
+        binding: null,
+        ambiguousSessions: [],
+        otherActiveSessions: [],
+        localServerSessionId: null,
+        resolvedServerSessionId: null,
+        resolvedChangeRequestId: null,
+        message: requestedCr
+            ? `No active work session for change request ${requestedCr}.`
+            : "No active tracked work session. Run agentbridge watch to start work.",
+    });
+}
+function requireWorkContextBinding(resolution, commandLabel) {
+    if (resolution.state === "current_session_resolved" && resolution.binding) {
+        return resolution.binding;
+    }
+    const code = (0, error_catalog_1.workContextStateToCode)(resolution.state);
+    const entry = (0, error_catalog_1.catalogEntryForCode)(code);
+    const guidance = renderWorkContextGuidance(resolution);
+    const nextFromGuidance = guidance.find((line) => line.startsWith("Next action:"));
+    throw new errors_1.SafeCliError({
+        code,
+        category: entry?.category ?? "WORK_CONTEXT_ERROR",
+        what: `Cannot run ${commandLabel}: ${resolution.message}`,
+        why: entry?.why ?? "This command requires a linked local/server work session.",
+        next: nextFromGuidance?.replace(/^Next action:\s*/, "") ?? entry?.next ?? "Run `agentbridge watch`.",
+    });
+}
+function renderWorkContextGuidance(resolution) {
+    const lines = [];
+    if (resolution.requestedChangeRequestId) {
+        lines.push(`Requested change request: ${resolution.requestedChangeRequestId}`);
+    }
+    if (resolution.localServerSessionId) {
+        lines.push(`Local session id: ${resolution.localServerSessionId}`);
+    }
+    switch (resolution.state) {
+        case "mismatch":
+            lines.push("Next action: fix AGENTBRIDGE_CHANGE_REQUEST_ID / config activeChangeRequestId, or clear local session.");
+            lines.push("  agentbridge session abandon --reason \"wrong cr\"");
+            break;
+        case "ambiguous_active_sessions":
+            lines.push("Ambiguous active sessions for this change request:");
+            for (const s of resolution.ambiguousSessions) {
+                lines.push(`  - ${s.id} (${s.status})`);
+            }
+            lines.push("Next action: agentbridge session abandon --session <id> --reason \"duplicate\"");
+            break;
+        case "other_active_sessions_exist":
+        case "no_current_session":
+            if (resolution.otherActiveSessions.length > 0) {
+                lines.push("Other active server sessions:");
+                for (const s of resolution.otherActiveSessions) {
+                    const cr = s.change_request_id?.trim() ?? "no CR";
+                    lines.push(`  - ${s.id}  CR=${cr}  status=${s.status}`);
+                }
+            }
+            lines.push("Next action: agentbridge watch --change-request <cr>  (does not auto-adopt unrelated sessions)");
+            break;
+        case "stale_orphan_session_detected":
+            lines.push("Next action: agentbridge session abandon --reason \"stale local id\"");
+            break;
+        case "current_session_closed":
+            lines.push("Next action: agentbridge session abandon --reason \"session closed\"");
+            break;
+        default:
+            break;
+    }
+    return lines;
+}
+function renderWorkContextLines(resolution) {
+    const code = (0, error_catalog_1.workContextStateToCode)(resolution.state);
+    const entry = (0, error_catalog_1.catalogEntryForCode)(code);
+    const header = [];
+    if (entry) {
+        header.push(`✗ Error code: ${code}`);
+        header.push(`  What happened: ${entry.what}`);
+        header.push(`  Why it matters: ${entry.why}`);
+        header.push("");
+    }
+    if (resolution.state === "mismatch") {
+        return [
+            ...header,
+            "Intended:",
+            `CR: ${resolution.requestedChangeRequestId ?? "none"}`,
+            `Session: ${resolution.localServerSessionId ?? "none"}`,
+            "",
+            "Resolved active server session:",
+            `CR: ${resolution.resolvedChangeRequestId ?? "none"}`,
+            `Session: ${resolution.resolvedServerSessionId ?? "none"}`,
+            "",
+            "This command will not continue because it may attach proof or acceptance to the wrong work.",
+            ...renderWorkContextGuidance(resolution),
+        ];
+    }
+    return [
+        ...header,
+        resolution.message,
+        ...renderWorkContextGuidance(resolution),
+    ];
+}
+/** Watch/open: find exactly one active session for a CR (explicit resume). */
+async function findSingleActiveSessionForChangeRequest(ctx, changeRequestId) {
+    const cr = changeRequestId.trim();
+    const active = await loadActiveSessions(ctx);
+    const matches = active.filter((s) => (s.change_request_id?.trim() ?? null) === cr);
+    if (matches.length === 0)
+        return null;
+    if (matches.length > 1)
+        return { ambiguous: matches };
+    return { workSessionId: matches[0].id };
+}

package/dist/work-contract.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferWorkContract = inferWorkContract;
+exports.confirmWorkContract = confirmWorkContract;
+const promises_1 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+const config_1 = require("./config");
+const domain_resolution_1 = require("./domain-resolution");
+function humanizeBranchName(branchName) {
+    const cleaned = branchName
+        .trim()
+        .replace(/^refs\/heads\//, "")
+        .replace(/^feature\//, "")
+        .replace(/^fix\//, "")
+        .replace(/^chore\//, "")
+        .replace(/^bugfix\//, "")
+        .replace(/^hotfix\//, "")
+        .replace(/[._-]+/g, " ")
+        .trim();
+    if (!cleaned)
+        return "Continue current work";
+    return cleaned[0].toUpperCase() + cleaned.slice(1);
+}
+function commonPrefixPath(files) {
+    if (files.length === 0)
+        return null;
+    const parts = files.map((file) => file.replaceAll("\\", "/").split("/").filter(Boolean));
+    const first = parts[0] ?? [];
+    const common = [];
+    for (let i = 0; i < first.length; i += 1) {
+        const value = first[i];
+        if (!value)
+            break;
+        if (parts.every((entry) => entry[i] === value)) {
+            common.push(value);
+        }
+        else {
+            break;
+        }
+    }
+    if (common.length === 0)
+        return null;
+    return `${common.join("/")}/**`;
+}
+function inferScopeFromFiles(dirtyFiles) {
+    const normalized = dirtyFiles
+        .map((file) => file.trim().replaceAll("\\", "/"))
+        .filter((file) => file.length > 0 && !file.startsWith(".agentbridge/") && file !== ".agentbridge");
+    if (normalized.length === 0)
+        return "**";
+    const cfg = (0, config_1.readConfig)();
+    const lane = (0, domain_resolution_1.inferLaneFromFiles)(normalized, cfg.domains ?? []);
+    if (lane.laneDomain) {
+        const domain = (cfg.domains ?? []).find((item) => item.domain === lane.laneDomain);
+        if (domain && domain.pathPatterns.length > 0) {
+            return domain.pathPatterns[0];
+        }
+    }
+    return commonPrefixPath(normalized) ?? "**";
+}
+function inferWorkContract(input) {
+    const prompt = input.prompt?.trim();
+    const summary = prompt || humanizeBranchName(input.branchName) || "Continue current work";
+    const scope = inferScopeFromFiles(input.dirtyFiles);
+    return { summary, scope };
+}
+async function confirmWorkContract(draft, opts = {}) {
+    if (opts.nonInteractive) {
+        const confirmed = (process.env.AGENTBRIDGE_START_CONFIRM ?? "").trim().toLowerCase();
+        if (confirmed !== "yes")
+            return null;
+        return {
+            summary: (process.env.AGENTBRIDGE_START_SUMMARY ?? "").trim() || draft.summary,
+            scope: (process.env.AGENTBRIDGE_START_SCOPE ?? "").trim() || draft.scope,
+        };
+    }
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+    let current = { ...draft };
+    try {
+        while (true) {
+            node_process_1.stdout.write([
+                "",
+                "Proposed work contract:",
+                `- Summary: ${current.summary}`,
+                `- Scope:   ${current.scope}`,
+                "[C]onfirm  [E]dit intent  [S]cope  [X] cancel",
+                "",
+            ].join("\n"));
+            const answer = (await rl.question("> ")).trim().toLowerCase();
+            if (answer === "c" || answer === "confirm" || answer === "")
+                return current;
+            if (answer === "x" || answer === "cancel")
+                return null;
+            if (answer === "e" || answer === "edit") {
+                const next = (await rl.question("New summary: ")).trim();
+                if (next)
+                    current.summary = next;
+                continue;
+            }
+            if (answer === "s" || answer === "scope") {
+                const next = (await rl.question("New scope: ")).trim();
+                if (next)
+                    current.scope = next;
+            }
+        }
+    }
+    finally {
+        rl.close();
+    }
+}