charness 0.0.0-stage → 3.0.0

package/dist/utils/terminalEmitPlan.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @description Pure decision helpers for the terminal adapter's streaming model.
+ * Kept out of `adapters/terminalAdapter.ts` so the "one rolling message per
+ * command" rule and the `tmux new-session` argv are unit-testable without
+ * booting tmux.
+ */
+/**
+ * @description Default terminal pane width in columns. Wide enough that normal
+ * command output (builds, logs, `ls -la`, `git status`) doesn't wrap awkwardly,
+ * matching the Claude adapter's pane sizing intent.
+ */
+export declare const terminalPaneCols = 200;
+/** @description Default terminal pane height in rows. */
+export declare const terminalPaneRows = 50;
+/**
+ * @description Tmux session-name prefix that namespaces terminal shells on the
+ * tmux server, distinct from Claude's `claude-` prefix. Parsed back to a
+ * `SessionKey` via `utils/tmuxSessionName` with this prefix.
+ */
+export declare const terminalTmuxPrefix = "term";
+/** @description Shell to spawn for a terminal session — the operator's `$SHELL`, else bash. */
+export declare const defaultShell: string;
+/**
+ * @description Decide how a non-empty cleaned diff chunk should be emitted for a
+ * terminal session, given whether the next output is "fresh" (a new command's
+ * first output) or a continuation of the in-flight one.
+ *
+ * Mirrors OpenCode's streaming-reply contract: the FIRST chunk after a command
+ * is a new message; every later chunk of the SAME command's output appends
+ * (`isContinuation`). The `nextOutputFresh` flag is re-armed by `sendInput`
+ * (every submitted command), so each command gets exactly one rolling message
+ * that grows as its output streams.
+ */
+export declare function getTerminalEmitPlan(nextOutputFresh: boolean): {
+    isContinuation: boolean;
+};
+/**
+ * @description Build the text actually emitted for one terminal poll-delta so the
+ * downstream bare-concat continuation join (`appendPendingOutput`: `pending +
+ * output`) keeps the inter-poll line break.
+ *
+ * Unlike OpenCode's token tails (cut mid-word, so they MUST concat bare), each
+ * terminal poll-delta is a complete line/block of shell output, so consecutive
+ * deltas of one command have to be SEPARATED by a `\n`. We carry that `\n` inside
+ * the emitted text (rather than a `meta` flag) so it works identically for the
+ * group `queueOutput` and the DM `feedDraft` paths without touching either.
+ *
+ * - CONTINUATION (`isContinuation` true) → prefix one `\n`, so the bare concat
+ *   yields `pending\n delta`.
+ * - FRESH (`isContinuation` false) → return the chunk unchanged: a fresh delta
+ *   opens a new message and a message must never start blank.
+ *
+ * No doubling: the chunk is already trailing-`\n`-trimmed upstream
+ * (`getNewPaneContent` trims, the adapter `.trim()`s again), so a single-poll
+ * multi-line chunk keeps its OWN interior newlines and gains no extra blank.
+ */
+export declare function buildTerminalEmitText(chunk: string, isContinuation: boolean): string;
+/**
+ * @description Build the `tmux new-session` argv for a terminal shell. Pure so
+ * the shell-command + `-c <workDir>` + size flags are unit-testable. tmux execs
+ * the trailing `shellCommand` via `$SHELL -c`; the caller passes an already
+ * shell-safe command string (the bare shell path needs no quoting, but routing
+ * it through the same builder keeps one assembly point).
+ *
+ * No `--session-id`, no permission flags, no MCP — a terminal is just a shell.
+ */
+export declare function buildTerminalNewSessionArgs(input: {
+    sessionName: string;
+    workDir: string;
+    shellCommand: string;
+    cols: number;
+    rows: number;
+}): string[];
+//# sourceMappingURL=terminalEmitPlan.d.ts.map

package/dist/utils/terminalEmitPlan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminalEmitPlan.d.ts","sourceRoot":"","sources":["../../src/utils/terminalEmitPlan.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC,yDAAyD;AACzD,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;GAIG;AACH,eAAO,MAAM,kBAAkB,SAAS,CAAC;AAEzC,+FAA+F;AAC/F,eAAO,MAAM,YAAY,QAAmC,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,eAAe,EAAE,OAAO,GAAG;IAAE,cAAc,EAAE,OAAO,CAAA;CAAE,CAEzF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,GAAG,MAAM,CAEpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE;IACjD,WAAW,EAAE,MAAM,CAAC;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,YAAY,EAAE,MAAM,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd,GAAG,MAAM,EAAE,CAUX"}

