@agentbridge1/cli 0.0.1

package/dist/commands/doctor.js

@@ -0,0 +1,300 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runDoctor = runDoctor;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const config_1 = require("../config");
+const error_catalog_1 = require("../error-catalog");
+const errors_1 = require("../errors");
+const http_1 = require("../http");
+const dist_freshness_1 = require("./dist-freshness");
+const session_state_1 = require("../session-state");
+const server_sync_1 = require("../server-sync");
+function cliRootFromCommandDir() {
+    return (0, node_path_1.resolve)(__dirname, "..", "..");
+}
+function normalizeReasonCandidate(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    const lowered = trimmed.toLowerCase();
+    if (lowered.includes("not_project_member"))
+        return "not_project_member";
+    if (lowered.includes("unauthorized") || lowered.includes("invalid_api_key"))
+        return "unauthorized";
+    if (lowered.includes("forbidden"))
+        return "forbidden";
+    if (lowered.includes("project_not_found"))
+        return "project_not_found";
+    if (lowered.includes("not_found") && lowered.includes("project"))
+        return "project_not_found";
+    if (lowered.includes("too_many_requests") || lowered.includes("rate_limit"))
+        return "rate_limited";
+    if (lowered.includes("timed_out") || lowered.includes("timeout"))
+        return "request_timeout";
+    if (lowered.includes("network_error") ||
+        lowered.includes("fetch failed") ||
+        lowered.includes("econnrefused") ||
+        lowered.includes("econnreset") ||
+        lowered.includes("enotfound")) {
+        return "network_error";
+    }
+    const normalized = lowered.replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+    if (normalized.length === 0)
+        return undefined;
+    if (normalized.length <= 64)
+        return normalized;
+    return undefined;
+}
+function extractHttpReason(error) {
+    const rawBodyReason = normalizeReasonCandidate(error.body);
+    if (rawBodyReason) {
+        return rawBodyReason;
+    }
+    if (error.body) {
+        try {
+            const parsed = JSON.parse(error.body);
+            const code = parsed.error?.code ?? parsed.code;
+            const codeReason = normalizeReasonCandidate(code);
+            if (codeReason)
+                return codeReason;
+            const message = parsed.error?.message ?? parsed.message;
+            const messageReason = normalizeReasonCandidate(message);
+            if (messageReason)
+                return messageReason;
+        }
+        catch {
+            // fall through to status/body fallback
+        }
+    }
+    if (error.status === 404) {
+        return "project_not_found";
+    }
+    if (error.status === 429) {
+        return "rate_limited";
+    }
+    if (error.status === 403) {
+        return "forbidden";
+    }
+    if (error.status === 401) {
+        return "unauthorized";
+    }
+    if (error.status >= 500) {
+        return "server_error";
+    }
+    return `http_${error.status}`;
+}
+async function checkProjectAccess(ctx) {
+    if (!ctx.configComplete) {
+        return {
+            status: "skipped",
+            reason: "config_incomplete",
+        };
+    }
+    const projectId = ctx.projectId;
+    const apiKey = ctx.apiKey;
+    const apiBaseUrl = ctx.apiBaseUrl;
+    try {
+        await (0, http_1.getJson)({ projectId, apiKey, apiBaseUrl, apiKeySource: "config" }, `/v1/dev/projects/${encodeURIComponent(projectId)}/packet`);
+        return { status: "ok" };
+    }
+    catch (error) {
+        if (error instanceof http_1.CliHttpError) {
+            const reason = extractHttpReason(error);
+            if (reason === "not_project_member") {
+                return {
+                    status: "failed",
+                    reason,
+                    suggestedNextAction: "use an API key/agent that is a member of this project, or add this agent to the project.",
+                };
+            }
+            if (reason === "unauthorized") {
+                return {
+                    status: "failed",
+                    reason,
+                    suggestedNextAction: "verify AGENTBRIDGE_API_KEY is valid for this environment and has project read access.",
+                };
+            }
+            if (reason === "project_not_found") {
+                return {
+                    status: "failed",
+                    reason,
+                    suggestedNextAction: "verify AGENTBRIDGE_PROJECT_ID points to an existing project in this API environment.",
+                };
+            }
+            return {
+                status: "failed",
+                reason,
+                suggestedNextAction: "confirm project ID, API key, and base URL are correct and that this key has project read access.",
+            };
+        }
+        const messageReason = error instanceof Error ? normalizeReasonCandidate(error.message) : undefined;
+        return {
+            status: "failed",
+            reason: messageReason ?? "network_error",
+            suggestedNextAction: "check network reachability to the API base URL and retry doctor.",
+        };
+    }
+}
+async function checkIdentityAccess(ctx) {
+    if (!ctx.configComplete) {
+        return { status: "skipped", reason: "config_incomplete" };
+    }
+    try {
+        const syncCtx = {
+            projectId: ctx.projectId,
+            apiKey: ctx.apiKey,
+            apiBaseUrl: ctx.apiBaseUrl,
+            apiKeySource: "config",
+        };
+        const [callerPacket, identities] = await Promise.all([
+            (0, server_sync_1.fetchCallerIdentityPacket)(syncCtx),
+            (0, server_sync_1.listWorkIdentities)(syncCtx),
+        ]);
+        const callerId = callerPacket?.work_identity?.id ?? null;
+        if (callerId)
+            return { status: "ok" };
+        if (identities.length === 1)
+            return { status: "ok" };
+        return { status: "failed", reason: "caller_identity_unresolved" };
+    }
+    catch {
+        return { status: "failed", reason: "caller_identity_unresolved" };
+    }
+}
+async function runDoctor(cliRootOverride) {
+    const cliRoot = cliRootOverride ?? cliRootFromCommandDir();
+    const cfg = (0, config_1.readConfig)();
+    const freshness = (0, dist_freshness_1.getDistFreshnessReport)(cliRoot);
+    const configPath = cliRootOverride
+        ? (0, node_path_1.resolve)(cliRoot, "..", ".agentbridge", "config.json")
+        : config_1.CONFIG_PATH;
+    const projectConfigFilePresent = (0, node_fs_1.existsSync)(configPath);
+    const resolvedProjectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId;
+    const resolvedApiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey;
+    const resolvedBaseUrl = process.env.AGENTBRIDGE_BASE_URL ??
+        cfg.apiBaseUrl ??
+        "https://agentauth-api-production.up.railway.app";
+    const resolvedAgentId = process.env.AGENTBRIDGE_AGENT_ID ?? cfg.activeAgentId;
+    const projectIdPresent = Boolean(resolvedProjectId);
+    const apiKeyPresent = Boolean(resolvedApiKey);
+    const baseUrlPresent = Boolean(resolvedBaseUrl);
+    const agentIdPresent = Boolean(resolvedAgentId);
+    const projectConfigPresent = projectIdPresent && apiKeyPresent && baseUrlPresent;
+    const activeSession = (0, session_state_1.readSessionState)();
+    const hasActiveWork = Boolean(activeSession?.id || activeSession?.serverSessionId);
+    const envContributed = Boolean(process.env.AGENTBRIDGE_PROJECT_ID) ||
+        Boolean(process.env.AGENTBRIDGE_API_KEY) ||
+        Boolean(process.env.AGENTBRIDGE_BASE_URL) ||
+        Boolean(process.env.AGENTBRIDGE_AGENT_ID);
+    const fileContributed = Boolean(cfg.projectId) || Boolean(cfg.apiKey) || Boolean(cfg.apiBaseUrl) || Boolean(cfg.activeAgentId);
+    const configSource = envContributed && fileContributed ? "mixed" : envContributed ? "env" : fileContributed ? "file" : "missing";
+    const lines = [];
+    lines.push("AgentBridge CLI doctor");
+    lines.push(`CLI dist: ${freshness.state}`);
+    lines.push(`Build timestamp: ${freshness.builtAt ?? "unknown"}`);
+    lines.push(`Git head: ${freshness.gitHead ?? "unknown"}`);
+    lines.push(`Source newer than dist: ${freshness.sourceNewerThanDist}`);
+    if (freshness.reason) {
+        lines.push(`Dist reason: ${freshness.reason}`);
+    }
+    lines.push(`Project config present: ${projectConfigPresent ? "yes" : "no"}`);
+    lines.push(`Project config file present: ${projectConfigFilePresent ? "yes" : "no"}`);
+    lines.push(`Project ID present: ${projectIdPresent ? "yes" : "no"}`);
+    lines.push(`Base URL present: ${baseUrlPresent ? "yes" : "no"}`);
+    lines.push(`API key present: ${apiKeyPresent ? "yes" : "no"}`);
+    lines.push(`Agent ID present: ${agentIdPresent ? "yes" : "no"}`);
+    lines.push(`Config source: ${configSource}`);
+    lines.push(`Active work state: ${hasActiveWork ? "found" : "none"}`);
+    const projectAccess = await checkProjectAccess({
+        projectId: resolvedProjectId,
+        apiKey: resolvedApiKey,
+        apiBaseUrl: resolvedBaseUrl,
+        configComplete: projectConfigPresent,
+    });
+    lines.push(`Project access: ${projectAccess.status}`);
+    if (projectAccess.reason) {
+        lines.push(`Project access reason: ${projectAccess.reason}`);
+    }
+    const identityAccess = await checkIdentityAccess({
+        projectId: resolvedProjectId,
+        apiKey: resolvedApiKey,
+        apiBaseUrl: resolvedBaseUrl,
+        configComplete: projectConfigPresent && projectAccess.status === "ok",
+    });
+    lines.push(`Caller identity access: ${identityAccess.status}`);
+    if (identityAccess.reason) {
+        lines.push(`Caller identity reason: ${identityAccess.reason}`);
+    }
+    if (projectAccess.status === "failed" && projectAccess.reason) {
+        const view = (0, error_catalog_1.catalogViewForDoctorReason)(projectAccess.reason, projectAccess.suggestedNextAction);
+        lines.push("");
+        lines.push((0, errors_1.renderCliErrorView)(view));
+    }
+    else if (projectAccess.status === "failed" && projectAccess.suggestedNextAction) {
+        lines.push(`Suggested next action: ${projectAccess.suggestedNextAction}`);
+    }
+    else if (freshness.state === "stale") {
+        lines.push("Suggested next action: run npm run build:cli, then rerun doctor.");
+    }
+    else if (freshness.state === "unknown") {
+        lines.push("Suggested next action: run npm run build:cli to generate dist metadata.");
+    }
+    else {
+        lines.push("Suggested next action: run npm run dogfood:check before external dogfood.");
+    }
+    let productStatus = "not_ready";
+    if (projectAccess.status === "ok" && identityAccess.status === "ok") {
+        if (hasActiveWork) {
+            productStatus = "active_work_found";
+        }
+        else {
+            productStatus =
+                cfg.domains && cfg.domains.length > 0
+                    ? "ready"
+                    : "needs_recover";
+        }
+    }
+    lines.push("");
+    lines.push("Product status:");
+    if (productStatus === "ready") {
+        lines.push("- Connection: ready");
+        lines.push("- Recovery: ready");
+        lines.push("- Next: agentbridge start");
+    }
+    else if (productStatus === "active_work_found") {
+        lines.push("- Connection: ready");
+        lines.push("- Recovery: ready");
+        lines.push("- Active work: found");
+        lines.push("- Next: agentbridge start");
+    }
+    else if (productStatus === "needs_recover") {
+        lines.push("- Connection: ready");
+        lines.push("- Recovery: required");
+        lines.push("- Next: agentbridge recover");
+    }
+    else {
+        lines.push("- Connection: required");
+        lines.push("- Recovery: pending");
+        if (!projectConfigPresent) {
+            lines.push("- Note: Connection details are missing. Add credentials, then rerun agentbridge doctor.");
+        }
+        else if (identityAccess.status !== "ok") {
+            lines.push("- Note: Caller identity is unresolved. Run agentbridge identity list and set a valid active agent.");
+        }
+        else {
+            lines.push("- Note: Connection check failed. Verify credentials/network, then rerun agentbridge doctor.");
+        }
+        lines.push("- Next: agentbridge doctor");
+    }
+    process.stdout.write(`${lines.join("\n")}\n`);
+    if (freshness.state === "stale")
+        return 1;
+    if (projectAccess.status === "failed")
+        return 1;
+    if (identityAccess.status === "failed")
+        return 1;
+    return 0;
+}

