commandmate 0.30.1 → 0.31.0

package/dist/server/src/lib/hooks/sources/opencode/history.js

@@ -320,6 +320,47 @@ async function publishOpencodeTurnProgress(target, turn) {
         });
     }
 }
+/**
+ * When each backfilled turn's last assistant message finished (Issue #2273).
+ *
+ * `info.time.completed` on every `role: "assistant"` message, folded onto the
+ * turn key (`parentID`) with `Math.max` — a tool-calling turn produces more than
+ * one assistant message (measured: two, in turn 2 of the captured session) and
+ * the turn ended when the last of them did. `time.created` is the fallback for a
+ * message opencode has not marked complete.
+ *
+ * Read here rather than on the accumulator because `./transcript` is not this
+ * Issue's to change, and read defensively for the reason everything in this
+ * subsystem is: a shape opencode changes must cost the timestamp, not the row.
+ *
+ * @returns `parentID` → epoch ms; absent for a turn with no usable clock
+ */
+function lastOpencodeCompletedAt(body) {
+    const at = new Map();
+    if (!Array.isArray(body))
+        return at;
+    for (const entry of body) {
+        if (!(0, event_mapper_1.isPlainObject)(entry))
+            continue;
+        const info = (0, event_mapper_1.isPlainObject)(entry.info) ? entry.info : null;
+        if (!info || info.role !== 'assistant')
+            continue;
+        const userMessageId = (0, event_mapper_1.readStringField)(info, transcript_1.OPENCODE_TURN_KEY_FIELD);
+        if (!userMessageId)
+            continue;
+        const time = (0, event_mapper_1.isPlainObject)(info.time) ? info.time : null;
+        const finished = readFiniteNumber(time?.completed) ?? readFiniteNumber(time?.created) ?? null;
+        if (finished === null)
+            continue;
+        if (finished > (at.get(userMessageId) ?? 0))
+            at.set(userMessageId, finished);
+    }
+    return at;
+}
+/** A finite number, or null. */
+function readFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
 /**
  * The turn currently open on this session, for tests and for callers that need
  * to know whether a flush would do anything.
@@ -342,9 +383,12 @@ function peekOpencodeTurn(target, sessionId) {
  *
  * @param target - The instance
  * @param sessionId - `ses_…` from the `session.idle` frame
+ * @param closedAt - When the turn ended, epoch ms. Defaults to now, which is
+ *   what `session.idle` means: opencode's own end-of-turn frame is being handled
+ *   (Issue #2273). A parameter only so a test need not move the clock.
  * @returns Whether a row was written
  */
