aicodeman 1.29.0 → 1.30.0

package/dist/reboot-restore.d.ts

@@ -0,0 +1,146 @@
+/**
+ * @fileoverview Decide which sessions a host reboot destroyed and may be rebuilt.
+ *
+ * A server restart and a host reboot both leave `reconcileSessions()` reporting
+ * dead sessions, and they need opposite handling. A server restart leaves the
+ * tmux panes running, so recovery ATTACHES to them. A host reboot takes the tmux
+ * server down with it, so there is nothing to attach to and the pane has to be
+ * created again. This module holds the decision half of that second case, kept
+ * free of tmux and disk access so it can be unit tested without either. Every
+ * observation it reads is gathered by the caller and passed in.
+ *
+ * "Eligible" here means a session the user did not end on purpose. The rule that
+ * an intentional kill or detach is never auto-revived is enforced at runtime by
+ * an in-memory guard in `TmuxManager`, and memory does not survive a reboot. The
+ * durable equivalent is the record `cleanupSession()` leaves behind. An unpinned
+ * kill deletes the record outright, so it is already absent here. A pinned kill
+ * goes through `demoteOrRemoveSession()` and lands as `status: 'stopped'`, which
+ * is the marker this module refuses. Pruning keeps a pinned record WITHOUT
+ * touching its status, so a pinned session a reboot killed still reads `idle` or
+ * `busy` and stays eligible.
+ *
+ * ⚠️ Ending the AGENT rather than the session is a shape this module CANNOT
+ * recognise today, and a reboot restores it. `/exit` ends the CLI inside the
+ * pane, `remain-on-exit` keeps the pane, and the PTY Codeman owns is the
+ * `tmux attach-session` process, which stays alive throughout — so no exit
+ * handler runs, no lifecycle `exit` is logged, and the record keeps both its pid
+ * and `status: 'idle'`. Nothing durable distinguishes it from a session that was
+ * simply idle when the power went. Ark0N/Codeman#446 covers making Codeman
+ * notice the dead pane; until a record can say the agent is gone, this pass will
+ * offer those sessions back, and the user dismisses or closes them.
+ *
+ * The `pid` check below is therefore NOT that rule. It refuses a record whose
+ * attach process was already gone, which is a session that never started or
+ * whose pane died outright.
+ *
+ * @dependencies types (SessionState), config/cli-registry
+ * @consumedby web/server (plan build at boot), web/routes/reboot-restore-routes
+ *
+ * @module reboot-restore
+ */
+import type { SessionState } from './types.js';
+/** Observations the reboot heuristic reads. Gathered by the caller, never here. */
+export interface RebootEvidence {
+    /** Sessions that still had a live pane during reconciliation. */
+    livePaneCount: number;
+    /** Sessions reconciliation just marked dead. */
+    deadSessionCount: number;
+    /** `os.uptime()`, in seconds. */
+    uptimeSeconds: number;
+    /** Newest `lastActivityAt` across the persisted records, in ms since the epoch. */
+    newestPersistedActivityAt: number;
+    /** `Date.now()` when the evidence was gathered, in ms. */
+    now: number;
+}
+/**
+ * Decide whether the machine plausibly rebooted rather than the server restarting.
+ *
+ * Two signals have to agree. The socket must hold no panes at all while state
+ * still lists sessions, which rules out an ordinary server restart. The host
+ * must also have booted after the newest persisted session activity, which is
+ * the corroboration `os.uptime()` provides cheaply. A wiped tmux socket on a
+ * long-uptime host fails the second test, so a user who killed the tmux server
+ * by hand does not get every session offered back to them.
+ *
+ * This heuristic decides whether to ASK, never whether to act. A wrong yes costs
+ * the user a banner they dismiss, because the restore itself waits for a click.
+ *
+ * ⚠️ `os.uptime()` reports the HOST's uptime, which a container shares, and that
+ * cuts BOTH ways rather than simply switching the feature off in Docker. After a
+ * genuine host reboot a containerized Codeman sees the host's short uptime, so the
+ * banner DOES appear and the feature works. What it cannot see is a container-only
+ * restart: the host uptime is long, the boot test fails, and no banner appears
+ * although every in-container pane is gone (`docker/server.Dockerfile` installs
+ * tmux inside the Codeman container, and the self-updater restarts the Compose
+ * deployment by exiting the container, so that is the case where this would help
+ * most). Failing quiet is the safe direction, and closing the gap needs a boot
+ * signal the container owns (PID 1's start time, gated on the existing
+ * `isRunningInContainer()`) rather than a wider heuristic.
+ */
+export declare function looksLikeHostReboot(evidence: RebootEvidence): boolean;
+/**
+ * Pick the conversation the rebuilt pane should resume.
+ *
+ * The chain's tail is the newest conversation the session was holding, which is
+ * what a compact or a clear leaves behind; `resumeSessionId` covers a session
+ * that was itself started as a resume, and the session id is the original
+ * conversation for everything else.
+ */
+export declare function resolveResumeConversationId(state: SessionState): string;
+/**
+ * Why one session was passed over. Reported for logging and shown to the user.
+ *
+ * The first seven are decided before anything is built. `capacity-reached` and
+ * `rebuild-failed` can only happen once a click is spending the plan, and they
+ * are the two the banner must not confuse with a missing workspace: one means
+ * "try again after closing something", the other means the CLI would not start.
+ */
+export interface RebootRestoreRejection {
+    sessionId: string;
+    reason: 'no-persisted-record' | 'intentionally-ended' | 'not-running' | 'respawn-blocked' | 'remote-or-docker' | 'unsupported-mode' | 'no-working-dir' | 'workspace-missing' | 'workspace-forbidden' | 'already-live' | 'capacity-reached' | 'rebuild-failed';
+}
+/** One restorable session, as the banner shows it and the rebuild replays it. */
+export interface RebootRestoreEntry {
+    sessionId: string;
+    name?: string;
+    workingDir: string;
+    owner?: string;
+    mode: string;
+    /** The conversation the rebuilt pane resumes. */
+    resumeConversationId: string;
+    /**
+     * The persisted record, kept whole so the rebuild can replay what it held.
+     * Read at boot, before pruning deletes it, and held in memory until the click.
+     */
+    state: SessionState;
+}
+export interface RebootRestorePlan {
+    restore: RebootRestoreEntry[];
+    skipped: RebootRestoreRejection[];
+}
+/**
+ * Split the sessions reconciliation just killed into the ones a reboot restore
+ * may offer and the ones it must leave alone.
+ *
+ * @param deadSessionIds Session ids `reconcileSessions()` reported as dead.
+ * @param persisted The `state.json` session records, which `cleanupStaleSessions()`
+ *   has not pruned yet at the point this runs.
+ * @param workspaceExists Whether a working directory is still on disk. A tmux
+ *   session can outlive its deleted repo, and rebuilding one there would scaffold
+ *   an empty tree. The caller owns the disk access; the click re-checks, because
+ *   a repo can be deleted between the boot and the click.
+ */
+export declare function planRebootRestore(deadSessionIds: readonly string[], persisted: Readonly<Record<string, SessionState>>, workspaceExists: (workingDir: string) => boolean): RebootRestorePlan;
+/**
+ * Drop the entries whose conversation is already on screen.
+ *
+ * Hours can pass between the boot that built the plan and the click that spends
+ * it, and the Resume list can reach the same conversation in the meantime. Two
+ * panes running `claude --resume` on one conversation is the failure this
+ * prevents, so a match on either the session id or the conversation id is enough
+ * to skip the entry.
+ */
+export declare function rejectAlreadyLive(entries: readonly RebootRestoreEntry[], liveSessionIds: ReadonlySet<string>, liveConversationIds: ReadonlySet<string>): RebootRestorePlan;
+/** Newest `lastActivityAt` across persisted records, or 0 when there are none. */
+export declare function newestPersistedActivity(persisted: Readonly<Record<string, SessionState>>): number;
+//# sourceMappingURL=reboot-restore.d.ts.map

