@sqdr2/dsh-fusion 0.0.0-stage → 0.3.2

package/lib/types/host/cache-defaults.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Default prompt-cache behaviour for the models most people pair in Fusion, from each provider's official
+ * documentation. Matching uses the model id (stable across DSH setups), never the route name, except for the
+ * routes of this project's own OAuth plugins, whose billing we know. Everything here is a default: the user's
+ * per-model setting always wins, and the runtime can shorten an interval it observes to be too long.
+ */
+export declare const CACHE_DEFAULTS_CHECKED = "2026-09-27";
+/** Safe for every provider documented here (the shortest documented lifetime is 5 minutes). */
+export declare const GENERIC_INTERVAL_SECONDS = 285;
+export type CacheMode = 'auto' | 'on' | 'off';
+export interface CacheFamily {
+    id: string;
+    label: string;
+    match: RegExp;
+    /** Official lifetime text as documented (not a guarantee; caches are best-effort). */
+    lifetime: {
+        zh: string;
+        en: string;
+    };
+    /** Cached input price relative to uncached input, as documented. */
+    discount: string;
+    keepalive: CacheMode;
+    intervalSeconds: number;
+    docs: string;
+}
+export declare const CACHE_FAMILIES: readonly CacheFamily[];
+/** Routes of this project's OAuth plugins (dsh-oauth-login, dsh-antigravity-oauth): billing we know. */
+export interface RouteBilling {
+    match: RegExp;
+    label: string;
+    keepalive: CacheMode;
+    reason: {
+        zh: string;
+        en: string;
+    };
+    /** Interval measured on this route; overrides the model family default. */
+    intervalSeconds?: number;
+}
+export declare const OWN_ROUTES: readonly RouteBilling[];
+export interface CacheDefaults {
+    keepalive: CacheMode;
+    intervalSeconds: number;
+    source: 'route' | 'family' | 'generic';
+    family?: CacheFamily;
+    route?: RouteBilling;
+}
+/** Defaults for one physical route; the model id selects the family, our own routes set the billing mode. */
+export declare function cacheDefaults(provider: string, model: string): CacheDefaults;

package/lib/types/host/cache-policy.d.ts