package/dist/utils/terminalEmitPlan.js

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * @description Pure decision helpers for the terminal adapter's streaming model.
+ * Kept out of `adapters/terminalAdapter.ts` so the "one rolling message per
+ * command" rule and the `tmux new-session` argv are unit-testable without
+ * booting tmux.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultShell = exports.terminalTmuxPrefix = exports.terminalPaneRows = exports.terminalPaneCols = void 0;
+exports.getTerminalEmitPlan = getTerminalEmitPlan;
+exports.buildTerminalEmitText = buildTerminalEmitText;
+exports.buildTerminalNewSessionArgs = buildTerminalNewSessionArgs;
+/**
+ * @description Default terminal pane width in columns. Wide enough that normal
+ * command output (builds, logs, `ls -la`, `git status`) doesn't wrap awkwardly,
+ * matching the Claude adapter's pane sizing intent.
+ */
+exports.terminalPaneCols = 200;
+/** @description Default terminal pane height in rows. */
+exports.terminalPaneRows = 50;
+/**
+ * @description Tmux session-name prefix that namespaces terminal shells on the
+ * tmux server, distinct from Claude's `claude-` prefix. Parsed back to a
+ * `SessionKey` via `utils/tmuxSessionName` with this prefix.
+ */
+exports.terminalTmuxPrefix = 'term';
+/** @description Shell to spawn for a terminal session — the operator's `$SHELL`, else bash. */
+exports.defaultShell = process.env.SHELL || '/bin/bash';
+/**
+ * @description Decide how a non-empty cleaned diff chunk should be emitted for a
+ * terminal session, given whether the next output is "fresh" (a new command's
+ * first output) or a continuation of the in-flight one.
+ *
+ * Mirrors OpenCode's streaming-reply contract: the FIRST chunk after a command
+ * is a new message; every later chunk of the SAME command's output appends
+ * (`isContinuation`). The `nextOutputFresh` flag is re-armed by `sendInput`
+ * (every submitted command), so each command gets exactly one rolling message
+ * that grows as its output streams.
+ */
+function getTerminalEmitPlan(nextOutputFresh) {
+    return { isContinuation: !nextOutputFresh };
+}
+/**
+ * @description Build the text actually emitted for one terminal poll-delta so the
+ * downstream bare-concat continuation join (`appendPendingOutput`: `pending +
+ * output`) keeps the inter-poll line break.
+ *
+ * Unlike OpenCode's token tails (cut mid-word, so they MUST concat bare), each
+ * terminal poll-delta is a complete line/block of shell output, so consecutive
+ * deltas of one command have to be SEPARATED by a `\n`. We carry that `\n` inside
+ * the emitted text (rather than a `meta` flag) so it works identically for the
+ * group `queueOutput` and the DM `feedDraft` paths without touching either.
+ *
+ * - CONTINUATION (`isContinuation` true) → prefix one `\n`, so the bare concat
+ *   yields `pending\n delta`.
+ * - FRESH (`isContinuation` false) → return the chunk unchanged: a fresh delta
+ *   opens a new message and a message must never start blank.
+ *
+ * No doubling: the chunk is already trailing-`\n`-trimmed upstream
+ * (`getNewPaneContent` trims, the adapter `.trim()`s again), so a single-poll
+ * multi-line chunk keeps its OWN interior newlines and gains no extra blank.
+ */
+function buildTerminalEmitText(chunk, isContinuation) {
+    return isContinuation ? `\n${chunk}` : chunk;
+}
+/**
+ * @description Build the `tmux new-session` argv for a terminal shell. Pure so
+ * the shell-command + `-c <workDir>` + size flags are unit-testable. tmux execs
+ * the trailing `shellCommand` via `$SHELL -c`; the caller passes an already
+ * shell-safe command string (the bare shell path needs no quoting, but routing
+ * it through the same builder keeps one assembly point).
+ *
+ * No `--session-id`, no permission flags, no MCP — a terminal is just a shell.
+ */
+function buildTerminalNewSessionArgs(input) {
+    return [
+        'new-session',
+        '-d',
+        '-s', input.sessionName,
+        '-x', input.cols.toString(),
+        '-y', input.rows.toString(),
+        '-c', input.workDir,
+        input.shellCommand,
+    ];
+}
+//# sourceMappingURL=terminalEmitPlan.js.map

