commandmate 0.26.1 → 0.27.0

package/dist/server/src/lib/detection/tools/registry.js

@@ -0,0 +1,58 @@
+"use strict";
+/**
+ * The tool → detector lookup (Issue #1927, 方針書 §4 D2).
+ *
+ * Every CLI resolves to a detector, including the ones with no branches of their
+ * own: `gemini` and `vibe-local` get {@link createGenericStatusDetector}, which
+ * is the shared chain with no tool steps and no idle rule. Returning a real
+ * detector for them rather than `null` is what keeps the caller free of a
+ * "does this tool have a module?" branch — the shape §4 D2 asks for.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TOOL_STATUS_DETECTORS = void 0;
+exports.createGenericStatusDetector = createGenericStatusDetector;
+exports.getToolStatusDetector = getToolStatusDetector;
+const detect_1 = require("./antigravity/detect");
+const detect_2 = require("./claude/detect");
+const detect_3 = require("./codex/detect");
+const detect_4 = require("./copilot/detect");
+const detect_5 = require("./opencode/detect");
+const run_detection_1 = require("./run-detection");
+const verified_against_1 = require("./verified-against");
+/**
+ * A tool whose frames nobody has measured yet.
+ *
+ * The shared chain and nothing else: prompt detection, the thinking window, the
+ * generic composer check, the two heuristics. No `readIdleEvidence`, so its
+ * `input_prompt` keeps the pre-#1927 reading (DR2-002), and no
+ * `unreadableReason`, so its floor stays the generic `default`.
+ */
+function createGenericStatusDetector(tool) {
+    return (0, run_detection_1.createToolStatusDetector)({
+        tool,
+        verifiedAgainst: verified_against_1.UNMEASURED_VERIFIED_AGAINST,
+    });
+}
+const geminiStatusDetector = createGenericStatusDetector('gemini');
+const vibeLocalStatusDetector = createGenericStatusDetector('vibe-local');
+const DETECTORS = {
+    claude: detect_2.claudeStatusDetector,
+    codex: detect_3.codexStatusDetector,
+    copilot: detect_4.copilotStatusDetector,
+    opencode: detect_5.opencodeStatusDetector,
+    antigravity: detect_1.antigravityStatusDetector,
+    gemini: geminiStatusDetector,
+    'vibe-local': vibeLocalStatusDetector,
+};
+/**
+ * The detector for one CLI.
+ *
+ * Falls back to a generic detector for an id outside {@link CLIToolType} —
+ * callers reach this from route params and CLI flags, and a crash there would be
+ * a worse answer than "no tool-specific rules apply".
+ */
+function getToolStatusDetector(cliToolId) {
+    return DETECTORS[cliToolId] ?? createGenericStatusDetector(cliToolId);
+}
+/** Every detector, for the fixture sweep in `tests/unit/detection/tools/`. */
+exports.TOOL_STATUS_DETECTORS = Object.values(DETECTORS);

package/dist/server/src/lib/detection/tools/run-detection.js