@@ -0,0 +1,155 @@
+import type { Role } from '../contracts.js';
+import type { SqliteFusionStore } from '../task/sqlite-store.js';
+import { type CacheDefaults, type CacheMode } from './cache-defaults.js';
+/** The user's choice for one physical model route; absent fields fall back to learned/default values. */
+export interface ModelCacheSetting {
+    mode?: CacheMode;
+    intervalSeconds?: number;
+}
+/** One model request that followed a wait: the evidence the policy learns from and the settings page shows. */
+export interface CacheSample {
+    at: string;
+    gapSeconds: number;
+    ping: boolean;
+    hit: boolean;
+    cacheRead: number;
+    input: number;
+    output?: number;
+}
+export interface ModelCacheStats {
+    schemaVersion: 1;
+    provider: string;
+    model: string;
+    samples: CacheSample[];
+    totals: {
+        /** Real requests after a wait of at least WAIT_SECONDS, and how many still found their prefix cached. */
+        waits: number;
+        waitHits: number;
+        /** Keepalive pings and the tokens they read (mostly at the cache price). */
+        pings: number;
+        pingHits: number;
+        pingTokens: number;
+        /** Output tokens of pings; absent on stats recorded before 0.2.3. A route that ignores the output cap shows here. */
+        pingOutputTokens?: number;
+        /** Prefix tokens served from cache after a wait, and tokens resent uncached after a wait. */
+        keptWarmTokens: number;
+        resentTokens: number;
+    };
+    /** Interval shortened after pings kept missing (never lengthened automatically). */
+    learnedIntervalSeconds?: number;
+    /** Rule that produced learnedIntervalSeconds; values from older rules are ignored. */
+    learnedRule?: number;
+    updatedAt: string;
+}
+export interface EffectiveCachePolicy {
+    mode: CacheMode;
+    intervalSeconds: number;
+    modeSource: 'user' | 'pair' | 'role' | CacheDefaults['source'];
+    intervalSource: 'user' | 'learned' | CacheDefaults['source'];
+    defaults: CacheDefaults;
+}
+/** A request counts as a wait when this long passed since the previous request of the same agent. */
+export declare const WAIT_SECONDS = 120;
+/**
+ * Rule 2 (0.2.3): shorten only when most recent pings at this interval missed (3 of the last up to 5).
+ * Rule 1 shortened on 2 misses, and providers also drop single prefixes at random: the live log had
+ * 4 partial misses in 123 pings, each keeping only the shared 3,968-token system+tools head, while
+ * a probe of the same route still hit after 10+ idle minutes. That noise cut a 285 s interval to 214 s.
+ */
+export declare const LEARNING_RULE = 2;
+/** A request reused its prefix when most of its input came from the cache. */
+export declare const cacheHit: (cacheRead: number, input: number) => boolean;
+export declare const clampInterval: (seconds: number) => number;
+export declare class CachePolicy {
+    readonly store: SqliteFusionStore;
+    constructor(store: SqliteFusionStore);
+    setting(provider: string, model: string): ModelCacheSetting | undefined;
+    /** Save or clear (null) the user's choice; invalid values are refused, not coerced. */
+    save(provider: string, model: string, setting: ModelCacheSetting | null): void;
+    stats(provider: string, model: string): ModelCacheStats | undefined;
+    /**
+     * Record a request that followed a wait (or any keepalive ping). Pings that keep missing at the current
+     * interval shorten it by a quarter: a too-long interval wastes every ping, a too-short one only costs extra
+     * cheap reads, so the rule only ever moves toward safety. Lengthening is left to the user (see suggestion).
+     */
+    observe(provider: string, model: string, sample: Omit<CacheSample, 'at'>, currentIntervalSeconds: number): void;
+    /**
+     * User setting > pair profile (older explicit choice) > learned interval > our own route's billing default >
+     * model family default > generic. The Worker defaults to off: it rarely waits long enough to need pings.
+     */
+    resolve(provider: string, model: string, role: Role, pairChoice?: boolean | 'auto'): EffectiveCachePolicy;
+    /** Suggest a longer interval only on repeated evidence: real waits that still hit well beyond the interval. */
+    suggestion(provider: string, model: string, intervalSeconds: number): number | undefined;
+    /** Every route the plugin has evidence or a setting for, plus the given routes (the configured pair). */
+    routes(extra?: readonly {
+        provider: string;
+        model: string;
+    }[]): {
+        provider: string;
+        model: string;
+    }[];
+}
+type Route = {
+    provider: string;
+    model: string;
+};
+/** One row of the settings page: what applies, why, what the defaults say, and what was observed. */
+export declare function cacheView(policy: CachePolicy, pair?: {
+    lead: Route;
+    worker: Route;
+}, pairChoice?: {
+    lead?: boolean | 'auto';
+    worker?: boolean | 'auto';
+}): {
+    provider: string;
+    model: string;
+    role: Role | undefined;
+    mode: CacheMode;
+    intervalSeconds: number;
+    modeSource: "user" | "role" | "route" | "family" | "generic" | "pair";
+    intervalSource: "user" | "route" | "family" | "generic" | "learned";
+    setting: ModelCacheSetting;
+    defaults: {
+        route?: {
+            label: string;
+            reason: {
+                zh: string;
+                en: string;
+            };
+        } | undefined;
+        family?: {
+            label: string;
+            lifetime: {
+                zh: string;
+                en: string;
+            };
+            discount: string;
+            docs: string;
+        } | undefined;
+        mode: CacheMode;
+        intervalSeconds: number;
+        source: "route" | "family" | "generic";
+    };
+    totals: {
+        /** Real requests after a wait of at least WAIT_SECONDS, and how many still found their prefix cached. */
+        waits: number;
+        waitHits: number;
+        /** Keepalive pings and the tokens they read (mostly at the cache price). */
+        pings: number;
+        pingHits: number;
+        pingTokens: number;
+        /** Output tokens of pings; absent on stats recorded before 0.2.3. A route that ignores the output cap shows here. */
+        pingOutputTokens?: number;
+        /** Prefix tokens served from cache after a wait, and tokens resent uncached after a wait. */
+        keptWarmTokens: number;
+        resentTokens: number;
+    } | null;
+    learnedIntervalSeconds: number | null;
+    suggestion: number | null;
+    recent: {
+        gapSeconds: number;
+        ping: boolean;
+        hit: boolean;
+    }[];
+}[];
+export {};