package/dist/utils/terminalEmitPlan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"terminalEmitPlan.js","sourceRoot":"","sources":["../../src/utils/terminalEmitPlan.ts"],"names":[],"mappings":";AAAA;;;;;GAKG;;;AAiCH,kDAEC;AAsBD,sDAEC;AAWD,kEAgBC;AApFD;;;;GAIG;AACU,QAAA,gBAAgB,GAAG,GAAG,CAAC;AAEpC,yDAAyD;AAC5C,QAAA,gBAAgB,GAAG,EAAE,CAAC;AAEnC;;;;GAIG;AACU,QAAA,kBAAkB,GAAG,MAAM,CAAC;AAEzC,+FAA+F;AAClF,QAAA,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,IAAI,WAAW,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,SAAgB,mBAAmB,CAAC,eAAwB;IAC1D,OAAO,EAAE,cAAc,EAAE,CAAC,eAAe,EAAE,CAAC;AAC9C,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,SAAgB,qBAAqB,CAAC,KAAa,EAAE,cAAuB;IAC1E,OAAO,cAAc,CAAC,CAAC,CAAC,KAAK,KAAK,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC;AAC/C,CAAC;AAED;;;;;;;;GAQG;AACH,SAAgB,2BAA2B,CAAC,KAM3C;IACC,OAAO;QACL,aAAa;QACb,IAAI;QACJ,IAAI,EAAE,KAAK,CAAC,WAAW;QACvB,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE;QAC3B,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,QAAQ,EAAE;QAC3B,IAAI,EAAE,KAAK,CAAC,OAAO;QACnB,KAAK,CAAC,YAAY;KACnB,CAAC;AACJ,CAAC"}

package/dist/utils/thinkingRender.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @description Pure decision + formatting helpers for the OpenCode "thinking"
+ * (chain-of-thought) rendering lifecycle. The adapter emits a mode-AGNOSTIC
+ * {@link ThinkingEvent}; the bot's `handleAgentThinking` consults
+ * {@link getThinkingEventAction} per emit and {@link getThinkingAnswerStartAction}
+ * when the answer begins. Extracted from `bot.ts` so the mode×phase matrix is
+ * unit-testable without the Telegraf / token-bucket machinery (same pattern as
+ * `statusFlushDecision.ts`).
+ *
+ * The mode only controls what REMAINS after reasoning ends — the live
+ * "thinking …" indicator is shown in ALL three modes while the agent reasons.
+ */
+import type { DisplayVerbosityMode, ThinkingPhase } from '../types';
+/**
+ * @name ThinkingMessageAction
+ * @description What the bot should do with the thread's thinking message.
+ *
+ * - `editLiveLabel`     — show / refresh the live "☁️ thinking …" indicator
+ *   (label only, no reasoning body). Used by `short` + `minimal` while reasoning.
+ * - `editLiveDetailed`  — show / refresh the live indicator WITH the full
+ *   accumulated reasoning text appended under it. Used by `full` while
+ *   reasoning.
+ * - `collapseToDuration`— replace the body with the collapsed
+ *   "💭 thought for {N}s" line and persist (clear the tracked id). `short` done.
+ * - `keep`              — leave the message exactly as-is and persist (clear the
+ *   tracked id so the next response starts a fresh message). `full` done.
+ * - `holdForAnswer`     — leave the message as-is but KEEP tracking its id, so
+ *   the answer-start trigger can delete it. `minimal` done — the live indicator
+ *   stays until the answer begins.
+ * - `delete`            — remove the thinking message entirely (clear the id).
+ *   `minimal` when the answer starts.
+ * - `noop`              — do nothing. (`full`/`short` need no special
+ *   handling when the answer starts — their message already persists.)
+ */
+export type ThinkingMessageAction = 'editLiveLabel' | 'editLiveDetailed' | 'collapseToDuration' | 'keep' | 'holdForAnswer' | 'delete' | 'noop';
+/**
+ * @description Decide what the bot does for a `thinking` event in `mode` at
+ * `phase`. Pure — depends only on the mode and phase, never on Telegram state.
+ *
+ * Matrix:
+ * ```
+ *            phase=live          phase=done
+ * full       editLiveDetailed    keep
+ * short      editLiveLabel       collapseToDuration
+ * minimal    editLiveLabel       holdForAnswer
+ * ```
+ * `minimal`+done resolves to `holdForAnswer` (not `delete`): the live indicator
+ * stays AND its id stays tracked until the ANSWER starts, which is a separate
+ * trigger ({@link getThinkingAnswerStartAction}). If the answer never comes
+ * (e.g. the turn ends with only reasoning), the held frame simply persists —
+ * acceptable and rare.
+ */
+export declare function getThinkingEventAction(mode: DisplayVerbosityMode, phase: ThinkingPhase): ThinkingMessageAction;
+/**
+ * @description Decide what the bot does to the thinking message when the real
+ * answer starts (first `output` of the response). Only `minimal` removes it;
+ * the other modes leave their persisted message in place.
+ */
+export declare function getThinkingAnswerStartAction(mode: DisplayVerbosityMode): ThinkingMessageAction;
+/**
+ * @description Format a reasoning duration (ms) into a whole-second count for
+ * the "thought for {N}s" collapsed line. Rounds to the nearest second, with a
+ * floor of 1 so a sub-second reasoning burst never reads "thought for 0s".
+ */
+export declare function formatThinkingDurationSeconds(durationMs: number): number;
+/**
+ * @description Parse the whole-second reasoning duration out of a scraped Claude
+ * thinking block, or null when no duration clause is present. The Claude backend
+ * has no millisecond timestamps like OpenCode — the only signal is the duration
+ * the TUI renders as text in the block's header / trailer, so this scrapes it
+ * from {@link THINKING_DURATION_CLAUSE_RE} (the first line that carries one).
+ */
+export declare function parseThinkingDurationSeconds(blockText: string): number | null;
+//# sourceMappingURL=thinkingRender.d.ts.map

