charness 0.0.0-stage → 3.0.0

package/dist/utils/compactOnIdle.js

@@ -0,0 +1,379 @@
+"use strict";
+/**
+ * @description Pure decision + text helpers for the compact-on-idle feature and
+ * the shared closing-section instruction (plan
+ * `agent/tasks/actual/2026-09-14-self-compact-and-compact-on-idle.md`, F2).
+ *
+ * Kept out of `bot.ts` (which cannot be imported by tests — its module-scope
+ * `parseEnv()` exits without a bot token) so every branch is unit-testable,
+ * mirroring `getCompactCommandRoute` in `compactCommandRoute.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compactionClosingEndMarker = exports.compactionClosingStartMarker = exports.compactionSkillsGuidance = exports.compactionSummaryGuidance = exports.compactIdleOverdueSpreadMs = exports.compactIdleOverdueMinDelayMs = exports.idleCompactMs = void 0;
+exports.getAgentIdleMs = getAgentIdleMs;
+exports.getIdleCompactionArmDecision = getIdleCompactionArmDecision;
+exports.resolveCompactOnIdleEnabled = resolveCompactOnIdleEnabled;
+exports.resolveCompactSummaryEnabled = resolveCompactSummaryEnabled;
+exports.checkIsBusyForRealTurn = checkIsBusyForRealTurn;
+exports.checkIsWorkingAtIdle = checkIsWorkingAtIdle;
+exports.getIdleFireDecision = getIdleFireDecision;
+exports.buildCompactionInstruction = buildCompactionInstruction;
+exports.formatTokenCount = formatTokenCount;
+exports.stripCompactionClosingMarkers = stripCompactionClosingMarkers;
+exports.checkShouldPostCompactionSummary = checkShouldPostCompactionSummary;
+exports.checkShouldAnnounceCompactionStart = checkShouldAnnounceCompactionStart;
+exports.buildIdleCompactionNoticeParts = buildIdleCompactionNoticeParts;
+const threadToggle_1 = require("./threadToggle");
+const minutesOverride_1 = require("./minutesOverride");
+/**
+ * Idle interval before an untouched, idle agent session is auto-compacted (F2)
+ * and, on a backend that can be suspended, stopped (lifecycle plan L3). Chosen
+ * to fire just inside the ~1h Anthropic extended prompt-cache window, so the
+ * compaction reads the still-warm cached prefix cheaply and a resume minutes
+ * later still finds the cache. `AGENT_IDLE_MINUTES` overrides it for a test or
+ * live-test instance only (L-D9) — see {@link getAgentIdleMs}.
+ */
+exports.idleCompactMs = 55 * 60 * 1000;
+/**
+ * @description The idle window, honouring the `AGENT_IDLE_MINUTES` override (a
+ * test needs minutes, not an hour; same pattern as `REQUEST_BACKSTOP_MINUTES`).
+ * A missing, non-numeric or non-positive value keeps {@link idleCompactMs}.
+ */
+function getAgentIdleMs(overrideMinutes) {
+    return (0, minutesOverride_1.getMinutesOverrideMs)(overrideMinutes, exports.idleCompactMs);
+}
+/**
+ * Floor delay for an OVERDUE arm (the thread has been idle longer than
+ * {@link idleCompactMs}, across one or more bot restarts). Never fire instantly at
+ * boot: the reattach is still adopting sessions and the topic may be about to
+ * receive a real prompt, so give it a minute of grace first.
+ */
+exports.compactIdleOverdueMinDelayMs = 60_000;
+/**
+ * Window the overdue arms are SPREAD over, on top of
+ * {@link compactIdleOverdueMinDelayMs}. See {@link getIdleCompactionArmDecision}
+ * for why the spread exists.
+ */
+exports.compactIdleOverdueSpreadMs = 10 * 60 * 1000;
+/**
+ * Deterministic non-negative string hash (FNV-1a over UTF-16 code units). Local
+ * and dependency-free on purpose: its only job is to derive a STABLE per-thread
+ * offset inside the overdue spread, so "same key ⇒ same delay" is testable and no
+ * two topics need to coordinate. Not a security primitive.
+ */
+function getStableHash(text) {
+    const fnvOffsetBasis = 0x811c9dc5;
+    const fnvPrime = 0x01000193;
+    let hash = fnvOffsetBasis;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, fnvPrime);
+    }
+    // `>>> 0` turns the signed 32-bit result of `Math.imul` into a non-negative int.
+    return hash >>> 0;
+}
+/**
+ * @description When the idle watchdog should fire for a thread, given when that
+ * thread was last ACTIVE (persisted, so it survives a restart) — the delay plus
+ * which of the three cases produced it.
+ *
+ * Three cases (reported back as {@link IdleCompactionArmKind}):
+ *  - no persisted history (`lastActivityAt === 0`) — a fresh session, or a state
+ *    file written before the tracking existed ⇒ the full {@link idleCompactMs}
+ *    window, i.e. exactly the pre-persistence behaviour.
+ *  - still inside the window ⇒ the REMAINDER, clamped to at most the full window:
+ *    a backward wall-clock step (an NTP correction on a VPS) puts `lastActivityAt`
+ *    in the FUTURE, which would otherwise make the thread wait the whole window
+ *    PLUS the skew — and a skew over ~24.8 days overflows `setTimeout`, which then
+ *    fires immediately with a `TimeoutOverflowWarning`. "The remainder can never
+ *    exceed the full window" is true by definition and costs nothing to enforce.
+ *    The remainder itself is the restart fix: the bot runs in hot-reload mode and
+ *    restarts on every code change, so re-arming a flat 55 minutes each time meant
+ *    a busy development day never let any topic reach the threshold.
+ *  - already past the window (idle across one or more restarts) ⇒ OVERDUE, so
+ *    fire soon, but staggered: {@link compactIdleOverdueMinDelayMs} plus a
+ *    per-thread offset inside {@link compactIdleOverdueSpreadMs}. The boot
+ *    reattach adopts every live session at once; without the stagger every
+ *    overdue topic would start an LLM compaction turn and post its notice in the
+ *    same instant. Spreading them over ~1–11 minutes keeps the backlog orderly,
+ *    and deriving the offset from the thread key keeps it deterministic (hence
+ *    testable) instead of random.
+ *
+ * The stagger being DETERMINISTIC was considered and chosen, not overlooked: a
+ * thread whose offset lands near the top of the spread never fires while the bot
+ * reloads more often than that offset, and a random offset would eventually get
+ * lucky. It is still the wrong trade — a random offset makes the fire time
+ * unpredictable and untestable, the starvation it would avoid lasts only while the
+ * operator is actively rebuilding (a state that ends), and under reloads that
+ * frequent a FULL-window arm starves just as surely, so the stagger is not
+ * uniquely affected. Do not re-litigate this as an oversight.
+ *
+ * An overdue thread is compacted even though its prompt cache has long gone
+ * cold. The 55-minute interval exists to make the compaction TURN itself cheap
+ * against a warm cache, but the payoff of compacting is that every SUBSEQUENT
+ * turn in that session reads a small context instead of a huge one — clearly
+ * worth one uncached read, whereas skipping it leaves the session permanently
+ * bloated.
+ */
+function getIdleCompactionArmDecision(input) {
+    const idleWindowMs = input.idleWindowMs ?? exports.idleCompactMs;
+    if (input.lastActivityAt <= 0)
+        return { delayMs: idleWindowMs, kind: 'fullWindow' };
+    const remainingMs = idleWindowMs - (input.now - input.lastActivityAt);
+    // Clamped: a backward clock step makes `lastActivityAt` future-dated, and the
+    // remainder must never exceed the window it is a remainder of.
+    if (remainingMs > 0)
+        return { delayMs: Math.min(remainingMs, idleWindowMs), kind: 'remainder' };
+    return {
+        delayMs: exports.compactIdleOverdueMinDelayMs + (getStableHash(input.threadKeyString) % exports.compactIdleOverdueSpreadMs),
+        kind: 'overdue',
+    };
+}
+/**
+ * @description Resolve whether compact-on-idle is enabled for a thread. A
+ * per-thread override always wins; otherwise the instance-wide default applies,
+ * which is ON when unset (mirrors `traceAllThreads` — the feature ships enabled).
+ */
+function resolveCompactOnIdleEnabled(globalDefault, threadOverride) {
+    return (0, threadToggle_1.resolveDefaultOnThreadToggle)(globalDefault, threadOverride);
+}
+/**
+ * @description Resolve whether the full compaction summary is posted for a thread
+ * (`/compact_summary`). A per-thread override always wins; otherwise the
+ * instance-wide default applies, which is OFF when unset: the operator asked for a
+ * compaction to end in one short line, with the summary there only for a topic
+ * (or an instance) that turns it on.
+ *
+ * Unlike compact-on-idle this is read at COMPACTION time rather than used to arm a
+ * timer, so it is meaningful in a topic with no live session and is deliberately
+ * not gated on one.
+ */
+function resolveCompactSummaryEnabled(globalDefault, threadOverride) {
+    return (0, threadToggle_1.resolveThreadToggle)(globalDefault, threadOverride, false);
+}
+/**
+ * @description Whether the session is busy for a REAL running turn, as opposed
+ * to merely idle-WAITING on an unanswered interactive question. Both states make
+ * `checkIsBusy` report `true`, but D1 draws them apart: a pending question at idle
+ * is a FIRE condition (reject + compact + re-ask), not a reason to hold off, while
+ * a genuinely running turn still blocks the idle compaction. So the fire guard
+ * treats "busy" as `checkIsBusy && !hasPendingQuestion`.
+ */
+function checkIsBusyForRealTurn(input) {
+    return input.isBusy && !input.hasPendingQuestion;
+}
+/**
+ * @description Whether the process is WORKING at the idle fire (L-D2): a real
+ * running turn ({@link checkIsBusyForRealTurn} — a pending question excuses the
+ * turn, D1) OR background work the question never excuses (a background task,
+ * input not yet taken in, a compaction in flight). The two are read apart so a
+ * question pending over a running background task still reads as working: the
+ * D1 reject-compact-re-ask would otherwise end in a stop that kills the task.
+ */
+function checkIsWorkingAtIdle(input) {
+    return checkIsBusyForRealTurn(input) || input.hasBackgroundWork;
+}
+/**
+ * @description The idle-fire decision, taken the moment the idle timer fires
+ * (lifecycle plan L3). Nothing happens to a session that is not there or is
+ * WORKING (L-D2: a real running turn, a background task, input not yet taken in,
+ * a compaction in flight — a pending interactive question is NOT work, see
+ * {@link checkIsBusyForRealTurn}; D1); the next activity re-arms the timer.
+ *
+ * The compaction runs only when the feature is enabled for the thread, the
+ * per-thread user-latch is NOT already spent (D2 — after a fire it stays latched
+ * until the next genuine USER message re-arms it, so idle compaction runs at most
+ * once per user-active period), at least one agent turn has completed since the
+ * last compaction (otherwise there is nothing new to compress), and no
+ * usage-limit wait is armed (L-D6: a compaction turn would hit the limit).
+ *
+ * The STOP happens whether or not the compaction runs (L-D1: a resume restores
+ * the full history, so a stopped process loses nothing) — on a backend that can
+ * be suspended; the tmux TUI and OpenCode stay (L-D8).
+ */
+function getIdleFireDecision(input) {
+    const notIdleReasons = [
+        !input.isSessionActive && 'no active session',
+        input.isWorking && 'working',
+    ].filter((reason) => typeof reason === 'string');
+    if (notIdleReasons.length > 0) {
+        return { shouldCompact: false, compactionSkipReasons: notIdleReasons, shouldSuspend: false, suspendSkipReasons: notIdleReasons };
+    }
+    const compactionSkipReasons = [
+        !input.isEnabled && 'disabled',
+        input.isLatched && 'latched (D2)',
+        !input.hasCompletedTurnSinceCompaction && 'nothing to compress',
+        input.isLimitWaitArmed && 'a usage-limit wait is armed (L-D6)',
+    ].filter((reason) => typeof reason === 'string');
+    return {
+        shouldCompact: compactionSkipReasons.length === 0,
+        compactionSkipReasons,
+        shouldSuspend: input.canSuspend,
+        suspendSkipReasons: input.canSuspend ? [] : ['the backend is not suspended'],
+    };
+}
+/**
+ * @description The maximally-complete-summary guidance (D3) — one canonical text
+ * used on EVERY bot-issued compaction, kept BACKEND-CONSISTENT: it is baked into
+ * the OpenCode fork's compaction prompt (so it also reaches the auto/overflow
+ * compaction the bot can't touch) and, for the Claude backends (which have no
+ * prompt the bot controls), appended to the `/compact <instruction>` the bot
+ * sends. A code constant (not an i18n key) because it is identical across all
+ * locales — it dictates WHAT the summary must contain, never its language — and
+ * because it must mirror the fork's baked wording without 12-locale drift.
+ */
+exports.compactionSummaryGuidance = 'Make the summary MAXIMALLY COMPLETE: preserve every detail needed to continue the work from a clean session with no memory of this conversation — never drop load-bearing information (decisions, constraints, file paths, commands, error strings, identifiers, active tasks, delegated-work state) for brevity. Capture only SESSION-SPECIFIC working nuances: the user\'s in-session directives and any deviations from the standard process. Do NOT restate the standard instructions that auto-load at session start (for example CLAUDE.md / AGENTS.md / rules files) — they reload automatically on the fresh session, so duplicating them only wastes the summary. Keep the conversational directives, active exceptions, and delegated-work state; drop the static rulebook.';
+/**
+ * @description The loaded-skills guidance, on EVERY compaction of both backends:
+ * bot-issued ones carry it in their instruction, and each backend's own overflow
+ * compaction gets it from a bot-installed hook — Claude's `PreCompact` hook
+ * (`claudeCompactHook.ts`, which also matches on this exact text to skip a
+ * compaction that already carries it) and OpenCode's compaction plugin
+ * (`openCodeCompactPlugin.ts`). A skill is loaded on demand mid-session (a tool call whose
+ * result carries its instructions), so — unlike CLAUDE.md / AGENTS.md — nothing
+ * reloads it after a compaction: the summary drops its text and the fresh
+ * session keeps working without the procedure it was following. Naming the
+ * skills and saying in plain words that they must be loaded again is the only
+ * way the continuing session learns to re-invoke them.
+ */
+exports.compactionSkillsGuidance = 'List every skill that was loaded (invoked) during this session by its exact name, and state explicitly, in plain words, that the continuing session MUST load each of these skills again and follow it before resuming the work: a skill\'s instructions are not carried over by this summary, so without reloading them the fresh session works without them. If no skill was loaded, omit this.';
+/**
+ * @description Compose the per-invocation compaction instruction the bot passes
+ * to a backend (D3 + loaded skills + F2 closing section). The general summary
+ * guidance is appended ONLY when the backend does NOT already bake it into its
+ * own prompt — OpenCode bakes it in the fork (`bakesSummaryGuidance: true`) so
+ * re-sending it would duplicate the text, whereas the Claude backends have no
+ * bot-controlled prompt and must receive it every time. The skills guidance is
+ * skipped the same way when the backend's own compaction prompt already gets it
+ * (`bakesSkillsGuidance`: an OpenCode server running the bot's compaction plugin,
+ * which cannot see this instruction and so cannot skip a duplicate itself). The F2 closing-section directive
+ * (per-locale, may carry a language directive) is appended LAST when present,
+ * because it tells the model to write nothing after its end marker.
+ */
+function buildCompactionInstruction(input) {
+    const parts = [];
+    if (!input.bakesSummaryGuidance)
+        parts.push(input.summaryGuidance);
+    const skills = input.bakesSkillsGuidance ? '' : input.skillsGuidance.trim();
+    if (skills)
+        parts.push(skills);
+    const closing = input.closingSectionInstruction?.trim();
+    if (closing)
+        parts.push(closing);
+    return parts.length > 0 ? parts.join('\n\n') : undefined;
+}
+/**
+ * Digit-group separator for a rendered context-token count. A NARROW NO-BREAK
+ * SPACE (U+202F), not a comma or a period: both of those are DECIMAL separators
+ * in some of the bot's 12 locales, so `314,150` reads as one number in an English
+ * topic and as `314.15` in a German one. A space is unambiguous everywhere, and
+ * no-break keeps the figure from wrapping mid-number in a Telegram bubble.
+ */
+const tokenCountGroupSeparator = ' ';
+/**
+ * @description Render a context-token count for the compaction completion
+ * message ("314 150 → 12 883 tokens"): digits grouped in threes.
+ *
+ * Deliberately NOT `Number.toLocaleString()` — that formats for the HOST's
+ * locale, not the topic's, so the same count would render differently depending
+ * on the machine the bot happens to run on. This is fixed and testable instead.
+ */
+function formatTokenCount(count) {
+    return Math.trunc(count)
+        .toString()
+        // Insert the separator at every position that has a multiple of three digits
+        // left to run, i.e. between groups only — never before the first digit.
+        .replace(/\B(?=(\d{3})+(?!\d))/g, tokenCountGroupSeparator);
+}
+/**
+ * FIXED (English, locale-independent) sentinel markers the closing section is
+ * wrapped in. Sentinels — not a markdown heading — because the two backends
+ * generate very different summary formats (OpenCode's `## Goals/…` template vs
+ * Claude Code's freeform numbered recap), so a heading match is unreliable while
+ * exact markers are backend-agnostic. They are stripped before a summary is
+ * posted ({@link stripCompactionClosingMarkers}). The per-locale instruction pins
+ * these exact strings, so changing them means changing the instruction wording in
+ * lockstep.
+ */
+exports.compactionClosingStartMarker = '<<<WHERE_WE_STOPPED>>>';
+exports.compactionClosingEndMarker = '<<<END_WHERE_WE_STOPPED>>>';
+/**
+ * @description Remove the sentinel marker LINES from a summary that is about to be
+ * posted to the topic, keeping every line of prose — including the closing section
+ * the markers wrap, which is genuine content.
+ *
+ * The markers are machine scaffolding and mean nothing to a reader. A marker sitting ALONE on its
+ * line takes the whole line with it (its own newline included), so the summary is
+ * not left with a blank gap where it stood; a marker the model happened to put
+ * AHEAD of real prose on one line loses only the marker, never the prose. A summary
+ * with no markers comes back unchanged apart from trimming.
+ */
+function stripCompactionClosingMarkers(summaryText) {
+    const markerLine = new RegExp(`^[ \\t]*(?:${escapeRegExpLiteral(exports.compactionClosingStartMarker)}|${escapeRegExpLiteral(exports.compactionClosingEndMarker)})[ \\t]*\\r?\\n?`, 'gm');
+    return summaryText.replace(markerLine, '').trim();
+}
+/** Escape every RegExp metacharacter in `literal` so it matches itself. */
+function escapeRegExpLiteral(literal) {
+    return literal.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * @description Should the bot post the FULL compaction summary into the topic?
+ *
+ * Three independent reasons not to, kept in one testable rule rather than spread
+ * across the call sites:
+ *  - the per-topic `/compact_summary` setting is off;
+ *  - the backend STREAMS its own summary into the topic already
+ *    (`streamsCompactionSummary` — OpenCode's `summarize` produces a real
+ *    assistant message), so the bot posting one too would duplicate it;
+ *  - the route is not a real, awaited compaction: `forwardToAgent` hands
+ *    `/compact` to a TUI that renders its own result and gives the bot no
+ *    completion signal, and `notSupported` never compacts at all — in both cases
+ *    there is no summary of ours to post.
+ */
+function checkShouldPostCompactionSummary(input) {
+    if (!input.isEnabled)
+        return false;
+    if (input.streamsOwnSummary)
+        return false;
+    return input.route === 'adapterCompact';
+}
+/**
+ * @description Should the bot announce that a compaction is STARTING (the notice
+ * that goes out BEFORE the wait, for the triggers the operator is present for)?
+ *
+ * Two reasons not to:
+ *  - the route is not one the bot awaits: `forwardToAgent` hands `/compact` to a TUI
+ *    that renders its own progress, and `notSupported` never compacts at all;
+ *  - no session is live. The compaction seam's first guard is exactly that, so
+ *    announcing here would be a promise the very next message retracts — `/compact`
+ *    in a bound topic whose agent was never started hits precisely that, and before
+ *    the notice moved ahead of the wait the operator only ever saw the refusal.
+ *
+ * Deliberately NOT the same rule as the COMPLETION report, which needs no liveness
+ * input: it is reached only after a compaction really succeeded.
+ */
+function checkShouldAnnounceCompactionStart(input) {
+    return input.route === 'adapterCompact' && input.isSessionActive;
+}
+/**
+ * @description Compose an idle-compaction report as SEPARATE parts in the §1.4
+ * order: notice → summary → re-asked question.
+ *
+ * Splitting what used to be one joined message is the point: the re-asked
+ * question carries inline option buttons, and gluing it behind a full summary
+ * would bury those buttons under a wall of text (and the summary alone can
+ * outgrow a single Telegram message).
+ *
+ * The notice is the one short line on its own. It used to carry the summary's
+ * "Where we stopped" block whenever the full summary was off, which still made
+ * every idle compaction a paragraph; with the summary off the operator now gets
+ * the line alone, and the block reaches the topic only inside the full summary.
+ */
+function buildIdleCompactionNoticeParts(input) {
+    return {
+        notice: input.noticeText && input.noticeText.length > 0 ? input.noticeText : null,
+        summary: input.summary && input.summary.length > 0 ? input.summary : null,
+        question: input.questionText && input.questionText.length > 0 ? input.questionText : null,
+    };
+}
+//# sourceMappingURL=compactOnIdle.js.map

package/dist/utils/compactOnIdle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compactOnIdle.js","sourceRoot":"","sources":["../../src/utils/compactOnIdle.ts"],"names":[],"mappings":"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"}

package/dist/utils/consoleFileTap.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @description Tee `process.stdout`/`process.stderr` to an hourly bucket file so
+ * the bot's console logs ([transcribe], [Bot], errors, …) are readable AFTER the
+ * fact, not only on the operator's live terminal. The original `write` still
+ * runs (terminal preserved) — this is a TEE, never a redirect-away.
+ *
+ * Critical constraints:
+ *  - Best-effort: a tap append failure is swallowed; it must NEVER throw into
+ *    the hot `write()` path or change the original write's return value.
+ *  - NO recursion: the tap appends with `fs.appendFileSync` directly and uses
+ *    NO `console.*` / no `process.std*.write` — logging from inside the tap
+ *    would re-enter the wrapped write and loop forever.
+ *  - Idempotent: a second install is a no-op (a hot rebuild re-imports cleanly).
+ */
+/** Bucket file base + extension — `bot-console-YYYYMMDDHH.log` per hour. The
+ * janitor (bot.ts) imports these to prune the same family it doesn't write. */
+export declare const consoleFileBase = "bot-console";
+export declare const consoleFileExt = "log";
+/** Chunk shapes the wrapped `write` may receive (matches Node's overloads). */
+type WriteChunk = string | Uint8Array;
+/** Minimal view of a writable stream the tap wraps — just its `write`. */
+export interface TappableStream {
+    write(...args: unknown[]): boolean;
+}
+/** How the tap appends a chunk — injectable so tests assert without real IO. */
+export type AppendChunkFn = (chunk: WriteChunk) => void;
+/**
+ * @description Append one chunk to the current hour's console bucket. The
+ * bucket is created owner-only (`0600`) — console logs may quote prompts and
+ * agent output, so they must not be world-readable on a shared host. Exported
+ * for the mode-bits unit test.
+ */
+export declare function appendConsoleBucketChunk(dir: string, chunk: WriteChunk): void;
+/**
+ * @description Wrap ONE stream's `write` so every call ALSO feeds the chunk to
+ * `appendChunk` (the tap) before forwarding to the original. The original's
+ * arguments are forwarded verbatim and its exact return value is returned, so
+ * backpressure semantics are untouched; `appendChunk` is a pure side effect that
+ * is called FIRST and must itself never throw (the bucket appender swallows IO
+ * errors). Pure of `process`/fs — the unit of test for S3.
+ */
+export declare function tapStreamWrite(stream: TappableStream, appendChunk: AppendChunkFn): void;
+/**
+ * @description Tee `process.stdout`/`process.stderr` to the hourly bucket file
+ * `DATA_DIR/bot-console-YYYYMMDDHH.log`. Install as EARLY as possible at the bot
+ * entry so boot logs are captured. Idempotent (a second call is a no-op) so a
+ * hot rebuild re-import can't double-wrap.
+ */
+export declare function installConsoleFileTap(dir: string): void;
+export {};
+//# sourceMappingURL=consoleFileTap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"consoleFileTap.d.ts","sourceRoot":"","sources":["../../src/utils/consoleFileTap.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AAEH;+EAC+E;AAC/E,eAAO,MAAM,eAAe,gBAAgB,CAAC;AAC7C,eAAO,MAAM,cAAc,QAAQ,CAAC;AAIpC,+EAA+E;AAC/E,KAAK,UAAU,GAAG,MAAM,GAAG,UAAU,CAAC;AAEtC,0EAA0E;AAC1E,MAAM,WAAW,cAAc;IAC7B,KAAK,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC;CACpC;AAED,gFAAgF;AAChF,MAAM,MAAM,aAAa,GAAG,CAAC,KAAK,EAAE,UAAU,KAAK,IAAI,CAAC;AAExD;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,GAAG,IAAI,CAQ7E;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,cAAc,EAAE,WAAW,EAAE,aAAa,GAAG,IAAI,CAMvF;AAED;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAkBvD"}

package/dist/utils/consoleFileTap.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.consoleFileExt = exports.consoleFileBase = void 0;
+exports.appendConsoleBucketChunk = appendConsoleBucketChunk;
+exports.tapStreamWrite = tapStreamWrite;
+exports.installConsoleFileTap = installConsoleFileTap;
+const node_fs_1 = require("node:fs");
+const rotatingLogFile_1 = require("./rotatingLogFile");
+/**
+ * @description Tee `process.stdout`/`process.stderr` to an hourly bucket file so
+ * the bot's console logs ([transcribe], [Bot], errors, …) are readable AFTER the
+ * fact, not only on the operator's live terminal. The original `write` still
+ * runs (terminal preserved) — this is a TEE, never a redirect-away.
+ *
+ * Critical constraints:
+ *  - Best-effort: a tap append failure is swallowed; it must NEVER throw into
+ *    the hot `write()` path or change the original write's return value.
+ *  - NO recursion: the tap appends with `fs.appendFileSync` directly and uses
+ *    NO `console.*` / no `process.std*.write` — logging from inside the tap
+ *    would re-enter the wrapped write and loop forever.
+ *  - Idempotent: a second install is a no-op (a hot rebuild re-imports cleanly).
+ */
+/** Bucket file base + extension — `bot-console-YYYYMMDDHH.log` per hour. The
+ * janitor (bot.ts) imports these to prune the same family it doesn't write. */
+exports.consoleFileBase = 'bot-console';
+exports.consoleFileExt = 'log';
+let isInstalled = false;
+/**
+ * @description Append one chunk to the current hour's console bucket. The
+ * bucket is created owner-only (`0600`) — console logs may quote prompts and
+ * agent output, so they must not be world-readable on a shared host. Exported
+ * for the mode-bits unit test.
+ */
+function appendConsoleBucketChunk(dir, chunk) {
+    try {
+        (0, node_fs_1.appendFileSync)((0, rotatingLogFile_1.getHourBucketPath)(dir, exports.consoleFileBase, exports.consoleFileExt, Date.now()), chunk, {
+            mode: 0o600,
+        });
+    }
+    catch {
+        // Best-effort: a tap write failure must never break the original write.
+    }
+}
+/**
+ * @description Wrap ONE stream's `write` so every call ALSO feeds the chunk to
+ * `appendChunk` (the tap) before forwarding to the original. The original's
+ * arguments are forwarded verbatim and its exact return value is returned, so
+ * backpressure semantics are untouched; `appendChunk` is a pure side effect that
+ * is called FIRST and must itself never throw (the bucket appender swallows IO
+ * errors). Pure of `process`/fs — the unit of test for S3.
+ */
+function tapStreamWrite(stream, appendChunk) {
+    const originalWrite = stream.write.bind(stream);
+    stream.write = ((chunk, ...rest) => {
+        appendChunk(chunk);
+        return originalWrite(chunk, ...rest);
+    });
+}
+/**
+ * @description Tee `process.stdout`/`process.stderr` to the hourly bucket file
+ * `DATA_DIR/bot-console-YYYYMMDDHH.log`. Install as EARLY as possible at the bot
+ * entry so boot logs are captured. Idempotent (a second call is a no-op) so a
+ * hot rebuild re-import can't double-wrap.
+ */
+function installConsoleFileTap(dir) {
+    if (isInstalled)
+        return;
+    isInstalled = true;
+    // Ensure DATA_DIR exists ONCE up front. On a fresh install the dir is created
+    // later by the state store's load() — but the tap is installed before that, so
+    // without this the very boot logs we want to capture would `ENOENT` and be
+    // swallowed (the run that matters most). Mirrors outputTrace.ts / diagLog.ts.
+    // Owner-only mode: this mkdir WINS on a fresh install (the state store's own
+    // 0700 mkdir is a no-op on an existing dir), so it must not leave DATA_DIR
+    // with the umask default. The state store additionally chmod-heals at init.
+    try {
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true, mode: 0o700 });
+    }
+    catch {
+        // Best-effort: if the dir can't be created the per-append swallow still holds.
+    }
+    for (const stream of [process.stdout, process.stderr]) {
+        tapStreamWrite(stream, (chunk) => appendConsoleBucketChunk(dir, chunk));
+    }
+}
+//# sourceMappingURL=consoleFileTap.js.map