@@ -0,0 +1,202 @@
+"use strict";
+/**
+ * The shared priority chain every {@link ToolStatusDetector} runs
+ * (Issue #1927, 方針書 §4 D2).
+ *
+ * The order below is the order `detectSessionStatus` has always used; what moved
+ * is where the per-tool steps live. Each tool module now owns its own branches
+ * and hands them back through {@link ToolDetectorSpec}, so the shared middle —
+ * prompt detection, the thinking window, the composer check, the two
+ * heuristics — is written once instead of being interleaved with seven tools'
+ * special cases.
+ *
+ * ```
+ *  0.x  spec.beforePrompt      tool pickers / pagers / status bars
+ *  1    detectPrompt           shared, with spec.isStalePrompt as the #1160 guard
+ *  1.5  spec.afterPrompt       tool selection-list footers
+ *  2    detectThinking         shared, 5-line window
+ *  2.x  spec.afterThinking     tool running + completion markers
+ *  3    promptPattern          shared composer check, gated by D1 evidence
+ *  4    staleness heuristic    `no_recent_output`
+ *  5    floor                  `unknown_frame` / `default`
+ * ```
+ *
+ * Steps 4 and 5 are where §4 D1 決定 3 lands: neither may say `ready` any more.
+ * A frame that reached them carries no evidence at all, and `ready` is the one
+ * word that must not be published on no evidence — it is what makes `wait`
+ * report a stalled worker as Completed (#1900) and what closes the send guard
+ * on a session that never finished.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runToolDetection = runToolDetection;
+exports.createToolStatusDetector = createToolStatusDetector;
+const cli_patterns_1 = require("../cli-patterns");
+const prompt_detector_1 = require("../prompt-detector");
+const status_reason_1 = require("../status-reason");
+const detection_evidence_config_1 = require("../../../config/detection-evidence-config");
+const idle_evidence_observation_1 = require("../idle-evidence-observation");
+/**
+ * Time threshold (in ms) for considering output as "stale".
+ *
+ * Unchanged since #54. What changed in #1927 is the verdict it produces: the
+ * same five seconds now mean "nothing has moved and I cannot read this frame",
+ * which is `running` with no evidence, not `ready`.
+ */
+const STALE_OUTPUT_THRESHOLD_MS = 5000;
+/**
+ * Which tools hand the FULL frame to `detectPrompt` instead of the 15-line tail.
+ *
+ * Their multiple-choice prompts with descriptions can exceed 15 lines: Codex
+ * approval prompts with long file lists, Claude "Yes, and don't ask again for:
+ * git commit -m …" options that embed full commit messages. `detectPrompt`
+ * applies its own 50-line window internally.
+ */
+const FULL_FRAME_PROMPT_TOOLS = new Set([
+    'opencode',
+    'codex',
+    'claude',
+    'copilot',
+]);
+/**
+ * Resolve the `evidence` for a `ready` / `input_prompt` verdict from the generic
+ * composer check (§4 D1 決定 1 item 2).
+ *
+ * A tool with no measured rule answers `'positive'`, which is the pre-#1927
+ * reading — the tool-by-tool rollout DR2-002 requires. A tool in `observe` mode
+ * runs its rule, counts the answer and still publishes `'positive'`, so the
+ * rollout can be measured before it is turned on (§11).
+ */
+function resolveIdleEvidence(spec, frame) {
+    if (spec.readIdleEvidence === undefined)
+        return 'positive';
+    const mode = (0, detection_evidence_config_1.resolveIdleEvidenceMode)(spec.tool);
+    if (mode === 'legacy')
+        return 'positive';
+    const evidence = spec.readIdleEvidence(frame);
+    (0, idle_evidence_observation_1.recordIdleEvidenceObservation)(spec.tool, mode, evidence);
+    return mode === 'observe' ? 'positive' : evidence;
+}
+/** Run the whole chain for one tool over one frame. */
+function runToolDetection(spec, frame, context = {}) {
+    // 0.x — the tool's own pre-prompt branches. A picker, a pager or a status bar
+    // whose body the generic parser would misread as a numbered dialog.
+    const early = spec.beforePrompt?.(frame) ?? null;
+    if (early)
+        return early;
+    // 1. Interactive prompt detection (highest shared priority).
+    // Apply stripBoxDrawing() for Gemini CLI and OpenCode TUI compatibility:
+    // Gemini wraps prompts in box-drawing characters (╭╮╰╯│─) which prevent
+    // detectPrompt() from recognizing the prompt content.
+    const promptOptions = (0, cli_patterns_1.buildDetectPromptOptions)(spec.tool);
+    const promptInput = FULL_FRAME_PROMPT_TOOLS.has(spec.tool)
+        ? (0, cli_patterns_1.stripBoxDrawing)(frame.clean)
+        : (0, cli_patterns_1.stripBoxDrawing)(frame.lastLines);
+    let promptDetection = (0, prompt_detector_1.detectPrompt)(promptInput, promptOptions);
+    if (promptDetection.isPrompt) {
+        if (spec.isStalePrompt?.(frame, promptDetection)) {
+            // Issue #1160: an ALREADY-ANSWERED block still inside the scan window.
+            // Neutralise it so Auto-Yes and the sidebar never act on a dead prompt,
+            // and let the chain continue to the tool's running/idle branches.
+            promptDetection = { ...promptDetection, isPrompt: false, promptData: undefined };
+        }
+        else {
+            return {
+                status: 'waiting',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.PROMPT_DETECTED,
+                hasActivePrompt: true,
+                evidence: 'positive',
+                promptDetection,
+            };
+        }
+    }
+    // 1.5 — tool branches that must sit between prompt detection and the thinking
+    // window (Claude's selection-list footer).
+    const afterPrompt = spec.afterPrompt?.(frame, promptDetection) ?? null;
+    if (afterPrompt)
+        return { ...afterPrompt, promptDetection: afterPrompt.promptDetection ?? promptDetection };
+    // 2. Thinking indicator detection — THINKING_TAIL_LINE_COUNT window (narrower).
+    // CLI tool is actively processing (shows spinner, "Planning...", etc.)
+    if ((0, cli_patterns_1.detectThinking)(spec.tool, frame.thinkingLines)) {
+        return {
+            status: 'running',
+            confidence: 'high',
+            reason: status_reason_1.STATUS_REASON.THINKING_INDICATOR,
+            hasActivePrompt: false,
+            evidence: 'positive',
+            promptDetection,
+        };
+    }
+    // 2.x — the tool's own running and completion markers.
+    const afterThinking = spec.afterThinking?.(frame, promptDetection) ?? null;
+    if (afterThinking)
+        return { ...afterThinking, promptDetection: afterThinking.promptDetection ?? promptDetection };
+    // 3. Input prompt detection — the generic composer check.
+    //
+    // The wire value stays `ready` / `input_prompt` whatever the evidence says
+    // (DR3-002). What moves is `statusEvidence`, not `sessionStatus`: flipping
+    // this branch to `running` would move `isProcessing` and with it `ls`, the
+    // sidebar aggregate, the "queued (session busy)" toast and demo-video's
+    // `wait_until_busy` probe, none of which are asking about evidence.
+    if (!spec.skipGenericInputPrompt) {
+        const { promptPattern } = (0, cli_patterns_1.getCliToolPatterns)(spec.tool);
+        if (promptPattern.test(frame.lastLines)) {
+            return {
+                status: 'ready',
+                confidence: 'high',
+                reason: status_reason_1.STATUS_REASON.INPUT_PROMPT,
+                hasActivePrompt: false,
+                evidence: resolveIdleEvidence(spec, frame),
+                promptDetection,
+            };
+        }
+    }
+    // 4. Time-based heuristic (§4 D1 決定 3: the `ready` here is abolished).
+    //
+    // Five seconds without a repaint is not a completion — it is the absence of
+    // one, and publishing `ready` for it is what turned a stalled worker into a
+    // Completed one. The reason code stays for diagnosis; the status is `running`
+    // and the evidence is nothing.
+    if (context.lastOutputTimestamp) {
+        const elapsed = Date.now() - context.lastOutputTimestamp.getTime();
+        if (elapsed > STALE_OUTPUT_THRESHOLD_MS) {
+            return {
+                status: 'running',
+                confidence: 'low',
+                reason: status_reason_1.STATUS_REASON.NO_RECENT_OUTPUT,
+                hasActivePrompt: false,
+                evidence: 'none',
+                promptDetection,
+            };
+        }
+    }
+    // 5. Floor. `running` with no evidence, as before — the safe default when the
+    // state cannot be determined.
+    //
+    // A tool whose positive chain is complete says so with `unknown_frame`: its
+    // rules looked at this frame and found nothing, which is a statement about the
+    // rules and an instruction to capture the frame as a fixture. `default` stays
+    // the answer for a tool that has no chain of its own, where nothing looked.
+    return {
+        status: 'running',
+        confidence: 'low',
+        reason: spec.unreadableReason ?? status_reason_1.STATUS_REASON.DEFAULT,
+        hasActivePrompt: false,
+        evidence: 'none',
+        promptDetection,
+    };
+}
+/** Bind the shared chain around one tool's declarations. */
+function createToolStatusDetector(spec) {
+    return {
+        ...spec,
+        detect: (frame, context) => runToolDetection(spec, frame, context),
+        // D1 決定 4's seam, filled per tool by Issue #1928. The substitute keeps
+        // every caller free of a null check; `hasDialogRules` is what tells a
+        // caller which of the two it got, because the Auto-Yes gate must suppress
+        // for "this tool has rules and this frame is not a dialog" and must NOT
+        // suppress for "nobody has measured this tool yet".
+        detectDialog: spec.detectDialog ?? (() => null),
+        hasDialogRules: spec.detectDialog !== undefined,
+    };
+}