package/dist/utils/thinkingRender.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinkingRender.d.ts","sourceRoot":"","sources":["../../src/utils/thinkingRender.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAMpE;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,qBAAqB,GAC7B,eAAe,GACf,kBAAkB,GAClB,oBAAoB,GACpB,MAAM,GACN,eAAe,GACf,QAAQ,GACR,MAAM,CAAC;AAEX;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,oBAAoB,EAAE,KAAK,EAAE,aAAa,GAAG,qBAAqB,CAQ9G;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,oBAAoB,GAAG,qBAAqB,CAE9F;AAKD;;;;GAIG;AACH,wBAAgB,6BAA6B,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAGxE;AAgBD;;;;;;GAMG;AACH,wBAAgB,4BAA4B,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAU7E"}

package/dist/utils/thinkingRender.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThinkingEventAction = getThinkingEventAction;
+exports.getThinkingAnswerStartAction = getThinkingAnswerStartAction;
+exports.formatThinkingDurationSeconds = formatThinkingDurationSeconds;
+exports.parseThinkingDurationSeconds = parseThinkingDurationSeconds;
+/**
+ * @description Decide what the bot does for a `thinking` event in `mode` at
+ * `phase`. Pure — depends only on the mode and phase, never on Telegram state.
+ *
+ * Matrix:
+ * ```
+ *            phase=live          phase=done
+ * full       editLiveDetailed    keep
+ * short      editLiveLabel       collapseToDuration
+ * minimal    editLiveLabel       holdForAnswer
+ * ```
+ * `minimal`+done resolves to `holdForAnswer` (not `delete`): the live indicator
+ * stays AND its id stays tracked until the ANSWER starts, which is a separate
+ * trigger ({@link getThinkingAnswerStartAction}). If the answer never comes
+ * (e.g. the turn ends with only reasoning), the held frame simply persists —
+ * acceptable and rare.
+ */
+function getThinkingEventAction(mode, phase) {
+    if (phase === 'live') {
+        return mode === 'full' ? 'editLiveDetailed' : 'editLiveLabel';
+    }
+    // phase === 'done'
+    if (mode === 'short')
+        return 'collapseToDuration';
+    if (mode === 'minimal')
+        return 'holdForAnswer';
+    return 'keep';
+}
+/**
+ * @description Decide what the bot does to the thinking message when the real
+ * answer starts (first `output` of the response). Only `minimal` removes it;
+ * the other modes leave their persisted message in place.
+ */
+function getThinkingAnswerStartAction(mode) {
+    return mode === 'minimal' ? 'delete' : 'noop';
+}
+/** Milliseconds in one second — for the "thought for {N}s" duration formatter. */
+const millisecondsPerSecond = 1000;
+/**
+ * @description Format a reasoning duration (ms) into a whole-second count for
+ * the "thought for {N}s" collapsed line. Rounds to the nearest second, with a
+ * floor of 1 so a sub-second reasoning burst never reads "thought for 0s".
+ */
+function formatThinkingDurationSeconds(durationMs) {
+    if (!Number.isFinite(durationMs) || durationMs <= 0)
+        return 1;
+    return Math.max(1, Math.round(durationMs / millisecondsPerSecond));
+}
+const secondsPerMinute = 60;
+const secondsPerHour = 3600;
+/**
+ * @description Extract the FIRST `for <Nh Nm Ns>` duration clause anywhere in a
+ * scraped Claude thinking block — the `Thinking for *1m 6s*…` header
+ * (`THINKING_HEADER_RE`) or the `✻ Cooked for 1m 6s` trailer
+ * (`POST_THINKING_TRAILER_RE`). Tolerates the ANSI-bold `*…*` wraps and the
+ * trailing U+2026 ellipsis around the duration. Each of h/m/s is optional but
+ * at least one must be present for a match.
+ */
+const THINKING_DURATION_CLAUSE_RE = /\bfor\s+\*?(?:(\d+)h\s+)?(?:(\d+)m\s+)?(?:(\d+)s)\*?/;
+/**
+ * @description Parse the whole-second reasoning duration out of a scraped Claude
+ * thinking block, or null when no duration clause is present. The Claude backend
+ * has no millisecond timestamps like OpenCode — the only signal is the duration
+ * the TUI renders as text in the block's header / trailer, so this scrapes it
+ * from {@link THINKING_DURATION_CLAUSE_RE} (the first line that carries one).
+ */
+function parseThinkingDurationSeconds(blockText) {
+    for (const line of blockText.split('\n')) {
+        const match = line.match(THINKING_DURATION_CLAUSE_RE);
+        if (!match)
+            continue;
+        const hours = match[1] ? Number(match[1]) : 0;
+        const minutes = match[2] ? Number(match[2]) : 0;
+        const seconds = match[3] ? Number(match[3]) : 0;
+        return hours * secondsPerHour + minutes * secondsPerMinute + seconds;
+    }
+    return null;
+}
+//# sourceMappingURL=thinkingRender.js.map