package/lib/types/host/change-evidence.d.ts

@@ -0,0 +1,38 @@
+import type { ArtifactRef, SnapshotId, TaskId } from '../contracts.js';
+import type { SqliteFusionStore } from '../task/sqlite-store.js';
+import type { WorkspaceEntry, WorkspaceSnapshot } from './workspace.js';
+export interface ChangeBase {
+    schemaVersion: 1;
+    snapshot: SnapshotId;
+    contents: Record<string, ArtifactRef>;
+    /**
+     * Paths the Lead widened the scope to only after they had already changed, so their
+     * delegation-time bytes are gone. Diffs carry no pre-image for them and the
+     * rewritten-test gate cannot compare original lines; the review must say so instead of
+     * pretending the file was untouched (`session-daa71a4a`: refusing to record them at all
+     * left the task with no admissible report and no admissible widening).
+     */
+    unavailable?: readonly string[];
+}
+export declare function captureChangeBase(store: SqliteFusionStore, taskId: TaskId, base: WorkspaceSnapshot, allowed: readonly string[]): ChangeBase;
+/**
+ * The same base bytes, for paths the Lead adds to the frozen scope after a report. A file the
+ * Worker (or the task's own build command) already changed no longer matches the snapshot, so
+ * its delegation-time bytes cannot be recorded: that path is reported as unavailable instead of
+ * failing, which would leave the task with no admissible report and no admissible widening.
+ */
+export declare function captureLaterChangeBase(store: SqliteFusionStore, taskId: TaskId, base: WorkspaceSnapshot, allowed: readonly string[]): ChangeBase;
+export interface ChangeDiff {
+    path: string;
+    status: 'text' | 'binary' | 'type-change' | 'unavailable-base';
+    before?: {
+        entry: WorkspaceEntry;
+        content?: ArtifactRef;
+    };
+    after?: {
+        entry: WorkspaceEntry;
+        content: ArtifactRef;
+    };
+    patch?: ArtifactRef;
+}
+export declare function saveChangeManifest(store: SqliteFusionStore, taskId: TaskId, base: WorkspaceSnapshot, candidate: WorkspaceSnapshot, captured?: ChangeBase): ArtifactRef;

package/lib/types/host/compaction-routing.d.ts

@@ -0,0 +1,15 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { PhysicalRoute, Role } from '../contracts.js';
+import type { SessionBinding } from './bindings.js';
+interface Owner {
+    binding: SessionBinding;
+    role: Role;
+}
+/** Publish exact session routes before another plugin estimates or chunks input. */
+export declare function installCompactionRouting(ctx: Context, input: {
+    owner(agent: Agent): Owner | undefined;
+    route(binding: SessionBinding, role: Role): PhysicalRoute;
+    epoch(binding: SessionBinding): number;
+}): () => void;
+export {};

package/lib/types/host/coordinator.d.ts