package/dist/server/src/lib/detection/tools/types.js

@@ -0,0 +1,34 @@
+"use strict";
+/**
+ * The per-tool status detection contract (Issue #1927, 方針書 §4 D2).
+ *
+ * Until this Issue, every tool's rules lived as `if (cliToolId === '…')` blocks
+ * inside one 1000-line `detectSessionStatus`. The blocks were already per-tool —
+ * what was missing was a place to say, per tool, **what counts as evidence**.
+ * §4 D1 turns on exactly that distinction ("完了は肯定的証拠でのみ宣言する"), and
+ * a rule that cannot be named per tool cannot be rolled out per tool either
+ * (DR2-002 requires exactly that: one tool at a time, each with its own measured
+ * rule and its own fixtures).
+ *
+ * So a {@link ToolStatusDetector} owns four things for one CLI:
+ *
+ *  1. the branches that must run **before** the shared prompt detection
+ *     ({@link ToolDetectorSpec.beforePrompt}) — a picker or a pager whose body
+ *     the generic parser would misread as a numbered dialog;
+ *  2. the branches that run **after** it ({@link ToolDetectorSpec.afterPrompt} /
+ *     {@link ToolDetectorSpec.afterThinking}) — the tool's own running and
+ *     completion markers;
+ *  3. {@link ToolDetectorSpec.readIdleEvidence} — the D1 rule: does this frame
+ *     carry POSITIVE evidence that the turn is not running, or is the `ready`
+ *     it is about to publish only "nothing looked busy"?
+ *  4. {@link ToolStatusDetector.detectDialog} — the seam Auto-Yes will read
+ *     (D1 決定 4). Declared here and answered `null` by every tool: the per-tool
+ *     dialog rules and the `response-checker` wiring are **Issue #1928**, and
+ *     landing them here would leave that Issue with nothing to do.
+ *
+ * `verifiedAgainst` is not decoration. Every rule in a tool module was read off
+ * a capture of one specific version at one specific pane geometry; recording
+ * which one is what lets a later reader tell "this rule is wrong" from "this
+ * rule was right for 1.0.80".
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/server/src/lib/detection/tools/verified-against.js

@@ -0,0 +1,88 @@
+"use strict";
+/**
+ * Which build of which CLI every tool module's rules were read off (Issue #1929).
+ *
+ * #1927 gave each tool module a `verifiedAgainst` stamp and declared it inline —
+ * claude's in `claude/patterns.ts`, the other four at the top of their
+ * `detect.ts`. That is the right place to *read* it when you are looking at a
+ * rule, and the wrong place to *collect* it: §4 D2's staleness probe has to
+ * compare "the version the rules were measured against" with "the version that
+ * is installed", and it needs the first as data, for every tool, at once.
+ *
+ * So the values move here and each tool module re-exports its own. The stamp
+ * still lives one import away from the rules it describes, and there is exactly
+ * one copy of it — `tests/unit/detection/tools/detector-contract.test.ts` pins
+ * that the detectors' `verifiedAgainst` and this table are the same objects, so
+ * the two cannot drift.
+ *
+ * ## Why this module imports nothing
+ *
+ * `commandmate status` is one of the two surfaces §4 D2 exposes the staleness
+ * on, and `tsconfig.cli.json` compiles the CLI with `"paths": {}`. A module the
+ * CLI bundle reaches may therefore not use the `@/` alias — see the same
+ * constraint written out in `src/cli/types/api-responses.ts`. `tools/types.ts`
+ * (where {@link DetectorProvenance} lives) imports `@/lib/cli-tools/types`, so
+ * these constants are left unannotated and match that interface structurally
+ * instead of importing it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DETECTOR_VERIFIED_AGAINST = exports.UNMEASURED_VERIFIED_AGAINST = exports.ANTIGRAVITY_VERIFIED_AGAINST = exports.OPENCODE_VERIFIED_AGAINST = exports.COPILOT_VERIFIED_AGAINST = exports.CODEX_VERIFIED_AGAINST = exports.CLAUDE_VERIFIED_AGAINST = void 0;
+/** claude these rules were read off (#1708 / #1927 fixtures). */
+exports.CLAUDE_VERIFIED_AGAINST = {
+    version: '2.1.240',
+    capturedAt: '2026-08-23',
+    paneGeometry: '200x1000',
+};
+/** codex-cli these rules were read off (#1628 / #1829 / #1890 fixtures). */
+exports.CODEX_VERIFIED_AGAINST = {
+    version: '0.148.0',
+    capturedAt: '2026-08-15',
+    paneGeometry: '200x1000',
+};
+/** copilot-cli these rules were read off (#1885 / #1895 fixtures). */
+exports.COPILOT_VERIFIED_AGAINST = {
+    version: '1.0.80',
+    capturedAt: '2026-08-21',
+    paneGeometry: '200x1000',
+};
+/** opencode these rules were read off (#1883 / #1893 / #1896 fixtures). */
+exports.OPENCODE_VERIFIED_AGAINST = {
+    version: '1.18.21',
+    capturedAt: '2026-08-21',
+    paneGeometry: '80x200',
+};
+/** agy these rules were read off (#988 / #995). */
+exports.ANTIGRAVITY_VERIFIED_AGAINST = {
+    version: '0.4.x',
+    capturedAt: '2026-07-30',
+    paneGeometry: 'inline',
+};
+/**
+ * The stamp for a tool whose frames nobody has captured yet.
+ *
+ * Not a version, on purpose. `parseCliVersion` cannot read `'unmeasured'`, so a
+ * tool carrying it is reported by {@link getDetectorFreshness} with a null
+ * comparison rather than as fresh — "we never measured this" and "we measured it
+ * and it is current" are different answers and must not print the same.
+ */
+exports.UNMEASURED_VERIFIED_AGAINST = {
+    version: 'unmeasured',
+    capturedAt: 'never',
+    paneGeometry: 'unmeasured',
+};
+/**
+ * Tool id → the build its rules were measured against.
+ *
+ * Keyed by the catalog / `CLIToolType` id, not by executable name: antigravity's
+ * binary is `agy` (DR2-023), and that mapping belongs to the probe table, not
+ * here.
+ */
+exports.DETECTOR_VERIFIED_AGAINST = {
+    claude: exports.CLAUDE_VERIFIED_AGAINST,
+    codex: exports.CODEX_VERIFIED_AGAINST,
+    copilot: exports.COPILOT_VERIFIED_AGAINST,
+    opencode: exports.OPENCODE_VERIFIED_AGAINST,
+    antigravity: exports.ANTIGRAVITY_VERIFIED_AGAINST,
+    gemini: exports.UNMEASURED_VERIFIED_AGAINST,
+    'vibe-local': exports.UNMEASURED_VERIFIED_AGAINST,
+};