-async function flushOpencodeTurn(target, sessionId) {
+async function flushOpencodeTurn(target, sessionId, closedAt = Date.now()) {
     const turns = transcripts.get(keyOf(target));
     const turn = turns?.get(sessionId);
     if (!turn || !turns)
@@ -353,7 +397,12 @@ async function flushOpencodeTurn(target, sessionId) {
     // not find the accumulator still there and race a duplicate insert past the
     // existence check below.
     turns.delete(sessionId);
-    return writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), turn.startedAt, 'stream');
+    // The turn's END and not its start (Issue #2273). A reply dated where the turn
+    // opened draws ABOVE the tool approvals that were written seconds into it, so
+    // the chat surface reads question → answer → approval for a turn that really
+    // went question → approval → answer. `Math.max` because a clock that went
+    // backwards must not put the reply before its own prompt.
+    return writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), Math.max(turn.startedAt, closedAt), 'stream');
 }
 /**
  * Forget everything held for one instance.
@@ -506,11 +555,16 @@ async function backfillOpencodeHistory(target, port, sessionId) {
                 limit: exports.MAX_OPENCODE_BACKFILLED_TURNS,
             });
         }
+        // Issue #2273: the same rule the live flush follows, off the REST document's
+        // own clock. `time.completed` is when opencode finished the assistant
+        // message; the stream route has no equivalent field and uses the instant
+        // `session.idle` arrived, which is the same fact a moment later.
+        const completedAt = lastOpencodeCompletedAt(body);
         let written = 0;
         // Oldest of the kept ones first, so the rows are inserted in conversation
         // order and `updateWorktreeTimestamp` ends on the newest.
         for (const turn of [...kept].reverse()) {
-            const saved = await writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), turn.startedAt, 'backfill');
+            const saved = await writeOpencodeTurn(target, (0, transcript_1.renderOpencodeTurn)(turn), Math.max(turn.startedAt, completedAt.get(turn.userMessageId) ?? 0), 'backfill');
             if (saved)
                 written += 1;
         }

package/dist/server/src/lib/hooks/sources/opencode/transcript.js

@@ -186,8 +186,14 @@ const OPENCODE_SILENT_PART_TYPES = new Set([
     'snapshot',
     'patch',
 ]);
-/** The label a reasoning block is folded behind. */
-exports.OPENCODE_REASONING_LABEL = 'Thinking';
+/**
+ * The label a reasoning block is folded behind.
+ *
+ * An alias of `../turn-body`'s constant since #2272 rather than a second copy
+ * of the string: the section heading and this name have to stay equal or the
+ * chat surface's reader stops recognising the section it is meant to fold.
+ */
+exports.OPENCODE_REASONING_LABEL = turn_body_1.TURN_REASONING_LABEL;
 /**
  * One tool call as a single Markdown line.
  *
@@ -218,33 +224,16 @@ function renderToolPart(part) {
 function collapseToLine(value) {
     return value.replace(/\s+/g, ' ').trim();
 }
-/**
- * Reasoning, folded.
- *
- * A blockquote rather than `<details>`, and the reason is a rendering decision
- * that belongs here because it decides what is *stored*: showing `<details>`
- * would mean running `rehype-raw` over agent output in `ConversationPairCard`,
- * and that costs every unfenced `<T>` in ordinary prose — the HTML parser eats
- * it as a tag. A blockquote is Markdown's own way of saying "subordinate", it
- * survives the sanitiser with no raw-HTML pass, and the card's existing
- * two-line collapse already keeps it out of the way.
- */
-function renderReasoningPart(text) {
-    const quoted = text
-        .trim()
-        .split('\n')
-        .map((line) => (line.length > 0 ? `> ${line}` : '>'))
-        .join('\n');
-    return `> **${exports.OPENCODE_REASONING_LABEL}**\n>\n${quoted}`;
-}
 /**
  * Render one turn to Markdown.
  *
- * Stream order within each kind — reasoning sits where the agent thought it and
- * the calls are in the order they were made. #2041 kept one stream for all of
- * them and #2234 split the tool calls out into a section of their own; the
- * layout is `../turn-body`'s, shared with the other three readers, and
- * {@link separateTurnBody} carries the reasoning for both halves of that.
+ * Stream order within each kind — the thoughts are in the order they were
+ * thought and the calls in the order they were made. #2041 kept one stream for
+ * all of them, #2234 split the tool calls out into a section of their own, and
+ * #2272 did the same for the reasoning: measured against 1.18.22, opencode
+ * emits a `reasoning` part in front of *every* text part, so leaving them
+ * inline meant a one-line answer whose bubble opened with `> **Thinking**` and a
+ * long one with four such quotes buried in it. The layout is `../turn-body`'s.
  *
  * @param turn - The accumulator, live or rebuilt from REST
  */
