dsh-lowtide 0.1.2

package/lib/types/src/models.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Available-model enumeration (functional round): every model this machine's
+ * dsh has configured. Uses the llm service's canonical catalog API
+ * (`ctx.llm.listProviders` + `ctx.llm.listModels`) instead of hard-coding the
+ * deepseek pair or reading one settings namespace, so ANY provider the user
+ * has connected — deepseek official, llm-pi-ai gateways, custom
+ * openai-compatible endpoints, … — is listed with exactly the models its
+ * adapter actually serves (configured catalog or adapter defaults).
+ */
+import { type PriceTier } from 'lowtide-core';
+import type { Context } from '@deepseek-ai/cordis';
+export interface AvailableModel {
+    id: string;
+    name: string;
+    /** Whether this model has an official/override price entry (deepseek pair). */
+    priceKnown: boolean;
+    /** Adapter-declared input modalities (e.g. ["text", "image"]) — optional. */
+    inputModalities?: string[];
+    /** Supported reasoning effort ids (e.g. ["off","low","high","max"]). */
+    reasoningEfforts?: string[];
+    /** The model's default reasoning effort id, when the adapter declares one. */
+    defaultReasoningEffort?: string;
+}
+export interface AvailableProvider {
+    provider: string;
+    displayName: string;
+    models: AvailableModel[];
+}
+/** Enumerate all configured models on this machine (deepseek first). A
+ *  provider whose catalog cannot be read (missing credential, no models) is
+ *  skipped rather than failing the whole listing. Reasoning metadata comes
+ *  from the adapter's exact-model resolution so every model — including
+ *  user-added providers — reports its own supported effort set. */
+export declare function listAvailableModels(ctx: Context, prices?: Record<string, PriceTier>): Promise<AvailableProvider[]>;
+/** Best-effort provider lookup for a bare model id — used by old persisted
+ *  tasks that carry `model` but no `modelProvider`. Returns the first
+ *  registered provider whose catalog contains the id, or undefined. */
+export declare function inferProvider(ctx: Context, model: string): Promise<string | undefined>;

package/lib/types/src/routes.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Lowtide HTTP API (PLAN T1.3 / §7.3, Phase 1 subset) under /ds-lowtide.
+ * The Host/Origin trust fence (T2.8) is not yet mounted — the server binds
+ * loopback only and the README deployment guidance (SSH tunnel) is Phase 4.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import type { Scheduler } from './scheduler.ts';
+import { LowtideStore } from './store.ts';
+export type { TriageAction } from './state-machine.ts';
+export { canTransition } from './state-machine.ts';
+export interface Routes {
+    store: LowtideStore;
+    scheduler: Scheduler;
+}
+export declare function registerRoutes(ctx: Context, routes: Routes): void;

package/lib/types/src/runner.d.ts

