@agentbridge1/cli 0.0.1

package/dist/init.js

@@ -0,0 +1,458 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertInsideGitRepo = assertInsideGitRepo;
+exports.refineRecoveredDomains = refineRecoveredDomains;
+exports.writeLocalRulesArtifacts = writeLocalRulesArtifacts;
+exports.buildBootstrapPayloadFromEvidence = buildBootstrapPayloadFromEvidence;
+exports.runInit = runInit;
+exports.runBootstrapRecovery = runBootstrapRecovery;
+const promises_1 = require("node:readline/promises");
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_process_1 = require("node:process");
+const http_1 = require("./http");
+const git_evidence_1 = require("./git-evidence");
+const config_1 = require("./config");
+const watch_core_1 = require("./watch-core");
+const precommit_1 = require("./precommit");
+const WORKFLOW_SUMMARY = "Recover domains from repository evidence, map ownership boundaries, enforce lane discipline, and require authority requests before cross-domain edits.";
+const KNOWN_DOMAIN_LABELS = {
+    communications: "Communications",
+    diagnosis: "Diagnosis",
+    dispatch: "Dispatch",
+    "photo-upload": "Photo Upload",
+    "live-ui": "Live UI",
+    ops: "Ops",
+    plumber: "Plumber",
+    "pm-report": "PM Report",
+    sessions: "Sessions",
+    database: "Supabase / Database",
+    shared: "Shared",
+};
+const KNOWN_DOMAIN_TIERS = {
+    communications: "tier_b",
+    diagnosis: "tier_b",
+    dispatch: "tier_b",
+    "photo-upload": "tier_b",
+    "live-ui": "tier_b",
+    ops: "tier_b",
+    plumber: "tier_b",
+    "pm-report": "tier_b",
+    sessions: "tier_b",
+    database: "tier_a",
+    shared: "tier_c",
+};
+const DOMAIN_PREFIX_BY_KEY = {
+    communications: ["src/communications/"],
+    diagnosis: ["src/diagnosis/"],
+    dispatch: ["src/dispatch/"],
+    "photo-upload": ["src/photo-upload/"],
+    "live-ui": ["src/live-ui/"],
+    ops: ["src/ops/"],
+    plumber: ["src/plumber/"],
+    "pm-report": ["src/pm-report/"],
+    sessions: ["src/sessions/"],
+    database: ["src/supabase/", "db/", "prisma/", "supabase/", "supabase_*.sql"],
+    shared: ["src/shared/"],
+};
+function toBootstrapDomains(domains) {
+    return domains.map((domain) => ({
+        name: domain.name,
+        pathPatterns: domain.pathPatterns,
+        files: domain.files,
+        evidenceSource: "git_history",
+        confidence: domain.confidence,
+        protectionTier: domain.protectionTier,
+        knownTraps: domain.knownTraps,
+        relatedDomains: [],
+        openRisks: [],
+    }));
+}
+function toTitle(value) {
+    return value
+        .split(/[\s_-]+/)
+        .filter(Boolean)
+        .map((part) => part[0]?.toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function describeCluster(cluster) {
+    const tier = (cluster.protection_tier ?? (0, watch_core_1.inferTierFromDomainName)(cluster.suggested_name)).toUpperCase();
+    const confidence = Math.round((cluster.confidence ?? 0.5) * 100);
+    const reason = cluster.rationale
+        ? cluster.rationale
+        : `files changed together under ${cluster.path_prefixes[0] ?? "mixed paths"}`;
+    return `- ${toTitle(cluster.suggested_name)} (${tier}, ${confidence}% confidence): ${reason}`;
+}
+function isValidAuthorityDomain(cluster) {
+    const hasOwnedFiles = cluster.files.length > 0 || cluster.path_prefixes.length > 0;
+    return hasOwnedFiles && cluster.confidence != null && cluster.confidence > 0;
+}
+function summarizeSkipped(skippedByReason) {
+    const top = Object.entries(skippedByReason)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5);
+    if (top.length === 0)
+        return "none";
+    return top.map(([reason, count]) => `${reason}=${count}`).join(", ");
+}
+function assertInsideGitRepo() {
+    (0, node_child_process_1.execFileSync)("git", ["rev-parse", "--is-inside-work-tree"], {
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+}
+function normalizeToken(value) {
+    return value.trim().toLowerCase().replace(/[_\s]+/g, "-");
+}
+function classifyDomainKey(path) {
+    const normalized = path.replace(/\\/g, "/");
+    const srcMatch = normalized.match(/^src\/([^/]+)\//);
+    if (srcMatch) {
+        const folder = normalizeToken(srcMatch[1] ?? "");
+        if (folder === "supabase")
+            return "database";
+        if (folder)
+            return folder;
+        return null;
+    }
+    if (normalized.startsWith("db/") || normalized.startsWith("prisma/") || normalized.startsWith("supabase/")) {
+        return "database";
+    }
+    if (/^supabase_.*\.sql$/i.test(normalized)) {
+        return "database";
+    }
+    return null;
+}
+function tierForDomainKey(domainKey, files) {
+    if (domainKey === "sessions") {
+        const highRisk = files.some((file) => /(token|auth|state|orchestrator|repository|session)/i.test(file));
+        return highRisk ? "tier_a" : "tier_b";
+    }
+    return KNOWN_DOMAIN_TIERS[domainKey] ?? "tier_b";
+}
+function knownTrapsForDomainKey(domainKey) {
+    if (domainKey === "database") {
+        return ["Schema changes can impact production state and migrations."];
+    }
+    if (domainKey === "sessions") {
+        return ["Session orchestration changes can disrupt active workflows."];
+    }
+    if (domainKey === "shared") {
+        return ["Shared contracts require handshake with dependent domains."];
+    }
+    return [];
+}
+function confidenceForDomain(fileCount) {
+    const confidence = 0.55 + Math.min(0.38, fileCount * 0.04);
+    return Number(confidence.toFixed(2));
+}
+function collectWorkspaceDomainSeeds() {
+    const seeds = new Set();
+    const srcPath = (0, node_path_1.resolve)(process.cwd(), "src");
+    if ((0, node_fs_1.existsSync)(srcPath)) {
+        for (const entry of (0, node_fs_1.readdirSync)(srcPath, { withFileTypes: true })) {
+            if (!entry.isDirectory())
+                continue;
+            const folder = normalizeToken(entry.name);
+            if (folder === "supabase") {
+                seeds.add("database");
+            }
+            else if (folder) {
+                seeds.add(folder);
+            }
+        }
+    }
+    for (const dbFolder of ["db", "prisma", "supabase"]) {
+        if ((0, node_fs_1.existsSync)((0, node_path_1.resolve)(process.cwd(), dbFolder))) {
+            seeds.add("database");
+        }
+    }
+    return Array.from(seeds);
+}
+function refineRecoveredDomains(inferredClusters, evidence, architectureDomains) {
+    const domainFiles = new Map();
+    const workspaceSeeds = collectWorkspaceDomainSeeds();
+    for (const seed of workspaceSeeds) {
+        if (!domainFiles.has(seed))
+            domainFiles.set(seed, new Set());
+    }
+    for (const file of evidence.files) {
+        const key = classifyDomainKey(file);
+        if (!key)
+            continue;
+        if (!domainFiles.has(key))
+            domainFiles.set(key, new Set());
+        domainFiles.get(key)?.add(file);
+    }
+    for (const cluster of inferredClusters) {
+        const clusterPaths = [...cluster.files, ...cluster.path_prefixes];
+        const keyVotes = new Map();
+        for (const path of clusterPaths) {
+            const key = classifyDomainKey(path);
+            if (!key)
+                continue;
+            keyVotes.set(key, (keyVotes.get(key) ?? 0) + 1);
+        }
+        const dominantKey = Array.from(keyVotes.entries()).sort((a, b) => b[1] - a[1])[0]?.[0];
+        const normalizedSuggested = normalizeToken(cluster.suggested_name);
+        const clusterIsGeneric = normalizedSuggested === "general" || normalizedSuggested === "misc";
+        const chosenKey = dominantKey ??
+            (normalizedSuggested === "general" || normalizedSuggested === "misc"
+                ? null
+                : normalizedSuggested || null);
+        if (!chosenKey || (clusterIsGeneric && !dominantKey))
+            continue;
+        if (!domainFiles.has(chosenKey))
+            domainFiles.set(chosenKey, new Set());
+        for (const file of cluster.files) {
+            if (classifyDomainKey(file) === chosenKey) {
+                domainFiles.get(chosenKey)?.add(file);
+            }
+        }
+    }
+    for (const hint of architectureDomains) {
+        const normalizedHint = normalizeToken(hint);
+        const hintKey = normalizedHint in KNOWN_DOMAIN_LABELS ? normalizedHint : null;
+        if (!hintKey)
+            continue;
+        if (!domainFiles.has(hintKey))
+            domainFiles.set(hintKey, new Set());
+    }
+    if (domainFiles.size === 0) {
+        return inferredClusters.map((cluster) => {
+            const name = toTitle(cluster.suggested_name);
+            const files = cluster.files.length > 0 ? cluster.files : cluster.path_prefixes;
+            const tier = cluster.protection_tier ?? (0, watch_core_1.inferTierFromDomainName)(cluster.suggested_name);
+            return {
+                name,
+                files,
+                pathPatterns: cluster.path_prefixes,
+                confidence: Number((cluster.confidence ?? 0.5).toFixed(2)),
+                protectionTier: tier,
+                knownTraps: cluster.known_traps ?? [],
+                rationale: cluster.rationale ?? `files changed together under ${cluster.path_prefixes[0] ?? "mixed paths"}`,
+            };
+        });
+    }
+    return Array.from(domainFiles.entries())
+        .map(([key, filesSet]) => {
+        const files = Array.from(filesSet).sort((a, b) => a.localeCompare(b));
+        const pathPatterns = DOMAIN_PREFIX_BY_KEY[key] ??
+            (key === "database"
+                ? ["db/", "prisma/", "supabase/", "supabase_*.sql"]
+                : key === "shared"
+                    ? ["src/shared/"]
+                    : [`src/${key}/`]);
+        const primaryPrefix = pathPatterns[0] ? pathPatterns[0].replace(/\/$/, "") : key;
+        const protectionTier = tierForDomainKey(key, files);
+        return {
+            name: KNOWN_DOMAIN_LABELS[key] ?? toTitle(key),
+            files,
+            pathPatterns,
+            confidence: files.length > 0 ? confidenceForDomain(files.length) : 0.56,
+            protectionTier,
+            knownTraps: knownTrapsForDomainKey(key),
+            rationale: files.length > 0
+                ? `grouped ${files.length} file(s) under ${primaryPrefix}`
+                : `seeded from workspace signals for ${primaryPrefix}`,
+        };
+    })
+        .filter((domain) => domain.pathPatterns.length > 0)
+        .sort((a, b) => a.name.localeCompare(b.name));
+}
+function toRulesMarkdown(domains) {
+    const protectedDomains = domains.filter((d) => d.tier === "tier_a" || d.tier === "tier_b");
+    return [
+        "# AgentBridge Local Rules",
+        "",
+        "## Recovered Domains",
+        ...domains.map((d) => `- ${d.domain} — owner: ${d.owner} (${d.tier.toUpperCase()})`),
+        "",
+        "## Protected Departments",
+        ...(protectedDomains.length > 0
+            ? protectedDomains.map((d) => `- ${d.domain}`)
+            : ["- none detected"]),
+        "",
+        "## Working Rules",
+        "- Do not cross domains without an authority request.",
+        "- Use `agentbridge watch` while editing.",
+        "- Handoff when work enters another owned domain.",
+        "",
+    ].join("\n");
+}
+function toCursorRule(domains) {
+    return [
+        "---",
+        "description: AgentBridge local enforcement",
+        "globs: [\"**/*\"]",
+        "alwaysApply: true",
+        "---",
+        "",
+        "Recovered domains:",
+        ...domains.map((d) => `- ${d.domain} :: ${d.owner} :: ${d.tier}`),
+        "",
+        "Required behavior:",
+        "- Request authority before cross-domain edits.",
+        "- Use `agentbridge watch` during implementation.",
+        "- Handoff when entering another domain boundary.",
+        "",
+    ].join("\n");
+}
+function writeLocalRulesArtifacts(domains) {
+    const md = toRulesMarkdown(domains);
+    const cursorRule = toCursorRule(domains);
+    const rootFile = (0, node_path_1.resolve)(process.cwd(), "AGENTBRIDGE.md");
+    const cursorRulesDir = (0, node_path_1.resolve)(process.cwd(), ".cursor", "rules");
+    (0, node_fs_1.mkdirSync)(cursorRulesDir, { recursive: true });
+    (0, node_fs_1.writeFileSync)(rootFile, `${md}\n`, "utf8");
+    (0, node_fs_1.writeFileSync)((0, node_path_1.resolve)(cursorRulesDir, "agentbridge.mdc"), `${cursorRule}\n`, "utf8");
+}
+async function buildBootstrapPayloadFromEvidence(ctx, productSummary, architectureDomains, evidence) {
+    const clusterResult = await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/recovery/evidence`, evidence);
+    const refinedDomains = refineRecoveredDomains(clusterResult.proposed_clusters, evidence, architectureDomains);
+    return {
+        inferredClusters: refinedDomains.map((domain, index) => ({
+            id: `refined_${index + 1}`,
+            suggested_name: domain.name,
+            files: domain.files,
+            path_prefixes: domain.pathPatterns,
+            churn_hot_files: domain.files.slice(0, 3),
+            confidence: domain.confidence,
+            evidence_source: "mixed",
+            protection_tier: domain.protectionTier,
+            related_domains: [],
+            known_traps: domain.knownTraps,
+            rationale: domain.rationale,
+        })),
+        payload: {
+            product_summary: productSummary,
+            recommended_first_action: "map_before_modify",
+            core_workflow: WORKFLOW_SUMMARY,
+            known_unknowns: [],
+            domains: toBootstrapDomains(refinedDomains),
+            architecture: {
+                summary: "Auto-generated from git evidence",
+                keyComponents: architectureDomains,
+                stackSignals: [],
+            },
+        },
+    };
+}
+async function runInit(ctx) {
+    if (!ctx.apiKey || ctx.apiKey.trim().length === 0) {
+        throw new Error("Missing AGENTBRIDGE_API_KEY. Provide --api-key, set AGENTBRIDGE_API_KEY, or save apiKey in .agentbridge/config.json.");
+    }
+    assertInsideGitRepo();
+    const rl = (0, promises_1.createInterface)({ input: node_process_1.stdin, output: node_process_1.stdout });
+    const runtimeCliPath = process.argv[1] ? (0, node_path_1.resolve)(process.argv[1]) : undefined;
+    const hookCliPath = runtimeCliPath ?? (0, node_path_1.resolve)(__dirname, "index.js");
+    try {
+        const productSummary = await rl.question("What does this project do? (1-3 sentences)\n> ");
+        const domainsRaw = await rl.question("Main product domains (comma-separated, optional)\n> ");
+        const architectureDomains = domainsRaw
+            .split(",")
+            .map((d) => d.trim())
+            .filter(Boolean);
+        const collectedEvidence = (0, git_evidence_1.collectGitEvidence)();
+        const evidence = collectedEvidence.payload;
+        node_process_1.stdout.write(`Recovery evidence commits scanned: ${collectedEvidence.report.commitCount}\n`);
+        node_process_1.stdout.write(`Recovery evidence counts before compaction: files=${collectedEvidence.report.beforeCounts.files}, coChange=${collectedEvidence.report.beforeCounts.coChange}, churn=${collectedEvidence.report.beforeCounts.churn}\n`);
+        node_process_1.stdout.write(`Recovery evidence counts after compaction: files=${collectedEvidence.report.afterCounts.files}, coChange=${collectedEvidence.report.afterCounts.coChange}, churn=${collectedEvidence.report.afterCounts.churn}\n`);
+        node_process_1.stdout.write(`Recovery evidence payload bytes: ${collectedEvidence.report.payloadBytes}\n`);
+        node_process_1.stdout.write(`Recovery evidence skipped/noisy summary: ${summarizeSkipped(collectedEvidence.report.skippedByReason)}\n`);
+        node_process_1.stdout.write(`Init auth context: hasApiKey=${Boolean(ctx.apiKey)} apiKeySource=${ctx.apiKeySource ?? "missing"} apiBaseUrl=${ctx.apiBaseUrl} projectId=${ctx.projectId}\n`);
+        const { inferredClusters, payload: bootstrapPayload } = await buildBootstrapPayloadFromEvidence(ctx, productSummary, architectureDomains, evidence);
+        node_process_1.stdout.write("Recovered domain map:\n");
+        for (const cluster of inferredClusters) {
+            node_process_1.stdout.write(`${describeCluster(cluster)}\n`);
+        }
+        const tierADomains = inferredClusters.filter((cluster) => (cluster.protection_tier ?? (0, watch_core_1.inferTierFromDomainName)(cluster.suggested_name)) === "tier_a");
+        if (tierADomains.length > 0) {
+            node_process_1.stdout.write(`Defaulting protection ON for high-risk domains: ${tierADomains
+                .map((cluster) => toTitle(cluster.suggested_name))
+                .join(", ")}.\n`);
+            const needsPaymentsPrompt = tierADomains.some((cluster) => /(billing|payment|stripe|checkout)/i.test(cluster.suggested_name));
+            if (needsPaymentsPrompt) {
+                const paymentsAnswer = await rl.question("Does this app take payments? [Y/n]\n> ");
+                if (paymentsAnswer.trim().toLowerCase() === "n") {
+                    node_process_1.stdout.write("Noted. Keep billing-related domain as advisory until you confirm provider details.\n");
+                }
+            }
+        }
+        await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/bootstrap`, bootstrapPayload);
+        const recoveredDomains = inferredClusters
+            .filter(isValidAuthorityDomain)
+            .map((cluster) => ({
+            domain: cluster.suggested_name,
+            pathPatterns: cluster.files.length > 0 ? cluster.files : cluster.path_prefixes,
+            ownerAgentId: `${cluster.suggested_name} Agent`,
+            tier: cluster.protection_tier ?? (0, watch_core_1.inferTierFromDomainName)(cluster.suggested_name),
+        }));
+        (0, config_1.updateConfig)({
+            apiBaseUrl: ctx.apiBaseUrl,
+            projectId: ctx.projectId,
+            domains: recoveredDomains,
+            cliPath: runtimeCliPath,
+        });
+        writeLocalRulesArtifacts(recoveredDomains.map((domain) => ({
+            domain: domain.domain,
+            owner: domain.ownerAgentId,
+            tier: domain.tier,
+        })));
+        node_process_1.stdout.write("Wrote AGENTBRIDGE.md and .cursor/rules/agentbridge.mdc\n");
+        const installHookAnswer = await rl.question("Install AgentBridge pre-commit protection? Recommended for hard-stop enforcement. [Y/n]\n> ");
+        if (installHookAnswer.trim() === "" || installHookAnswer.trim().toLowerCase() === "y") {
+            (0, precommit_1.installPrecommitHookWithPath)(hookCliPath);
+            (0, config_1.updateConfig)({ precommitHookInstalled: true, cliPath: runtimeCliPath });
+            node_process_1.stdout.write("Pre-commit hook installed.\n");
+        }
+        else {
+            (0, config_1.updateConfig)({ precommitHookInstalled: false, cliPath: runtimeCliPath });
+            node_process_1.stdout.write("Pre-commit protection disabled. Watch will still warn/block, but commits are not blocked.\n");
+        }
+        node_process_1.stdout.write(`Recovery bootstrap completed with ${inferredClusters.length} inferred domains.\n`);
+    }
+    finally {
+        rl.close();
+    }
+}
+async function runBootstrapRecovery(ctx, opts = {}) {
+    assertInsideGitRepo();
+    const runtimeCliPath = process.argv[1] ? (0, node_path_1.resolve)(process.argv[1]) : undefined;
+    const hookCliPath = runtimeCliPath ?? (0, node_path_1.resolve)(__dirname, "index.js");
+    const productSummary = opts.productSummary?.trim() || "Recovered existing repository baseline for supervised agent work.";
+    const architectureDomains = opts.architectureDomains ?? [];
+    const collectedEvidence = (0, git_evidence_1.collectGitEvidence)();
+    const evidence = collectedEvidence.payload;
+    const { inferredClusters, payload: bootstrapPayload } = await buildBootstrapPayloadFromEvidence(ctx, productSummary, architectureDomains, evidence);
+    await (0, http_1.postJson)(ctx, `/v1/dev/projects/${encodeURIComponent(ctx.projectId)}/bootstrap`, bootstrapPayload);
+    const recoveredDomains = inferredClusters
+        .filter(isValidAuthorityDomain)
+        .map((cluster) => ({
+        domain: cluster.suggested_name,
+        pathPatterns: cluster.files.length > 0 ? cluster.files : cluster.path_prefixes,
+        ownerAgentId: `${cluster.suggested_name} Agent`,
+        tier: cluster.protection_tier ?? (0, watch_core_1.inferTierFromDomainName)(cluster.suggested_name),
+    }));
+    (0, config_1.updateConfig)({
+        apiBaseUrl: ctx.apiBaseUrl,
+        projectId: ctx.projectId,
+        domains: recoveredDomains,
+        cliPath: runtimeCliPath,
+    });
+    writeLocalRulesArtifacts(recoveredDomains.map((domain) => ({
+        domain: domain.domain,
+        owner: domain.ownerAgentId,
+        tier: domain.tier,
+    })));
+    if (opts.installHook) {
+        (0, precommit_1.installPrecommitHookWithPath)(hookCliPath);
+        (0, config_1.updateConfig)({ precommitHookInstalled: true, cliPath: runtimeCliPath });
+    }
+    node_process_1.stdout.write([
+        "Recovery baseline created.",
+        `Domains mapped: ${recoveredDomains.length}.`,
+        "Project context and local rules are now ready.",
+        "",
+    ].join("\n"));
+}

package/dist/memory-context-render.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderMemoryContextLines = renderMemoryContextLines;
+exports.renderWatchMemoryContext = renderWatchMemoryContext;
+function isRelevant(context) {
+    return Boolean(context?.relevant);
+}
+function renderMemoryContextLines(context, options) {
+    if (!isRelevant(context))
+        return [];
+    const prefix = options?.prefix ?? "";
+    const lines = [];
+    const traps = context.items.filter((item) => item.type === "known_trap" || item.type === "invariant");
+    const lessons = context.items.filter((item) => item.type === "accepted_lesson");
+    const contextItems = [...traps, ...lessons].slice(0, 3);
+    if (contextItems.length > 0) {
+        lines.push(`${prefix}Memory context:`);
+        for (const item of contextItems) {
+            const label = item.type === "known_trap" ? "Known trap" : item.type === "invariant" ? "Invariant" : "Lesson";
+            lines.push(`${prefix}- ${label}: ${item.summary}`);
+        }
+    }
+    if (context.proof_requirements.length > 0) {
+        lines.push(`${prefix}Memory-derived proof requirements:`);
+        for (const req of context.proof_requirements) {
+            const status = req.satisfied ? "satisfied" : "missing";
+            lines.push(`${prefix}- ${req.requirement}`);
+            lines.push(`${prefix}  Status: ${status}`);
+        }
+    }
+    return lines;
+}
+function renderWatchMemoryContext(context) {
+    if (!isRelevant(context))
+        return [];
+    const lines = ["AgentBridge memory context:"];
+    const traps = context.items.filter((item) => item.type === "known_trap");
+    if (traps.length > 0) {
+        lines.push("Known traps:");
+        for (const trap of traps.slice(0, 3)) {
+            lines.push(`- ${trap.summary}`);
+        }
+    }
+    if (context.proof_requirements.length > 0) {
+        lines.push("Memory-derived proof requirements:");
+        for (const req of context.proof_requirements.slice(0, 4)) {
+            lines.push(`- ${req.requirement}`);
+        }
+    }
+    return lines;
+}

package/dist/operator-snapshot.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.COMPLETION_STATE_LABELS = void 0;
+exports.buildOperatorSnapshot = buildOperatorSnapshot;
+exports.renderOperatorSnapshotHuman = renderOperatorSnapshotHuman;
+exports.renderOperatorNextStepBlock = renderOperatorNextStepBlock;
+const canonical_state_1 = require("./canonical-state");
+exports.COMPLETION_STATE_LABELS = {
+    no_current_session: "No current session",
+    needs_proof: "Needs proof",
+    stale_evidence: "Needs proof — stale evidence",
+    failed: "Failed",
+    needs_review: "Needs review",
+    ready_for_handoff: "Ready for handoff",
+    ready_to_accept: "Ready to accept",
+    accepted: "Accepted",
+};
+function quote(value) {
+    return value.replace(/"/g, '\\"');
+}
+function inferNoSessionNextAction(resolution) {
+    if (resolution.state === "other_active_sessions_exist") {
+        return "agentbridge session list --active";
+    }
+    if (resolution.state === "ambiguous_active_sessions") {
+        if (resolution.requestedChangeRequestId) {
+            return `agentbridge session list --change-request "${quote(resolution.requestedChangeRequestId)}" --active`;
+        }
+        return "agentbridge session list --active";
+    }
+    if (resolution.state === "mismatch" || resolution.state === "stale_orphan_session_detected") {
+        return 'agentbridge session abandon --reason "clear stale/mismatched local session"';
+    }
+    if (resolution.state === "current_session_closed") {
+        return 'agentbridge session abandon --reason "session closed on server"';
+    }
+    return "agentbridge watch";
+}
+function inferReportNextAction(report) {
+    if (report.completion?.nextCommand && report.completion.nextCommand.trim().length > 0) {
+        return report.completion.nextCommand.trim();
+    }
+    const state = report.completion?.state ?? report.decision;
+    switch (state) {
+        case "needs_proof":
+        case "stale_evidence":
+            return "agentbridge verify -- <command>";
+        case "failed":
+            return "agentbridge check";
+        case "needs_review":
+            return "agentbridge handoff --summary \"<what changed>\"";
+        case "ready_for_handoff":
+            return 'agentbridge handoff --summary "<what changed>"';
+        case "ready_to_accept":
+            return "agentbridge accept";
+        case "accepted":
+            return "agentbridge watch";
+        default:
+            return "agentbridge check";
+    }
+}
+function buildOperatorSnapshot(resolution) {
+    const report = resolution.binding?.report;
+    const completionState = report?.completion?.state ?? report?.decision ?? "no_current_session";
+    const nextAction = report ? inferReportNextAction(report) : inferNoSessionNextAction(resolution);
+    const nextReason = report?.completion?.blockingReasons?.[0] ?? report?.next_required_action?.[0] ?? resolution.message;
+    return {
+        completion_state: completionState,
+        completion_state_label: exports.COMPLETION_STATE_LABELS[completionState],
+        decision: report?.decision ?? "none",
+        next_action: nextAction,
+        next_reason: nextReason,
+        work_context_state: (0, canonical_state_1.toCanonicalWorkContextState)(resolution.state),
+        work_context_source: resolution.contextSource,
+        has_current_session: resolution.state === "current_session_resolved" && !!resolution.binding,
+        current_change_request_id: report?.change_request_id ?? resolution.resolvedChangeRequestId,
+        current_work_session_id: report?.work_session_id ?? resolution.resolvedServerSessionId,
+        other_active_sessions_count: resolution.otherActiveSessions.length,
+        changed_files_count: report?.changed_files?.length ?? 0,
+        evidence_missing_count: report?.evidence_missing?.length ?? 0,
+        risks_remaining_count: report?.risks_remaining?.length ?? 0,
+        protocol_warnings_count: report?.protocol_warnings?.length ?? 0,
+    };
+}
+function renderOperatorSnapshotHuman(snapshot) {
+    return [
+        `State: ${snapshot.completion_state}`,
+        `Next: ${snapshot.next_action}`,
+        `Why: ${snapshot.next_reason}`,
+    ].join("\n");
+}
+function renderOperatorNextStepBlock(snapshot) {
+    return [
+        "Operator next step:",
+        `- state: ${snapshot.completion_state}`,
+        `- next action: ${snapshot.next_action}`,
+        `- why: ${snapshot.next_reason}`,
+    ];
+}

package/dist/precommit.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPrecommitCheck = runPrecommitCheck;
+exports.readStagedFilesFromGitDiff = readStagedFilesFromGitDiff;
+exports.stagedFilesFromGit = stagedFilesFromGit;
+exports.blockedFilesFromSession = blockedFilesFromSession;
+exports.runPrecommitCheckFromSession = runPrecommitCheckFromSession;
+exports.installPrecommitHook = installPrecommitHook;
+exports.installPrecommitHookWithPath = installPrecommitHookWithPath;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_child_process_1 = require("node:child_process");
+const session_state_1 = require("./session-state");
+function runPrecommitCheck(input) {
+    void input.stagedFiles;
+    const blocked = [...new Set(input.blockedFiles)];
+    return { ok: blocked.length === 0, blocked };
+}
+function readStagedFilesFromGitDiff(diffTextPath) {
+    const raw = (0, node_fs_1.readFileSync)(diffTextPath, "utf8");
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function stagedFilesFromGit() {
+    const raw = (0, node_child_process_1.execSync)("git diff --name-only --cached", {
+        encoding: "utf8",
+        stdio: ["ignore", "pipe", "pipe"],
+    });
+    return raw
+        .split("\n")
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+function blockedFilesFromSession() {
+    const state = (0, session_state_1.readSessionState)();
+    if (!state) {
+        return [];
+    }
+    return state.crossings
+        .filter((crossing) => (crossing.status === "unresolved" || crossing.status === "handoff") &&
+        (crossing.tier === "tier_a" || crossing.tier === "tier_b"))
+        .map((crossing) => crossing.file);
+}
+function runPrecommitCheckFromSession(stagedFiles) {
+    return runPrecommitCheck({
+        stagedFiles,
+        blockedFiles: blockedFilesFromSession(),
+    });
+}
+function installPrecommitHook() {
+    const runtimeCliPath = process.argv[1] ? (0, node_path_1.resolve)(process.argv[1]) : (0, node_path_1.resolve)(__dirname, "index.js");
+    installPrecommitHookWithPath(runtimeCliPath);
+}
+function installPrecommitHookWithPath(cliPath) {
+    const hookPath = (0, node_path_1.resolve)(process.cwd(), ".git", "hooks", "pre-commit");
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.resolve)(process.cwd(), ".git"))) {
+        return;
+    }
+    const escapedCliPath = cliPath.replace(/"/g, '\\"');
+    const script = `#!/bin/sh
+node "${escapedCliPath}" precommit-check
+status=$?
+if [ "$status" -ne 0 ]; then
+  echo "agentbridge: unresolved protected crossing; resolve authority request first."
+fi
+exit "$status"
+`;
+    (0, node_fs_1.writeFileSync)(hookPath, script, "utf8");
+    (0, node_fs_1.chmodSync)(hookPath, 0o755);
+}