@@ -0,0 +1,169 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { GenerateOptions } from '@deepseek-ai/dsh-llm';
+import type { ToolExecution, ToolRunContext } from '@deepseek-ai/dsh-tools';
+import type { FusionEvent, Role, TaskId } from '../contracts.js';
+import { WorkspaceWriteLease } from '../execution/write-lease.js';
+import type { ResolvedProfile } from '../profile/resolve.js';
+import type { SqliteFusionStore } from '../task/sqlite-store.js';
+import type { TaskState } from '../task/state.js';
+import type { DeletionBlocker } from '../task/deletion.js';
+import { BindingRepository } from './bindings.js';
+import type { SessionBinding } from './bindings.js';
+import type { CheckDefinition } from './native-checks.js';
+import { NativeFusionScopes } from './native-scopes.js';
+import { NativeModelControl } from './native-model-control.js';
+import { NativeWorkflow } from './native-workflow.js';
+import { NativeRoleSandbox } from './native-role-sandbox.js';
+import { NativeOnDemandContext } from './native-on-demand-context.js';
+import { NativeTaskContext } from './native-task-context.js';
+import { NativeApprovals } from './native-approvals.js';
+import { NativeEffects } from './native-effects.js';
+import { NativeCacheKeepalive } from './native-keepalive.js';
+import type { KeepaliveClock } from './native-keepalive.js';
+import { NativeWorkerTransport } from './native-worker.js';
+import { NativeFusionActivity } from './native-activity.js';
+import { CachePolicy } from './cache-policy.js';
+import type { ChangeBase } from './change-evidence.js';
+export interface CoordinatorOptions {
+    profile: ResolvedProfile;
+    workerTools: readonly string[];
+    /** Must validate existing authorization and durably reserve this actual request. */
+    authorizeRequest(agent: Agent, binding: SessionBinding, role: Role, turn: number, step: number): void;
+    /** Actual native stream admission, including auxiliary compaction calls. */
+    resumeAuthorization?(binding: SessionBinding): string;
+    reserveRequest?(request: GenerateOptions, binding: SessionBinding, role: Role): void;
+    leaseRoot?: string;
+    maxWorkerSteps?: number;
+    maxReworkRounds?: number;
+    commandMaxSeconds?: number;
+    /** Test clock only; production retains the recovered fixed schedule. */
+    keepaliveClock?: KeepaliveClock;
+}
+/** At least a sentence that is not a stock stub. */
+export declare function substantiveReview(reason: string): boolean;
+type LooseCheck = {
+    command: string;
+    id?: string;
+    description?: string;
+    parser?: CheckDefinition['parser'];
+    kind?: CheckDefinition['kind'];
+    timeoutSeconds?: number;
+    definitionPaths?: readonly string[];
+    baseline?: CheckDefinition['baseline'];
+};
+/** Fill the defaults a Lead may omit; an explicit test kind without a parser still fails in freezeChecks. */
+export declare function normalizeChecks(raw: readonly LooseCheck[]): CheckDefinition[];
+/** Consecutive read-only calls allowed before a model must act; the Lead delegates broad reading. */
+export declare const READ_STREAK: Record<Role, number>;
+/** A few lines stay natural for the Lead; anything larger goes to the Sidekick. */
+export declare const LEAD_DIRECT_WRITE: {
+    readonly perCall: 30;
+    readonly perTask: 80;
+};
+/** Lines a Lead tool call would write; 0 for reads and ordinary commands. */
+export declare function directWriteLines(exec: Readonly<ToolExecution>): number;
+/**
+ * The Worker is the cheap model: a real task needs room to explore, run and fix.
+ * Stopping it early pushes work back to the expensive Lead or the user.
+ */
+export declare const DEFAULT_POLICY: {
+    readonly maxWorkerSteps: 150;
+    readonly maxReworkRounds: 3;
+    readonly commandMaxSeconds: 600;
+};
+interface DelegateInput {
+    goal: string;
+    brief: string;
+    constraints: string[];
+    allowedPaths: string[];
+    checks: CheckDefinition[];
+    block?: boolean;
+    /** Verbatim quotes of the user's hard requirements; frozen as user-provenance constraints. */
+    requirements?: string[];
+}
+/** Whitespace-insensitive, otherwise exact: a requirement must be the user's own words. */
+export declare const normalizeQuote: (text: string) => string;
+/** Literal code spans (`like this`) a requirement asks for; a candidate that omits them gets flagged. */
+export declare const literalSpans: (text: string) => string[];
+export interface RewrittenTest {
+    path: string;
+    /** Original lines no longer present in the file. */
+    removedLines?: number;
+    deleted?: boolean;
+    /** Widened into scope after the change: no original bytes exist to compare against. */
+    unavailableBase?: boolean;
+}
+/**
+ * Existing test files whose original lines were removed or changed (pure additions are not listed). A Worker
+ * that rewrites an old test to fit its change hides a regression the maintainers' test would catch
+ * (round 4, canvasapi): the Lead must look at these before accepting.
+ */
+export declare function rewrittenTests(store: SqliteFusionStore, taskId: TaskId, root: string, changeBase: ChangeBase | undefined, changes: readonly string[]): RewrittenTest[];
+/** Rework rounds after which a still-failing work order unlocks Lead takeover (enforced-v3). */
+export declare const ESCALATE_AFTER_REWORKS = 2;
+/** Lead takeover submissions allowed per escalated work order. */
+export declare const MAX_LEAD_SUBMISSIONS = 3;
+/** Native AgentLoop owns work; optional auxiliary calls use the public LLM service. */
+export declare class FusionCoordinator {
+    #private;
+    readonly ctx: Context;
+    readonly store: SqliteFusionStore;
+    readonly options: CoordinatorOptions;
+    readonly bindings: BindingRepository;
+    readonly scopes: NativeFusionScopes;
+    readonly transport: NativeWorkerTransport;
+    readonly activity: NativeFusionActivity;
+    readonly leases: WorkspaceWriteLease;
+    readonly taskContext: NativeTaskContext;
+    readonly onDemand: NativeOnDemandContext;
+    readonly approvals: NativeApprovals;
+    readonly effects: NativeEffects;
+    readonly keepalive: NativeCacheKeepalive;
+    /** Per-model cache keepalive settings, evidence and defaults (shared with the settings API). */
+    readonly cachePolicy: CachePolicy;
+    readonly modelControl: NativeModelControl;
+    readonly workflow: NativeWorkflow;
+    readonly roleSandbox: NativeRoleSandbox;
+    constructor(ctx: Context, store: SqliteFusionStore, options: CoordinatorOptions);
+    state(id: TaskId): TaskState;
+    /**
+     * Why a task still owns live work in this Host process, or `undefined` when it
+     * owns none. This answers the deletion question that persisted state cannot:
+     * `control.mode` and `phase` only ever record what a running process last
+     * appended, so a task whose process was replaced keeps `mode: 'running'`
+     * forever. The registries below are the truth about what runs *now*.
+     *
+     * Read-only and side-effect free: it may be called from the delete route.
+     */
+    liveWork(id: TaskId): DeletionBlocker | undefined;
+    append<T extends FusionEvent['type']>(id: TaskId, type: T, payload: Extract<FusionEvent, {
+        type: T;
+    }>['payload']): TaskState;
+    owner(agent: Agent): {
+        binding: SessionBinding;
+        role: Role;
+    } | undefined;
+    select(agent: Agent, resolved?: ResolvedProfile): Promise<void>;
+    /** Only at idle selection or native running reservation, before prompt assembly. */
+    selectBeforeAssembly(agent: Agent, resolved: ResolvedProfile): void;
+    clear(agent: Agent): Promise<void>;
+    wait(agent: Agent, exec: ToolRunContext): Promise<string>;
+    delegate(agent: Agent, args: DelegateInput, exec: ToolRunContext, mode?: 'explore' | 'implement' | 'text'): Promise<string>;
+    rework(agent: Agent, feedback: string, exec: ToolRunContext, block?: boolean, checks?: readonly CheckDefinition[], addAllowedPaths?: readonly string[]): Promise<string>;
+    review(agent: Agent, decision: 'accept' | 'rework' | 'needs-decision', reason: string, exec: ToolRunContext, verdicts?: readonly {
+        index: number;
+        met: boolean;
+        evidence: string;
+    }[]): string;
+    pause(agent: Agent): Promise<void>;
+    resume(agent: Agent, authorizationId: string): Promise<void>;
+    /** Human command only. Never exposed as an LLM tool or triggered by a dead PID alone. */
+    reconcile(agent: Agent, inspection: {
+        commandId: string;
+        note: string;
+        effectsStopped?: boolean;
+    }): Promise<void>;
+    close(): Promise<void>;
+}
+export {};