@@ -0,0 +1,89 @@
+/**
+ * Lowtide runner (PLAN T1.4 / §7.2 + v2 execution strategies): preflight →
+ * unattended execution (single / iterative / sampling) → collection → retry.
+ * Built from the spike-1 route A template with all rc.7 findings applied
+ * (D4 preset mount, D5 setup shape, D6 message location, turn/end completion
+ * signal, no silence event) and the round-1 fixes (B1 crash→failed, B2 empty
+ * batch, B4 listener cleanup, B5 gitRef preflight, batch model pinning).
+ *
+ * Strategy semantics (PLAN v2 §1):
+ *  - single:    one turn, like a normal harness prompt;
+ *  - iterative: one session, N turns; each later turn reviews and improves
+ *               the previous output; early-stop when two consecutive turns
+ *               converge (cheap bigram-Jaccard similarity);
+ *  - sampling:  N independent fresh sessions of the same prompt; N candidates
+ *               are produced at night — the USER picks the best the next
+ *               morning (no auto-selection, no synthesis).
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type MorningReport, type ReportTaskRow, type Task, type UsageLike } from 'lowtide-core';
+import { LowtideStore } from './store.ts';
+/** Price table from the store (undefined = official defaults; tierFor falls back). */
+type PriceTable = Record<string, {
+    peak: {
+        input: number;
+        inputCached: number;
+        output: number;
+    };
+    off: {
+        input: number;
+        inputCached: number;
+        output: number;
+    };
+}>;
+/** Hypothetical peak-hour cost of a usage — the "what you saved" baseline.
+ *  Only models with a real price entry (official table incl.
+ *  deepseek-v4-flash-vision-exp, or a user price override) get a baseline;
+ *  anything else yields 0 so no fake savings are ever reported. */
+export declare function peakCostOf(usage: UsageLike, modelId: string, prices: PriceTable | undefined): number;
+/** Retrying a quota/balance rejection is pointless (and costly): the account
+ *  state cannot change inside one batch. Matches deepseek's 402 payload. */
+export declare function isQuotaError(error: string | undefined): boolean;
+/** Result of running one task through the batch pipeline. */
+export interface RunTaskResult {
+    row: ReportTaskRow;
+    /** This task's peak-price counterfactual savings (0 when skipped). */
+    savedYuan: number;
+    /** Preflight skipped the task (stale / deferred) — excluded from the report list. */
+    skipped: boolean;
+    /** Preflight deferred it (window fit / budget) — counts toward deferredCount. */
+    deferred: boolean;
+}
+/** Run one task through preflight + strategy execution + one retry. */
+export declare function runTask(ctx: Context, store: LowtideStore, task: Task, windowEndAt: Date): Promise<RunTaskResult>;
+/**
+ * Schedule workspace groups through the batch runner with a concurrency cap.
+ * Each group is a SERIAL queue (same-workspace tasks must not overlap — git
+ * index locks and shared cwd state); different groups run in parallel, at
+ * most `maxConcurrency` groups at once (Kimi refactor plan §2, corrected:
+ * no agent-session reuse — every task keeps its own isolated session).
+ * Returns results in the input order.
+ */
+export declare function scheduleGroups<T>(items: T[], keyOf: (item: T) => string, maxConcurrency: number, runOne: (item: T) => Promise<{
+    skipped: boolean;
+    deferred: boolean;
+}>): Promise<void>;
+/**
+ * Assemble the report rows in the ORIGINAL queue order (priority, then
+ * createdAt — the same sort runBatch applied when picking the queue).
+ * scheduleGroups finishes workspace groups in arbitrary order, so results
+ * are collected into a Map and re-ordered here; otherwise the morning
+ * report would list tasks in completion order (post-refactor review H-001).
+ * Deferred (preflight-skipped) tasks count toward deferredCount but never
+ * enter the report's task list.
+ */
+export declare function assembleReportRows(queue: Task[], results: Map<string, RunTaskResult>): {
+    rows: ReportTaskRow[];
+    savedTotal: number;
+    deferredCount: number;
+};
+/**
+ * Run the queued set with per-workspace serialization and cross-workspace
+ * concurrency (`batch.maxConcurrency`, default 3). Stops launching new tasks
+ * past windowEndAt but never interrupts a running task (PLAN §7.2). Returns
+ * null when nothing executed — no empty execution reports (review round 1, B2).
+ */
+export declare function runBatch(ctx: Context, store: LowtideStore, windowEndAt: Date, forced?: boolean): Promise<MorningReport | null>;
+/** Helper for the /state aggregate: yesterday-style formatting for the report header. */
+export declare function reportDateLabel(dateIso: string): string;
+export {};