package/dist/utils/consoleFileTap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consoleFileTap.js","sourceRoot":"","sources":["../../src/utils/consoleFileTap.ts"],"names":[],"mappings":";;;AA0CA,4DAQC;AAUD,wCAMC;AAQD,sDAkBC;AA5FD,qCAAoD;AACpD,uDAAsD;AAEtD;;;;;;;;;;;;;GAaG;AAEH;+EAC+E;AAClE,QAAA,eAAe,GAAG,aAAa,CAAC;AAChC,QAAA,cAAc,GAAG,KAAK,CAAC;AAEpC,IAAI,WAAW,GAAG,KAAK,CAAC;AAaxB;;;;;GAKG;AACH,SAAgB,wBAAwB,CAAC,GAAW,EAAE,KAAiB;IACrE,IAAI,CAAC;QACH,IAAA,wBAAc,EAAC,IAAA,mCAAiB,EAAC,GAAG,EAAE,uBAAe,EAAE,sBAAc,EAAE,IAAI,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE;YACzF,IAAI,EAAE,KAAK;SACZ,CAAC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACP,wEAAwE;IAC1E,CAAC;AACH,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,cAAc,CAAC,MAAsB,EAAE,WAA0B;IAC/E,MAAM,aAAa,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAChD,MAAM,CAAC,KAAK,GAAG,CAAC,CAAC,KAAiB,EAAE,GAAG,IAAe,EAAW,EAAE;QACjE,WAAW,CAAC,KAAK,CAAC,CAAC;QACnB,OAAO,aAAa,CAAC,KAAK,EAAE,GAAG,IAAI,CAAC,CAAC;IACvC,CAAC,CAAwB,CAAC;AAC5B,CAAC;AAED;;;;;GAKG;AACH,SAAgB,qBAAqB,CAAC,GAAW;IAC/C,IAAI,WAAW;QAAE,OAAO;IACxB,WAAW,GAAG,IAAI,CAAC;IACnB,8EAA8E;IAC9E,+EAA+E;IAC/E,2EAA2E;IAC3E,8EAA8E;IAC9E,6EAA6E;IAC7E,2EAA2E;IAC3E,4EAA4E;IAC5E,IAAI,CAAC;QACH,IAAA,mBAAS,EAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IACnD,CAAC;IAAC,MAAM,CAAC;QACP,+EAA+E;IACjF,CAAC;IACD,KAAK,MAAM,MAAM,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC;QACtD,cAAc,CAAC,MAAM,EAAE,CAAC,KAAK,EAAE,EAAE,CAAC,wBAAwB,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC,CAAC;IAC1E,CAAC;AACH,CAAC"}

