@deepseek-harness-tui/dsh-tui 0.11.1 → 0.12.0

package/lib/types/dsh-adapter/migrate/sessionize.js

@@ -0,0 +1,271 @@
+/**
+ * Cross-agent conversation migration: MigrationSession → official DSH events.
+ *
+ * The sessionize step owns NO storage decisions. It drives the official
+ * `Session` logical-event API (`Session.create` + `append`), so envelope
+ * fields (seq/time/id), surface contract and format version come from the
+ * upstream implementation — the part the first iteration of this feature got
+ * wrong by hand-crafting physical log rows. Physical encoding, project
+ * layout, zstd and atomic writes belong to JsonlSessionPersistence (see
+ * index.ts), exactly as scripts/migrate-sessions-to-jsonl.mts does for the
+ * retired sqlite store.
+ *
+ * Turn shape follows the live loop: `turn/start`, then one step per
+ * {@link ImportStep} with the turn's prompt as the first step's user message,
+ * then `turn/end`. A turn with no prompt (source lost its head) carries no
+ * user message; a turn with no step is a legal step-less turn whose prompt
+ * sits directly inside the turn.
+ *
+ * Inside a step, events follow the live loop too: the step's user inputs
+ * (mid-turn context), the assistant message whose content carries the
+ * tool-call blocks, one `tool/call` per call, then one `tool/result` per
+ * call citing its call event. Parsing already closed every call
+ * (closeToolPairs), so no step leaves a call unanswered — the invariant the
+ * wire needs on resume: every tool call is followed by its tool message
+ * before any later assistant message.
+ *
+ * System head: the live loop reserves surface node 0 for the system prompt
+ * (an empty `system/message` in the first step, before any user message).
+ * An imported log gets the same empty head: it projects to no message, so
+ * re-reading is unchanged, and when the session is resumed the loop REPLACES
+ * it with the rendered prompt. Without it the loop appends its prompt after
+ * the imported history, where adapters that only lift a LEADING system
+ * message (pi-ai) send it as one more user message.
+ *
+ * Compaction: a turn carrying {@link ImportTurn.compaction} is preceded by
+ * one native compaction transaction — `compaction/start` (standalone,
+ * `turn: null`), `compaction/summary`, the checkpoint `user/message` that
+ * REPLACES every surface node after the head, `compaction/end` — the same
+ * shape `/compact` writes. The raw log keeps the shadowed events (replay
+ * stays exact) while the model sees the checkpoint plus what follows, which
+ * is the context the source agent itself continued with. The upstream
+ * compaction package is not a dependency here, so its event and source
+ * shapes are written structurally (see compactionEvents below).
+ *
+ * Title: only a title the SOURCE owns (`titleExplicit`) is written, as one
+ * trailing `session/title` — a first-prompt fallback is left out so DSH
+ * derives it from the first user message exactly as for a native session.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/sessionize
+ */
+import { ToolCallId, createAssistantMessage, createSystemMessage, createToolResultMessage, createUserMessage, } from '@deepseek-ai/dsh-llm';
+import { SESSION_FORMAT_VERSION, Session, } from '@deepseek-ai/dsh-session';
+import { userTitleData } from '../compat/sessionLog.js';
+import { normalizeTitle } from './parse/title.js';
+/** Rough token estimate for shadowed text (the compaction metering field). */
+function estimateTokens(chars) {
+    return Math.ceil(chars / 4);
+}
+/** Blocks for one migrated step, in source order (reasoning before the text
+ *  it explains, tool calls where the model made them). A step with no
+ *  content keeps one empty text block so the assistant message stays
+ *  well-formed. */
+function assistantBlocks(step) {
+    const blocks = step.blocks.map(block => block.type === 'tool-call'
+        ? { type: 'tool-call', id: ToolCallId(block.id), name: block.name, arguments: block.arguments }
+        : { type: block.type, text: block.text });
+    if (blocks.length === 0)
+        blocks.push({ type: 'text', text: '' });
+    return blocks;
+}
+/**
+ * The empty system head an imported log opens with, in whichever shape the
+ * installed harness writes. `createSystemMessage` changed arity between the
+ * validated lines: 0.1.5-alpha.2 takes the owning plugin and stamps a plugin
+ * source, later lines take the text alone and stamp `system-prompt`. Calling
+ * it with both arguments lets each line build its own native head (the later
+ * one ignores the extra argument) instead of this module hard-coding either.
+ */
+/**
+ * The checkpoint framing the native compaction engine writes around a summary
+ * (dsh-compaction-basic `frameSummary`): a preamble, then the summary inside
+ * `<compacted-summary>` tags. The tags are how a LATER compaction recognises
+ * this node as a prior checkpoint and merges it instead of summarising the
+ * summary, so an imported checkpoint has to carry them exactly. The package
+ * does not export the constants; verify-migrate pins these against the
+ * installed engine's own source so a drift fails the regression.
+ */
+export const CHECKPOINT_PREAMBLE = 'This is an automatically generated checkpoint condensing an earlier span of the conversation to free up context. Treat the captured context as established background and build on it without restating it. Continue the task directly from the messages that follow, without acknowledging this checkpoint.';
+export const SUMMARY_OPEN_TAG = '<compacted-summary>';
+export const SUMMARY_CLOSE_TAG = '</compacted-summary>';
+function frameCheckpoint(summary) {
+    return [
+        { type: 'text', text: `${CHECKPOINT_PREAMBLE}\n\n${SUMMARY_OPEN_TAG}` },
+        { type: 'text', text: summary },
+        { type: 'text', text: SUMMARY_CLOSE_TAG },
+    ];
+}
+function emptySystemHead() {
+    const create = createSystemMessage;
+    return create('', 'dsh-tui-migrate');
+}
+/**
+ * Build one official DSH session log from a normalized foreign conversation.
+ *
+ * @param id - deterministic session id (see uuid.ts); the id IS the dedupe.
+ * @param agentId - source adapter id, stamped into assistant provenance as
+ *   `migrated:<agentId>` so the transcript can name where text came from.
+ * @param session - the normalized foreign conversation.
+ * @returns the official header plus the full event log, exactly as the
+ *   persistence backend expects them.
+ */
+export function sessionize(id, agentId, session) {
+    const header = {
+        version: SESSION_FORMAT_VERSION,
+        id,
+        createdAt: session.startedAt,
+        cwd: session.cwd,
+        isSeeded: false,
+    };
+    const model = Session.create(id, undefined, header);
+    // Collect each append()'s RETURN (a fully enveloped event) instead of the
+    // deprecated snapshotEvents() bulk read — upstream forbids NEW callers of
+    // the latter, and append already returns seq/time-stamped events.
+    const events = [];
+    let headWritten = false;
+    const writeHead = (turn, step) => {
+        events.push(model.append('system/message', { turn, step, message: emptySystemHead() }, { surfaceOp: 'append' }));
+        headWritten = true;
+    };
+    const writePrompt = (prompt) => {
+        if (prompt === '')
+            return;
+        surfaceChars += prompt.length;
+        events.push(model.append('user/message', createUserMessage({
+            content: [{ type: 'text', text: prompt }],
+            source: { kind: 'user' },
+        }), { surfaceOp: 'append' }));
+    };
+    const writeTools = (turn, step, imported) => {
+        const callSeqs = new Map();
+        for (const block of imported.blocks) {
+            if (block.type !== 'tool-call')
+                continue;
+            const call = model.append('tool/call', { turn, step, callId: ToolCallId(block.id), name: block.name, arguments: block.arguments });
+            events.push(call);
+            callSeqs.set(block.id, call.seq);
+        }
+        for (const result of imported.results) {
+            const callSeq = callSeqs.get(result.callId);
+            if (callSeq === undefined)
+                continue;
+            events.push(model.append('tool/result', {
+                turn,
+                step,
+                message: createToolResultMessage({
+                    callId: ToolCallId(result.callId),
+                    content: result.text === '' ? [] : [{ type: 'text', text: result.text }],
+                    isError: result.isError,
+                }),
+            }, { surfaceOp: 'append', sourceEventSeqs: [callSeq] }));
+        }
+    };
+    let compactions = 0;
+    // Text volume on the surface since the last checkpoint, for the summary's
+    // shadowedTokenCount (an estimate, like the live engine's).
+    let surfaceChars = 0;
+    /** Fold every surface node after the head into one checkpoint; false when
+     *  there is nothing to fold (the upstream contract needs a non-empty span). */
+    const writeCompaction = (summary, summaryModel) => {
+        const shadowed = model.surface.nodes.filter(seq => model.eventAt(seq)?.type !== 'system/message');
+        if (shadowed.length === 0)
+            return false;
+        compactions += 1;
+        const compactionId = `import:${id}:c${compactions}`;
+        const untyped = model;
+        const range = { start: shadowed[0], end: shadowed[shadowed.length - 1] };
+        events.push(untyped.append('compaction/start', { compactionId, turn: null }));
+        events.push(untyped.append('compaction/summary', {
+            compactionId,
+            summary: [{ type: 'text', text: summary }],
+            shadowedRange: range,
+            shadowedSeqs: shadowed,
+            shadowedTokenCount: estimateTokens(surfaceChars),
+            provider: `migrated:${agentId}`,
+            model: summaryModel ?? agentId,
+        }));
+        events.push(untyped.append('user/message', createUserMessage({
+            content: frameCheckpoint(summary),
+            // The compaction package's checkpoint marker (COMPACT_CHECKPOINT_MARKER).
+            source: { kind: 'compact-checkpoint', compactionId },
+        }), { surfaceOp: { op: 'replace', startSeq: range.start, endSeq: range.end }, sourceEventSeqs: shadowed }));
+        events.push(untyped.append('compaction/end', { compactionId, turn: null }));
+        surfaceChars = summary.length;
+        return true;
+    };
+    let turnIndex = 0;
+    for (const turn of session.turns) {
+        // A summary with nothing before it to fold still reaches the model: it
+        // opens the turn as a plain user message instead.
+        let preface = '';
+        if (turn.compaction !== undefined && turn.compaction.summary !== '') {
+            if (!writeCompaction(turn.compaction.summary, turn.compaction.model))
+                preface = turn.compaction.summary;
+            // A boundary with no prompt and no step (the source stopped right at
+            // the compaction) needs no turn of its own.
+            if (turn.prompt === '' && turn.steps.length === 0 && preface === '')
+                continue;
+        }
+        turnIndex += 1;
+        events.push(model.append('turn/start', { turn: turnIndex }));
+        if (turn.steps.length === 0) {
+            if (headWritten) {
+                writePrompt(preface);
+                writePrompt(turn.prompt);
+            }
+            else {
+                // The head needs an open step; a step-less first turn gets one that
+                // carries only the head and the prompt (no model call).
+                events.push(model.append('step/start', { turn: turnIndex, step: 1 }));
+                writeHead(turnIndex, 1);
+                writePrompt(preface);
+                writePrompt(turn.prompt);
+                events.push(model.append('step/end', { turn: turnIndex, step: 1 }));
+            }
+        }
+        let step = 0;
+        for (const imported of turn.steps) {
+            step += 1;
+            events.push(model.append('step/start', { turn: turnIndex, step }));
+            if (!headWritten)
+                writeHead(turnIndex, step);
+            if (step === 1) {
+                writePrompt(preface);
+                writePrompt(turn.prompt);
+            }
+            for (const input of imported.inputs)
+                writePrompt(input);
+            for (const block of imported.blocks)
+                surfaceChars += block.type === 'tool-call' ? block.arguments.length : block.text.length;
+            for (const result of imported.results)
+                surfaceChars += result.text.length;
+            events.push(model.append('assistant/message', {
+                turn: turnIndex,
+                step,
+                message: createAssistantMessage({
+                    content: assistantBlocks(imported),
+                    // createAssistantMessage stamps `kind: 'model'` itself; the
+                    // caller-visible provenance is provider + model only.
+                    source: {
+                        provider: `migrated:${agentId}`,
+                        model: imported.model ?? agentId,
+                    },
+                }),
+                stream: [],
+            }, { surfaceOp: 'append' }));
+            writeTools(turnIndex, step, imported);
+            events.push(model.append('step/end', { turn: turnIndex, step }));
+        }
+        // A source-recorded interruption keeps its meaning. Sources record it
+        // coarsely (no user/hook/dispose distinction), which is exactly what the
+        // `legacy` cancel cause exists for.
+        events.push(model.append('turn/end', {
+            turn: turnIndex,
+            reason: turn.aborted === true ? { kind: 'aborted', reason: { kind: 'legacy' } } : { kind: 'completed' },
+        }));
+    }
+    const title = session.titleExplicit ? normalizeTitle(session.title) : '';
+    if (title !== '')
+        events.push(model.append('session/title', userTitleData(title)));
+    return { header: model.header, events };
+}

