charness 0.0.0-stage → 3.0.0

package/dist/utils/canonicalPathContainment.d.ts

@@ -0,0 +1,7 @@
+export interface CanonicalPathContainment {
+    canonicalPath: string;
+    isWithinRoot: boolean;
+}
+/** Resolve one candidate against a canonical root and compare with a separator-safe boundary. */
+export declare function resolveCanonicalPathContainment(canonicalRootPath: string, relativePath: string): CanonicalPathContainment;
+//# sourceMappingURL=canonicalPathContainment.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalPathContainment.d.ts","sourceRoot":"","sources":["../../src/utils/canonicalPathContainment.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,wBAAwB;IACvC,aAAa,EAAE,MAAM,CAAC;IACtB,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,iGAAiG;AACjG,wBAAgB,+BAA+B,CAC7C,iBAAiB,EAAE,MAAM,EACzB,YAAY,EAAE,MAAM,GACnB,wBAAwB,CAQ1B"}

package/dist/utils/canonicalPathContainment.js

@@ -0,0 +1,48 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveCanonicalPathContainment = resolveCanonicalPathContainment;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Resolve one candidate against a canonical root and compare with a separator-safe boundary. */
+function resolveCanonicalPathContainment(canonicalRootPath, relativePath) {
+    const canonicalPath = fs.realpathSync(path.resolve(canonicalRootPath, relativePath));
+    return {
+        canonicalPath,
+        isWithinRoot: canonicalPath === canonicalRootPath ||
+            canonicalPath.startsWith(canonicalRootPath + path.sep),
+    };
+}
+//# sourceMappingURL=canonicalPathContainment.js.map

package/dist/utils/canonicalPathContainment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalPathContainment.js","sourceRoot":"","sources":["../../src/utils/canonicalPathContainment.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,0EAWC;AApBD,uCAAyB;AACzB,2CAA6B;AAO7B,iGAAiG;AACjG,SAAgB,+BAA+B,CAC7C,iBAAyB,EACzB,YAAoB;IAEpB,MAAM,aAAa,GAAG,EAAE,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,iBAAiB,EAAE,YAAY,CAAC,CAAC,CAAC;IACrF,OAAO;QACL,aAAa;QACb,YAAY,EACV,aAAa,KAAK,iBAAiB;YACnC,aAAa,CAAC,UAAU,CAAC,iBAAiB,GAAG,IAAI,CAAC,GAAG,CAAC;KACzD,CAAC;AACJ,CAAC"}

package/dist/utils/claudeAuthLogin.d.ts