package/dist/reboot-restore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reboot-restore.d.ts","sourceRoot":"","sources":["../src/reboot-restore.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAM/C,mFAAmF;AACnF,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,aAAa,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,gBAAgB,EAAE,MAAM,CAAC;IACzB,iCAAiC;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,mFAAmF;IACnF,yBAAyB,EAAE,MAAM,CAAC;IAClC,0DAA0D;IAC1D,GAAG,EAAE,MAAM,CAAC;CACb;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,cAAc,GAAG,OAAO,CAMrE;AAED;;;;;;;GAOG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,YAAY,GAAG,MAAM,CAIvE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,sBAAsB;IACrC,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EACF,qBAAqB,GACrB,qBAAqB,GACrB,aAAa,GACb,iBAAiB,GACjB,kBAAkB,GAClB,kBAAkB,GAClB,gBAAgB,GAChB,mBAAmB,GACnB,qBAAqB,GACrB,cAAc,GACd,kBAAkB,GAClB,gBAAgB,CAAC;CACtB;AAED,iFAAiF;AACjF,MAAM,WAAW,kBAAkB;IACjC,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,iDAAiD;IACjD,oBAAoB,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,KAAK,EAAE,YAAY,CAAC;CACrB;AAED,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,OAAO,EAAE,sBAAsB,EAAE,CAAC;CACnC;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,cAAc,EAAE,SAAS,MAAM,EAAE,EACjC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,EACjD,eAAe,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,GAC/C,iBAAiB,CAuEnB;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,OAAO,EAAE,SAAS,kBAAkB,EAAE,EACtC,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,EACnC,mBAAmB,EAAE,WAAW,CAAC,MAAM,CAAC,GACvC,iBAAiB,CAWnB;AAED,kFAAkF;AAClF,wBAAgB,uBAAuB,CAAC,SAAS,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,GAAG,MAAM,CAOjG"}