package/lib/types/dsh-adapter/migrate/types.d.ts

@@ -0,0 +1,176 @@
+/**
+ * Cross-agent conversation migration: shared types.
+ *
+ * An adapter turns one foreign agent's stored conversation into the neutral
+ * {@link MigrationSession} shape; the sessionizer (see sessionize.ts) then
+ * emits DSH session events. Adapters are read-only against their source and
+ * defensive by default: a malformed line costs that line, never the scan.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/types
+ */
+/**
+ * One message of a foreign conversation as a flat role list — the shape the
+ * omp adapter still produces; {@link fromRoleTurns} in parse/role-turns.ts
+ * folds it into {@link ImportTurn}s.
+ */
+export interface MigrationTurn {
+    readonly role: 'user' | 'assistant';
+    readonly text: string;
+    /** Assistant reasoning trace, when the source recorded one. */
+    readonly reasoning?: string;
+    /** Source-recorded model id for an assistant turn, when available. */
+    readonly model?: string;
+    /** Epoch milliseconds when the source recorded the turn. */
+    readonly time: number;
+}
+/** One assistant content block of an imported step. */
+export type ImportBlock = {
+    readonly type: 'text';
+    readonly text: string;
+} | {
+    readonly type: 'reasoning';
+    readonly text: string;
+} | {
+    readonly type: 'tool-call';
+    readonly id: string;
+    readonly name: string;
+    readonly arguments: string;
+};
+/** The model-facing result of one tool call, paired by call id. */
+export interface ImportToolResult {
+    readonly callId: string;
+    /** Result text; images are replaced by a placeholder, oversize text is clamped. */
+    readonly text: string;
+    readonly isError: boolean;
+}
+/** One model call and the tool executions it requested. */
+export interface ImportStep {
+    /** User-role messages entering this step before the model answers (mid-turn
+     *  context such as skill bodies or image notes — never the turn's prompt). */
+    inputs: string[];
+    blocks: ImportBlock[];
+    /** Results for this step's tool-call blocks; after closeToolPairs() exactly
+     *  one per call, in call order. */
+    results: ImportToolResult[];
+    /** Source-recorded model id for this step, when available. */
+    model?: string;
+}
+/** A context-compaction boundary the source recorded before a turn. */
+export interface ImportCompaction {
+    readonly summary: string;
+    readonly model?: string;
+}
+/** One imported turn: a human prompt and the steps that answered it. */
+export interface ImportTurn {
+    /** The human prompt; '' when the turn has none (source lost its head, or
+     *  the turn only carries a compaction checkpoint). */
+    prompt: string;
+    /** A compaction checkpoint emitted BEFORE this turn opens. */
+    compaction?: ImportCompaction;
+    steps: ImportStep[];
+    /** The source recorded this turn as interrupted. */
+    aborted?: boolean;
+}
+/** Per-conversation counters for what parsing had to leave out. */
+export interface ImportStats {
+    /** Lines that were not valid JSON. */
+    badLines: number;
+    /** Tool results with no matching call, or a second result for one call. */
+    droppedToolResults: number;
+    /** Rows left out: harness injection in the user role, local-command
+     *  echoes, provider-side tool rows with no harness counterpart. */
+    filtered: number;
+    /** Mid-turn machine context folded into a step's inputs (Claude isMeta, …). */
+    meta: number;
+}
+/** A discovered foreign conversation, ready for conversion. */
+export interface MigrationSession {
+    /** Stable id in the SOURCE store (file uuid, rollout id, …). */
+    readonly sourceId: string;
+    /** Source working directory, when recorded; falls back to the scan root. */
+    readonly cwd: string;
+    /** Conversation title, when the source has one (possibly a first-prompt fallback). */
+    readonly title?: string;
+    /** Whether {@link title} is the source's own title (written to the log as
+     *  `session/title`) rather than a first-prompt fallback (left for DSH to derive). */
+    readonly titleExplicit: boolean;
+    readonly startedAt: number;
+    readonly turns: readonly ImportTurn[];
+    readonly stats: ImportStats;
+}
+/** What one adapter found on disk. */
+export interface MigrationDiscovery {
+    /** Absolute roots that were scanned (reported to the user). */
+    readonly roots: readonly string[];
+    readonly sessions: readonly MigrationSession[];
+}
+/** Change token of one source artifact: unchanged means reuse its summary. */
+export interface Fingerprint {
+    readonly mtimeMs: number;
+    readonly size: number;
+}
+/** A foreign conversation as listed, derived from the head (and tail) of
+ *  its artifact and stat alone — never from a full parse. */
+export interface ForeignSessionSummary {
+    readonly agentId: string;
+    /** Stable source id; always equals the `sourceId` a full parse yields, so
+     *  both import entries land on the same deterministic session id. */
+    readonly sessionKey: string;
+    /** Opaque locator of the full content (file path / session directory). */
+    readonly ref: string;
+    /** Normalized title; possibly the first-prompt fallback. */
+    readonly title: string;
+    /** '' when unknown. */
+    readonly cwd: string;
+    /** Sort key: when the conversation last changed. */
+    readonly lastMessageAt: number;
+    readonly createdAt: number;
+}
+/** One scanned artifact: its summary, or null when it is not a conversation
+ *  of its own (sub-agent log, no prompt) — negative results are cached too. */
+export interface ScanEntry {
+    readonly ref: string;
+    readonly fp: Fingerprint;
+    readonly summary: ForeignSessionSummary | null;
+}
+export interface ScanOptions {
+    readonly signal?: AbortSignal;
+    /** A previous result for an unchanged artifact: a summary, null (known not
+     *  to be a conversation), or undefined (unknown — read it). */
+    cached?(ref: string, fp: Fingerprint): ForeignSessionSummary | null | undefined;
+    /** Called per conversation as the scan finds it. */
+    onEntry?(summary: ForeignSessionSummary): void;
+}
+/** Where a source's artifacts sit under its roots, by name alone. */
+export interface WalkSpec {
+    readonly maxDepth: number;
+    readonly match: (name: string) => boolean;
+    /** Directory names never descended into. */
+    readonly skipDirs?: readonly string[];
+}
+/** Why a full load produced no session. */
+export interface LoadSkip {
+    readonly skip: 'missing' | 'too-large' | 'not-a-session';
+}
+/** A migration adapter for one foreign agent. */
+export interface MigrationAdapter {
+    readonly id: string;
+    readonly label: string;
+    /** Absolute source roots this adapter would scan on this machine. */
+    roots(): readonly string[];
+    /** Scan the roots and normalize every readable conversation. */
+    discover(): MigrationDiscovery;
+    /** Cheap per-root file count for list mode (no parsing). Implementations
+     *  that cannot count by name alone may omit this and fall back to
+     *  discover() — the count then equals the parsed session total. */
+    count?(): number;
+    /** The name-only walk scan() follows; lets a caller count candidates and
+     *  find the newest activity without parsing. Present with scan(). */
+    readonly walk?: WalkSpec;
+    /** Asynchronous, abortable summary scan for browsing (head/tail reads,
+     *  fingerprint reuse). Sources without it are not browsable. */
+    scan?(options?: ScanOptions): Promise<readonly ScanEntry[]>;
+    /** Full parse of one conversation found by scan(). */
+    load?(ref: string): Promise<MigrationSession | LoadSkip>;
+}
+//# sourceMappingURL=types.d.ts.map