package/lib/types/src/scheduler.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Lowtide scheduler (PLAN T1.4): minute-aligned tick driving the batch
+ * runner inside the configured window. The window end stops new launches but
+ * never interrupts a running task. `runNow` is the manual/test path.
+ *
+ * Fixes over the MVP tick (2026-08 review round 1):
+ *  - once-per-window guard: a window (start-day keyed, midnight-crossing
+ *    safe) runs the batch at most once even when the host restarts inside it;
+ *  - deferred auto-recovery: at window start, preflight-deferred tasks
+ *    (deferCount > 0) go back to queued (retry next window), user-triaged
+ *    deferred tasks (deferCount === 0) reappear in pending-review — the
+ *    "下一个裁定周期再出现" promise of PLAN §2.1;
+ *  - skip the batch entirely when nothing is queued (no empty reports).
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { LowtideStore } from './store.ts';
+export interface Scheduler {
+    stop(): void;
+    runNow(): Promise<void>;
+    isRunning(): boolean;
+    batchStartedAt(): Date | null;
+}
+/** Maximum consecutive preflight deferrals before a task is marked failed. */
+export declare const MAX_PREFLIGHT_DEFER = 3;
+/** Whether `now` is inside [start, end) of the batch window (local tz). */
+export declare function inBatchWindow(now: Date, window: string, tz?: string): boolean;
+/** The batch window's end as an absolute Date (today's or the next occurrence). */
+export declare function batchWindowEnd(now: Date, window: string, tz?: string): Date;
+/**
+ * Identity of the batch window currently in progress, keyed by the calendar
+ * day the window STARTED (so a midnight-crossing window cannot run twice).
+ * Returns null when `now` is outside the window.
+ */
+export declare function currentWindowKey(now: Date, window: string, tz?: string): string | null;
+/** Window-start recovery for deferred tasks (PLAN §2.1 + review B3). */
+export declare function recoverDeferred(store: LowtideStore): void;
+export declare function startScheduler(ctx: Context, store: LowtideStore, tickMs?: number): Scheduler;

package/lib/types/src/session-picker.d.ts

@@ -0,0 +1,14 @@
+export interface WorkspaceSession {
+    id: string;
+    /** Conversation title from the proj cache (null when never titled). */
+    title: string | null;
+    lastModified: number;
+}
+export interface WorkspaceSessions {
+    cwd: string;
+    label: string | null;
+    sessions: WorkspaceSession[];
+}
+export declare function storagesDir(): string;
+/** List conversations per workspace, most recently active first. */
+export declare function listWorkspaceSessions(limitPerWorkspace?: number): WorkspaceSessions[];

package/lib/types/src/state-machine.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Triage state-machine (review round 1, B6): the transition table guarding
+ * every /tasks/:id/:action route. Kept dependency-free so the full matrix is
+ * unit-testable without pulling the host bundle.
+ */
+/** Triage actions accepted by the /tasks/:id/:action routes. */
+export type TriageAction = 'approve' | 'defer' | 'drop' | 'cancel' | 'retry' | 'delete' | 'restore' | 'choose-candidate';
+/**
+ * A transition is rejected unless the current status allows it — otherwise a
+ * running task could be re-queued behind the agent's back and the persisted
+ * state would fight the live execution.
+ */
+export declare function canTransition(status: string, action: TriageAction): boolean;

package/lib/types/src/store.d.ts