package/dist/utils/displayVerbosity.d.ts

@@ -0,0 +1,44 @@
+/**
+ * @description THE single source of truth for the unified display-verbosity
+ * vocabulary (`minimal | short | full`) shared by `/thinking`,
+ * `/tool_results` and `/subagent`: the picker option order, the locked
+ * default, the type guard, and the legacy-name normalization. Per-command
+ * SEMANTICS stay in their own helper modules (`thinkingRender.ts`,
+ * `toolResultRender.ts`, `subagentRender.ts`); this module only owns the
+ * vocabulary itself, so the three commands can never drift apart again.
+ */
+import type { DisplayVerbosityMode, ResolvedThreadDisplayPrefs } from '../types';
+/** Every selectable display-verbosity mode, in picker-button order (quiet →
+ * loud). Single source of truth for arg validation and the mode keyboards of
+ * all three display commands. */
+export declare const displayVerbosityModeOptions: readonly DisplayVerbosityMode[];
+/**
+ * @description Locked default for EVERY display pref (user decision
+ * 2026-06-11: "по умолчанию минимум"). `state.ts` resolves absent persisted
+ * fields to it, and the adapters fall back to it for reads that happen before
+ * the bot injects its mode reader at boot.
+ */
+export declare const defaultDisplayVerbosityMode: DisplayVerbosityMode;
+/**
+ * @description Every display pref at its locked default — what the adapters
+ * resolve for a read that happens before the bot injects its prefs reader at
+ * boot, and the baseline `state.ts` fills absent persisted fields from.
+ */
+export declare function getDefaultDisplayPrefs(): ResolvedThreadDisplayPrefs;
+/**
+ * @description Type guard: is `value` one of the {@link DisplayVerbosityMode}
+ * options? Narrows a free-form string to the union WITHOUT a cast. Accepts
+ * ONLY the new vocabulary — legacy names go through
+ * {@link normalizeDisplayVerbosityMode}.
+ */
+export declare function checkIsDisplayVerbosityMode(value: string): value is DisplayVerbosityMode;
+/**
+ * @description Normalize a mode string to the unified vocabulary: a new name
+ * passes through, a legacy name maps per
+ * {@link legacyDisplayVerbosityAliases}, anything else (unknown string,
+ * `undefined`) → `null` so the caller decides between "use the default"
+ * (read-time normalization of persisted values) and "reject the input"
+ * (command arg / callback validation).
+ */
+export declare function normalizeDisplayVerbosityMode(value: string | undefined): DisplayVerbosityMode | null;
+//# sourceMappingURL=displayVerbosity.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"displayVerbosity.d.ts","sourceRoot":"","sources":["../../src/utils/displayVerbosity.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,MAAM,UAAU,CAAC;AAGjF;;iCAEiC;AACjC,eAAO,MAAM,2BAA2B,EAAE,SAAS,oBAAoB,EAAiC,CAAC;AAEzG;;;;;GAKG;AACH,eAAO,MAAM,2BAA2B,EAAE,oBAAgC,CAAC;AAE3E;;;;GAIG;AACH,wBAAgB,sBAAsB,IAAI,0BAA0B,CAOnE;AAED;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,oBAAoB,CAExF;AAsBD;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,oBAAoB,GAAG,IAAI,CAIpG"}