package/lib/types/dsh-adapter/migrate/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/types.ts"],"names":[],"mappings":"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"}

package/lib/types/dsh-adapter/migrate/types.js

@@ -0,0 +1,11 @@
+/**
+ * Cross-agent conversation migration: shared types.
+ *
+ * An adapter turns one foreign agent's stored conversation into the neutral
+ * {@link MigrationSession} shape; the sessionizer (see sessionize.ts) then
+ * emits DSH session events. Adapters are read-only against their source and
+ * defensive by default: a malformed line costs that line, never the scan.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/types
+ */
+export {};

package/lib/types/dsh-adapter/migrate/uuid.d.ts

@@ -0,0 +1,7 @@
+/**
+ * RFC 4122 UUIDv5 over the migration namespace.
+ * @param name - The distinguishing name (e.g. `claude-code:<file uuid>`).
+ * @returns Dashed lowercase uuid v5.
+ */
+export declare function migrationUuid(name: string): string;
+//# sourceMappingURL=uuid.d.ts.map

package/lib/types/dsh-adapter/migrate/uuid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/migrate/uuid.ts"],"names":[],"mappings":"AAeA;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAMlD"}

package/lib/types/dsh-adapter/migrate/uuid.js

@@ -0,0 +1,25 @@
+/**
+ * Deterministic UUIDv5 for migration ids.
+ *
+ * Re-importing the same source conversation must land on the SAME DSH
+ * session id, so repeats overwrite their own copy instead of stacking
+ * duplicates — the id IS the dedupe. Inline SHA-1 RFC 4122 variant (no
+ * runtime dependency; node:crypto does the hashing).
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/uuid
+ */
+import { createHash } from 'node:crypto';
+/** This project's migration namespace: dsh-tui-migrate as 16 fixed bytes. */
+const NAMESPACE = Buffer.from([0x9f, 0x1d, 0x3a, 0x72, 0x6c, 0x55, 0x4c, 0x8e, 0xb0, 0x2f, 0x6d, 0x69, 0x67, 0x72, 0x61, 0x74]);
+/**
+ * RFC 4122 UUIDv5 over the migration namespace.
+ * @param name - The distinguishing name (e.g. `claude-code:<file uuid>`).
+ * @returns Dashed lowercase uuid v5.
+ */
+export function migrationUuid(name) {
+    const hash = createHash('sha1').update(NAMESPACE).update(name, 'utf8').digest();
+    hash[6] = (hash[6] & 0x0f) | 0x50;
+    hash[8] = (hash[8] & 0x3f) | 0x80;
+    const hex = hash.subarray(0, 16).toString('hex');
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}