package/dist/server/src/lib/hooks/agent-event-types.js

@@ -19,7 +19,7 @@
  * @module lib/hooks/agent-event-types
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MAX_EVENT_DETAIL_LENGTH = exports.AGENT_EVENT_TYPES = void 0;
+exports.PERMISSION_REPLIED_DETAIL = exports.MAX_EVENT_DETAIL_LENGTH = exports.AGENT_EVENT_TYPES = void 0;
 exports.isAgentEventType = isAgentEventType;
 /**
  * Event kinds accepted by `POST /api/hooks/agent-event`.
@@ -50,3 +50,21 @@ function isAgentEventType(value) {
 }
 /** Bound on the stored `detail`; every observed value is a short enum-ish word. */
 exports.MAX_EVENT_DETAIL_LENGTH = 128;
+/**
+ * The `notification` detail meaning "the approval dialog has been answered"
+ * (Issue #1898).
+ *
+ * A fourth word beside `permission_prompt` / `idle_prompt` / an error, and the
+ * only one that is *not* a report that something needs a human — it is the
+ * report that something no longer does. Named here rather than in a source's
+ * own file because two unrelated callers have to agree on it: the source that
+ * maps the agent's own "somebody replied" frame, and the adjudicator that
+ * delivered a verdict itself. `lib/session/agent-event-state` keys its
+ * prompt-waiting release off exactly this string.
+ *
+ * Nothing here names a tool, and this does not either: any source that can
+ * observe an approval being answered may publish it. Whether observing one
+ * settles anything is the source's
+ * `AgentSourceCapabilities.permissionReplyReleasesPrompt` to declare.
+ */
+exports.PERMISSION_REPLIED_DETAIL = 'permission_replied';