package/dist/reboot-restore.js

@@ -0,0 +1,205 @@
+/**
+ * @fileoverview Decide which sessions a host reboot destroyed and may be rebuilt.
+ *
+ * A server restart and a host reboot both leave `reconcileSessions()` reporting
+ * dead sessions, and they need opposite handling. A server restart leaves the
+ * tmux panes running, so recovery ATTACHES to them. A host reboot takes the tmux
+ * server down with it, so there is nothing to attach to and the pane has to be
+ * created again. This module holds the decision half of that second case, kept
+ * free of tmux and disk access so it can be unit tested without either. Every
+ * observation it reads is gathered by the caller and passed in.
+ *
+ * "Eligible" here means a session the user did not end on purpose. The rule that
+ * an intentional kill or detach is never auto-revived is enforced at runtime by
+ * an in-memory guard in `TmuxManager`, and memory does not survive a reboot. The
+ * durable equivalent is the record `cleanupSession()` leaves behind. An unpinned
+ * kill deletes the record outright, so it is already absent here. A pinned kill
+ * goes through `demoteOrRemoveSession()` and lands as `status: 'stopped'`, which
+ * is the marker this module refuses. Pruning keeps a pinned record WITHOUT
+ * touching its status, so a pinned session a reboot killed still reads `idle` or
+ * `busy` and stays eligible.
+ *
+ * ⚠️ Ending the AGENT rather than the session is a shape this module CANNOT
+ * recognise today, and a reboot restores it. `/exit` ends the CLI inside the
+ * pane, `remain-on-exit` keeps the pane, and the PTY Codeman owns is the
+ * `tmux attach-session` process, which stays alive throughout — so no exit
+ * handler runs, no lifecycle `exit` is logged, and the record keeps both its pid
+ * and `status: 'idle'`. Nothing durable distinguishes it from a session that was
+ * simply idle when the power went. Ark0N/Codeman#446 covers making Codeman
+ * notice the dead pane; until a record can say the agent is gone, this pass will
+ * offer those sessions back, and the user dismisses or closes them.
+ *
+ * The `pid` check below is therefore NOT that rule. It refuses a record whose
+ * attach process was already gone, which is a session that never started or
+ * whose pane died outright.
+ *
+ * @dependencies types (SessionState), config/cli-registry
+ * @consumedby web/server (plan build at boot), web/routes/reboot-restore-routes
+ *
+ * @module reboot-restore
+ */
+import { getCli } from './config/cli-registry/registry.js';
+/** Session statuses a reboot restore may rebuild. `stopped` is the kill marker. */
+const RESTORABLE_STATUSES = new Set(['idle', 'busy', 'error']);
+/**
+ * Decide whether the machine plausibly rebooted rather than the server restarting.
+ *
+ * Two signals have to agree. The socket must hold no panes at all while state
+ * still lists sessions, which rules out an ordinary server restart. The host
+ * must also have booted after the newest persisted session activity, which is
+ * the corroboration `os.uptime()` provides cheaply. A wiped tmux socket on a
+ * long-uptime host fails the second test, so a user who killed the tmux server
+ * by hand does not get every session offered back to them.
+ *
+ * This heuristic decides whether to ASK, never whether to act. A wrong yes costs
+ * the user a banner they dismiss, because the restore itself waits for a click.
+ *
+ * ⚠️ `os.uptime()` reports the HOST's uptime, which a container shares, and that
+ * cuts BOTH ways rather than simply switching the feature off in Docker. After a
+ * genuine host reboot a containerized Codeman sees the host's short uptime, so the
+ * banner DOES appear and the feature works. What it cannot see is a container-only
+ * restart: the host uptime is long, the boot test fails, and no banner appears
+ * although every in-container pane is gone (`docker/server.Dockerfile` installs
+ * tmux inside the Codeman container, and the self-updater restarts the Compose
+ * deployment by exiting the container, so that is the case where this would help
+ * most). Failing quiet is the safe direction, and closing the gap needs a boot
+ * signal the container owns (PID 1's start time, gated on the existing
+ * `isRunningInContainer()`) rather than a wider heuristic.
+ */
+export function looksLikeHostReboot(evidence) {
+    if (evidence.deadSessionCount === 0)
+        return false;
+    if (evidence.livePaneCount > 0)
+        return false;
+    if (evidence.newestPersistedActivityAt <= 0)
+        return false;
+    const bootedAt = evidence.now - evidence.uptimeSeconds * 1000;
+    return bootedAt > evidence.newestPersistedActivityAt;
+}
+/**
+ * Pick the conversation the rebuilt pane should resume.
+ *
+ * The chain's tail is the newest conversation the session was holding, which is
+ * what a compact or a clear leaves behind; `resumeSessionId` covers a session
+ * that was itself started as a resume, and the session id is the original
+ * conversation for everything else.
+ */
+export function resolveResumeConversationId(state) {
+    const chain = state.claudeSessionChain;
+    const chainTail = Array.isArray(chain) && chain.length > 0 ? chain[chain.length - 1] : undefined;
+    return chainTail || state.resumeSessionId || state.id;
+}
+/**
+ * Split the sessions reconciliation just killed into the ones a reboot restore
+ * may offer and the ones it must leave alone.
+ *
+ * @param deadSessionIds Session ids `reconcileSessions()` reported as dead.
+ * @param persisted The `state.json` session records, which `cleanupStaleSessions()`
+ *   has not pruned yet at the point this runs.
+ * @param workspaceExists Whether a working directory is still on disk. A tmux
+ *   session can outlive its deleted repo, and rebuilding one there would scaffold
+ *   an empty tree. The caller owns the disk access; the click re-checks, because
+ *   a repo can be deleted between the boot and the click.
+ */
+export function planRebootRestore(deadSessionIds, persisted, workspaceExists) {
+    const restore = [];
+    const skipped = [];
+    for (const sessionId of deadSessionIds) {
+        const state = persisted[sessionId];
+        if (!state) {
+            // An unpinned kill already deleted the record, so absence IS the guard.
+            skipped.push({ sessionId, reason: 'no-persisted-record' });
+            continue;
+        }
+        if (!RESTORABLE_STATUSES.has(state.status)) {
+            // A pinned kill was demoted to `stopped`. Reviving it would undo the kill.
+            skipped.push({ sessionId, reason: 'intentionally-ended' });
+            continue;
+        }
+        if (state.pid === null || state.pid === undefined) {
+            // No attach process when the record was last written: the session never
+            // started, or its pane died outright rather than its agent exiting inside a
+            // surviving pane. Either way there was nothing running to bring back.
+            //
+            // ⚠️ This does NOT catch a session the user ended with `/exit`. See the
+            // module header: that leaves the pid in place, because the pid is the tmux
+            // attach process and `remain-on-exit` keeps it alive.
+            //
+            // Conservative on purpose. A session that somehow persisted no pid while
+            // genuinely running is not offered, and its conversation stays reachable
+            // from the Resume list, which is where every session would be without this
+            // feature.
+            skipped.push({ sessionId, reason: 'not-running' });
+            continue;
+        }
+        if (state.respawnBlocked === true) {
+            // The crash-loop breaker tripped on this pane. Re-creating it restarts the loop.
+            skipped.push({ sessionId, reason: 'respawn-blocked' });
+            continue;
+        }
+        if (state.remote || state.docker) {
+            // Both need another host or a container to be up, which a just-booted machine
+            // cannot promise. The remote reconnect watcher owns the remote case already.
+            skipped.push({ sessionId, reason: 'remote-or-docker' });
+            continue;
+        }
+        // Capability, not a CLI id: this pass resumes by handing the CLI a conversation
+        // id through the top-level `resumeSessionId`, which only a CLI whose history the
+        // claude-jsonl reader understands can consume that way. Others carry their thread
+        // id in their own `<Mode>Config`, which this pass does not thread through.
+        if (getCli(state.mode ?? 'claude')?.capabilities.transcript !== 'claude-jsonl') {
+            skipped.push({ sessionId, reason: 'unsupported-mode' });
+            continue;
+        }
+        if (!state.workingDir) {
+            skipped.push({ sessionId, reason: 'no-working-dir' });
+            continue;
+        }
+        if (!workspaceExists(state.workingDir)) {
+            skipped.push({ sessionId, reason: 'workspace-missing' });
+            continue;
+        }
+        restore.push({
+            sessionId,
+            name: state.name,
+            workingDir: state.workingDir,
+            owner: state.owner,
+            mode: state.mode ?? 'claude',
+            resumeConversationId: resolveResumeConversationId(state),
+            state,
+        });
+    }
+    return { restore, skipped };
+}
+/**
+ * Drop the entries whose conversation is already on screen.
+ *
+ * Hours can pass between the boot that built the plan and the click that spends
+ * it, and the Resume list can reach the same conversation in the meantime. Two
+ * panes running `claude --resume` on one conversation is the failure this
+ * prevents, so a match on either the session id or the conversation id is enough
+ * to skip the entry.
+ */
+export function rejectAlreadyLive(entries, liveSessionIds, liveConversationIds) {
+    const restore = [];
+    const skipped = [];
+    for (const entry of entries) {
+        if (liveSessionIds.has(entry.sessionId) || liveConversationIds.has(entry.resumeConversationId)) {
+            skipped.push({ sessionId: entry.sessionId, reason: 'already-live' });
+            continue;
+        }
+        restore.push(entry);
+    }
+    return { restore, skipped };
+}
+/** Newest `lastActivityAt` across persisted records, or 0 when there are none. */
+export function newestPersistedActivity(persisted) {
+    let newest = 0;
+    for (const state of Object.values(persisted)) {
+        const stamp = state.lastActivityAt ?? state.createdAt ?? 0;
+        if (stamp > newest)
+            newest = stamp;
+    }
+    return newest;
+}
+//# sourceMappingURL=reboot-restore.js.map