package/lib/types/dsh-adapter/oauth/bonus.d.ts

@@ -0,0 +1,27 @@
+import type { DeepSeekAccount, AccountBonusOrderId, AccountUserId } from '@deepseek-ai/dsh-deepseek-account';
+export interface WhaleCouponNotice {
+    readonly accountId: AccountUserId;
+    readonly orderId: AccountBonusOrderId;
+    readonly amount: string;
+    readonly currency: 'CNY' | 'USD';
+    readonly expiresAt: string;
+}
+type BonusAccount = Pick<DeepSeekAccount, 'getUnnotifiedBonuses' | 'ackBonusNotified'>;
+/** TUI-only presentation of a Platform-confirmed login grant. */
+export declare class WhaleCouponStore {
+    private readonly listeners;
+    private readonly seen;
+    private notice;
+    private account;
+    private generation;
+    readonly subscribe: (listener: () => void) => (() => void);
+    readonly getSnapshot: () => WhaleCouponNotice | null;
+    refresh(account: BonusAccount): Promise<void>;
+    /** Called only after the modal has painted; a read alone never acknowledges. */
+    shown(orderId: AccountBonusOrderId): void;
+    dismiss(orderId: AccountBonusOrderId): void;
+    clear(): void;
+    private emit;
+}
+export {};
+//# sourceMappingURL=bonus.d.ts.map