package/lib/types/host/evidence-page.d.ts

@@ -0,0 +1,13 @@
+/** Lossless text decoding; binary artifacts stay available as explicit base64. */
+export declare function evidenceText(bytes: Uint8Array): string | undefined;
+/** Offsets count UTF-16 code units of text, or characters of base64. */
+export declare function evidencePage(bytes: Uint8Array, offset?: number, limit?: number): {
+    bytes: number;
+    encoding: string;
+    offsetUnit: string;
+    offset: number;
+    totalCharacters: number;
+    text: string;
+    truncated: boolean;
+    nextOffset: number | null;
+};

package/lib/types/host/history.d.ts

@@ -0,0 +1,88 @@
+import type { SqliteFusionStore } from '../task/sqlite-store.js';
+import type { TaskState } from '../task/state.js';
+import type { NativeUsageRecord } from './native-usage.js';
+import { type Count } from '../usage/ledger.js';
+export interface TaskSummary {
+    id: string;
+    sessionId: string;
+    seq: number;
+    createdAt: string;
+    updatedAt: string;
+    title: string;
+    phase: string;
+    verification: string;
+    mode: string;
+}
+export declare function taskSummary(state: TaskState, createdAt: string, updatedAt: string): TaskSummary;
+export interface UsageSummary {
+    id: string;
+    taskId: string;
+    role: string;
+    provider: string;
+    model: string;
+    purpose: string;
+    startedAt: string;
+    outcome: string;
+    authority: 'none' | 'provisional' | 'final';
+    input: Count;
+    output: Count;
+    reasoning: Count;
+    totalOutput: Count;
+    cacheRead: Count;
+}
+export declare function usageSummary(row: NativeUsageRecord): UsageSummary;
+/** Once at plugin startup; GET never writes, starts agents, or scans full task/usage snapshots. */
+export declare function backfillHistory(store: SqliteFusionStore): void;
+export interface HistoryTotals {
+    calls: number;
+    final: number;
+    provisional: number;
+    unreported: number;
+    input: {
+        known: number;
+        reported: number;
+    };
+    output: {
+        known: number;
+        reported: number;
+    };
+    reasoning: {
+        known: number;
+        reported: number;
+    };
+    totalOutput: {
+        known: number;
+        reported: number;
+    };
+    cacheRead: {
+        known: number;
+        reported: number;
+    };
+}
+/** How often the Host unlocked Lead takeover (enforced-v3), by reason. */
+export interface TakeoverTotals {
+    total: number;
+    tasks: number;
+    reasons: Record<string, number>;
+}
+export interface HistoryView {
+    observedAt: string;
+    totalTasks: number;
+    tasks: (TaskSummary & {
+        usage: HistoryTotals;
+        takeovers: number;
+    })[];
+    nextCursor: string | null;
+    takeovers: TakeoverTotals;
+    totals: HistoryTotals;
+    groups: ({
+        role: string;
+        provider: string;
+        model: string;
+        purpose: string;
+    } & HistoryTotals)[];
+    actualBilledUsd: null;
+    savingsPercent: null;
+    upstreamHttpCalls: null;
+}
+export declare function readHistory(store: SqliteFusionStore, cursor?: string, limit?: number): HistoryView;