package/dist/reboot-restore.js.map

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

package/dist/session-auto-name.d.ts

@@ -0,0 +1,74 @@
+/**
+ * @fileoverview Automatic session names from the first prompt.
+ *
+ * A new tab is born as `w3-myapp`, which says where it runs and nothing about
+ * what it is doing. Once the user submits a real prompt the tab can carry a
+ * title derived from it (`w3-myapp: fix the login redirect`), and this module
+ * holds the three pure pieces of that: a tracker that reconstructs the composer
+ * text from the keystrokes Codeman forwards, the title heuristic, and the
+ * prefix-preserving composition.
+ *
+ * Deliberately no LLM: the prompt already passes through the input boundary,
+ * so a local title is private, deterministic and identical for every CLI.
+ *
+ * ⚠️ The tracker sits on the raw keystroke stream, which carries far more than
+ * the prompt: cursor keys, mouse reports Codeman forwards to the CLI, bracketed
+ * pastes, Alt chords, the bare Esc that interrupts a turn. Every one of those
+ * once named a tab something wrong (a lone Esc ate the next prompt's first
+ * character; a wheel tick mid-word dropped the first half of the prompt), so
+ * the rules below are explicit per key. The model is a best-effort transcript:
+ * keys whose effect on the composer is knowable are mirrored, keys that leave
+ * the text alone are ignored, and keys that replace it with something the
+ * tracker cannot see (history recall) TAINT the draft so that Enter submits
+ * nothing rather than a fragment. A prompt that yields no title leaves the
+ * session eligible for the next one.
+ *
+ * Only user-originated input is fed here; the Session decides that. Ralph
+ * kick-starts, respawn `/clear`s, cron launches and approval answers all go
+ * through the same write paths and must never become a tab title.
+ *
+ * @module session-auto-name
+ */
+/**
+ * Reconstructs the composer draft from forwarded keystrokes and reports each
+ * submitted prompt. Input arrives in arbitrary chunks (one keystroke, a paste,
+ * an agent's whole prompt plus Enter), so all state lives across calls.
+ */
+export declare class SubmittedPromptTracker {
+    private buffer;
+    private bufferCodePoints;
+    /** Code points typed past the cap; backspaces eat these before real text. */
+    private overflow;
+    /** Escape sequence in progress; a lone ESC means "just saw ESC". */
+    private sequence;
+    private inPaste;
+    /** The composer holds text the tracker never saw (history recall); Enter submits nothing. */
+    private tainted;
+    feed(data: string): string[];
+    private continueSequence;
+    private handleKeyOrEscape;
+    private handleCsi;
+    private handleKey;
+    /** One space between lines, never a run of them, and none at the start. */
+    private appendSeparator;
+    private append;
+    private backspace;
+    private killWord;
+    private reset;
+}
+/**
+ * Turns a submitted prompt into a title, or null when the prompt is not a task:
+ * empty, a slash command (`/clear`, `/model`), or a `!` shell escape.
+ */
+export declare function deriveAutoSessionName(prompt: string): string | null;
+/**
+ * The name a placeholder becomes: `<prefix>: <title>`, so the tab keeps its
+ * case identity and its `w<n>` counter (the tab strip already renders that
+ * form as the title alone, prefix in the tooltip, and the next-session counter
+ * still matches it). A session with no name at all just takes the title. The
+ * result honours `maxLength` in UTF-16 units, the unit the rename route caps.
+ */
+export declare function composeAutoSessionName(currentName: string, title: string, maxLength?: number): string;
+/** Codeman's own `w<n>-<case>` / `s<n>-<case>` placeholders, the only names auto-naming replaces. */
+export declare function isGeneratedSessionName(name: string): boolean;
+//# sourceMappingURL=session-auto-name.d.ts.map

