charness 0.0.0-stage → 3.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeChunkClassifier.d.ts","sourceRoot":"","sources":["../../src/utils/claudeChunkClassifier.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAeL,KAAK,cAAc,EACpB,MAAM,sBAAsB,CAAC;AAG9B;;;;;;;;;;;;;;;GAeG;AACH,oBAAY,cAAc;IACxB,aAAa,kBAAkB;IAC/B,UAAU,eAAe;IACzB,QAAQ,aAAa;IACrB,oBAAoB,yBAAyB;IAC7C,KAAK,UAAU;IACf,MAAM,WAAW;CAClB;AAED,kFAAkF;AAClF,MAAM,WAAW,kBAAkB;IACjC,GAAG,EAAE,cAAc,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd;AAED;;;;;;GAMG;AACH,MAAM,WAAW,kBAAkB;IACjC,sFAAsF;IACtF,QAAQ,EAAE,cAAc,GAAG,IAAI,CAAC;IAChC,iFAAiF;IACjF,cAAc,EAAE,OAAO,CAAC;IACxB,2FAA2F;IAC3F,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED,+EAA+E;AAC/E,wBAAgB,yBAAyB,IAAI,kBAAkB,CAE9D;AAED,oFAAoF;AACpF,MAAM,WAAW,yBAAyB;IACxC,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC/B,eAAe,EAAE,kBAAkB,CAAC;CACrC;AAeD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CACjC,SAAS,EAAE,MAAM,EACjB,eAAe,EAAE,kBAAkB,GAClC,yBAAyB,CA8K3B"}

package/dist/utils/claudeChunkClassifier.js