package/dist/utils/thinkingRender.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thinkingRender.js","sourceRoot":"","sources":["../../src/utils/thinkingRender.ts"],"names":[],"mappings":";;AAiEA,wDAQC;AAOD,oEAEC;AAUD,sEAGC;AAuBD,oEAUC;AAhFD;;;;;;;;;;;;;;;;GAgBG;AACH,SAAgB,sBAAsB,CAAC,IAA0B,EAAE,KAAoB;IACrF,IAAI,KAAK,KAAK,MAAM,EAAE,CAAC;QACrB,OAAO,IAAI,KAAK,MAAM,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,eAAe,CAAC;IAChE,CAAC;IACD,mBAAmB;IACnB,IAAI,IAAI,KAAK,OAAO;QAAE,OAAO,oBAAoB,CAAC;IAClD,IAAI,IAAI,KAAK,SAAS;QAAE,OAAO,eAAe,CAAC;IAC/C,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;GAIG;AACH,SAAgB,4BAA4B,CAAC,IAA0B;IACrE,OAAO,IAAI,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC;AAChD,CAAC;AAED,kFAAkF;AAClF,MAAM,qBAAqB,GAAG,IAAI,CAAC;AAEnC;;;;GAIG;AACH,SAAgB,6BAA6B,CAAC,UAAkB;IAC9D,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAC,IAAI,UAAU,IAAI,CAAC;QAAE,OAAO,CAAC,CAAC;IAC9D,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,UAAU,GAAG,qBAAqB,CAAC,CAAC,CAAC;AACrE,CAAC;AAED,MAAM,gBAAgB,GAAG,EAAE,CAAC;AAC5B,MAAM,cAAc,GAAG,IAAI,CAAC;AAE5B;;;;;;;GAOG;AACH,MAAM,2BAA2B,GAC/B,sDAAsD,CAAC;AAEzD;;;;;;GAMG;AACH,SAAgB,4BAA4B,CAAC,SAAiB;IAC5D,KAAK,MAAM,IAAI,IAAI,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACzC,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,2BAA2B,CAAC,CAAC;QACtD,IAAI,CAAC,KAAK;YAAE,SAAS;QACrB,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9C,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,MAAM,OAAO,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAChD,OAAO,KAAK,GAAG,cAAc,GAAG,OAAO,GAAG,gBAAgB,GAAG,OAAO,CAAC;IACvE,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/utils/threadStatusReport.d.ts

@@ -0,0 +1,55 @@
+import type { AgentRuntimeInfo } from '../types';
+export interface ThreadStatusReportInput {
+    agentLine: string;
+    subdir: string;
+    isActive: boolean;
+    /** No live process, but the session is kept: the next message resumes it (lifecycle plan L3). */
+    isSleeping: boolean;
+    workDir: string | null;
+    model: string | null;
+    effort: string | null;
+    startedAt: string | null;
+    runtime: AgentRuntimeInfo | null;
+    /** The topic's view, already localized (`verbosity.view.*`). */
+    view: string;
+    /** Instance timezone, already resolved (stored pick, else the host zone). */
+    timezone: string;
+    /** That zone's current wall clock, e.g. `18:42 (+03:00)`. */
+    timezoneNow: string;
+}
+/**
+ * @description Render the per-topic `/status` report. Pure (locale comes from
+ * the caller's async i18n context) and kept OUT of `bot.ts` so it is unit-testable
+ * without importing the bot module, whose module-scope `parseEnv()` exits the
+ * process when `TELEGRAM_BOT_TOKEN` is unset.
+ *
+ * Model / effort / start date / runtime rows are session properties: they are
+ * meaningless once the session stopped, so a stopped thread renders only the
+ * header, the bound working directory, the topic's view and the timezone.
+ */
+export declare function getThreadStatusReport({ agentLine, subdir, isActive, isSleeping, workDir, model, effort, startedAt, runtime, view, timezone, timezoneNow, }: ThreadStatusReportInput): string;
+export interface ThreadStatusModelSources {
+    /** Live model the adapter itself can name right now (`getCurrentModel`). */
+    adapterModel: string | null;
+    /** Model the runtime reports it ACTUALLY ran last ({@link AgentRuntimeInfo.model}). */
+    runtimeModel: string | null;
+    /** Model persisted on the agent row when the session was started. */
+    persistedModel: string | null;
+}
+/**
+ * @description Resolve the model `/status` names for a live session, most
+ * authoritative source first.
+ *
+ * The runtime report sits in the MIDDLE on purpose: the Claude tmux backend
+ * keeps its model inside the TUI, so its `getCurrentModel` is permanently null
+ * and the runtime's self-report is the only model source there — without this
+ * step `/status` named no model at all on that whole backend. It must still lose
+ * to a live adapter value, which knows about a model switch the runtime has not
+ * yet written a turn for.
+ *
+ * Each step falls through on any FALSY value, not just `null`: an adapter that
+ * answers with an empty string knows no model either, and `??` let that empty
+ * string win over a real runtime-reported one, rendering a blank `/status` row.
+ */
+export declare function getThreadStatusModel({ adapterModel, runtimeModel, persistedModel, }: ThreadStatusModelSources): string | null;
+//# sourceMappingURL=threadStatusReport.d.ts.map