package/dist/server/src/lib/hooks/permission-adjudication.js

@@ -0,0 +1,160 @@
+"use strict";
+/**
+ * Adjudicating an approval CommandMate holds, rather than one it is being
+ * asked about (Issue #1898).
+ *
+ * Five tools ask over a hook and wait for the response body; the receiver route
+ * answers and the story ends there. opencode's approvals arrive on a stream and
+ * are answered by a separate POST, which means the decision has to be taken in
+ * three places rather than one — when the frame arrives, when a re-connect
+ * re-reads what is still pending, and when the *policy* changes under a dialog
+ * that is already up (`auto-yes --enable` on a blocked session, #1898-2).
+ *
+ * This module is that decision, once. The judgement itself is unchanged and
+ * still `resolvePermissionRequest`, shared with every hook tool; what is here
+ * is the part that only a caller holding the pending decision can do:
+ *
+ *  1. **Adjudicate, then record.** The order is the Issue. Recording first
+ *     opens a prompt-waiting record — `agent-event-state` keys it off
+ *     `notification(permission_prompt)` — and an approval Auto-Yes is about to
+ *     answer then reads `waiting` until the tool call it was gating finishes.
+ *     Measured at eight seconds on `sleep 8; pwd`.
+ *  2. **Ask the source whether the delivery settles anything.** Only a source
+ *     whose {@link AgentSourceCapabilities.permissionReplyReleasesPrompt} is
+ *     true can say that a delivered verdict means the dialog is gone (#1924,
+ *     §4 D3). Every hook source answers false: its verdict goes into the body
+ *     of a request nobody hears the end of.
+ *
+ * Nothing here branches on a tool id, and nothing here is allowed to: the
+ * capability block is the whole vocabulary (`docs/design/
+ * multi-agent-state-architecture.md` §4 D3).
+ *
+ * ## Why `permission-decision-service` is imported dynamically
+ *
+ * The same reason `sources/opencode/ingest` does it: that module reaches the
+ * database, and this one is on the import path of a launcher that must not.
+ *
+ * @module lib/hooks/permission-adjudication
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.adjudicatePendingPermission = adjudicatePendingPermission;
+const logger_1 = require("../../lib/logger");
+const abstain_1 = require("./sources/abstain");
+const pending_decisions_1 = require("./sources/pending-decisions");
+const permission_decision_state_1 = require("./permission-decision-state");
+const logger = (0, logger_1.createLogger)('lib/hooks/permission-adjudication');
+/**
+ * Judge one pending approval and deliver the verdict over the source's own
+ * channel.
+ *
+ * Never throws. An approval is a fact about a session that is still running,
+ * and a failure to answer it must cost the answer, never the session — the
+ * caller's own fail-open path then leaves the dialog for a human, which is what
+ * every uncertain branch of `resolvePermissionRequest` already means.
+ *
+ * @param source - The source that raised it, and that will carry the verdict
+ * @param target - Worktree / tool / instance the approval belongs to
+ * @param decision - The pending decision, with the id the reply is addressed to
+ * @param payload - Parsed approval, or null when it could not be read — which
+ *   the adjudicator treats as "no decision", i.e. leave it for the human
+ * @param trigger - Why this is being judged now; recorded for the operator
+ */
+async function adjudicatePendingPermission(source, target, decision, payload, trigger = 'event') {
+    const instanceId = target.instanceId ?? target.cliToolId;
+    const session = {
+        worktreeId: target.worktreeId,
+        cliToolId: target.cliToolId,
+        instanceId,
+    };
+    const { resolvePermissionRequest } = await Promise.resolve().then(() => __importStar(require('./permission-decision-service')));
+    const verdictSource = resolvePermissionRequest(session, payload);
+    const verdict = verdictSource.behavior === 'allow' ? { kind: 'allowOnce' } : { kind: 'abstain' };
+    if (verdict.kind === 'abstain') {
+        const abstain = (0, abstain_1.describeAbstain)(source);
+        if (!abstain.safe) {
+            // On this source silence is an action rather than the absence of one: the
+            // agent waits with no timeout at all (#1758 §5.5.3), and a blocked
+            // opencode session looks exactly like one that is thinking. Nothing else
+            // will say so.
+            logger.warn('permission-request-abstain-blocks-agent', {
+                worktreeId: target.worktreeId,
+                cliToolId: target.cliToolId,
+                instanceId,
+                toolName: payload?.toolName ?? null,
+                decisionId: decision.id,
+                reason: verdictSource.reason,
+                consequence: abstain.summary,
+                blocksForMs: abstain.blocksForMs,
+            });
+        }
+    }
+    // C2: the caller does not know whether this writes a response body or opens a
+    // second connection, and must not. What it does now get back is whether the
+    // verdict landed (#1898).
+    const { delivery } = await (0, pending_decisions_1.answerPendingDecisionWithReceipt)(source, target, decision, verdict);
+    const delivered = delivery?.delivered === true;
+    const settled = delivered && source.capabilities.permissionReplyReleasesPrompt;
+    (0, permission_decision_state_1.recordPermissionDecision)(target.worktreeId, target.cliToolId, target.instanceId, {
+        decisionId: decision.id,
+        toolName: payload?.toolName ?? null,
+        behavior: verdictSource.behavior === 'allow' ? 'allow' : null,
+        reason: verdictSource.reason,
+        delivered,
+        releasedPrompt: settled,
+        trigger,
+        at: decision.askedAt,
+    });
+    logger.info('permission-decision-adjudicated', {
+        worktreeId: target.worktreeId,
+        cliToolId: target.cliToolId,
+        instanceId,
+        decisionId: decision.id,
+        toolName: payload?.toolName ?? null,
+        behavior: verdictSource.behavior,
+        reason: verdictSource.reason,
+        suppressedBy: verdictSource.suppressedBy,
+        delivered,
+        settled,
+        trigger,
+    });
+    return {
+        decisionId: decision.id,
+        behavior: verdictSource.behavior === 'allow' ? 'allow' : null,
+        reason: verdictSource.reason,
+        delivered,
+        settled,
+    };
+}