@@ -0,0 +1,254 @@
+"use strict";
+/**
+ * @description PURE classifier that segments a scraped, ANSI-cleaned Claude
+ * TUI pane chunk into TAGGED spans, carrying tool-fence context across poll
+ * chunks (the same cross-poll state the relay already threads as
+ * `session.openToolKind` through {@link stripTuiElementsWithContext}).
+ *
+ * This is the decision layer for the verbosity scopes (S4 `/tool_results`, S5
+ * `/thinking`, S6 sub-agent panel fold): given a chunk it labels each run of
+ * lines so a later caller can keep / drop / re-route them per the topic's
+ * verbosity mode. S3 only BUILDS and TESTS the classifier — it is NOT wired
+ * into the live relay yet, so the relay path keeps behaving exactly as today.
+ *
+ * Design rules:
+ *  - Reuses the line-shape regexes from {@link ./claudeScrapeShapes} and the
+ *    sub-agent progress shape from {@link ../progressLine} — ONE definition per
+ *    shape, never a copy.
+ *  - Conservative default: a line not positively recognised as tool / thinking
+ *    / panel chatter / chrome is tagged {@link ClaudeChunkTag.Prose} — the
+ *    agent's real answer is never swallowed.
+ *  - Cross-poll fence semantics DERIVE FROM {@link fenceToolResultBodies} but
+ *    are not identical (this classifier serves the verbosity consumer, not the
+ *    fencer): a tool header opens a kind; a `⎿` body or its orphan indented
+ *    continuation is the tool body for that kind; a solid prose line closes the
+ *    kind. Two intentional divergences, flagged at their call sites below: a
+ *    file-kind `⎿` summary is tagged `ToolBody` (the fencer keeps it prose),
+ *    and a `◯`/`▰▱` panel line does NOT close an open kind (the fencer resets
+ *    it). A future S4 reader must not assume identical reset behavior.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeChunkTag = void 0;
+exports.createInitialChunkContext = createInitialChunkContext;
+exports.classifyClaudeChunk = classifyClaudeChunk;
+const claudeScrapeShapes_1 = require("./claudeScrapeShapes");
+const progressLine_1 = require("../progressLine");
+/**
+ * @name ClaudeChunkTag
+ * @description The classification of a run of pane lines.
+ *  - `thinkingBlock`        — "Thinking for {N}s…" / "Thought for Ns" headers,
+ *                             their reasoning body, and the post-thinking trailer.
+ *  - `toolHeader`           — a tool-call header line (`● Bash(…)`, `✓ Read(…)`).
+ *  - `toolBody`             — the `⎿` result body + its fenced/indented body.
+ *  - `subagentPanelPreview` — the tool-PREVIEW chatter the TUI draws under a
+ *                             running `◯` sub-agent panel (`⎿ Bash(…)` previews,
+ *                             "… +N tool uses" walls) — distinct from the ◯
+ *                             title line itself (progress, tagged chrome).
+ *  - `prose`                — real agent answer text (the conservative default).
+ *  - `chrome`               — TUI chrome the relay already drops (box-drawing,
+ *                             nav hints, question/survey chrome, input echo,
+ *                             installer ads, ◯ panel title, spinner ticks).
+ */
+var ClaudeChunkTag;
+(function (ClaudeChunkTag) {
+    ClaudeChunkTag["ThinkingBlock"] = "thinkingBlock";
+    ClaudeChunkTag["ToolHeader"] = "toolHeader";
+    ClaudeChunkTag["ToolBody"] = "toolBody";
+    ClaudeChunkTag["SubagentPanelPreview"] = "subagentPanelPreview";
+    ClaudeChunkTag["Prose"] = "prose";
+    ClaudeChunkTag["Chrome"] = "chrome";
+})(ClaudeChunkTag || (exports.ClaudeChunkTag = ClaudeChunkTag = {}));
+/** The all-closed starting context (also used when a fresh session begins). */
+function createInitialChunkContext() {
+    return { toolKind: null, isThinkingOpen: false, isSubagentPanelOpen: false };
+}
+/** Indented (leading-whitespace) non-blank continuation line of an open body. */
+function checkIsIndentedContinuation(line) {
+    return /^\s/.test(line) && line.trim() !== '';
+}
+/** A `⎿` line whose post-marker content is itself a tool-call header = a sub-agent panel preview. */
+function checkIsPanelToolPreviewMarker(line) {
+    const markerMatch = line.match(claudeScrapeShapes_1.TOOL_RESULT_MARKER_RE);
+    if (!markerMatch)
+        return false;
+    const afterMarker = line.slice(markerMatch[0].length);
+    return claudeScrapeShapes_1.ANY_TOOL_HEADER_RE.test(afterMarker);
+}
+/**
+ * @description Classify one scraped, ANSI-cleaned chunk into tagged segments,
+ * threading {@link ClaudeChunkContext} across polls.
+ *
+ * Per-line precedence (first match wins), then adjacent same-tag lines coalesce:
+ *  1. blank line  → inherits the still-open block's tag (keeps a body contiguous)
+ *  2. code fence  → toggles an agent fence; inside it everything is prose
+ *  3. ◯ panel title / spinner tick / generic chrome → `chrome` (sets panel flag)
+ *  4. sub-agent panel preview (`⎿ Tool(…)`, indented `Tool(…)`, "+N tool uses"
+ *     while a panel is open) → `subagentPanelPreview`
+ *  5. thinking header / trailer / open-thinking body → `thinkingBlock`
+ *  6. tool header → `toolHeader` (opens the matching kind)
+ *  7. `⎿` marker / indented continuation of an open tool kind → `toolBody`
+ *  8. anything else → `prose` (closes any open tool/thinking block)
+ */
+function classifyClaudeChunk(chunkText, incomingContext) {
+    const lines = chunkText.split('\n');
+    const context = { ...incomingContext };
+    const segments = [];
+    let inAgentFence = false;
+    const push = (tag, line) => {
+        const last = segments[segments.length - 1];
+        if (last && last.tag === tag) {
+            last.text += `\n${line}`;
+            return;
+        }
+        segments.push({ tag, text: line });
+    };
+    /** The tag a blank line / inherited run carries given the open block. */
+    const getOpenBlockTag = () => {
+        if (context.toolKind !== null)
+            return ClaudeChunkTag.ToolBody;
+        if (context.isThinkingOpen)
+            return ClaudeChunkTag.ThinkingBlock;
+        return ClaudeChunkTag.Prose;
+    };
+    for (const line of lines) {
+        // 0. Inside an agent-authored ``` block: pass through as prose, the fence
+        // toggles on its delimiters. A fence line itself stays prose (it is real
+        // agent content). Tool/thinking context is irrelevant inside the fence.
+        if (claudeScrapeShapes_1.CODE_FENCE_LINE_RE.test(line)) {
+            inAgentFence = !inAgentFence;
+            context.toolKind = null;
+            context.isThinkingOpen = false;
+            push(ClaudeChunkTag.Prose, line);
+            continue;
+        }
+        if (inAgentFence) {
+            push(ClaudeChunkTag.Prose, line);
+            continue;
+        }
+        // 1. Blank line — keep the open block contiguous (do NOT close it; the
+        // adapter's fencer also leaves the kind intact across blanks).
+        if (line.trim() === '') {
+            push(getOpenBlockTag(), line);
+            continue;
+        }
+        // 2. ◯ sub-agent panel title / compaction bar / spinner tick → chrome. The
+        // ◯ line marks a panel as open so its previews below are panel chatter; it
+        // does NOT close an open tool/thinking block (the panel is a separate pane).
+        if (claudeScrapeShapes_1.PROGRESS_PASSTHROUGH_RE.test(line) || progressLine_1.SUBAGENT_PROGRESS_LINE_RE.test(line)) {
+            context.isSubagentPanelOpen = true;
+            push(ClaudeChunkTag.Chrome, line);
+            continue;
+        }
+        if (claudeScrapeShapes_1.SPINNER_TICK_RE.test(line)) {
+            push(ClaudeChunkTag.Chrome, line);
+            continue;
+        }
+        // 3. Sub-agent panel preview chatter (the bulk of the overview-2 flood):
+        //   - a `⎿  Bash(…)` whose marker content is itself a tool header;
+        //   - a "… +N tool uses" collapse wall while a panel is open;
+        //   - an indented bare `Tool(…)` header continuation while a panel is open.
+        if (checkIsPanelToolPreviewMarker(line)) {
+            context.isSubagentPanelOpen = true;
+            push(ClaudeChunkTag.SubagentPanelPreview, line);
+            continue;
+        }
+        if (context.isSubagentPanelOpen && claudeScrapeShapes_1.COLLAPSE_MARKER_RE.test(line)) {
+            push(ClaudeChunkTag.SubagentPanelPreview, line);
+            continue;
+        }
+        if (context.isSubagentPanelOpen &&
+            checkIsIndentedContinuation(line) &&
+            claudeScrapeShapes_1.ANY_TOOL_HEADER_RE.test(line)) {
+            push(ClaudeChunkTag.SubagentPanelPreview, line);
+            continue;
+        }
+        // An orphan "… +N tool uses" collapse wall (panel already closed / scrolled
+        // off, no open panel context above) is still sub-agent panel chrome — drop it
+        // rather than leak it as prose. The panel-OPEN case is handled above (folds to
+        // a sub-agent status activity); this catches the orphan tail. "+N lines" (a
+        // real tool-body summary) is deliberately NOT matched here.
+        if (claudeScrapeShapes_1.COLLAPSE_TOOLUSE_MARKER_RE.test(line)) {
+            push(ClaudeChunkTag.Chrome, line);
+            continue;
+        }
+        // 4. Thinking block: header opens it, trailer / body continue it.
+        if (claudeScrapeShapes_1.THINKING_HEADER_RE.test(line)) {
+            context.isThinkingOpen = true;
+            context.toolKind = null;
+            context.isSubagentPanelOpen = false;
+            push(ClaudeChunkTag.ThinkingBlock, line);
+            continue;
+        }
+        if (claudeScrapeShapes_1.POST_THINKING_TRAILER_RE.test(line.trim())) {
+            // The trailer closes the thinking block (the reasoning is done).
+            context.isThinkingOpen = false;
+            push(ClaudeChunkTag.ThinkingBlock, line);
+            continue;
+        }
+        if (context.isThinkingOpen) {
+            // The reasoning body: the `⎿  <summary>` line and its indented wrapped
+            // continuation. A non-indented, non-`⎿` solid line ends the block (it is
+            // the agent resuming prose / a tool header), handled by falling through.
+            if (claudeScrapeShapes_1.TOOL_RESULT_MARKER_RE.test(line) || checkIsIndentedContinuation(line)) {
+                push(ClaudeChunkTag.ThinkingBlock, line);
+                continue;
+            }
+            context.isThinkingOpen = false;
+        }
+        // 5. Tool header → opens the matching fence kind (output / file / generic).
+        if (claudeScrapeShapes_1.ANY_TOOL_HEADER_RE.test(line)) {
+            context.isSubagentPanelOpen = false;
+            if (claudeScrapeShapes_1.OUTPUT_TOOL_HEADER_RE.test(line))
+                context.toolKind = 'output';
+            else if (claudeScrapeShapes_1.FILE_TOOL_HEADER_RE.test(line))
+                context.toolKind = 'file';
+            else
+                context.toolKind = 'output'; // non-code tools: treat the body region as one block
+            push(ClaudeChunkTag.ToolHeader, line);
+            continue;
+        }
+        // 6. `⎿` result marker. With an open tool kind it is the tool body. With no
+        // open kind the header was consumed by a prior poll's line-SET diff and an
+        // interleaved prose line nulled the context (rule #10) — the `⎿` glyph is
+        // itself a positive tool-result signal in the TUI, so OPEN a synthetic
+        // `output` kind and tag it ToolBody. The indented-continuation branch (#7)
+        // then keeps the rest of the orphan result region as ToolBody until a solid
+        // prose line ends the run. Without this an orphan `⎿ trace rows: …` block
+        // leaked as Prose, which the router always keeps even in minimal.
+        if (claudeScrapeShapes_1.TOOL_RESULT_MARKER_RE.test(line)) {
+            if (context.toolKind === null)
+                context.toolKind = 'output';
+            context.isSubagentPanelOpen = false;
+            push(ClaudeChunkTag.ToolBody, line);
+            continue;
+        }
+        // 7. Orphan indented continuation of an open tool body (header / `⎿` came in
+        // a prior poll) → tool body. Mirrors the adapter's orphan-output fencing.
+        if (context.toolKind !== null && checkIsIndentedContinuation(line)) {
+            push(ClaudeChunkTag.ToolBody, line);
+            continue;
+        }
+        // 8. Tool-body status / summary lines (`Running…`, "… +N lines",
+        // "Done (… tokens)") belong to the open tool body region.
+        if (context.toolKind !== null &&
+            (claudeScrapeShapes_1.TRANSIENT_TICK_RE.test(line) ||
+                claudeScrapeShapes_1.COLLAPSE_MARKER_RE.test(line) ||
+                claudeScrapeShapes_1.COMPLETION_SUMMARY_RE.test(line))) {
+            push(ClaudeChunkTag.ToolBody, line);
+            continue;
+        }
+        // 9. Generic TUI chrome (box-drawing, nav hints, installer ad, input echo).
+        if ((0, claudeScrapeShapes_1.checkIsClaudeChromeLine)(line)) {
+            push(ClaudeChunkTag.Chrome, line);
+            continue;
+        }
+        // 10. Default: real agent prose. A solid prose line CLOSES any open tool /
+        // thinking / panel block (the agent has resumed answering).
+        context.toolKind = null;
+        context.isThinkingOpen = false;
+        context.isSubagentPanelOpen = false;
+        push(ClaudeChunkTag.Prose, line);
+    }
+    return { segments, outgoingContext: context };
+}
+//# sourceMappingURL=claudeChunkClassifier.js.map