package/dist/commands/done.js

@@ -0,0 +1,292 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.__doneInternals = void 0;
+exports.runDone = runDone;
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const acceptance_preflight_1 = require("../acceptance-preflight");
+const acceptance_block_1 = require("../acceptance-block");
+const work_context_resolver_1 = require("../work-context-resolver");
+const operator_snapshot_1 = require("../operator-snapshot");
+const operator_snapshot_2 = require("../operator-snapshot");
+const proof_guidance_1 = require("../proof-guidance");
+const memory_context_render_1 = require("../memory-context-render");
+const check_1 = require("./check");
+function resolveNetworkContext() {
+    const cfg = (0, config_1.readConfig)();
+    const projectId = process.env.AGENTBRIDGE_PROJECT_ID ?? cfg.projectId;
+    const apiKey = process.env.AGENTBRIDGE_API_KEY ?? cfg.apiKey ?? "";
+    const apiBaseUrl = process.env.AGENTBRIDGE_BASE_URL ?? cfg.apiBaseUrl ?? "https://agentauth-api-production.up.railway.app";
+    if (!projectId) {
+        throw new errors_1.SafeCliError("Missing AGENTBRIDGE_PROJECT_ID. Set AGENTBRIDGE_PROJECT_ID (or run `agentbridge init --project ...`).");
+    }
+    if (!apiKey) {
+        throw new errors_1.SafeCliError("Missing AGENTBRIDGE_API_KEY. Provide --api-key, set AGENTBRIDGE_API_KEY, or save apiKey in .agentbridge/config.json.");
+    }
+    return { projectId, apiKey, apiBaseUrl };
+}
+function normalizeChangedFiles(files) {
+    return [...new Set(files.map((file) => file.trim()).filter((file) => file.length > 0))].sort();
+}
+function resolveHandoffStatus(report) {
+    return report.handoff.status === "posted" ? "present" : "missing";
+}
+function renderNoActive(ctx) {
+    const cfg = (0, config_1.readConfig)();
+    const lines = [];
+    if (cfg.lastAcceptedSessionId) {
+        lines.push(`Status: no_current_session (${operator_snapshot_2.COMPLETION_STATE_LABELS.no_current_session})`);
+        lines.push("Error code: WORK_CONTEXT_NO_CURRENT_SESSION");
+        lines.push("What happened: No active tracked work session is currently resolved.");
+        lines.push("Why it matters: Done/acceptance gates cannot evaluate without a current session.");
+        lines.push(`Last accepted session: ${cfg.lastAcceptedSessionId}`);
+        lines.push("Next: agentbridge watch");
+        return lines.join("\n");
+    }
+    lines.push("Status: no_current_session (No current tracked work session)");
+    lines.push("Error code: WORK_CONTEXT_NO_CURRENT_SESSION");
+    lines.push("What happened: No active tracked work session found.");
+    lines.push("Why it matters: Done/acceptance gates cannot evaluate without a current session.");
+    lines.push("Next: agentbridge watch");
+    return lines.join("\n");
+}
+function renderList(title, values) {
+    if (values.length === 0)
+        return [title, "- none"];
+    return [title, ...values.map((value, index) => `${index + 1}. ${value}`)];
+}
+function renderEvidenceSummary(report) {
+    if (report.verification_runs.length === 0)
+        return "none";
+    const fresh = report.verification_runs.filter((run) => !run.stale);
+    const stale = report.verification_runs.filter((run) => run.stale);
+    const freshText = fresh.length > 0 ? fresh.map((run) => `[${run.status}] ${run.command}`).join(" | ") : "none";
+    const staleText = stale.length > 0 ? stale.map((run) => `[${run.status}] ${run.command} (stale)`).join(" | ") : "none";
+    return `Fresh: ${freshText}; Stale: ${staleText}`;
+}
+function suggestVerifyCommand(report, changedFiles) {
+    const detailSuggestion = (0, proof_guidance_1.getMissingProofDetails)(report)
+        .map((detail) => detail.suggested_verify?.trim())
+        .find((value) => Boolean(value && value.length > 0));
+    if (detailSuggestion)
+        return detailSuggestion;
+    const candidates = (0, proof_guidance_1.suggestVerifyCommands)([...changedFiles, ...report.changed_files], report.detected_work_type);
+    return candidates[0] ?? "agentbridge verify -- <command>";
+}
+function buildNeedsProofPrompt(report, verifyCommand, missingDetails = (0, proof_guidance_1.getMissingProofDetails)(report)) {
+    const numbered = (missingDetails.length > 0
+        ? missingDetails.map((detail) => `${detail.message}\n   Why: ${detail.why}\n   Source/rule: ${detail.source_rule}\n   Recipe: ${detail.proof_recipe}`)
+        : ["(no explicit missing proof listed)"])
+        .map((item, idx) => `${idx + 1}. ${item}`)
+        .join("\n");
+    return (`"Before this work can be accepted, complete the following proof items:\n` +
+        `${numbered}\n` +
+        `Run the relevant verification commands.\n` +
+        `Suggested first command: ${verifyCommand}\n` +
+        `Return exact outputs.\n` +
+        `Do not modify unrelated files."`);
+}
+function buildFailedPrompt(report) {
+    const failed = report.verification_runs
+        .filter((run) => run.status === "failed")
+        .map((run) => run.command);
+    const reasons = failed.length > 0 ? failed : report.next_required_action;
+    const numbered = (reasons.length > 0 ? reasons : ["(no explicit failure reason listed)"])
+        .map((item, idx) => `${idx + 1}. ${item}`)
+        .join("\n");
+    return (`"This work failed acceptance because:\n` +
+        `${numbered}\n` +
+        `Investigate only the changed files and failed evidence.\n` +
+        `Do not broaden scope."`);
+}
+function buildNeedsReviewPrompt(report) {
+    const scopeDriftReasons = (report.out_of_scope_files ?? []).length > 0
+        ? (report.out_of_scope_files ?? []).map((file, idx) => `${idx + 1}. out-of-scope file: ${file}`)
+        : [];
+    const fallbackReasons = report.next_required_action.length > 0
+        ? report.next_required_action.map((item, idx) => `${idx + 1}. ${item}`)
+        : ["1. (no explicit review reason listed)"];
+    const reasons = [...scopeDriftReasons, ...fallbackReasons].join("\n");
+    return (`"This work needs review due to scope/boundary constraints:\n` +
+        `${reasons}\n` +
+        `Revert/remove out-of-scope files, rerun agentbridge check, then continue.\n` +
+        `Do not broaden implementation."`);
+}
+function renderAcceptanceSweep(report, preSyncedChangedFiles) {
+    const lines = [];
+    const handoffStatus = resolveHandoffStatus(report);
+    const changedUnion = normalizeChangedFiles([...preSyncedChangedFiles, ...report.changed_files]);
+    const changedFiles = changedUnion.length > 0 ? changedUnion.join(", ") : "none";
+    const evidenceSummary = renderEvidenceSummary(report);
+    const missingDetails = (0, proof_guidance_1.getMissingProofDetails)(report);
+    const verifyCommand = suggestVerifyCommand(report, changedUnion);
+    let statusState = "no_current_session";
+    let exactNextAction = "agentbridge check";
+    let next = `Next: ${exactNextAction}`;
+    const completionState = report.completion.state;
+    if (completionState === "needs_proof") {
+        statusState = "needs_proof";
+        exactNextAction = verifyCommand;
+        next = "Next: agentbridge verify -- <command>";
+    }
+    else if (completionState === "stale_evidence") {
+        statusState = "stale_evidence";
+        exactNextAction = verifyCommand;
+        next = "Next: agentbridge verify -- <command> (re-verify after file change)";
+    }
+    else if (completionState === "failed") {
+        statusState = "failed";
+        exactNextAction = "investigate failed evidence in changed files only";
+        next = "Next: investigate failed evidence in changed files only";
+    }
+    else if (completionState === "needs_review") {
+        statusState = "needs_review";
+        if ((report.out_of_scope_files ?? []).length > 0) {
+            exactNextAction = "revert/remove out-of-scope files, then rerun agentbridge check";
+            next = "Next: revert/remove out-of-scope files, then rerun agentbridge check";
+        }
+        else {
+            exactNextAction = "request approval / handoff / update scope";
+            next = "Next: request approval / handoff / update scope";
+        }
+    }
+    else if (completionState === "ready_for_handoff") {
+        statusState = "ready_for_handoff";
+        exactNextAction = 'agentbridge handoff --summary "<what changed>"';
+        next = 'Next: agentbridge handoff --summary "<what changed>"';
+    }
+    else if (completionState === "ready_to_accept") {
+        statusState = "ready_to_accept";
+        exactNextAction = "agentbridge accept";
+        next = "Next: agentbridge accept";
+    }
+    else if (completionState === "accepted") {
+        statusState = "accepted";
+        exactNextAction = "agentbridge watch";
+        next = "Next: agentbridge watch";
+    }
+    else {
+        statusState = "no_current_session";
+        exactNextAction = "agentbridge watch";
+        next = "Next: agentbridge watch";
+    }
+    lines.push("ACCEPTANCE SWEEP");
+    lines.push(`Status: ${statusState} (${operator_snapshot_2.COMPLETION_STATE_LABELS[statusState]})`);
+    lines.push(`Current CR/session: ${report.change_request_id ?? "none"} / ${report.work_session_id}`);
+    lines.push(`Changed files: ${changedFiles}`);
+    lines.push(`Evidence summary: ${evidenceSummary}`);
+    if (report.proof_quality) {
+        lines.push(`Proof confidence: ${report.proof_quality.confidence_level}`);
+        if (report.proof_quality.missing_robustness.length > 0) {
+            lines.push(`Missing robustness: ${report.proof_quality.missing_robustness.join(" | ")}`);
+        }
+    }
+    const memoryContextLines = (0, memory_context_render_1.renderMemoryContextLines)(report.memory_context);
+    if (memoryContextLines.length > 0) {
+        lines.push("");
+        lines.push(...memoryContextLines);
+    }
+    lines.push(`Missing proof: ${missingDetails.length > 0 ? missingDetails.map((detail) => detail.message).join(" | ") : "none"}`);
+    lines.push(`Risks remaining: ${report.risks_remaining.length > 0 ? report.risks_remaining.join(" | ") : "none"}`);
+    lines.push(`Protocol warnings: ${report.protocol_warnings.length > 0
+        ? report.protocol_warnings.map((warning) => `${warning.code}: ${warning.message}`).join(" | ")
+        : "none"}`);
+    lines.push(`Handoff status: ${handoffStatus}`);
+    lines.push(`Acceptance decision: ${report.decision}`);
+    lines.push(`Exact next action: ${exactNextAction}`);
+    lines.push(next);
+    if (completionState === "needs_proof") {
+        lines.push("");
+        lines.push("Missing proof list:");
+        if (missingDetails.length === 0) {
+            lines.push("1. (no explicit missing proof listed)");
+        }
+        else {
+            for (const [index, detail] of missingDetails.entries()) {
+                lines.push(`${index + 1}. ${detail.message}`);
+                lines.push(`   Why: ${detail.why}`);
+                lines.push(`   Source/rule: ${detail.source_rule}`);
+                lines.push(`   Recipe: ${detail.proof_recipe}`);
+                if (detail.suggested_verify) {
+                    lines.push(`   Suggested verify: ${detail.suggested_verify}`);
+                }
+            }
+        }
+        lines.push("Copy this back to the agent:");
+        lines.push(buildNeedsProofPrompt(report, verifyCommand, missingDetails));
+    }
+    else if (completionState === "stale_evidence") {
+        lines.push("");
+        lines.push("Stale evidence (PROOF_STALE_AFTER_CHANGE):");
+        if ((report.stale_files ?? []).length > 0) {
+            lines.push(...renderList("Files needing re-verification:", report.stale_files ?? []));
+        }
+        lines.push("Copy this back to the agent:");
+        lines.push((0, check_1.buildStaleProofPrompt)(report));
+    }
+    else if (completionState === "failed") {
+        const failedEvidence = report.verification_runs
+            .filter((run) => run.status === "failed")
+            .map((run) => run.command);
+        lines.push("");
+        lines.push(...renderList("Failed evidence/reasons:", failedEvidence.length > 0 ? failedEvidence : report.next_required_action));
+        lines.push("Copy this back to the agent:");
+        lines.push(buildFailedPrompt(report));
+    }
+    else if (completionState === "needs_review") {
+        lines.push("");
+        if ((report.out_of_scope_files ?? []).length > 0) {
+            lines.push("Scope drift (SCOPE_DRIFT_OUT_OF_SCOPE_FILE):");
+            lines.push(...(report.out_of_scope_files ?? []).map((file) => `- ${file}`));
+        }
+        else {
+            lines.push(...renderList("Scope/boundary reasons:", report.next_required_action));
+        }
+        lines.push("Copy this back to the agent:");
+        lines.push(buildNeedsReviewPrompt(report));
+    }
+    if (report.protocol_warnings.length > 0) {
+        lines.push("");
+        lines.push("Protocol warnings:");
+        for (const warning of report.protocol_warnings) {
+            lines.push(`- ${warning.code}: ${warning.message}`);
+        }
+    }
+    return lines.join("\n");
+}
+async function runDone(options = {}) {
+    const ctx = resolveNetworkContext();
+    const { resolution, preflight, report } = await (0, acceptance_preflight_1.resolveAcceptanceWorkContext)(ctx);
+    const snapshot = (0, operator_snapshot_1.buildOperatorSnapshot)(resolution);
+    const preSyncedChangedFiles = preflight.observedFiles;
+    if (resolution.state !== "current_session_resolved" || !report) {
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({ snapshot }, null, 2)}\n`);
+            process.exitCode = 1;
+            return;
+        }
+        const body = resolution.state === "no_current_session"
+            ? `${renderNoActive(ctx)}\n\n${(0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n")}`
+            : (0, work_context_resolver_1.renderWorkContextLines)(resolution).join("\n");
+        process.stdout.write(`${body}\n`);
+        process.exitCode = 1;
+        return;
+    }
+    if (options.json) {
+        process.stdout.write(`${JSON.stringify({ snapshot, acceptance_report: report }, null, 2)}\n`);
+        if ((0, acceptance_block_1.shouldBlockAcceptanceAction)(report)) {
+            process.exitCode = 1;
+        }
+        return;
+    }
+    const rendered = renderAcceptanceSweep(report, preSyncedChangedFiles);
+    process.stdout.write(`${rendered}\n`);
+    if ((0, acceptance_block_1.shouldBlockAcceptanceAction)(report)) {
+        process.exitCode = 1;
+    }
+}
+exports.__doneInternals = {
+    renderAcceptanceSweep,
+    resolveHandoffStatus,
+    renderNoActive,
+};