package/lib/types/dsh-adapter/oauth/bonus.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bonus.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/oauth/bonus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,aAAa,EAAE,MAAM,mCAAmC,CAAA;AAG5G,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,SAAS,EAAE,aAAa,CAAA;IACjC,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAA;IACrC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;IACvB,QAAQ,CAAC,QAAQ,EAAE,KAAK,GAAG,KAAK,CAAA;IAChC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAC3B;AAED,KAAK,YAAY,GAAG,IAAI,CAAC,eAAe,EAAE,sBAAsB,GAAG,kBAAkB,CAAC,CAAA;AAEtF,iEAAiE;AACjE,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAwB;IAClD,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoB;IACzC,OAAO,CAAC,MAAM,CAAiC;IAC/C,OAAO,CAAC,OAAO,CAA0B;IACzC,OAAO,CAAC,UAAU,CAAI;IAEtB,QAAQ,CAAC,SAAS,GAAI,UAAU,MAAM,IAAI,KAAG,CAAC,MAAM,IAAI,CAAC,CAGxD;IAED,QAAQ,CAAC,WAAW,QAAO,iBAAiB,GAAG,IAAI,CAAe;IAE5D,OAAO,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAmBnD,gFAAgF;IAChF,KAAK,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IASzC,OAAO,CAAC,OAAO,EAAE,mBAAmB,GAAG,IAAI;IAS3C,KAAK,IAAI,IAAI;IAQb,OAAO,CAAC,IAAI;CACb"}