package/dist/utils/threadStatusReport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threadStatusReport.d.ts","sourceRoot":"","sources":["../../src/utils/threadStatusReport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAC;AAEjD,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,EAAE,OAAO,CAAC;IAClB,iGAAiG;IACjG,UAAU,EAAE,OAAO,CAAC;IACpB,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IACvB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACtB,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,OAAO,EAAE,gBAAgB,GAAG,IAAI,CAAC;IACjC,gEAAgE;IAChE,IAAI,EAAE,MAAM,CAAC;IACb,6EAA6E;IAC7E,QAAQ,EAAE,MAAM,CAAC;IACjB,6DAA6D;IAC7D,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CAAC,EACpC,SAAS,EACT,MAAM,EACN,QAAQ,EACR,UAAU,EACV,OAAO,EACP,KAAK,EACL,MAAM,EACN,SAAS,EACT,OAAO,EACP,IAAI,EACJ,QAAQ,EACR,WAAW,GACZ,EAAE,uBAAuB,GAAG,MAAM,CA2BlC;AAED,MAAM,WAAW,wBAAwB;IACvC,4EAA4E;IAC5E,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,uFAAuF;IACvF,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,qEAAqE;IACrE,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,EACnC,YAAY,EACZ,YAAY,EACZ,cAAc,GACf,EAAE,wBAAwB,GAAG,MAAM,GAAG,IAAI,CAE1C"}

package/dist/utils/threadStatusReport.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getThreadStatusReport = getThreadStatusReport;
+exports.getThreadStatusModel = getThreadStatusModel;
+const i18n_1 = require("../i18n");
+/**
+ * @description Render the per-topic `/status` report. Pure (locale comes from
+ * the caller's async i18n context) and kept OUT of `bot.ts` so it is unit-testable
+ * without importing the bot module, whose module-scope `parseEnv()` exits the
+ * process when `TELEGRAM_BOT_TOKEN` is unset.
+ *
+ * Model / effort / start date / runtime rows are session properties: they are
+ * meaningless once the session stopped, so a stopped thread renders only the
+ * header, the bound working directory, the topic's view and the timezone.
+ */
+function getThreadStatusReport({ agentLine, subdir, isActive, isSleeping, workDir, model, effort, startedAt, runtime, view, timezone, timezoneNow, }) {
+    const lines = [
+        (0, i18n_1.t)('status.thread_report', {
+            agent: agentLine,
+            subdir,
+            session: isActive ? (0, i18n_1.t)('status.thread_running') : isSleeping ? (0, i18n_1.t)('status.thread_sleeping') : (0, i18n_1.t)('status.thread_stopped'),
+        }),
+    ];
+    if (workDir !== null)
+        lines.push((0, i18n_1.t)('status.thread_workdir', { workDir }));
+    // A topic property, not a session one (S6): named whether or not an agent runs.
+    lines.push((0, i18n_1.t)('status.thread_view', { view }));
+    // Instance-wide, not a session property: it belongs ABOVE the early return so
+    // a stopped thread still reports which clock its schedules will fire on.
+    lines.push((0, i18n_1.t)('timezone.status', { zone: timezone, now: timezoneNow }));
+    if (!isActive)
+        return lines.join('\n');
+    if (model)
+        lines.push((0, i18n_1.t)('status.thread_model', { model }));
+    if (effort)
+        lines.push((0, i18n_1.t)('status.thread_effort', { effort }));
+    if (startedAt)
+        lines.push((0, i18n_1.t)('status.thread_started', { started: startedAt }));
+    const unavailable = (0, i18n_1.t)('version.unknown');
+    lines.push((0, i18n_1.t)('status.thread_runtime_version', { version: runtime?.version ?? unavailable }));
+    lines.push((0, i18n_1.t)('status.thread_context', {
+        used: runtime?.contextUsedTokens ?? unavailable,
+        limit: runtime?.contextWindowTokens ?? unavailable,
+    }));
+    return lines.join('\n');
+}
+/**
+ * @description Resolve the model `/status` names for a live session, most
+ * authoritative source first.
+ *
+ * The runtime report sits in the MIDDLE on purpose: the Claude tmux backend
+ * keeps its model inside the TUI, so its `getCurrentModel` is permanently null
+ * and the runtime's self-report is the only model source there — without this
+ * step `/status` named no model at all on that whole backend. It must still lose
+ * to a live adapter value, which knows about a model switch the runtime has not
+ * yet written a turn for.
+ *
+ * Each step falls through on any FALSY value, not just `null`: an adapter that
+ * answers with an empty string knows no model either, and `??` let that empty
+ * string win over a real runtime-reported one, rendering a blank `/status` row.
+ */
+function getThreadStatusModel({ adapterModel, runtimeModel, persistedModel, }) {
+    return adapterModel || runtimeModel || persistedModel || null;
+}
+//# sourceMappingURL=threadStatusReport.js.map