@@ -0,0 +1,71 @@
+/**
+ * @description Pure helpers behind the json-stream `/login` out-of-band auth
+ * flow. The json-stream Claude backend has no TUI to host Claude's interactive
+ * `/login`, so the bot drives `claude auth login --claudeai` in a pty and relays
+ * it through the topic (URL out -> pasted code in). These are the parse/decision
+ * helpers; the impure pty driving + per-thread state live in `agentLogin/agentLogin.ts`
+ * (mirrors the `apiErrorRetry.ts` pure-layer / manager split).
+ *
+ * The success signal is authoritative from `claude auth status --json`
+ * (`{"loggedIn": true, ...}`), with the process exit code as the fallback.
+ */
+/**
+ * @description The load-bearing marker line of Claude's `/login` OAuth
+ * "paste the code" step (`Paste code here if prompted > `). Shared with the
+ * tmux-scrape backend's login-paste detection so the marker string has a single
+ * definition.
+ */
+export declare const claudeLoginPastePromptRe: RegExp;
+/**
+ * @description First `http(s)` URL in `claude auth login`'s pty output — the
+ * OAuth sign-in link. The CLI prints it inside an OSC-8 hyperlink
+ * (`ESC]8;;<url>BEL`) and again as visible blue text; the match stops at the
+ * first whitespace / C0 control char (the BEL that terminates the OSC-8 target),
+ * so the captured URL is already clean of ANSI. Returns `null` if none yet.
+ */
+export declare function parseClaudeAuthLoginUrl(ptyOutput: string): string | null;
+/**
+ * @description Whether the accumulated pty output has reached the "paste the
+ * code" prompt — i.e. the CLI has printed the sign-in URL and is now waiting for
+ * the code. Used to gate the URL relay so a URL split across pty chunks is never
+ * relayed half-rendered.
+ */
+export declare function checkIsClaudeAuthLoginCodePrompt(ptyOutput: string): boolean;
+/**
+ * @description Read `loggedIn` out of `claude auth status --json`. Returns the
+ * boolean, or `null` when the JSON is missing/malformed or lacks the field.
+ */
+export declare function parseAuthStatusLoggedIn(statusJson: string): boolean | null;
+/**
+ * @description Decide whether the login succeeded. `claude auth status` is
+ * authoritative (it reflects the real on-disk credentials after the flow); the
+ * process exit code is only the fallback when the status probe could not be read
+ * (`loggedIn === null`).
+ */
+export declare function checkIsAuthLoginSucceeded(input: {
+    exitCode: number | null;
+    loggedIn: boolean | null;
+}): boolean;
+/** How a `/login` slash command is handled for a thread. */
+export type LoginCommandRoute = 'outOfBand' | 'forwardToAgent';
+/**
+ * @description Route a `/login` command by the thread's Claude backend. Only the
+ * json-stream backends (`claude-json-stream` and `claude-per-turn` — one host,
+ * no TUI to host the OAuth flow) intercept it into the bot-driven out-of-band
+ * flow; every other case — tmux-scrape Claude
+ * (its TUI hosts `/login` itself), OpenCode/terminal, or a no-pick thread — keeps
+ * the existing verbatim forward.
+ *
+ * The backend is read from the thread's RAW adapter pick, NOT a "resolve to the
+ * Claude default" call: an OpenCode/terminal thread has a non-Claude raw pick, so
+ * gating on the raw name avoids wrongly intercepting `/login` on those threads
+ * (which a default-resolving check would do once json-stream is the default).
+ * `checkIsJsonStreamBackend` is injected to keep this helper free of an adapter
+ * import.
+ */
+export declare function getLoginCommandRoute(input: {
+    command: string;
+    rawBackendName: string | undefined;
+    checkIsJsonStreamBackend: (adapterName: string) => boolean;
+}): LoginCommandRoute;
+//# sourceMappingURL=claudeAuthLogin.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claudeAuthLogin.d.ts","sourceRoot":"","sources":["../../src/utils/claudeAuthLogin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,QAAgC,CAAC;AAKtE;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAGxE;AAED;;;;;GAKG;AACH,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAE3E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,GAAG,IAAI,CAO1E;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,QAAQ,EAAE,OAAO,GAAG,IAAI,CAAC;CAC1B,GAAG,OAAO,CAGV;AAED,4DAA4D;AAC5D,MAAM,MAAM,iBAAiB,GAAG,WAAW,GAAG,gBAAgB,CAAC;AAE/D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,OAAO,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,wBAAwB,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC;CAC5D,GAAG,iBAAiB,CAIpB"}

package/dist/utils/claudeAuthLogin.js