package/lib/types/dsh-adapter/oauth/bonus.js

@@ -0,0 +1,69 @@
+import { deepSeekClientMetadata } from './deepseek.js';
+/** TUI-only presentation of a Platform-confirmed login grant. */
+export class WhaleCouponStore {
+    listeners = new Set();
+    seen = new Set();
+    notice = null;
+    account;
+    generation = 0;
+    subscribe = (listener) => {
+        this.listeners.add(listener);
+        return () => { this.listeners.delete(listener); };
+    };
+    getSnapshot = () => this.notice;
+    async refresh(account) {
+        const generation = ++this.generation;
+        if (this.listeners.size === 0)
+            return;
+        let batch;
+        try {
+            batch = await account.getUnnotifiedBonuses(deepSeekClientMetadata());
+        }
+        catch {
+            return;
+        }
+        if (generation !== this.generation || batch === null)
+            return;
+        const granted = batch.bonuses.find(bonus => bonus.campaign === 'dsh_login_bonus'
+            && !this.seen.has(`${batch.accountId}:${bonus.orderId}`)
+            && (Number.isNaN(Date.parse(bonus.expiresAt)) || Date.parse(bonus.expiresAt) > Date.now()));
+        if (granted === undefined)
+            return;
+        this.account = account;
+        this.notice = {
+            accountId: batch.accountId, orderId: granted.orderId,
+            amount: granted.amount, currency: granted.currency, expiresAt: granted.expiresAt,
+        };
+        this.emit();
+    }
+    /** Called only after the modal has painted; a read alone never acknowledges. */
+    shown(orderId) {
+        const notice = this.notice;
+        if (notice?.orderId !== orderId || this.account === undefined)
+            return;
+        const key = `${notice.accountId}:${notice.orderId}`;
+        if (this.seen.has(key))
+            return;
+        this.seen.add(key);
+        void this.account.ackBonusNotified(notice.accountId, orderId, deepSeekClientMetadata()).catch(() => false);
+    }
+    dismiss(orderId) {
+        if (this.notice?.orderId !== orderId)
+            return;
+        this.shown(orderId);
+        const account = this.account;
+        this.notice = null;
+        this.emit();
+        if (account !== undefined)
+            void this.refresh(account);
+    }
+    clear() {
+        this.generation++;
+        this.notice = null;
+        this.account = undefined;
+        this.seen.clear();
+        this.emit();
+    }
+    emit() { for (const listener of this.listeners)
+        listener(); }
+}