package/dist/utils/threadStatusReport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"threadStatusReport.js","sourceRoot":"","sources":["../../src/utils/threadStatusReport.ts"],"names":[],"mappings":";;AAgCA,sDAwCC;AA0BD,oDAMC;AAxGD,kCAA4B;AAsB5B;;;;;;;;;GASG;AACH,SAAgB,qBAAqB,CAAC,EACpC,SAAS,EACT,MAAM,EACN,QAAQ,EACR,UAAU,EACV,OAAO,EACP,KAAK,EACL,MAAM,EACN,SAAS,EACT,OAAO,EACP,IAAI,EACJ,QAAQ,EACR,WAAW,GACa;IACxB,MAAM,KAAK,GAAG;QACZ,IAAA,QAAC,EAAC,sBAAsB,EAAE;YACxB,KAAK,EAAE,SAAS;YAChB,MAAM;YACN,OAAO,EAAE,QAAQ,CAAC,CAAC,CAAC,IAAA,QAAC,EAAC,uBAAuB,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,IAAA,QAAC,EAAC,wBAAwB,CAAC,CAAC,CAAC,CAAC,IAAA,QAAC,EAAC,uBAAuB,CAAC;SACvH,CAAC;KACH,CAAC;IACF,IAAI,OAAO,KAAK,IAAI;QAAE,KAAK,CAAC,IAAI,CAAC,IAAA,QAAC,EAAC,uBAAuB,EAAE,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;IAC1E,gFAAgF;IAChF,KAAK,CAAC,IAAI,CAAC,IAAA,QAAC,EAAC,oBAAoB,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC;IAC9C,8EAA8E;IAC9E,yEAAyE;IACzE,KAAK,CAAC,IAAI,CAAC,IAAA,QAAC,EAAC,iBAAiB,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC,CAAC;IACvE,IAAI,CAAC,QAAQ;QAAE,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAEvC,IAAI,KAAK;QAAE,KAAK,CAAC,IAAI,CAAC,IAAA,QAAC,EAAC,qBAAqB,EAAE,EAAE,KAAK,EAAE,CAAC,CAAC,CAAC;IAC3D,IAAI,MAAM;QAAE,KAAK,CAAC,IAAI,CAAC,IAAA,QAAC,EAAC,sBAAsB,EAAE,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC;IAC9D,IAAI,SAAS;QAAE,KAAK,CAAC,IAAI,CAAC,IAAA,QAAC,EAAC,uBAAuB,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;IAC9E,MAAM,WAAW,GAAG,IAAA,QAAC,EAAC,iBAAiB,CAAC,CAAC;IACzC,KAAK,CAAC,IAAI,CAAC,IAAA,QAAC,EAAC,+BAA+B,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,CAAC,CAAC,CAAC;IAC7F,KAAK,CAAC,IAAI,CAAC,IAAA,QAAC,EAAC,uBAAuB,EAAE;QACpC,IAAI,EAAE,OAAO,EAAE,iBAAiB,IAAI,WAAW;QAC/C,KAAK,EAAE,OAAO,EAAE,mBAAmB,IAAI,WAAW;KACnD,CAAC,CAAC,CAAC;IAEJ,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAWD;;;;;;;;;;;;;;GAcG;AACH,SAAgB,oBAAoB,CAAC,EACnC,YAAY,EACZ,YAAY,EACZ,cAAc,GACW;IACzB,OAAO,YAAY,IAAI,YAAY,IAAI,cAAc,IAAI,IAAI,CAAC;AAChE,CAAC"}

package/dist/utils/threadToggle.d.ts