@@ -0,0 +1,116 @@
+import { z } from 'zod';
+import { type MorningReport, type LowtideConfig, type Task, type TaskRun, type TaskStatus } from 'lowtide-core';
+/**
+ * Partial config update accepted by PUT /ds-lowtide/config.
+ * Removed `.strict()` so older clients with extra fields don't break
+ * forward-compatibility (unknown keys are silently stripped by zod default).
+ */
+export declare const configUpdateSchema: z.ZodObject<{
+    autonomy: z.ZodOptional<z.ZodEnum<{
+        l1: "l1";
+        l2: "l2";
+        l3: "l3";
+    }>>;
+    batch: z.ZodOptional<z.ZodObject<{
+        gateLeadMin: z.ZodOptional<z.ZodNumber>;
+        maxTasksPerNight: z.ZodOptional<z.ZodNumber>;
+        maxDurationMin: z.ZodOptional<z.ZodNumber>;
+        paused: z.ZodOptional<z.ZodBoolean>;
+        maxConcurrency: z.ZodOptional<z.ZodOptional<z.ZodNumber>>;
+        window: z.ZodOptional<z.ZodString>;
+        tz: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, z.core.$strip>>;
+    windows: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        level: z.ZodEnum<{
+            custom: "custom";
+            off: "off";
+            peak: "peak";
+        }>;
+        days: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+        multiplier: z.ZodOptional<z.ZodNumber>;
+        start: z.ZodString;
+        end: z.ZodString;
+        tz: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    prices: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        peak: z.ZodObject<{
+            input: z.ZodNumber;
+            inputCached: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>;
+        off: z.ZodObject<{
+            input: z.ZodNumber;
+            inputCached: z.ZodNumber;
+            output: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>>>;
+    budgetDailyYuan: z.ZodOptional<z.ZodNumber>;
+    maxReportHistory: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type ConfigUpdate = z.infer<typeof configUpdateSchema>;
+export interface LedgerDay {
+    yuan: number;
+    savedYuan: number;
+}
+export interface StoreState {
+    version: 1;
+    config: LowtideConfig;
+    tasks: Task[];
+    reports: MorningReport[];
+    ledger: Record<string, LedgerDay>;
+    dismissedPeakDay?: string;
+}
+export declare function stateFilePath(): string;
+/** Hard cap for locked-file snapshots: bigger files are refused (streamed
+ *  hashing would still work, but a multi-GB locked file is almost certainly
+ *  a mistake and would stall the batch). */
+export declare const MAX_SNAPSHOT_BYTES: number;
+/**
+ * File snapshot: sha256 + size via a STREAM (readFileSync would load a
+ * multi-GB file fully into memory — Kimi review H3).
+ */
+export declare function snapshotFile(path: string): Promise<{
+    sha256: string;
+    size: number;
+}>;
+export declare class LowtideStore {
+    private state;
+    private readonly file;
+    constructor(file: string, seed: StoreState);
+    static load(file: string): LowtideStore;
+    /** Startup scan: a dead process leaves running/preflight behind — requeue them. */
+    private recover;
+    snapshot(): StoreState;
+    /** Atomic-ish write: tmp in the same directory, then rename over.
+     *  tmp is cleaned up in every path (including crashes during rename). */
+    save(): void;
+    private mutate;
+    get tasks(): readonly Task[];
+    get config(): LowtideConfig;
+    get reports(): readonly MorningReport[];
+    setConfig(config: LowtideConfig): void;
+    /** Merge a validated partial update into the live config (deep-merge batch). */
+    updateConfig(patch: ConfigUpdate): LowtideConfig;
+    addTask(task: Task): Task;
+    taskById(id: string): Task | undefined;
+    /**
+     * Hard-delete a task: removes it from the persisted state for good
+     * (user-level "投错/不要了" path). Reports and the ledger are history
+     * snapshots and stay untouched; the route layer guards running tasks.
+     */
+    deleteTask(id: string): boolean;
+    setStatus(id: string, status: TaskStatus, patch?: Partial<Task>): Task | undefined;
+    recordRun(id: string, run: TaskRun, finalStatus: TaskStatus): Task | undefined;
+    addSavings(savedYuan: number): void;
+    ledgerToday(now: Date): LedgerDay;
+    dismissPeakToday(): void;
+    isPeakDismissedToday(now: Date): boolean;
+    addReport(report: MorningReport): void;
+    /** Delete a single report by id (ledger and tasks are untouched evidence). */
+    deleteReport(reportId: string): boolean;
+    /** Clear all reports (keep ledger and tasks untouched). Returns removed count. */
+    clearReports(): number;
+}
+export declare function defaultState(): StoreState;

package/lib/types/src/strategies/review-dimensions.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Review dimensions for the smart-iterative strategy (Kimi refactor plan §3,
+ * corrected): per-task-type structured review dimensions instead of the
+ * vague "请改进". Pure data + a keyword-based task-type inferrer.
+ */
+export type TaskType = 'code-review' | 'doc-generation' | 'test-generation' | 'refactoring' | 'general';
+export interface ReviewDimension {
+    id: string;
+    name: string;
+    prompt: string;
+}
+export declare const DIMENSIONS: Record<TaskType, ReviewDimension[]>;
+/** Keyword heuristic for the task type (zh + en). */
+export declare function inferTaskType(prompt: string): TaskType;

package/lib/types/src/strategies/smart-iterative.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Smart Iterative strategy (Kimi refactor plan §3, corrected):
+ *
+ *  Round 0 (generate)  → the task prompt, one turn.
+ *  Round k (review)    → structured review prompt (per inferred task type),
+ *                        strict-JSON issue list; parse with a degraded
+ *                        fallback.
+ *  Stop when           → no `high` issues and ≤1 `medium` (quality gate),
+ *                        OR bigram convergence with the previous round
+ *                        (cheap, deterministic), OR `rounds` exhausted.
+ *  Round k (fix)       → issue-driven repair prompt (fix listed issues only).
+ *
+ * Corrections vs the plan: same model throughout (no pro tier), no extra
+ * LLM convergence call (the quality gate + bigram cover it), cost is ~2
+ * calls per round and is accounted in the intake estimate.
+ */
+import type { Context } from '@deepseek-ai/cordis';
+import { type TurnResult } from '../turns.ts';
+import type { Task, ReasoningEffort, UsageLike } from 'lowtide-core';
+export interface ReviewIssue {
+    dim?: string;
+    severity?: string;
+    location?: string;
+    issue?: string;
+    suggestion?: string;
+}
+export interface ReviewReport {
+    issues: ReviewIssue[];
+    summary: string;
+    overallScore: number;
+}
+export interface SmartIterativeOutcome {
+    final: 'done' | 'failed' | 'timeout' | 'aborted';
+    turns: TurnResult[];
+    roundsRun: number;
+    elapsedMs: number;
+    reviewExcerpt?: string;
+    /** True when the draft round CONTINUED the requested conversation in place. */
+    resumed?: boolean;
+    /** True when the draft round ran in a NEW session seeded with the source's
+     *  full history (fork-style continuation). */
+    forked?: boolean;
+    /** Set when the requested conversation resume failed and a fresh session was used. */
+    resumeNote?: string;
+}
+/** Extract the first JSON object from a model answer (degraded on failure).
+ *  Tries markdown code blocks first, then uses a depth-limited brace match
+ *  to avoid swallowing multiple objects or trailing prose (review fix). */
+export declare function parseReviewReport(text: string): ReviewReport;
+/** Quality gate: stop when no high-severity issues and ≤1 medium. */
+export declare function qualityMet(report: ReviewReport): boolean;
+/**
+ * Smart iterative: generate → review → fix until the quality gate or
+ * convergence, capped at `task.rounds` total turns (user-controlled).
+ */
+export declare function runSmartIterative(ctx: Context, task: Task, timeoutMs: number, reasoning?: ReasoningEffort, 
+/** Session to resume for Round 0 (generate). Subsequent review/fix rounds
+ *  always use fresh sessions — only the draft continues the conversation. */
+resumeSessionId?: string): Promise<SmartIterativeOutcome>;
+/** Usage summed across all turns of a smart-iterative run. */
+export declare function smartUsage(turns: TurnResult[]): UsageLike;

package/lib/types/src/turns.d.ts

@@ -0,0 +1,97 @@
+import { SessionId } from '@deepseek-ai/dsh-session';
+import type { Context } from '@deepseek-ai/cordis';
+import { type ReasoningEffort, type Task, type UsageLike } from 'lowtide-core';
+export interface TurnOutcome {
+    kind: string;
+    text: string;
+    usage: UsageLike | null;
+    reason: unknown;
+}
+export interface TurnWatcher {
+    promise: Promise<TurnOutcome>;
+    off(): void;
+}
+export interface TurnResult {
+    text: string;
+    usage: UsageLike | null;
+    kind: string;
+}
+export interface SessionResult {
+    turns: TurnResult[];
+    elapsedMs: number;
+    status: 'done' | 'failed' | 'timeout' | 'aborted';
+    error?: string;
+    /** True when the task CONTINUED the ORIGINAL conversation (resume succeeded). */
+    resumed?: boolean;
+    /** True when a NEW session was seeded with the source conversation's FULL
+     *  history (fork-style continuation — the lossless fallback when the
+     *  source session is live in this runtime and cannot be resumed). */
+    forked?: boolean;
+    /** Set when the task was asked to CONTINUE an existing conversation but the
+     *  resume failed and a fresh session was used instead (lossy fallback). */
+    resumeNote?: string;
+}
+/**
+ * Unique, recognizable title for a lowtide task session. The timestamp makes
+ * repeated runs of the same task distinguishable in the session list, and the
+ * prefix separates ordinary task sessions from continuation sessions (which
+ * would otherwise inherit the source conversation's title and look identical).
+ */
+export declare function taskSessionTitle(task: Task, mode: 'task' | 'resumed' | 'forked', now?: Date): string;
+/** Returns the next user message to send (index = round, 0-based), or null to stop. */
+export type NextMessage = (index: number, turns: TurnResult[]) => string | null;
+/**
+ * Cut index (exclusive) for seeding a continuation session from a source
+ * event log: through the LAST completed turn (turn/end), skipping any
+ * residual between-turn events — the same boundary the harness's own
+ * session.fork uses. Returns null when the log has no completed turn (a
+ * blank/unfinished conversation cannot be continued losslessly).
+ */
+export declare function forkSeedBoundary(events: readonly {
+    type: string;
+    seq: number;
+}[]): number | null;
+export declare function sleep(ms: number): Promise<void>;
+export declare function usageOf(raw: unknown): UsageLike;
+/** Best-effort human-readable summary of a failed turn/end reason. */
+export declare function summarizeReason(reason: unknown, kind: string): string;
+/**
+ * Resolve the model for batch execution. Trusts the user's live UI selection
+ * or task-level override without forcing a DeepSeek fallback. The caller
+ * (runner) is responsible for ensuring the chosen provider/model is usable in
+ * headless mode.
+ */
+export declare function resolveBatchModel(selection: {
+    provider: string;
+    model: string;
+}, reasoning?: ReasoningEffort, modelOverride?: string, providerOverride?: string): {
+    provider: string;
+    model: string;
+    reasoningEffort?: import('@deepseek-ai/dsh-llm').ReasoningEffortId;
+};
+/**
+ * Wait for the next turn/end on a session, collecting assistant text + usage.
+ * Returns a watcher so the caller can detach the event listener when the
+ * timeout branch wins — otherwise every timed-out task leaks a listener (B4).
+ * The off is idempotent (Kimi review: double-cancel safety).
+ */
+export declare function waitTurnEnd(ctx: Context, sessionId: ReturnType<typeof SessionId>, firstSeq: number): TurnWatcher;
+/**
+ * One session, sequential turns: create the agent once, send each message via
+ * followup, wait each turn/end, collect text + usage. Timeout or a failed
+ * turn aborts the session (listener detached first — B4). Every path —
+ * including exceptions — releases the agent session (try/finally, Kimi review).
+ */
+export declare function executeTurns(ctx: Context, task: Task, nextMessage: NextMessage, timeoutMs: number, reasoning?: ReasoningEffort, 
+/** Historical session id to RESUME — the agent continues that conversation
+ *  (full context). A failed resume falls back to a fresh session so the
+ *  task still runs. */
+resumeSessionId?: string): Promise<SessionResult>;
+/** The task prompt + file context (attachment paths) + user strategy hint.
+ *  Continuation context comes from RESUMING a dsh conversation at execution
+ *  time (executeTurns resumeSessionId), not from string injection. */
+export declare function buildPrompt(task: Task): string;
+export declare function sumUsage(a: UsageLike, b: UsageLike): UsageLike;
+export declare function sumTurns(turns: TurnResult[]): UsageLike;
+/** Cheap convergence check: bigram-Jaccard similarity above the threshold. */
+export declare function isConverged(a: TurnResult, b: TurnResult): boolean;

package/package.json

@@ -0,0 +1,105 @@
+{
+  "name": "dsh-lowtide",
+  "version": "0.1.2",
+  "description": "lowtide: human-adjudicated off-peak batch task pipeline for dsh (peak/valley pricing aware)",
+  "type": "module",
+  "main": "lib/index.js",
+  "types": "lib/types/src/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./lib/types/src/index.d.ts",
+      "default": "./lib/index.js"
+    },
+    "./client": {
+      "types": "./lib/types/client/index.d.ts",
+      "default": "./lib/client.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "dsh": {
+    "bundle": {
+      "patch": "./cordis.patch.yml"
+    },
+    "client": {
+      "inject": [
+        "@deepseek-ai/dsh-client-locale",
+        "@deepseek-ai/dsh-client-runtime",
+        "@deepseek-ai/dsh-client-ui-conversation",
+        "@deepseek-ai/dsh-client-ui-primitives",
+        "@deepseek-ai/dsh-client-ui-settings",
+        "@deepseek-ai/dsh-client-ui-slots",
+        "@deepseek-ai/dsh-client-connection"
+      ],
+      "platform": "web"
+    }
+  },
+  "files": [
+    "lib/index.js",
+    "lib/client.js",
+    "lib/client.js.map",
+    "lib/types/**/*.d.ts",
+    "cordis.patch.yml"
+  ],
+  "scripts": {
+    "bundle": "tsdown && tsc -p tsconfig.build.json",
+    "watch": "tsdown --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "dev": "npx @deepseek-ai/dsh@0.1.0-rc.7 web --patch ./cordis.dev.yml"
+  },
+  "license": "MIT",
+  "keywords": [
+    "dsh-plugin",
+    "deepseek-harness",
+    "deepseek",
+    "off-peak",
+    "batch-tasks",
+    "pricing",
+    "scheduler",
+    "productivity"
+  ],
+  "author": "dsh-lowtide contributors",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/KelaoHu/dsh-lowtide",
+    "directory": "packages/dsh"
+  },
+  "peerDependencies": {
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-storage-domain": "^0.1.0-rc.7"
+  },
+  "devDependencies": {
+    "@deepseek-ai/cordis": "^4.0.1",
+    "@deepseek-ai/dsh-agent": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-agent-default-model": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-agent-presets": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-connection": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-locale": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-runtime": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-conversation": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-layout": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-primitives": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-settings": "0.1.0-rc.7",
+    "@deepseek-ai/dsh-client-ui-slots": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-host-apiproxy": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-host-webserver": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-llm": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-permission-presets": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-session": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-settings": "^0.1.0-rc.7",
+    "@deepseek-ai/dsh-storage-domain": "^0.1.0-rc.7",
+    "@playwright/test": "^1.62.1",
+    "@types/node": "^22.20.0",
+    "@types/react": "~18.3.1",
+    "lightningcss": "^1.32.0",
+    "lowtide-core": "workspace:*",
+    "react": "^18.2.0",
+    "tsdown": "^0.22.2",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.8",
+    "zod": "^4.4.3"
+  }
+}