@@ -268,7 +257,9 @@ function renderOpencodeTurn(turn) {
             const text = part.text?.trim() ?? '';
             if (text.length === 0)
                 continue;
-            blocks.push({ kind: 'aside', text: renderReasoningPart(text) });
+            // Raw, not pre-quoted: `separateTurnBody` folds the whole run under one
+            // `Thinking (N)` heading and owns the quoting (Issue #2272).
+            blocks.push({ kind: 'reasoning', text });
             continue;
         }
         if (part.type === 'tool') {
@@ -284,7 +275,11 @@ function renderOpencodeTurn(turn) {
         if (!OPENCODE_SILENT_PART_TYPES.has(part.type))
             unknown.add(part.type);
     }
-    let body = (0, turn_body_1.separateTurnBody)(blocks).body;
+    const separated = (0, turn_body_1.separateTurnBody)(blocks);
+    // The cap still counts the whole body, reasoning included — but the reasoning
+    // now sits behind the prose, so what a 200 kB turn loses is the tail of its
+    // thinking rather than the answer (Issue #2272).
+    let body = separated.body;
     if (body.length > exports.MAX_OPENCODE_TURN_BODY_LENGTH) {
         body =
             body.slice(0, exports.MAX_OPENCODE_TURN_BODY_LENGTH - exports.OPENCODE_TURN_TRUNCATION_MARKER.length) +
@@ -296,6 +291,7 @@ function renderOpencodeTurn(turn) {
         body,
         textParts,
         toolParts,
+        reasoningParts: separated.reasoningBlocks,
         unknownPartTypes: [...unknown],
     };
 }

package/dist/server/src/lib/hooks/sources/registry.js

@@ -40,6 +40,7 @@ const source_3 = require("./gemini/source");
 const source_4 = require("./antigravity/source");
 const source_5 = require("./codex/source");
 const source_6 = require("./opencode/source");
+const source_7 = require("./command-code/source");
 const registered = (globalThis.__agentEventSources ??= new Map());
 /** Memoised compatibility sources, so repeated lookups return one object. */
 const legacy = (globalThis.__agentEventLegacySources ??= new Map());
@@ -109,3 +110,6 @@ registerAgentEventSource(source_3.geminiAgentEventSource);
 registerAgentEventSource(source_4.antigravityAgentEventSource);
 registerAgentEventSource(source_5.codexAgentEventSource);
 registerAgentEventSource(source_6.opencodeAgentEventSource);
+// Issue #2251, Epic #2249 Phase B. The seventh, and the last line of "adding a
+// tool" — its own directory plus this.
+registerAgentEventSource(source_7.commandCodeAgentEventSource);

package/dist/server/src/lib/hooks/sources/turn-body.js

@@ -13,13 +13,32 @@
  * body in full, so those 141 bubbles opened with a tool log instead of a reply.
  *
  * This module is the one place that decides the layout, and every reader goes
- * through it. Two rules:
+ * through it. Three rules:
  *
- *  1. **Prose leads.** Text the agent wrote — and the folded `Thinking` quotes
- *     that sit between the sentences — keep their transcript order and come
+ *  1. **Prose leads.** Text the agent wrote keeps its transcript order and comes
  *     first.
  *  2. **The tool log is one section, at the end**, in transcript order, folded
  *     into a blockquote under a labelled heading.
+ *  3. **Reasoning is one section too** (Issue #2272), between the two, on the
+ *     same shape — see {@link TURN_REASONING_LABEL}.
+ *
+ * ## Why reasoning became a section of its own (Issue #2272)
+ *
+ * #2234 moved the tool calls and deliberately left the folded `Thinking` quotes
+ * where they sat, on the argument that they are the agent's own words about the
+ * reply. Measured against opencode 1.18.22 that argument does not survive
+ * contact: opencode emits a `reasoning` part before *every* text part, so the
+ * body opens with `> **Thinking**` on a one-line answer and carries four such
+ * quotes on a long one — which is exactly the failure #2234 set out to fix, from
+ * the other producer.
+ *
+ * The distinction is therefore drawn on the **block kind**, not on the reader:
+ * `reasoning` carries the raw text and is folded into the trailing section,
+ * `aside` carries text a reader already folded itself and stays with the prose.
+ * The four readers that push `aside` (claude, codex, antigravity, command-code)
+ * are untouched by this Issue because none of them has been measured the way
+ * opencode has; they can move a block at a time by switching kind, with no
+ * change here.
  *
  * ## Why the order claim from #2041 / #2121 is narrowed rather than dropped
  *
@@ -46,7 +65,7 @@
  * @module lib/hooks/sources/turn-body
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TURN_TOOL_LOG_LABEL = void 0;
+exports.TURN_REASONING_LABEL = exports.TURN_TOOL_LOG_LABEL = void 0;
 exports.separateTurnBody = separateTurnBody;
 /**
  * The bold first line of the folded tool section.
@@ -58,15 +77,31 @@ exports.separateTurnBody = separateTurnBody;
  */
 exports.TURN_TOOL_LOG_LABEL = 'Tool calls';
 /**
- * Quote one already-rendered tool line.
+ * The bold first line of the folded reasoning section (Issue #2272).
  *
- * The four readers all render a call as a **single-line** list item — their
- * detail readers collapse whitespace precisely so a heredoc in a shell command
- * cannot put a newline here — so one prefix per line is enough and the split is
- * a guard rather than a case that is expected to fire.
+ * The same string the five readers already used for their own inline quotes, on
+ * purpose: it is baked into `chat_messages.content` at read time, so the rows
+ * written before this Issue carry `> **Thinking**` and the rows written after it
+ * carry `> **Thinking (N)**`. Keeping the label identical is what lets one
+ * reader on the chat surface fold both shapes — see `splitChatThinking` in
+ * `components/worktree/ChatMessageBubble`.
  */
-function quoteToolLine(line) {
-    return line
+exports.TURN_REASONING_LABEL = 'Thinking';
+/**
+ * Put one block inside a blockquote, line by line.
+ *
+ * Every line gets its own `> ` because a blockquote ends at the first line that
+ * has none — a lazy continuation would work in CommonMark for a paragraph and
+ * would NOT for the list items the tool log is made of.
+ *
+ * For a tool line the split is a guard rather than a case that is expected to
+ * fire: the five readers all render a call as a single-line list item and
+ * collapse whitespace precisely so a heredoc in a shell command cannot put a
+ * newline here. For a reasoning block it is the normal path — that text is
+ * paragraphs.
+ */
+function quoteBlock(text) {
+    return text
         .split('\n')
         .map((part) => (part.length > 0 ? `> ${part}` : '>'))
         .join('\n');
@@ -80,21 +115,25 @@ function quoteToolLine(line) {
  * (#2199) agree — both reach this function through the same renderer, so the
  * text a reader watches being written is the text that settles.
  *
- * A turn with no tool calls comes out **byte-identical** to what the readers
- * produced before this Issue: the whole change is the section this adds.
+ * A turn with neither a tool call nor a `reasoning` block comes out
+ * **byte-identical** to what the readers produced before #2234 / #2272: the
+ * whole change is the sections this adds.
  *
  * @param blocks - Rendered pieces in transcript order; empty text is the
  *   caller's to drop
- * @returns The body and the two halves it was built from
+ * @returns The body and the three parts it was built from
  */
 function separateTurnBody(blocks) {
     const prose = [];
+    const reasoning = [];
     const tools = [];
     for (const block of blocks) {
         if (block.text.length === 0)
             continue;
         if (block.kind === 'tool')
             tools.push(block.text);
+        else if (block.kind === 'reasoning')
+            reasoning.push(block.text);
         else
             prose.push(block.text);
     }
@@ -104,15 +143,34 @@ function separateTurnBody(blocks) {
     // stayed one Markdown list — which is gone because no tool line reaches this
     // list any more.
     const proseText = prose.join('\n\n');
+    // One heading for the whole run, and a bare `>` between the blocks so two
+    // consecutive thoughts stay two paragraphs inside the quote rather than
+    // running into one another.
+    const reasoningLog = reasoning.length === 0
+        ? ''
+        : [
+            `> **${exports.TURN_REASONING_LABEL} (${reasoning.length})**`,
+            '>',
+            reasoning.map(quoteBlock).join('\n>\n'),
+        ].join('\n');
     const toolLog = tools.length === 0
         ? ''
         : [
             `> **${exports.TURN_TOOL_LOG_LABEL} (${tools.length})**`,
             '>',
-            ...tools.map(quoteToolLine),
+            ...tools.map(quoteBlock),
         ].join('\n');
-    const body = proseText.length > 0 && toolLog.length > 0
-        ? `${proseText}\n\n${toolLog}`
-        : `${proseText}${toolLog}`;
-    return { body, prose: proseText, toolLog, toolCalls: tools.length };
+    // Prose, then reasoning, then the tool log. The tool log stays last because
+    // #2234 put it there and the readers' rows are matched on `request_id` rather
+    // than rewritten, so moving it would split History into two layouts for no
+    // gain.
+    const body = [proseText, reasoningLog, toolLog].filter((part) => part.length > 0).join('\n\n');
+    return {
+        body,
+        prose: proseText,
+        reasoningLog,
+        reasoningBlocks: reasoning.length,
+        toolLog,
+        toolCalls: tools.length,
+    };
 }

package/dist/server/src/lib/hooks/stop-history-capture.js

@@ -20,6 +20,15 @@
  * The agent itself knows the boundary exactly, and has been telling us: the
  * `stop` hook. This module is that second trigger.
  *
+ * ## Knowing the boundary is not the same as the file having reached it
+ *
+ * The `stop` post and the transcript's last append are two events with no
+ * ordering between them, and Issue #2264 is what happens when the reader is
+ * asked in the gap. The reader now refuses a turn it cannot prove is closed, so
+ * the cost of asking too early is a `false` rather than a truncated row — and
+ * this module's answer to a `false` is to ask again, up to
+ * {@link STOP_TRANSCRIPT_MAX_ATTEMPTS} times, before handing the turn back.
+ *
  * ## What it does not do
  *
  * **It does not replace the poller's call.** A session with no hooks — or with
@@ -70,27 +79,42 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.STOP_TRANSCRIPT_RETRY_DELAY_MS = void 0;
+exports.STOP_TRANSCRIPT_MAX_ATTEMPTS = exports.STOP_TRANSCRIPT_RETRY_DELAY_MS = void 0;
 exports.captureTranscriptTurnOnStop = captureTranscriptTurnOnStop;
 const logger_1 = require("../../lib/logger");
 const logger = (0, logger_1.createLogger)('lib/hooks/stop-history-capture');
 /**
- * How long to wait before asking a second time.
+ * How long to wait before asking again.
  *
  * The `stop` hook fires when the agent considers the turn over, and the last
  * assistant record is appended to the transcript around — not necessarily
- * before — that instant. A reader that arrives in the gap sees the prompt
- * record and no body, answers false (correctly: an empty row would be a blank
- * reply forever) and, without a retry, hands a turn the agent has definitely
- * finished back to the scraper.
+ * before — that instant. A reader that arrives in the gap sees a turn that is
+ * not closed, answers false (correctly: the row it would write is a reply with
+ * its last paragraph missing, frozen under the turn key forever) and, without a
+ * retry, hands a turn the agent has definitely finished back to the scraper.
  *
  * Half a second is chosen against what the gap actually is — a file append that
- * has already been issued — rather than against a timeout. One retry and not a
- * loop, because the poller's own trigger is still behind this: if the file is
- * still empty after the retry, the next poll is the right place to notice, and
- * a hook handler that waits on a file is a hook handler that can hang a turn.
+ * has already been issued — rather than against a timeout.
  */
 exports.STOP_TRANSCRIPT_RETRY_DELAY_MS = 500;
+/**
+ * How many times the reader is asked in total (Issue #2264).
+ *
+ * #2246 asked twice, on the reading that the only thing a retry waits for is one
+ * append that has already been issued. The incident #2264 was reported for says
+ * that is not always one append: the measured gap between the `stop` post and
+ * the last `text` record was around 100 ms in the fast case, but the turns that
+ * were saved short had *tool* records still arriving, and a single 500 ms retry
+ * lands inside that run rather than after it.
+ *
+ * Three and not a loop, because the poller's own trigger is still behind this:
+ * if the turn is still open after the third ask, the next poll is the right
+ * place to notice — it runs when the pane returns to the composer, by which time
+ * the transcript is written — and a hook handler that waits on a file is a hook
+ * handler that can hang a turn. The worst case this bounds is 1 s of the agent's
+ * stop path, spent only on an instance that has a transcript and an open turn.
+ */
+exports.STOP_TRANSCRIPT_MAX_ATTEMPTS = 3;
 function sleep(ms) {
     return new Promise((resolve) => {
         setTimeout(resolve, ms);
@@ -130,24 +154,33 @@ async function captureTranscriptTurnOnStop(worktree, cliToolId, instanceId, opti
         const retryDelayMs = options.retryDelayMs ?? exports.STOP_TRANSCRIPT_RETRY_DELAY_MS;
         if (retryDelayMs <= 0)
             return false;
-        // The retry is for one failure and one only: the turn's last assistant
-        // record had not been appended yet. Every other reason the capture answers
-        // false — no session pointer, no transcript, the operator never wired hooks
-        // for this tool — is a reason waiting cannot fix, and this handler is on the
-        // agent's own stop path, so half a second spent for nothing is half a second
-        // added to every turn it is spent on.
+        // The retry is for one failure and one only: the turn is not closed yet
+        // because its remaining assistant records have not been appended. Every
+        // other reason the capture answers false — no session pointer, no
+        // transcript, the operator never wired hooks for this tool — is a reason
+        // waiting cannot fix, and this handler is on the agent's own stop path, so
+        // half a second spent for nothing is half a second added to every turn it is
+        // spent on. Asked once, before the first sleep: a transcript that exists
+        // does not stop existing between attempts.
         if (!(await hasStructuredHistoryTranscript(worktree.id, cliToolId, instanceId, capture))) {
             return false;
         }
-        await sleep(retryDelayMs);
-        const captured = await captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture);
-        logger.debug('stop-history-capture-retried', {
-            worktreeId: worktree.id,
-            cliToolId,
-            instanceId,
-            captured,
-        });
-        return captured;
+        const maxAttempts = Math.max(1, options.maxAttempts ?? exports.STOP_TRANSCRIPT_MAX_ATTEMPTS);
+        for (let attempt = 2; attempt <= maxAttempts; attempt += 1) {
+            await sleep(retryDelayMs);
+            const captured = await captureStructuredHistoryTurn(worktree.id, cliToolId, instanceId, capture);
+            logger.debug('stop-history-capture-retried', {
+                worktreeId: worktree.id,
+                cliToolId,
+                instanceId,
+                attempt,
+                maxAttempts,
+                captured,
+            });
+            if (captured)
+                return true;
+        }
+        return false;
     }
     catch (error) {
         logger.warn('stop-history-capture-failed', {

package/dist/server/src/lib/job-executor.js

@@ -7,6 +7,11 @@
  * This module manages the DB logging lifecycle (create/update execution logs)
  * and delegates actual command execution to claude-executor.
  *
+ * Scheduled tools: claude, codex, gemini, vibe-local, opencode, copilot,
+ * antigravity, command-code (Issue #2253). Which flags each one is launched
+ * with, and how its stdout is decoded back into an answer, is claude-executor's
+ * business — this module only records the verdict.
+ *
  * Trust boundary: All inputs are DB-derived from schedule-manager.ts (trusted).
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -186,6 +191,13 @@ async function executeSchedule(state) {
         // Resolve the CLI options via the centralized helper (DR1-004, #2044)
         const options = resolveScheduleExecuteOptions(state.entry, worktree);
         const result = await (0, claude_executor_1.executeClaudeCommand)(state.entry.message, worktree.path, state.entry.cliToolId, state.entry.permission, options);
+        // Issue #2253: `result.status` is not always "did the process exit 0".
+        // command-code writes a `{"type":"result","subtype":…}` line even on a
+        // non-zero exit and can pair `subtype: "success"` with exit 9, so
+        // claude-executor reads both halves and folds the verdict into `status` and
+        // into the head of `output` (a `Reason: command-code exit N (…)` line).
+        // This row is therefore the failure reason as well as the transcript, and
+        // must keep writing `result.output` verbatim rather than a summary of it.
         updateExecutionLog(logId, result.status, result.output, result.exitCode);
         updateScheduleLastExecuted(state.scheduleId);
         logger.info('execution:completed', { name: state.entry.name, status: result.status });

package/dist/server/src/lib/polling/auto-yes-dialog-gate.js

@@ -94,6 +94,12 @@ exports.AUTO_YES_DIALOG_GATE_DEFAULT_MODE = {
     gemini: 'legacy',
     antigravity: 'legacy',
     'vibe-local': 'legacy',
+    // Issue #2250 / Epic #2249 決定 3: Command Code's Auto-Yes stays on the legacy
+    // numbered-response path. Its `PreToolUse` hook fires AFTER the permission
+    // dialog is answered (measured: dialog 00:11:37, answer 00:11:46, hook
+    // 00:11:46), so a `permissionDecision` cannot dismiss the dialog and there is
+    // no measured dialog rule to gate on.
+    'command-code': 'legacy',
 };
 /**
  * The kill switch (§13.1 DR3-016).