@@ -0,0 +1,93 @@
+"use strict";
+/**
+ * @description Pure helpers behind the json-stream `/login` out-of-band auth
+ * flow. The json-stream Claude backend has no TUI to host Claude's interactive
+ * `/login`, so the bot drives `claude auth login --claudeai` in a pty and relays
+ * it through the topic (URL out -> pasted code in). These are the parse/decision
+ * helpers; the impure pty driving + per-thread state live in `agentLogin/agentLogin.ts`
+ * (mirrors the `apiErrorRetry.ts` pure-layer / manager split).
+ *
+ * The success signal is authoritative from `claude auth status --json`
+ * (`{"loggedIn": true, ...}`), with the process exit code as the fallback.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudeLoginPastePromptRe = void 0;
+exports.parseClaudeAuthLoginUrl = parseClaudeAuthLoginUrl;
+exports.checkIsClaudeAuthLoginCodePrompt = checkIsClaudeAuthLoginCodePrompt;
+exports.parseAuthStatusLoggedIn = parseAuthStatusLoggedIn;
+exports.checkIsAuthLoginSucceeded = checkIsAuthLoginSucceeded;
+exports.getLoginCommandRoute = getLoginCommandRoute;
+/**
+ * @description The load-bearing marker line of Claude's `/login` OAuth
+ * "paste the code" step (`Paste code here if prompted > `). Shared with the
+ * tmux-scrape backend's login-paste detection so the marker string has a single
+ * definition.
+ */
+exports.claudeLoginPastePromptRe = /Paste code here if prompted/;
+/** Matches the first http(s) URL, stopping at whitespace or any C0 control char. */
+const oauthLoginUrlRe = /https?:\/\/[^\s\u0000-\u001f]+/;
+/**
+ * @description First `http(s)` URL in `claude auth login`'s pty output — the
+ * OAuth sign-in link. The CLI prints it inside an OSC-8 hyperlink
+ * (`ESC]8;;<url>BEL`) and again as visible blue text; the match stops at the
+ * first whitespace / C0 control char (the BEL that terminates the OSC-8 target),
+ * so the captured URL is already clean of ANSI. Returns `null` if none yet.
+ */
+function parseClaudeAuthLoginUrl(ptyOutput) {
+    const match = ptyOutput.match(oauthLoginUrlRe);
+    return match ? match[0] : null;
+}
+/**
+ * @description Whether the accumulated pty output has reached the "paste the
+ * code" prompt — i.e. the CLI has printed the sign-in URL and is now waiting for
+ * the code. Used to gate the URL relay so a URL split across pty chunks is never
+ * relayed half-rendered.
+ */
+function checkIsClaudeAuthLoginCodePrompt(ptyOutput) {
+    return exports.claudeLoginPastePromptRe.test(ptyOutput);
+}
+/**
+ * @description Read `loggedIn` out of `claude auth status --json`. Returns the
+ * boolean, or `null` when the JSON is missing/malformed or lacks the field.
+ */
+function parseAuthStatusLoggedIn(statusJson) {
+    try {
+        const parsed = JSON.parse(statusJson);
+        return typeof parsed.loggedIn === 'boolean' ? parsed.loggedIn : null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * @description Decide whether the login succeeded. `claude auth status` is
+ * authoritative (it reflects the real on-disk credentials after the flow); the
+ * process exit code is only the fallback when the status probe could not be read
+ * (`loggedIn === null`).
+ */
+function checkIsAuthLoginSucceeded(input) {
+    if (input.loggedIn !== null)
+        return input.loggedIn;
+    return input.exitCode === 0;
+}
+/**
+ * @description Route a `/login` command by the thread's Claude backend. Only the
+ * json-stream backends (`claude-json-stream` and `claude-per-turn` — one host,
+ * no TUI to host the OAuth flow) intercept it into the bot-driven out-of-band
+ * flow; every other case — tmux-scrape Claude
+ * (its TUI hosts `/login` itself), OpenCode/terminal, or a no-pick thread — keeps
+ * the existing verbatim forward.
+ *
+ * The backend is read from the thread's RAW adapter pick, NOT a "resolve to the
+ * Claude default" call: an OpenCode/terminal thread has a non-Claude raw pick, so
+ * gating on the raw name avoids wrongly intercepting `/login` on those threads
+ * (which a default-resolving check would do once json-stream is the default).
+ * `checkIsJsonStreamBackend` is injected to keep this helper free of an adapter
+ * import.
+ */
+function getLoginCommandRoute(input) {
+    return input.command === 'login' && input.rawBackendName !== undefined && input.checkIsJsonStreamBackend(input.rawBackendName)
+        ? 'outOfBand'
+        : 'forwardToAgent';
+}
+//# sourceMappingURL=claudeAuthLogin.js.map

package/dist/utils/claudeAuthLogin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"claudeAuthLogin.js","sourceRoot":"","sources":["../../src/utils/claudeAuthLogin.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;GAUG;;;AAoBH,0DAGC;AAQD,4EAEC;AAMD,0DAOC;AAQD,8DAMC;AAoBD,oDAQC;AAtFD;;;;;GAKG;AACU,QAAA,wBAAwB,GAAG,6BAA6B,CAAC;AAEtE,oFAAoF;AACpF,MAAM,eAAe,GAAG,gCAAgC,CAAC;AAEzD;;;;;;GAMG;AACH,SAAgB,uBAAuB,CAAC,SAAiB;IACvD,MAAM,KAAK,GAAG,SAAS,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC;IAC/C,OAAO,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC;AACjC,CAAC;AAED;;;;;GAKG;AACH,SAAgB,gCAAgC,CAAC,SAAiB;IAChE,OAAO,gCAAwB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;AAClD,CAAC;AAED;;;GAGG;AACH,SAAgB,uBAAuB,CAAC,UAAkB;IACxD,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,UAAU,CAA2B,CAAC;QAChE,OAAO,OAAO,MAAM,CAAC,QAAQ,KAAK,SAAS,CAAC,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC,CAAC,IAAI,CAAC;IACvE,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED;;;;;GAKG;AACH,SAAgB,yBAAyB,CAAC,KAGzC;IACC,IAAI,KAAK,CAAC,QAAQ,KAAK,IAAI;QAAE,OAAO,KAAK,CAAC,QAAQ,CAAC;IACnD,OAAO,KAAK,CAAC,QAAQ,KAAK,CAAC,CAAC;AAC9B,CAAC;AAKD;;;;;;;;;;;;;;GAcG;AACH,SAAgB,oBAAoB,CAAC,KAIpC;IACC,OAAO,KAAK,CAAC,OAAO,KAAK,OAAO,IAAI,KAAK,CAAC,cAAc,KAAK,SAAS,IAAI,KAAK,CAAC,wBAAwB,CAAC,KAAK,CAAC,cAAc,CAAC;QAC5H,CAAC,CAAC,WAAW;QACb,CAAC,CAAC,gBAAgB,CAAC;AACvB,CAAC"}

package/dist/utils/claudeChunkClassifier.d.ts

@@ -0,0 +1,97 @@
+/**
+ * @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.
+ */
+import { type ToolResultKind } from './claudeScrapeShapes';
+/**
+ * @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).
+ */
+export declare enum ClaudeChunkTag {
+    ThinkingBlock = "thinkingBlock",
+    ToolHeader = "toolHeader",
+    ToolBody = "toolBody",
+    SubagentPanelPreview = "subagentPanelPreview",
+    Prose = "prose",
+    Chrome = "chrome"
+}
+/** One classified run of consecutive same-tag lines, original order preserved. */
+export interface ClaudeChunkSegment {
+    tag: ClaudeChunkTag;
+    text: string;
+}
+/**
+ * @description Fence / block state threaded BETWEEN poll chunks — mirrors the
+ * adapter's `session.openToolKind`. A tool body, a thinking block, or a
+ * sub-agent panel can span the boundary between two scraped chunks (Claude
+ * redraws the whole pane each poll; the diff emits only NEW lines, so a slow
+ * command's output arrives in a later poll without its header).
+ */
+export interface ClaudeChunkContext {
+    /** Open tool-result kind (`output`/`file`) whose body is still streaming, or null. */
+    toolKind: ToolResultKind | null;
+    /** A "Thinking for…" block is open and its reasoning body is still streaming. */
+    isThinkingOpen: boolean;
+    /** A `◯` sub-agent panel is on screen, so its `⎿`/`Tool(…)` previews are panel chatter. */
+    isSubagentPanelOpen: boolean;
+}
+/** The all-closed starting context (also used when a fresh session begins). */
+export declare function createInitialChunkContext(): ClaudeChunkContext;
+/** Result of classifying one chunk: ordered segments + the context to thread on. */
+export interface ClaudeChunkClassification {
+    segments: ClaudeChunkSegment[];
+    outgoingContext: ClaudeChunkContext;
+}
+/**
+ * @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)
+ */
+export declare function classifyClaudeChunk(chunkText: string, incomingContext: ClaudeChunkContext): ClaudeChunkClassification;
+//# sourceMappingURL=claudeChunkClassifier.d.ts.map

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"}