package/dist/utils/claudeChunkClassifier.js.map

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

package/dist/utils/claudeCodeVersion.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @description The Claude Code version gate for the json-stream lifecycle
+ * (plan 2026-10-04-claude-process-lifecycle, L-D10). A process may be stopped
+ * automatically (idle stop, per-turn stop) ONLY when its CLI reports the
+ * `system/background_tasks_changed` list — verified on 2.1.287 and never seen
+ * before it. Without that list a stop could kill background work (a background
+ * Bash, a Monitor, a background sub-agent): stdin EOF kills them ~5 s later
+ * (probe 2026-10-04). An unknown version (no `claude_code_version` on `init`)
+ * is treated as too old.
+ */
+/** The first Claude Code version whose stream-json reports the background-task list. */
+export declare const minAutoStopClaudeCodeVersion = "2.1.287";
+/**
+ * @description Compare two `major.minor.patch` versions numerically (so `2.1.300`
+ * sorts after `2.1.287`, which a string compare gets wrong). Returns a negative
+ * number, zero, or a positive number like `Array.prototype.sort` expects; `null`
+ * when either side does not parse.
+ */
+export declare function compareClaudeCodeVersions(left: string, right: string): number | null;
+/** Whether a process reporting `version` may be auto-stopped (L-D10); `null` / unparseable → `false`. */
+export declare function checkIsClaudeAutoStopSupported(version: string | null): boolean;
+/**
+ * @description The version a switch of a conversation to the per-turn lifecycle
+ * is REFUSED on (L-D10, narrowed): its last known Claude Code version — from the
+ * live process or the persisted tail record — when that is below the gate;
+ * `null` when the switch is allowed. An unknown version allows it: the refusal is
+ * only decidable once a version is known, and the stop gate keeps an unknown or
+ * old process alive anyway.
+ */
+export declare function getPerTurnRefusedVersion(lastKnownVersion: string | null): string | null;
+//# sourceMappingURL=claudeCodeVersion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeCodeVersion.d.ts","sourceRoot":"","sources":["../../src/utils/claudeCodeVersion.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,wFAAwF;AACxF,eAAO,MAAM,4BAA4B,YAAY,CAAC;AAWtD;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQpF;AAED,yGAAyG;AACzG,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAI9E;AAED;;;;;;;GAOG;AACH,wBAAgB,wBAAwB,CAAC,gBAAgB,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAEvF"}