package/dist/session-auto-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-auto-name.d.ts","sourceRoot":"","sources":["../src/session-auto-name.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AA4CH;;;;GAIG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,gBAAgB,CAAK;IAC7B,6EAA6E;IAC7E,OAAO,CAAC,QAAQ,CAAK;IACrB,oEAAoE;IACpE,OAAO,CAAC,QAAQ,CAAM;IACtB,OAAO,CAAC,OAAO,CAAS;IACxB,6FAA6F;IAC7F,OAAO,CAAC,OAAO,CAAS;IAExB,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE;IAsB5B,OAAO,CAAC,gBAAgB;IA8CxB,OAAO,CAAC,iBAAiB;IAUzB,OAAO,CAAC,SAAS;IAiBjB,OAAO,CAAC,SAAS;IA8CjB,2EAA2E;IAC3E,OAAO,CAAC,eAAe;IAMvB,OAAO,CAAC,MAAM;IASd,OAAO,CAAC,SAAS;IAYjB,OAAO,CAAC,QAAQ;IAMhB,OAAO,CAAC,KAAK;CAMd;AAED;;;GAGG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAInE;AA8BD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,WAAW,EAAE,MAAM,EACnB,KAAK,EAAE,MAAM,EACb,SAAS,SAA0B,GAClC,MAAM,CAMR;AAeD,qGAAqG;AACrG,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE5D"}