@agentbridge1/cli 0.0.1

package/dist/supervision.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferSupervisionWorkType = inferSupervisionWorkType;
+exports.requiredProofHints = requiredProofHints;
+exports.computeScopeDriftAlerts = computeScopeDriftAlerts;
+exports.supervisionFromAcceptance = supervisionFromAcceptance;
+exports.fallbackSupervisionSnapshot = fallbackSupervisionSnapshot;
+exports.supervisionSignature = supervisionSignature;
+exports.renderSupervisionSummary = renderSupervisionSummary;
+const domain_resolution_1 = require("./domain-resolution");
+const memory_context_render_1 = require("./memory-context-render");
+const CLI_GIT_REQUIRED_PROOF = [
+    "tracked modified file handled",
+    "untracked new file handled",
+    "staged-new file handled",
+    "tracked deleted file handled",
+    "missing file handled safely",
+    "watcher does not crash",
+    "precommit enforces unresolved Tier A/B crossings",
+];
+function uniqueSorted(values) {
+    return [...new Set(values.map((v) => v.trim()).filter(Boolean))].sort();
+}
+function inferSupervisionWorkType(changedFiles) {
+    if (changedFiles.length === 0)
+        return "unknown";
+    const lower = changedFiles.map((file) => file.toLowerCase());
+    const cliSignal = lower.some((file) => file.includes("cli/src/") &&
+        (file.includes("watch") || file.includes("precommit") || file.includes("revert-crossing")));
+    if (cliSignal)
+        return "cli_git_enforcement";
+    const docsOnly = lower.every((file) => file.startsWith("docs/") || file.endsWith(".md") || file.endsWith(".mdx") || file.includes("/docs/"));
+    if (docsOnly)
+        return "documentation";
+    return "general";
+}
+function requiredProofHints(workType) {
+    if (workType === "cli_git_enforcement")
+        return [...CLI_GIT_REQUIRED_PROOF];
+    if (workType === "documentation")
+        return ["explicit verification evidence for changed docs/files"];
+    return [
+        "explicit verification evidence for changed files",
+        "run agentbridge check for full acceptance state",
+    ];
+}
+function escapeRegex(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function globToRegex(glob) {
+    const normalized = glob.replaceAll("\\", "/");
+    const withDouble = normalized.replaceAll("**", "__DOUBLE_STAR__");
+    const withSingle = withDouble.replaceAll("*", "__SINGLE_STAR__");
+    const escaped = escapeRegex(withSingle)
+        .replaceAll("__DOUBLE_STAR__", ".*")
+        .replaceAll("__SINGLE_STAR__", "[^/]*");
+    return new RegExp(`^${escaped}$`);
+}
+function fileWithinClaimedPaths(file, claimedPaths) {
+    if (claimedPaths.length === 0)
+        return false;
+    return claimedPaths.some((claim) => {
+        const normalized = claim.trim().replaceAll("\\", "/");
+        if (!normalized)
+            return false;
+        if (normalized === file)
+            return true;
+        if (normalized.endsWith("/**")) {
+            const prefix = normalized.slice(0, -3);
+            return file.startsWith(prefix);
+        }
+        if (normalized.includes("*")) {
+            return globToRegex(normalized).test(file);
+        }
+        return file.startsWith(normalized.endsWith("/") ? normalized : `${normalized}/`);
+    });
+}
+function toAlertSeverity(tier) {
+    return tier === "tier_d" ? "informational" : "review";
+}
+function computeScopeDriftAlerts(input) {
+    const claimed = uniqueSorted(input.claimedPaths);
+    if (claimed.length === 0)
+        return [];
+    const alerts = [];
+    for (const file of uniqueSorted(input.changedFiles)) {
+        if (fileWithinClaimedPaths(file, claimed))
+            continue;
+        const resolved = (0, domain_resolution_1.resolveDomainForFile)(file, input.domains);
+        if (resolved.tier === "tier_a" || resolved.tier === "tier_b")
+            continue;
+        alerts.push({
+            file,
+            claimedPaths: claimed,
+            likelyDomain: resolved.domain ?? "unknown",
+            severity: toAlertSeverity(resolved.tier),
+        });
+    }
+    return alerts;
+}
+function supervisionFromAcceptance(report, domains) {
+    const changedFiles = uniqueSorted(report.changed_files);
+    const workType = report.detected_work_type;
+    let requiredProof = report.required_proof.length > 0 ? uniqueSorted(report.required_proof) : requiredProofHints(workType);
+    if (workType === "documentation" &&
+        requiredProof.includes("explicit verification evidence for the changed files")) {
+        requiredProof = ["explicit verification evidence for changed docs/files"];
+    }
+    const claimedPaths = report.claimed_paths ?? [];
+    const driftAlerts = report.scope_status === "drift"
+        ? computeScopeDriftAlerts({ changedFiles, claimedPaths, domains })
+        : [];
+    return {
+        workSessionId: report.work_session_id,
+        changeRequestId: report.change_request_id,
+        changedFiles,
+        workType,
+        scopeStatus: report.scope_status,
+        boundaryStatus: report.boundary_status,
+        decision: report.decision,
+        requiredProof,
+        knownTraps: report.known_traps.slice(0, 3),
+        memoryContext: report.memory_context,
+        nextAction: "Run verification command(s), then run agentbridge check.",
+        driftAlerts,
+    };
+}
+function fallbackSupervisionSnapshot(input) {
+    const changedFiles = uniqueSorted(input.changedFiles);
+    const workType = inferSupervisionWorkType(changedFiles);
+    const requiredProof = requiredProofHints(workType);
+    const driftAlerts = computeScopeDriftAlerts({
+        changedFiles,
+        claimedPaths: [],
+        domains: input.domains,
+    });
+    return {
+        workSessionId: input.workSessionId,
+        changeRequestId: input.changeRequestId,
+        changedFiles,
+        workType,
+        scopeStatus: driftAlerts.length > 0 ? "drift" : changedFiles.length > 0 ? "clean" : "unknown",
+        boundaryStatus: input.unresolvedProtectedCrossing || input.blocked ? "unresolved_crossing" : "clean",
+        decision: input.unresolvedProtectedCrossing || input.blocked ? "failed" : "needs_proof",
+        requiredProof,
+        knownTraps: [],
+        nextAction: "Run verification command(s), then run agentbridge check.",
+        driftAlerts,
+        serverAcceptanceUnavailable: input.serverAcceptanceUnavailable,
+    };
+}
+function supervisionSignature(snapshot) {
+    return JSON.stringify({
+        workSessionId: snapshot.workSessionId,
+        changedFiles: snapshot.changedFiles,
+        workType: snapshot.workType,
+        scopeStatus: snapshot.scopeStatus,
+        boundaryStatus: snapshot.boundaryStatus,
+        decision: snapshot.decision,
+        requiredProof: snapshot.requiredProof,
+        drift: snapshot.driftAlerts.map((a) => `${a.file}:${a.severity}:${a.likelyDomain}`),
+        serverAcceptanceUnavailable: snapshot.serverAcceptanceUnavailable ? "yes" : "no",
+    });
+}
+function renderSupervisionSummary(snapshot) {
+    const lines = [];
+    lines.push("AgentBridge supervision:");
+    lines.push(`Current run: ${snapshot.workSessionId}${snapshot.changeRequestId ? ` / task ${snapshot.changeRequestId}` : ""}`);
+    lines.push(`Changed files: ${snapshot.changedFiles.length}`);
+    lines.push(`Detected work type: ${snapshot.workType}`);
+    lines.push(`Scope: ${snapshot.scopeStatus}`);
+    lines.push(`Boundary: ${snapshot.boundaryStatus}`);
+    lines.push(`Watch result: ${snapshot.decision}`);
+    if (snapshot.requiredProof.length > 0) {
+        lines.push("");
+        lines.push("Likely required proof:");
+        for (const proof of snapshot.requiredProof) {
+            lines.push(`- ${proof}`);
+        }
+    }
+    if (snapshot.knownTraps.length > 0) {
+        lines.push("");
+        lines.push("Known traps:");
+        for (const trap of snapshot.knownTraps.slice(0, 3)) {
+            lines.push(`- ${trap}`);
+        }
+    }
+    const watchMemoryLines = (0, memory_context_render_1.renderWatchMemoryContext)(snapshot.memoryContext);
+    if (watchMemoryLines.length > 0) {
+        lines.push("");
+        lines.push(...watchMemoryLines);
+    }
+    if (snapshot.driftAlerts.length > 0) {
+        for (const alert of snapshot.driftAlerts) {
+            lines.push("");
+            lines.push("Files outside scope detected:");
+            lines.push(`- file: ${alert.file}`);
+            lines.push(`- claimed paths: [${alert.claimedPaths.join(", ")}]`);
+            lines.push(`- likely domain: ${alert.likelyDomain}`);
+            lines.push(`- severity: ${alert.severity}`);
+            lines.push("- suggested action: update scope or confirm this belongs to the current work");
+        }
+    }
+    if (snapshot.serverAcceptanceUnavailable) {
+        lines.push("");
+        lines.push(`Watch result unavailable: ${snapshot.serverAcceptanceUnavailable}`);
+    }
+    lines.push("");
+    lines.push("Before saying done:");
+    lines.push(`- ${snapshot.nextAction}`);
+    return lines.join("\n");
+}

package/dist/terminal-ui.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptLine = promptLine;
+exports.info = info;
+const promises_1 = require("node:readline/promises");
+const node_process_1 = require("node:process");
+async function promptLine(question) {
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+    try {
+        return await rl.question(`${question}\n> `);
+    }
+    finally {
+        rl.close();
+    }
+}
+function info(message) {
+    node_process_1.stdout.write(`${message}\n`);
+}

package/dist/test-runner.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectTestCommand = detectTestCommand;
+exports.runDetectedTests = runDetectedTests;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+function detectTestCommand(cwd = process.cwd()) {
+    const packageJsonPath = (0, node_path_1.resolve)(cwd, "package.json");
+    if (!(0, node_fs_1.existsSync)(packageJsonPath))
+        return null;
+    const pkg = JSON.parse((0, node_fs_1.readFileSync)(packageJsonPath, "utf8"));
+    if (!pkg.scripts)
+        return null;
+    if (pkg.scripts["test:unit"])
+        return "npm run test:unit";
+    if (pkg.scripts.test)
+        return "npm run test";
+    return null;
+}
+async function runDetectedTests(timeoutMs = 5 * 60 * 1000) {
+    const command = detectTestCommand();
+    if (!command)
+        return null;
+    const started = Date.now();
+    return new Promise((resolveResult) => {
+        const child = (0, node_child_process_1.spawn)(command, {
+            shell: true,
+            cwd: process.cwd(),
+            env: process.env,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        child.stdout?.on("data", (chunk) => {
+            stdout += chunk.toString();
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        const timeout = setTimeout(() => {
+            child.kill("SIGTERM");
+            resolveResult({
+                command,
+                passed: false,
+                stdout,
+                stderr: `${stderr}\nTimed out after ${timeoutMs}ms`,
+                durationMs: Date.now() - started,
+            });
+        }, timeoutMs);
+        child.on("close", (code) => {
+            clearTimeout(timeout);
+            resolveResult({
+                command,
+                passed: code === 0,
+                stdout,
+                stderr,
+                durationMs: Date.now() - started,
+            });
+        });
+    });
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/verification-conditions.js

@@ -0,0 +1,185 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.analyzeVerificationCommand = analyzeVerificationCommand;
+exports.buildVerificationConfidence = buildVerificationConfidence;
+exports.renderConfidenceSummary = renderConfidenceSummary;
+exports.renderMockHygieneWarning = renderMockHygieneWarning;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const REPEAT_PATTERNS = [
+    /--repeat(?:=|\s|$)/i,
+    /\bfor\s+\(?\s*\w+\s+in\s+/i,
+    /\bwhile\s+\(/i,
+    /\bseq\s+\d+/i,
+];
+const SHUFFLE_PATTERNS = [
+    /--sequence\.shuffle/i,
+    /--shuffle(?:=|\s|$)/i,
+    /--random(?:=|\s|$)/i,
+    /\bvitest\s+run\b.*--sequence\.shuffle/i,
+    /\bnpm\s+test\b.*--sequence\.shuffle/i,
+];
+const SEED_PATTERNS = [/--seed(?:=|\s+)(\S+)/i, /\bVITEST_SEED=(\S+)/i, /\bSEED=(\S+)/i];
+function isTestFile(path) {
+    const normalized = path.replaceAll("\\", "/").toLowerCase();
+    return (normalized.endsWith(".test.ts") ||
+        normalized.endsWith(".test.tsx") ||
+        normalized.endsWith(".spec.ts") ||
+        normalized.endsWith(".spec.tsx"));
+}
+function inferIntegrationLevel(command) {
+    const lower = command.toLowerCase();
+    if (/\b(dogfood|browse|playwright|e2e|cypress)\b/.test(lower))
+        return "dogfood";
+    if (/\b(integration|acceptance-check|work-sessions)\b/.test(lower))
+        return "integration";
+    if (/\b(vitest|jest|mocha|npm test|pnpm test|yarn test)\b/.test(lower))
+        return "unit";
+    if (/\b(test -f|test -d|manual)\b/.test(lower))
+        return "manual";
+    return "unknown";
+}
+function parseSeed(command) {
+    for (const pattern of SEED_PATTERNS) {
+        const match = command.match(pattern);
+        if (match?.[1])
+            return match[1];
+    }
+    return undefined;
+}
+function detectRepeated(command) {
+    return REPEAT_PATTERNS.some((pattern) => pattern.test(command));
+}
+function detectRandomizedOrShuffled(command) {
+    return SHUFFLE_PATTERNS.some((pattern) => pattern.test(command));
+}
+function scanFileForMockHygiene(filePath, cwd) {
+    let content = "";
+    try {
+        content = (0, node_fs_1.readFileSync)((0, node_path_1.join)(cwd, filePath), "utf8");
+    }
+    catch {
+        return { risk: "unknown" };
+    }
+    const clearAllMocks_used = /\bclearAllMocks\s*\(/.test(content);
+    const resetAllMocks_used = /\bresetAllMocks\s*\(/.test(content);
+    const mockImplementation_used = /\bmockImplementation\s*\(/.test(content);
+    let risk = "none";
+    if (clearAllMocks_used || resetAllMocks_used || mockImplementation_used) {
+        if (clearAllMocks_used && mockImplementation_used && !resetAllMocks_used) {
+            risk = "high";
+        }
+        else if (clearAllMocks_used && !resetAllMocks_used) {
+            risk = "medium";
+        }
+        else {
+            risk = "low";
+        }
+    }
+    return {
+        clearAllMocks_used,
+        resetAllMocks_used,
+        mockImplementation_used,
+        risk,
+    };
+}
+function aggregateMockHygiene(scopes, cwd) {
+    const testFiles = scopes.filter(isTestFile);
+    if (testFiles.length === 0)
+        return undefined;
+    const scans = testFiles.map((file) => scanFileForMockHygiene(file, cwd));
+    const clearAllMocks_used = scans.some((s) => s.clearAllMocks_used);
+    const resetAllMocks_used = scans.some((s) => s.resetAllMocks_used);
+    const mockImplementation_used = scans.some((s) => s.mockImplementation_used);
+    const riskOrder = ["high", "medium", "low", "unknown", "none"];
+    const observed = new Set(scans.map((scan) => scan.risk ?? "unknown"));
+    const risk = riskOrder.find((candidate) => observed.has(candidate)) ?? "none";
+    return {
+        clearAllMocks_used,
+        resetAllMocks_used,
+        mockImplementation_used,
+        risk,
+    };
+}
+function analyzeVerificationCommand(input) {
+    const repeated = detectRepeated(input.command);
+    const randomized_or_shuffled = detectRandomizedOrShuffled(input.command);
+    const run_count = repeated ? 2 : 1;
+    return {
+        run_count,
+        repeated,
+        randomized_or_shuffled,
+        seed: parseSeed(input.command),
+        integration_level: inferIntegrationLevel(input.command),
+        server_backed: input.serverBacked,
+        proof_scope_source: input.proofScopeSource,
+        mock_hygiene: aggregateMockHygiene(input.proofScopeFiles, input.cwd ?? process.cwd()),
+    };
+}
+function buildVerificationConfidence(input) {
+    const reasons = [];
+    const missing_robustness = [];
+    if (input.status === "failed") {
+        return {
+            level: "low",
+            reasons: ["verification command exited non-zero"],
+            missing_robustness: ["passing verification run"],
+        };
+    }
+    reasons.push("single targeted verification run passed");
+    if (input.conditions.repeated) {
+        reasons.push("command indicates repeated execution");
+    }
+    else {
+        missing_robustness.push("repeated run");
+    }
+    if (input.conditions.randomized_or_shuffled) {
+        reasons.push("command indicates randomized or shuffled execution");
+    }
+    else {
+        missing_robustness.push("randomized_or_shuffled proof");
+    }
+    const hasRepeated = Boolean(input.conditions.repeated);
+    const hasShuffle = Boolean(input.conditions.randomized_or_shuffled);
+    if (hasRepeated && hasShuffle) {
+        return {
+            level: "high",
+            reasons: [...reasons, "repeated and shuffled proof conditions met"],
+            missing_robustness: [],
+        };
+    }
+    return {
+        level: "medium",
+        reasons,
+        missing_robustness,
+    };
+}
+function renderConfidenceSummary(confidence) {
+    const lines = [`Proof confidence: ${confidence.level}`];
+    if (confidence.reasons.length > 0) {
+        lines.push("Reasons:");
+        for (const reason of confidence.reasons) {
+            lines.push(`  - ${reason}`);
+        }
+    }
+    if (confidence.missing_robustness.length > 0) {
+        lines.push("Missing robustness:");
+        for (const item of confidence.missing_robustness) {
+            lines.push(`  - ${item}`);
+        }
+    }
+    return lines;
+}
+function renderMockHygieneWarning(hygiene) {
+    if (!hygiene || !hygiene.risk || hygiene.risk === "none" || hygiene.risk === "low") {
+        return null;
+    }
+    if (hygiene.risk === "high") {
+        return ("Mock hygiene: high risk — clearAllMocks and mockImplementation without resetAllMocks " +
+            "in proof-scope test files.");
+    }
+    if (hygiene.risk === "medium") {
+        return "Mock hygiene: medium risk — clearAllMocks without resetAllMocks in proof-scope test files.";
+    }
+    return "Mock hygiene: review mock reset patterns in proof-scope test files.";
+}

package/dist/watch-core.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyFileChange = applyFileChange;
+exports.applyBoundaryDecision = applyBoundaryDecision;
+exports.canCloseSession = canCloseSession;
+exports.inferTierFromDomainName = inferTierFromDomainName;
+exports.toDomainOwnershipInput = toDomainOwnershipInput;
+const domain_resolution_1 = require("./domain-resolution");
+const claimed_paths_1 = require("./claimed-paths");
+function findCrossing(state, file) {
+    return state.crossings.find((crossing) => crossing.file === file);
+}
+function applyFileChange(state, file) {
+    if (!state.changedFiles.includes(file)) {
+        state.changedFiles.push(file);
+    }
+    const resolved = (0, domain_resolution_1.resolveDomainForFile)(file, state.domains);
+    if (!state.laneDomain) {
+        return {
+            requiresAuthorityPrompt: false,
+            requestType: null,
+            crossingDomain: resolved.domain,
+            crossingTier: resolved.tier,
+        };
+    }
+    if (!resolved.domain) {
+        const claimedPaths = state.claimedPaths ?? [];
+        if (claimedPaths.length > 0 && (0, claimed_paths_1.fileWithinClaimedPaths)(file, claimedPaths)) {
+            return {
+                requiresAuthorityPrompt: false,
+                requestType: null,
+                crossingDomain: null,
+                crossingTier: "tier_d",
+            };
+        }
+        const existing = findCrossing(state, file);
+        if (!existing) {
+            state.crossings.push({
+                file,
+                domain: null,
+                tier: "tier_d",
+                status: "unresolved",
+            });
+        }
+        return {
+            requiresAuthorityPrompt: true,
+            requestType: "handshake",
+            crossingDomain: null,
+            crossingTier: "tier_d",
+        };
+    }
+    if (resolved.domain === state.laneDomain) {
+        return {
+            requiresAuthorityPrompt: false,
+            requestType: null,
+            crossingDomain: resolved.domain,
+            crossingTier: resolved.tier,
+        };
+    }
+    const existing = findCrossing(state, file);
+    if (existing &&
+        existing.status !== "unresolved" &&
+        existing.status !== "pending_handshake") {
+        return {
+            requiresAuthorityPrompt: false,
+            requestType: null,
+            crossingDomain: existing.domain,
+            crossingTier: existing.tier,
+        };
+    }
+    if (existing?.status === "pending_handshake") {
+        return {
+            requiresAuthorityPrompt: false,
+            requestType: null,
+            crossingDomain: existing.domain,
+            crossingTier: existing.tier,
+        };
+    }
+    if (!existing) {
+        state.crossings.push({
+            file,
+            domain: resolved.domain,
+            tier: resolved.tier,
+            status: resolved.tier === "tier_d" ? "logged" : "unresolved",
+        });
+    }
+    if (resolved.tier === "tier_a" || resolved.tier === "tier_b") {
+        state.blockedAt = new Date().toISOString();
+        state.status = "blocked";
+        return {
+            requiresAuthorityPrompt: true,
+            requestType: "authority",
+            crossingDomain: resolved.domain,
+            crossingTier: resolved.tier,
+        };
+    }
+    if (resolved.tier === "tier_c") {
+        return {
+            requiresAuthorityPrompt: true,
+            requestType: "handshake",
+            crossingDomain: resolved.domain,
+            crossingTier: resolved.tier,
+        };
+    }
+    return {
+        requiresAuthorityPrompt: false,
+        requestType: null,
+        crossingDomain: resolved.domain,
+        crossingTier: resolved.tier,
+    };
+}
+function clearBlockedIfResolved(state) {
+    const unresolvedProtected = state.crossings.some((crossing) => crossing.status === "unresolved" &&
+        (crossing.tier === "tier_a" || crossing.tier === "tier_b"));
+    if (!unresolvedProtected) {
+        state.blockedAt = undefined;
+        if (state.status !== "closed") {
+            state.status = "active";
+        }
+    }
+}
+function applyBoundaryDecision(state, file, decision, handlers, options) {
+    const crossing = findCrossing(state, file);
+    if (!crossing) {
+        throw new Error(`No crossing found for file ${file}`);
+    }
+    switch (decision) {
+        case "approve":
+            crossing.status = "approved";
+            state.approvals.push({
+                domain: crossing.domain ?? "unknown",
+                file,
+                mode: "file_only",
+                createdAt: new Date().toISOString(),
+            });
+            clearBlockedIfResolved(state);
+            return;
+        case "deny":
+            handlers.revertFile(file);
+            crossing.status = "denied";
+            clearBlockedIfResolved(state);
+            return;
+        case "limit_scope":
+            crossing.status = "limited";
+            state.approvals.push({
+                domain: crossing.domain ?? "unknown",
+                file,
+                mode: options?.limitMode ?? "file_only",
+                createdAt: new Date().toISOString(),
+            });
+            clearBlockedIfResolved(state);
+            return;
+        case "handoff":
+            crossing.status = "handoff";
+            state.status = "closed";
+            state.closeReason = "handoff_required";
+            return;
+        case "abandon":
+            handlers.revertAll([...state.changedFiles]);
+            crossing.status = "abandoned";
+            state.status = "closed";
+            state.closeReason = "abandoned";
+            state.blockedAt = undefined;
+            return;
+        default:
+            return;
+    }
+}
+function canCloseSession(state) {
+    const unresolved = state.crossings.some((crossing) => crossing.status === "unresolved");
+    if (unresolved) {
+        return { ok: false, reason: "Session has unresolved authority crossings." };
+    }
+    return { ok: true };
+}
+function inferTierFromDomainName(domain) {
+    const value = domain.toLowerCase();
+    if (value.includes("auth") ||
+        value.includes("billing") ||
+        value.includes("payment") ||
+        value.includes("webhook") ||
+        value.includes("database") ||
+        value.includes("schema") ||
+        value.includes("secret") ||
+        value.includes("permission") ||
+        value.includes("middleware") ||
+        value.includes("deploy")) {
+        return "tier_a";
+    }
+    if (value.includes("api") ||
+        value.includes("backend") ||
+        value.includes("frontend") ||
+        value.includes("service")) {
+        return "tier_b";
+    }
+    if (value.includes("shared") || value.includes("infra") || value.includes("test") || value.includes("util")) {
+        return "tier_c";
+    }
+    return "tier_d";
+}
+function toDomainOwnershipInput(domains) {
+    return domains.map((domain) => ({
+        domain: domain.domain,
+        pathPatterns: domain.pathPatterns,
+        ownerAgentId: domain.ownerAgentId ?? `${domain.domain} Agent`,
+        tier: domain.tier ?? inferTierFromDomainName(domain.domain),
+    }));
+}