package/dist/utils/claudeCodeVersion.js

@@ -0,0 +1,62 @@
+"use strict";
+/**
+ * @description The Claude Code version gate for the json-stream lifecycle
+ * (plan 2026-10-04-claude-process-lifecycle, L-D10). A process may be stopped
+ * automatically (idle stop, per-turn stop) ONLY when its CLI reports the
+ * `system/background_tasks_changed` list — verified on 2.1.287 and never seen
+ * before it. Without that list a stop could kill background work (a background
+ * Bash, a Monitor, a background sub-agent): stdin EOF kills them ~5 s later
+ * (probe 2026-10-04). An unknown version (no `claude_code_version` on `init`)
+ * is treated as too old.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minAutoStopClaudeCodeVersion = void 0;
+exports.compareClaudeCodeVersions = compareClaudeCodeVersions;
+exports.checkIsClaudeAutoStopSupported = checkIsClaudeAutoStopSupported;
+exports.getPerTurnRefusedVersion = getPerTurnRefusedVersion;
+/** The first Claude Code version whose stream-json reports the background-task list. */
+exports.minAutoStopClaudeCodeVersion = '2.1.287';
+const versionRe = /^(\d+)\.(\d+)\.(\d+)/;
+/** Parse `major.minor.patch` (a trailing pre-release / build suffix is ignored); `null` for anything else. */
+function parseClaudeCodeVersion(version) {
+    const match = versionRe.exec(version.trim());
+    if (!match)
+        return null;
+    return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+/**
+ * @description Compare two `major.minor.patch` versions numerically (so `2.1.300`
+ * sorts after `2.1.287`, which a string compare gets wrong). Returns a negative
+ * number, zero, or a positive number like `Array.prototype.sort` expects; `null`
+ * when either side does not parse.
+ */
+function compareClaudeCodeVersions(left, right) {
+    const leftParts = parseClaudeCodeVersion(left);
+    const rightParts = parseClaudeCodeVersion(right);
+    if (!leftParts || !rightParts)
+        return null;
+    for (let index = 0; index < leftParts.length; index += 1) {
+        if (leftParts[index] !== rightParts[index])
+            return leftParts[index] - rightParts[index];
+    }
+    return 0;
+}
+/** Whether a process reporting `version` may be auto-stopped (L-D10); `null` / unparseable → `false`. */
+function checkIsClaudeAutoStopSupported(version) {
+    if (version === null)
+        return false;
+    const comparison = compareClaudeCodeVersions(version, exports.minAutoStopClaudeCodeVersion);
+    return comparison !== null && comparison >= 0;
+}
+/**
+ * @description The version a switch of a conversation to the per-turn lifecycle
+ * is REFUSED on (L-D10, narrowed): its last known Claude Code version — from the
+ * live process or the persisted tail record — when that is below the gate;
+ * `null` when the switch is allowed. An unknown version allows it: the refusal is
+ * only decidable once a version is known, and the stop gate keeps an unknown or
+ * old process alive anyway.
+ */
+function getPerTurnRefusedVersion(lastKnownVersion) {
+    return lastKnownVersion !== null && !checkIsClaudeAutoStopSupported(lastKnownVersion) ? lastKnownVersion : null;
+}
+//# sourceMappingURL=claudeCodeVersion.js.map

package/dist/utils/claudeCodeVersion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeCodeVersion.js","sourceRoot":"","sources":["../../src/utils/claudeCodeVersion.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAoBH,8DAQC;AAGD,wEAIC;AAUD,4DAEC;AA7CD,wFAAwF;AAC3E,QAAA,4BAA4B,GAAG,SAAS,CAAC;AAEtD,MAAM,SAAS,GAAG,sBAAsB,CAAC;AAEzC,8GAA8G;AAC9G,SAAS,sBAAsB,CAAC,OAAe;IAC7C,MAAM,KAAK,GAAG,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC;IAC7C,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAC;IACxB,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAChE,CAAC;AAED;;;;;GAKG;AACH,SAAgB,yBAAyB,CAAC,IAAY,EAAE,KAAa;IACnE,MAAM,SAAS,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC;IAC/C,MAAM,UAAU,GAAG,sBAAsB,CAAC,KAAK,CAAC,CAAC;IACjD,IAAI,CAAC,SAAS,IAAI,CAAC,UAAU;QAAE,OAAO,IAAI,CAAC;IAC3C,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;QACzD,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,UAAU,CAAC,KAAK,CAAC;YAAE,OAAO,SAAS,CAAC,KAAK,CAAC,GAAG,UAAU,CAAC,KAAK,CAAC,CAAC;IAC1F,CAAC;IACD,OAAO,CAAC,CAAC;AACX,CAAC;AAED,yGAAyG;AACzG,SAAgB,8BAA8B,CAAC,OAAsB;IACnE,IAAI,OAAO,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC;IACnC,MAAM,UAAU,GAAG,yBAAyB,CAAC,OAAO,EAAE,oCAA4B,CAAC,CAAC;IACpF,OAAO,UAAU,KAAK,IAAI,IAAI,UAAU,IAAI,CAAC,CAAC;AAChD,CAAC;AAED;;;;;;;GAOG;AACH,SAAgB,wBAAwB,CAAC,gBAA+B;IACtE,OAAO,gBAAgB,KAAK,IAAI,IAAI,CAAC,8BAA8B,CAAC,gBAAgB,CAAC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,IAAI,CAAC;AAClH,CAAC"}

package/dist/utils/claudeCompactHook.d.ts

@@ -0,0 +1,64 @@
+/**
+ * @description The `PreCompact` hook the bot hands every Claude session it starts,
+ * so the compaction Claude runs ON ITS OWN when the context overflows gets the
+ * same summary guidance as a bot-issued one.
+ *
+ * WHY this exists: a bot-issued compaction carries its instruction as
+ * `/compact <instruction>`, but the overflow-triggered (auto) compaction is started
+ * by the CLI itself and has no argument the bot could fill. It summarised with the
+ * default prompt: the loaded skills were not named, and the continuing session
+ * silently stopped following them. Claude Code runs `PreCompact` hooks before
+ * EVERY compaction (`trigger` `auto` and `manual`) and appends a hook's stdout to
+ * that compaction's custom instructions — measured on v2.1.289: an
+ * overflow-triggered compaction's summary opened with the line the hook printed.
+ * The hook rides `--settings <file>`, which is merged with the user's own settings
+ * and never writes to them.
+ *
+ * A bot-issued compaction already carries the same text, so the hook prints
+ * nothing when the compaction's `custom_instructions` (part of the JSON the hook
+ * reads on stdin) already contain the skills guidance — otherwise the model would
+ * get the instruction twice.
+ */
+/**
+ * Name of the hook settings file inside `DATA_DIR`. ONE file shared by every
+ * session: its content is the same for all of them, and a session that outlives
+ * the bot (json-stream) must never find it deleted under it.
+ */
+export declare const claudeCompactHookSettingsFileName = "claude-compact-hook.json";
+/**
+ * @description The instruction the hook adds to a compaction the bot did not
+ * issue: D3 + the loaded-skills guidance. No closing section — that one exists for
+ * the bot's own idle-compaction report, which an overflow compaction never feeds.
+ */
+export declare function getHookCompactionInstruction(): string;
+/**
+ * @description Build the hook's shell command: print `instruction` unless the
+ * hook's stdin (the `PreCompact` input JSON) already contains `alreadySentMarker`.
+ * The marker is matched as a fixed string against the raw JSON, so it must be text
+ * JSON leaves unescaped — the caller passes the skills guidance, and a test pins
+ * that it qualifies.
+ */
+export declare function buildPreCompactHookCommand(input: {
+    instruction: string;
+    alreadySentMarker: string;
+}): string;
+/** The `--settings` payload: one `PreCompact` command hook, no matcher (auto AND manual). */
+export declare function buildClaudeCompactHookSettings(command: string): {
+    hooks: {
+        PreCompact: Array<{
+            hooks: Array<{
+                type: 'command';
+                command: string;
+            }>;
+        }>;
+    };
+};
+/**
+ * @description Write the hook settings file and return the `--settings <path>`
+ * argument pair for a Claude launch. Rewritten on every launch (atomic rename, so
+ * a concurrently starting session never reads a half-written file) so a changed
+ * guidance reaches the next session. A write failure returns `[]` and only logs:
+ * the hook improves a summary, it must never stop an agent from starting.
+ */
+export declare function prepareClaudeCompactHookFlags(dataDir: string): string[];
+//# sourceMappingURL=claudeCompactHook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeCompactHook.d.ts","sourceRoot":"","sources":["../../src/utils/claudeCompactHook.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;AAWH;;;;GAIG;AACH,eAAO,MAAM,iCAAiC,6BAA6B,CAAC;AAE5E;;;;GAIG;AACH,wBAAgB,4BAA4B,IAAI,MAAM,CAOrD;AAED;;;;;;GAMG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE;IAChD,WAAW,EAAE,MAAM,CAAC;IACpB,iBAAiB,EAAE,MAAM,CAAC;CAC3B,GAAG,MAAM,CAET;AAED,6FAA6F;AAC7F,wBAAgB,8BAA8B,CAAC,OAAO,EAAE,MAAM,GAAG;IAC/D,KAAK,EAAE;QAAE,UAAU,EAAE,KAAK,CAAC;YAAE,KAAK,EAAE,KAAK,CAAC;gBAAE,IAAI,EAAE,SAAS,CAAC;gBAAC,OAAO,EAAE,MAAM,CAAA;aAAE,CAAC,CAAA;SAAE,CAAC,CAAA;KAAE,CAAC;CACtF,CAEA;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,EAAE,CAiBvE"}

package/dist/utils/claudeCompactHook.js

@@ -0,0 +1,98 @@
+"use strict";
+/**
+ * @description The `PreCompact` hook the bot hands every Claude session it starts,
+ * so the compaction Claude runs ON ITS OWN when the context overflows gets the
+ * same summary guidance as a bot-issued one.
+ *
+ * WHY this exists: a bot-issued compaction carries its instruction as
+ * `/compact <instruction>`, but the overflow-triggered (auto) compaction is started
+ * by the CLI itself and has no argument the bot could fill. It summarised with the
+ * default prompt: the loaded skills were not named, and the continuing session
+ * silently stopped following them. Claude Code runs `PreCompact` hooks before
+ * EVERY compaction (`trigger` `auto` and `manual`) and appends a hook's stdout to
+ * that compaction's custom instructions — measured on v2.1.289: an
+ * overflow-triggered compaction's summary opened with the line the hook printed.
+ * The hook rides `--settings <file>`, which is merged with the user's own settings
+ * and never writes to them.
+ *
+ * A bot-issued compaction already carries the same text, so the hook prints
+ * nothing when the compaction's `custom_instructions` (part of the JSON the hook
+ * reads on stdin) already contain the skills guidance — otherwise the model would
+ * get the instruction twice.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeCompactHookSettingsFileName = void 0;
+exports.getHookCompactionInstruction = getHookCompactionInstruction;
+exports.buildPreCompactHookCommand = buildPreCompactHookCommand;
+exports.buildClaudeCompactHookSettings = buildClaudeCompactHookSettings;
+exports.prepareClaudeCompactHookFlags = prepareClaudeCompactHookFlags;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const compactOnIdle_1 = require("./compactOnIdle");
+const tmuxExec_1 = require("./tmuxExec");
+/**
+ * Name of the hook settings file inside `DATA_DIR`. ONE file shared by every
+ * session: its content is the same for all of them, and a session that outlives
+ * the bot (json-stream) must never find it deleted under it.
+ */
+exports.claudeCompactHookSettingsFileName = 'claude-compact-hook.json';
+/**
+ * @description The instruction the hook adds to a compaction the bot did not
+ * issue: D3 + the loaded-skills guidance. No closing section — that one exists for
+ * the bot's own idle-compaction report, which an overflow compaction never feeds.
+ */
+function getHookCompactionInstruction() {
+    return (0, compactOnIdle_1.buildCompactionInstruction)({
+        bakesSummaryGuidance: false,
+        summaryGuidance: compactOnIdle_1.compactionSummaryGuidance,
+        bakesSkillsGuidance: false,
+        skillsGuidance: compactOnIdle_1.compactionSkillsGuidance,
+    }) ?? '';
+}
+/**
+ * @description Build the hook's shell command: print `instruction` unless the
+ * hook's stdin (the `PreCompact` input JSON) already contains `alreadySentMarker`.
+ * The marker is matched as a fixed string against the raw JSON, so it must be text
+ * JSON leaves unescaped — the caller passes the skills guidance, and a test pins
+ * that it qualifies.
+ */
+function buildPreCompactHookCommand(input) {
+    return `grep -qF -e ${(0, tmuxExec_1.shellSingleQuote)(input.alreadySentMarker)} || printf '%s\\n' ${(0, tmuxExec_1.shellSingleQuote)(input.instruction)}`;
+}
+/** The `--settings` payload: one `PreCompact` command hook, no matcher (auto AND manual). */
+function buildClaudeCompactHookSettings(command) {
+    return { hooks: { PreCompact: [{ hooks: [{ type: 'command', command }] }] } };
+}
+/**
+ * @description Write the hook settings file and return the `--settings <path>`
+ * argument pair for a Claude launch. Rewritten on every launch (atomic rename, so
+ * a concurrently starting session never reads a half-written file) so a changed
+ * guidance reaches the next session. A write failure returns `[]` and only logs:
+ * the hook improves a summary, it must never stop an agent from starting.
+ */
+function prepareClaudeCompactHookFlags(dataDir) {
+    const settingsPath = path_1.default.join(dataDir, exports.claudeCompactHookSettingsFileName);
+    const command = buildPreCompactHookCommand({
+        instruction: getHookCompactionInstruction(),
+        alreadySentMarker: compactOnIdle_1.compactionSkillsGuidance,
+    });
+    const tmpPath = `${settingsPath}.${process.pid}.${Date.now()}.tmp`;
+    try {
+        fs_1.default.mkdirSync(dataDir, { recursive: true });
+        fs_1.default.writeFileSync(tmpPath, JSON.stringify(buildClaudeCompactHookSettings(command)));
+        fs_1.default.renameSync(tmpPath, settingsPath);
+    }
+    catch (e) {
+        console.warn(`[compact-hook] cannot write ${settingsPath}:`, e);
+        try {
+            fs_1.default.unlinkSync(tmpPath);
+        }
+        catch { /* never written */ }
+        return [];
+    }
+    return ['--settings', settingsPath];
+}
+//# sourceMappingURL=claudeCompactHook.js.map

package/dist/utils/claudeCompactHook.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeCompactHook.js","sourceRoot":"","sources":["../../src/utils/claudeCompactHook.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;;;;GAoBG;;;;;;AAuBH,oEAOC;AASD,gEAKC;AAGD,wEAIC;AASD,sEAiBC;AA3ED,4CAAoB;AACpB,gDAAwB;AACxB,mDAIyB;AACzB,yCAA8C;AAE9C;;;;GAIG;AACU,QAAA,iCAAiC,GAAG,0BAA0B,CAAC;AAE5E;;;;GAIG;AACH,SAAgB,4BAA4B;IAC1C,OAAO,IAAA,0CAA0B,EAAC;QAChC,oBAAoB,EAAE,KAAK;QAC3B,eAAe,EAAE,yCAAyB;QAC1C,mBAAmB,EAAE,KAAK;QAC1B,cAAc,EAAE,wCAAwB;KACzC,CAAC,IAAI,EAAE,CAAC;AACX,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,0BAA0B,CAAC,KAG1C;IACC,OAAO,eAAe,IAAA,2BAAgB,EAAC,KAAK,CAAC,iBAAiB,CAAC,sBAAsB,IAAA,2BAAgB,EAAC,KAAK,CAAC,WAAW,CAAC,EAAE,CAAC;AAC7H,CAAC;AAED,6FAA6F;AAC7F,SAAgB,8BAA8B,CAAC,OAAe;IAG5D,OAAO,EAAE,KAAK,EAAE,EAAE,UAAU,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;AAChF,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,6BAA6B,CAAC,OAAe;IAC3D,MAAM,YAAY,GAAG,cAAI,CAAC,IAAI,CAAC,OAAO,EAAE,yCAAiC,CAAC,CAAC;IAC3E,MAAM,OAAO,GAAG,0BAA0B,CAAC;QACzC,WAAW,EAAE,4BAA4B,EAAE;QAC3C,iBAAiB,EAAE,wCAAwB;KAC5C,CAAC,CAAC;IACH,MAAM,OAAO,GAAG,GAAG,YAAY,IAAI,OAAO,CAAC,GAAG,IAAI,IAAI,CAAC,GAAG,EAAE,MAAM,CAAC;IACnE,IAAI,CAAC;QACH,YAAE,CAAC,SAAS,CAAC,OAAO,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QAC3C,YAAE,CAAC,aAAa,CAAC,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,8BAA8B,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;QACnF,YAAE,CAAC,UAAU,CAAC,OAAO,EAAE,YAAY,CAAC,CAAC;IACvC,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,CAAC,IAAI,CAAC,+BAA+B,YAAY,GAAG,EAAE,CAAC,CAAC,CAAC;QAChE,IAAI,CAAC;YAAC,YAAE,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QAAC,CAAC;QAAC,MAAM,CAAC,CAAC,mBAAmB,CAAC,CAAC;QAC7D,OAAO,EAAE,CAAC;IACZ,CAAC;IACD,OAAO,CAAC,YAAY,EAAE,YAAY,CAAC,CAAC;AACtC,CAAC"}

package/dist/utils/claudeLimitSwitch.d.ts

@@ -0,0 +1,40 @@
+/**
+ * @description Pure decisions behind SWITCHING A TOPIC TO ANOTHER CLAUDE ACCOUNT when its own hits a usage
+ * limit (`utils/claudeProfiles.ts`, `utils/claudeUsage.ts`): which profiles may take the work over, ranked by
+ * headroom, and until when the exhausted one is marked limited. This ranking is what the fallback chain
+ * (`utils/fallbackChain.ts`) falls back to when the operator configured no chain: the within-Claude
+ * account→account switch as it existed before the chain. The auto / offer decision, the notice's buttons and
+ * the auto-switch toggle (`/account`, `/fallback`; OFF by default — the operator opts in, because moving work
+ * between subscriptions is an account-policy decision) live in the chain module.
+ *
+ * No I/O, no `Date.now()`: the caller passes the clock and the profile views, so every rule is unit-tested.
+ */
+import { type ClaudeProfileUsageView, type ClaudeUsageSnapshot } from './claudeUsage';
+/** The toggle's resolver (OFF when unset) lives beside `/auto_continue_limits`'s, where `state.ts` reads it. */
+export { resolveClaudeAutoSwitchOnLimitEnabled } from './autoContinueOnLimit';
+/**
+ * @description The profiles that may take a topic's work over, best first: signed in, not marked limited, with
+ * KNOWN and fresh usage that leaves headroom on the windows `model` drains, and not the profile that just hit
+ * the limit. A profile whose usage is unknown or stale is left out on purpose — the switch is sold as "this
+ * one has room", and a guess could land the topic in a second limit.
+ */
+export declare function pickClaudeLimitSwitchCandidates(input: {
+    profiles: readonly ClaudeProfileUsageView[];
+    /** The profile the topic runs on — the one at its limit. */
+    currentName: string;
+    model: string | null;
+    nowMs: number;
+}): string[];
+/**
+ * @description Until when the profile that hit the limit is marked limited, so the ranking skips it before the
+ * window resets: the instant the error named, else the profile's own session-window reset when that lies ahead,
+ * else `fallbackMs` from now (the retry's blind delay). A mark already further in the future is kept.
+ */
+export declare function resolveClaudeLimitedUntil(input: {
+    resetAtMs: number | undefined;
+    usage: ClaudeUsageSnapshot | undefined;
+    existingLimitedUntil: string | null;
+    nowMs: number;
+    fallbackMs: number;
+}): string;
+//# sourceMappingURL=claudeLimitSwitch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeLimitSwitch.d.ts","sourceRoot":"","sources":["../../src/utils/claudeLimitSwitch.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAmD,KAAK,sBAAsB,EAAE,KAAK,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEvI,gHAAgH;AAChH,OAAO,EAAE,qCAAqC,EAAE,MAAM,uBAAuB,CAAC;AAE9E;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAAC,KAAK,EAAE;IACrD,QAAQ,EAAE,SAAS,sBAAsB,EAAE,CAAC;IAC5C,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,KAAK,EAAE,MAAM,CAAC;CACf,GAAG,MAAM,EAAE,CAQX;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;IAC9B,KAAK,EAAE,mBAAmB,GAAG,SAAS,CAAC;IACvC,oBAAoB,EAAE,MAAM,GAAG,IAAI,CAAC;IACpC,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;CACpB,GAAG,MAAM,CAWT"}