package/lib/types/host/http.d.ts

@@ -0,0 +1,4 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+export declare function trustedRequest(req: IncomingMessage): boolean;
+export declare function json(res: ServerResponse, status: number, body: unknown): void;
+export declare function readJson(req: IncomingMessage): Promise<Record<string, unknown>>;

package/lib/types/host/model-output.d.ts

@@ -0,0 +1,13 @@
+import type { Context } from '@deepseek-ai/cordis';
+/**
+ * Output limits come only from the public model metadata DSH discloses for the route (context window and
+ * the adapter's default max tokens). No route or model names are special-cased: route names differ between
+ * installations, and a guessed cap would be wrong for someone else's setup.
+ */
+export interface ModelOutputLimits {
+    contextWindow: number;
+    defaultMaxTokens?: number;
+    testedOutputCap?: number;
+}
+/** Public model metadata only; resolving limits does not start a model turn. */
+export declare function resolveModelOutputLimits(ctx: Context, provider: string, model: string): Promise<ModelOutputLimits>;

package/lib/types/host/native-activity.d.ts

@@ -0,0 +1,26 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Session } from '@deepseek-ai/dsh-session';
+import type { FusionActivityPage } from '../activity.js';
+import type { SqliteFusionStore } from '../task/sqlite-store.js';
+/** Paginated read-only data for a plugin-owned tool view; no runtime activation. */
+export declare function readFusionActivity(store: SqliteFusionStore, parentId: string, callId: string, after?: number): FusionActivityPage;
+/** Old conversations remain readable through the public, non-activating history
+ * API. Correlate accepted message ids, never timing guesses or model narration.
+ * This fallback neither rewrites the old log nor creates a replacement Worker.
+ */
+export declare function readHistoricalFusionActivity(ctx: Context, store: SqliteFusionStore, parentId: string, callId: string, after?: number): Promise<FusionActivityPage>;
+/** Copies actual Worker tool events into plugin-owned presentation storage only.
+ * Model history still contains solely the Lead's native messages and reports.
+ * Stored source coordinates make replay/HMR idempotent without executing tools.
+ */
+export declare class NativeFusionActivity {
+    #private;
+    readonly ctx: Context;
+    readonly store: SqliteFusionStore;
+    readonly errors: Map<string, string>;
+    constructor(ctx: Context, store: SqliteFusionStore);
+    /** Called before each native delivery. No inference, dispatch or approval. */
+    link(parent: Session, childId: string, taskId: string, callId: string): void;
+    flush(): Promise<void>;
+    close(): Promise<void>;
+}