package/{node_modules/@deepseek-harness-tui/dsh-auth/lib → lib/types/dsh-adapter/oauth}/command.d.ts

@@ -2,7 +2,7 @@
  * The `/auth` command: a textual veneer over the {@link DshAuthApi} — status
  * listing, login (optionally picking the provider interactively), logout.
  *
- * @module dsh-auth/command
+ * @module @deepseek-harness-tui/dsh-tui/oauth/command
  */
 import type { CommandInvocation, CommandResult } from '@deepseek-ai/dsh-commands';
 import type { DshAuthApi } from './service.js';
@@ -12,3 +12,4 @@ import type { DshAuthApi } from './service.js';
  * propagate for the host's own error surface.
  */
 export declare function createAuthCommandHandler(api: DshAuthApi): (invocation: CommandInvocation) => Promise<CommandResult>;
+//# sourceMappingURL=command.d.ts.map

package/lib/types/dsh-adapter/oauth/command.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command.d.ts","sourceRoot":"","sources":["../../../../src/dsh-adapter/oauth/command.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAA;AACjF,OAAO,KAAK,EAAE,UAAU,EAAuB,MAAM,cAAc,CAAA;AA0BnE;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,GAAG,EAAE,UAAU,GAAG,CAAC,UAAU,EAAE,iBAAiB,KAAK,OAAO,CAAC,aAAa,CAAC,CAiCnH"}