@@ -0,0 +1,29 @@
+/**
+ * @description The resolution rule shared by every per-thread toggle with an
+ * instance-wide default (`/compact_on_idle`, `/auto_continue_limits`,
+ * `/compact_summary`): a per-thread override always wins, otherwise the
+ * instance-wide default applies, and an unset default means the setting's own
+ * fallback — ON for the first two, OFF for `/compact_summary`.
+ *
+ * Extracted because the same four lines were already written out twice and the
+ * third toggle would have made three copies of one rule — the kind of duplication
+ * where one copy silently stops matching the others. Each toggle keeps its OWN
+ * named wrapper: the name is what documents which setting is being resolved (and
+ * why its fallback is the right one), so call sites and tests stay unchanged.
+ */
+/**
+ * @description Resolve a per-thread toggle. `threadOverride` present (true OR
+ * false) wins over everything; otherwise `globalDefault`; `undefined` for both
+ * means `unsetValue`.
+ *
+ * Both inputs are `boolean | undefined` on purpose: "never set" must stay
+ * distinguishable from an explicit value, or a General «Disable» would be
+ * re-enabled by the fallback on the next boot.
+ */
+export declare function resolveThreadToggle(globalDefault: boolean | undefined, threadOverride: boolean | undefined, unsetValue: boolean): boolean;
+/**
+ * @description {@link resolveThreadToggle} for a toggle that is ON when nothing is
+ * set.
+ */
+export declare function resolveDefaultOnThreadToggle(globalDefault: boolean | undefined, threadOverride: boolean | undefined): boolean;
+//# sourceMappingURL=threadToggle.d.ts.map

package/dist/utils/threadToggle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"threadToggle.d.ts","sourceRoot":"","sources":["../../src/utils/threadToggle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;GAQG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,OAAO,GAAG,SAAS,EAClC,cAAc,EAAE,OAAO,GAAG,SAAS,EACnC,UAAU,EAAE,OAAO,GAClB,OAAO,CAGT;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,OAAO,GAAG,SAAS,EAClC,cAAc,EAAE,OAAO,GAAG,SAAS,GAClC,OAAO,CAET"}

package/dist/utils/threadToggle.js

@@ -0,0 +1,39 @@
+"use strict";
+/**
+ * @description The resolution rule shared by every per-thread toggle with an
+ * instance-wide default (`/compact_on_idle`, `/auto_continue_limits`,
+ * `/compact_summary`): a per-thread override always wins, otherwise the
+ * instance-wide default applies, and an unset default means the setting's own
+ * fallback — ON for the first two, OFF for `/compact_summary`.
+ *
+ * Extracted because the same four lines were already written out twice and the
+ * third toggle would have made three copies of one rule — the kind of duplication
+ * where one copy silently stops matching the others. Each toggle keeps its OWN
+ * named wrapper: the name is what documents which setting is being resolved (and
+ * why its fallback is the right one), so call sites and tests stay unchanged.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveThreadToggle = resolveThreadToggle;
+exports.resolveDefaultOnThreadToggle = resolveDefaultOnThreadToggle;
+/**
+ * @description Resolve a per-thread toggle. `threadOverride` present (true OR
+ * false) wins over everything; otherwise `globalDefault`; `undefined` for both
+ * means `unsetValue`.
+ *
+ * Both inputs are `boolean | undefined` on purpose: "never set" must stay
+ * distinguishable from an explicit value, or a General «Disable» would be
+ * re-enabled by the fallback on the next boot.
+ */
+function resolveThreadToggle(globalDefault, threadOverride, unsetValue) {
+    if (threadOverride !== undefined)
+        return threadOverride;
+    return globalDefault ?? unsetValue;
+}
+/**
+ * @description {@link resolveThreadToggle} for a toggle that is ON when nothing is
+ * set.
+ */
+function resolveDefaultOnThreadToggle(globalDefault, threadOverride) {
+    return resolveThreadToggle(globalDefault, threadOverride, true);
+}
+//# sourceMappingURL=threadToggle.js.map

package/dist/utils/threadToggle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"threadToggle.js","sourceRoot":"","sources":["../../src/utils/threadToggle.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;GAYG;;AAWH,kDAOC;AAMD,oEAKC;AA3BD;;;;;;;;GAQG;AACH,SAAgB,mBAAmB,CACjC,aAAkC,EAClC,cAAmC,EACnC,UAAmB;IAEnB,IAAI,cAAc,KAAK,SAAS;QAAE,OAAO,cAAc,CAAC;IACxD,OAAO,aAAa,IAAI,UAAU,CAAC;AACrC,CAAC;AAED;;;GAGG;AACH,SAAgB,4BAA4B,CAC1C,aAAkC,EAClC,cAAmC;IAEnC,OAAO,mBAAmB,CAAC,aAAa,EAAE,cAAc,EAAE,IAAI,CAAC,CAAC;AAClE,CAAC"}