package/lib/types/host/native-approvals.d.ts

@@ -0,0 +1,29 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { LogicalApproval, Role, TaskId } from '../contracts.js';
+import type { SqliteFusionStore } from '../task/sqlite-store.js';
+import type { TaskState } from '../task/state.js';
+import type { SessionBinding } from './bindings.js';
+type Owner = {
+    binding: SessionBinding;
+    role: Role;
+};
+interface Callbacks {
+    owner(agent: Agent): Owner | undefined;
+    state(id: TaskId): TaskState;
+    pending(id: TaskId, approval: LogicalApproval): void;
+    answered(id: TaskId, approvalId: string, state: 'approved' | 'rejected' | 'withdrawn'): void;
+    failed(agent: Agent, error: unknown): void;
+}
+/** Observe native decisions; never answer on the user's behalf or replay a grant. */
+export declare class NativeApprovals {
+    #private;
+    readonly ctx: Context;
+    readonly store: SqliteFusionStore;
+    readonly callbacks: Callbacks;
+    constructor(ctx: Context, store: SqliteFusionStore, callbacks: Callbacks);
+    install(): () => void;
+    /** Caller must first stop/release both native Agents and inspect uncertain effects. */
+    reconcile(taskId: TaskId, evidence: string): void;
+}
+export {};

package/lib/types/host/native-auxiliary.d.ts

@@ -0,0 +1,17 @@
+import type { GenerateOptions } from '@deepseek-ai/dsh-llm';
+import type { Digest, Role, TaskId } from '../contracts.js';
+export interface AuxiliaryRequest {
+    purpose: 'cache-keepalive';
+    taskId: TaskId;
+    sessionId: string;
+    profileDigest: Digest;
+    role: Role;
+    seriesId: string;
+    iteration: number;
+}
+/** Plugin-local identity: do not widen or misuse the Host's purpose enum. */
+export declare class NativeAuxiliaryRequests {
+    #private;
+    tag(request: GenerateOptions, metadata: AuxiliaryRequest): void;
+    get(request: GenerateOptions): Readonly<AuxiliaryRequest> | undefined;
+}

package/lib/types/host/native-budget.d.ts

@@ -0,0 +1,33 @@
+import type { Context } from '@deepseek-ai/cordis';
+import type { Agent } from '@deepseek-ai/dsh-agent';
+import type { PhysicalRoute, Role } from '../contracts.js';
+import type { SqliteFusionStore } from '../task/sqlite-store.js';
+import type { SessionBinding } from './bindings.js';
+/** Explicit bounded authorization when the native provider exposes no reliable money meter. */
+export interface NativeSpendingAuthorization {
+    schemaVersion: 1;
+    kind: 'native-fusion-requests';
+    approved: true;
+    authorizationId: string;
+    approvedBy: string;
+    expiresAt: string;
+    routes: readonly PhysicalRoute[];
+    maxNativeRequests: number;
+    maxReservedOutputTokens: number;
+    /** This cannot be represented as a hard dollar cap. */
+    costPolicy: 'unknown-cost-acknowledged';
+}
+export declare function nativeAuthorization(raw: unknown): NativeSpendingAuthorization;
+/** Called only by explicit human settings actions (save or limits), never by a model tool. */
+export declare function authorizeConfiguredPair(store: SqliteFusionStore, routes: readonly PhysicalRoute[], limits: unknown): NativeSpendingAuthorization;
+export declare class NativeRequestBudget {
+    readonly store: SqliteFusionStore;
+    readonly authorizationFile?: string | undefined;
+    constructor(store: SqliteFusionStore, authorizationFile?: string | undefined);
+    check(routes: readonly PhysicalRoute[]): NativeSpendingAuthorization;
+    install(ctx: Context, owner: (agent: Agent) => {
+        binding: SessionBinding;
+        role: Role;
+    } | undefined, onBlocked?: (binding: SessionBinding, error: unknown) => void): () => void;
+    reserve(route: PhysicalRoute, maxOutputTokens: number): void;
+}