package/{node_modules/@deepseek-harness-tui/dsh-auth/lib → lib/types/dsh-adapter/oauth}/command.js

@@ -2,13 +2,15 @@
  * The `/auth` command: a textual veneer over the {@link DshAuthApi} — status
  * listing, login (optionally picking the provider interactively), logout.
  *
- * @module dsh-auth/command
+ * @module @deepseek-harness-tui/dsh-tui/oauth/command
  */
 const USAGE = 'Usage: /auth [status] | /auth login [provider] | /auth logout <provider>';
 function renderStatus(rows) {
     const lines = rows.map(row => {
         const state = row.signedIn
-            ? `signed in — token expires ${new Date(row.expiresAt ?? 0).toISOString()}`
+            ? row.expiresAt === undefined
+                ? 'signed in'
+                : `signed in — token expires ${new Date(row.expiresAt).toISOString()}`
             : row.expired
                 ? 'signed in, token expired — /auth login to refresh'
                 : 'not signed in';
@@ -41,8 +43,9 @@ export function createAuthCommandHandler(api) {
                 const result = await api.login(target, invocation.signal);
                 return {
                     kind: 'success',
-                    text: `Signed in to ${result.oauthLabel} (${result.provider}); token expires `
-                        + `${new Date(result.expiresAt).toISOString()}. Its models are selectable via /model.`,
+                    text: `Signed in to ${result.oauthLabel} (${result.provider})`
+                        + `${result.expiresAt === undefined ? '' : `; token expires ${new Date(result.expiresAt).toISOString()}`}. `
+                        + 'Its models are selectable via /model.',
                 };
             }
             catch (error) {