dsh-mnemon 0.1.6 → 0.2.0

package/lib/types/service.d.ts

@@ -2,24 +2,50 @@ import type { JsonValue } from './contracts.ts';
 import type { ResolvedConfig } from './config.ts';
 import { MemoryBodyRegistry, type CreateMemoryBodyRequest, type MemoryBody, type UpdateMemoryBodyRequest } from './memory-bodies.ts';
 import type { MnemonRunner } from './runner.ts';
-import { type EdgeType, type EntityView, type Insight, type MemoryBodyCatalog, type MemoryGraphSnapshot, type MemoryListRequest, type MemoryListView, type RememberRequest, type SearchRequest, type StatusView } from './shared/contracts.ts';
+import { type LlmMemoryPlacementSelection, type PreparedMemoryPlacement } from './provider-placement.ts';
+import { type EdgeType, type EntityView, type Insight, type MemoryBodyCatalog, type MemoryBodyMetadataUpdate, type MemoryBodyView, type MemoryGraphSnapshot, type MemoryListRequest, type MemoryListView, type MemoryPlacementDecision, type MemoryReadSource, type RememberRequest, type SearchRequest, type StatusView } from './shared/contracts.ts';
 export { CATEGORIES, EDGE_TYPES, INTENTS, SOURCES } from './shared/contracts.ts';
-export type { Category, EdgeType, EntityView, Insight, Intent, MemoryBodyCatalog, MemoryBodyStats, MemoryBodyView, MemoryGraphEdge, MemoryGraphNode, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, RememberRequest, SearchRequest, Source, StatusView, } from './shared/contracts.ts';
+export type { Category, EdgeType, EntityView, Insight, Intent, MemoryBodyCatalog, MemoryBodyStats, MemoryBodyView, MemoryGraphEdge, MemoryGraphNode, MemoryGraphSnapshot, MemoryListRequest, MemoryListView, MemoryReadSource, RememberRequest, SearchRequest, Source, StatusView, } from './shared/contracts.ts';
+export interface MemoryBodyMetadataSample {
+    memoryBodyId: string;
+    name: string;
+    description: string;
+    providerId: MemoryBody['provider']['id'];
+    providerLabel: string;
+    method: 'native-basic' | 'browse' | 'search';
+    evidence: Array<Pick<Insight, 'content' | 'category' | 'entities'>>;
+}
 /** Parse the official Mnemon vis.js export without executing its HTML or loading its CDN script. */
 export declare function parseMemoryGraph(html: string, now?: Date): MemoryGraphSnapshot;
 export declare class MnemonService {
     readonly runner: MnemonRunner;
     readonly config: ResolvedConfig;
     readonly memoryBodies: MemoryBodyRegistry;
+    private readonly providers;
+    private bodiesInFlight;
     constructor(runner: MnemonRunner, config: ResolvedConfig, memoryBodies?: MemoryBodyRegistry);
     bodies(signal?: AbortSignal): Promise<MemoryBodyCatalog>;
+    /** Coalesce simultaneous Status/Memory-page probes without caching mutations. */
+    private collectBodies;
+    /** Return the control-plane directory without waiting for provider I/O. */
+    bodyDirectory(): MemoryBodyCatalog;
+    /** Return a usable system snapshot without waiting for any Provider I/O. */
+    statusSummary(): StatusView;
     status(signal?: AbortSignal): Promise<StatusView>;
+    reconnectBody(id: string, signal?: AbortSignal): Promise<MemoryBodyView>;
     search(request: SearchRequest, signal?: AbortSignal): Promise<{
         query: string;
         mode: string;
         results: Insight[];
         hint?: string;
+        sources: MemoryReadSource[];
     }>;
+    /**
+     * Read a deliberately small metadata sample through the cheapest useful path
+     * exposed by the owning Provider. This avoids federated ranking, graph
+     * expansion, and large browse projections before an LLM metadata pass.
+     */
+    metadataSample(memoryBodyId: string, signal?: AbortSignal): Promise<MemoryBodyMetadataSample>;
     graph(signal?: AbortSignal, memoryBodyIds?: string[]): Promise<MemoryGraphSnapshot>;
     list(request?: MemoryListRequest, signal?: AbortSignal): Promise<MemoryListView>;
     entities(entity?: string, limit?: number, signal?: AbortSignal): Promise<EntityView>;
@@ -27,14 +53,36 @@ export declare class MnemonService {
     related(id: string, depth?: number, edge?: EdgeType, signal?: AbortSignal, memoryBodyId?: string): Promise<Insight[]>;
     link(sourceId: string, targetId: string, type?: EdgeType, weight?: number, reason?: string, signal?: AbortSignal, memoryBodyId?: string): Promise<JsonValue>;
     forget(id: string, signal?: AbortSignal, memoryBodyId?: string): Promise<JsonValue>;
-    createBody(request: CreateMemoryBodyRequest, signal?: AbortSignal): Promise<MemoryBody>;
+    prepareBodyPlacement(request: CreateMemoryBodyRequest): PreparedMemoryPlacement;
+    createBody(request: CreateMemoryBodyRequest, signal?: AbortSignal, placement?: MemoryPlacementDecision): Promise<MemoryBody>;
+    /**
+     * Create a Memory Space from the configured distillation policy. The model
+     * may choose only among candidates already filtered by the host; manual mode
+     * ignores model preference and always uses the configured fixed provider.
+     */
+    createBodyForPersistence(body: {
+        name: string;
+        description: string;
+    }, selection: LlmMemoryPlacementSelection | undefined, signal?: AbortSignal, delegation?: {
+        runId: string;
+        provider: string;
+    }): Promise<MemoryBody>;
+    updateProviderService(providerId: MemoryBody['provider']['id'], settings: Record<string, string | number | boolean>, clearSecrets?: readonly string[], enabled?: boolean, signal?: AbortSignal): Promise<import("./shared/contracts.ts").MemoryProviderServiceView>;
     updateBody(id: string, request: UpdateMemoryBodyRequest): MemoryBody;
+    updateBodyMetadata(updates: readonly MemoryBodyMetadataUpdate[]): MemoryBody[];
     deleteBody(id: string, signal?: AbortSignal): Promise<MemoryBody>;
     mergeBodies(targetBodyId: string, sourceBodyIds: string[], deactivateSources?: boolean, signal?: AbortSignal): Promise<JsonValue>;
-    private bodyStatus;
+    private nativeBodyStatus;
     private parseStats;
-    private graphForBody;
-    private allInsights;
+    private nativeGraph;
+    private allNativeInsights;
+    private nativeMetadataSample;
+    private nativeSearch;
+    private nativeRemember;
+    private nativeRelated;
+    private nativeLink;
+    private nativeForget;
+    private providerFor;
     private readBodies;
     private readBody;
     private writeBody;

package/lib/types/shared/contracts.d.ts

@@ -89,6 +89,48 @@ export interface Config {
         turnBar?: boolean;
         saveAction?: boolean;
     };
+    /** Provider policy used when an Agent must create a new Memory Space while distilling memory. */
+    persistenceStrategy?: MemoryPersistenceStrategy;
+    /** Model route used by clean, session-independent maintenance Agents. */
+    taskAgentModel?: TaskAgentModelConfig;
+}
+export interface TaskAgentModelConfig {
+    mode?: 'inherit' | 'fixed';
+    provider?: string;
+    model?: string;
+}
+export interface ResolvedTaskAgentModelConfig {
+    mode: 'inherit' | 'fixed';
+    provider?: string;
+    model?: string;
+}
+export interface TaskAgentModelCatalogModel {
+    id: string;
+    name: string;
+    description?: string;
+}
+export interface TaskAgentModelCatalogGroup {
+    id: string;
+    name: string;
+    models: TaskAgentModelCatalogModel[];
+}
+export interface TaskAgentModelCatalogFailure {
+    id: string;
+    name: string;
+    message: string;
+}
+export interface TaskAgentModelCatalog {
+    effective?: {
+        provider: string;
+        model: string;
+        source: 'fixed' | 'dsh-default' | 'active-agent';
+    };
+    defaultSelection?: {
+        provider: string;
+        model: string;
+    };
+    groups: TaskAgentModelCatalogGroup[];
+    failures: TaskAgentModelCatalogFailure[];
 }
 export interface InteractionConfig {
     turnBar?: boolean;
@@ -114,17 +156,167 @@ export interface ResolvedConfig {
         turnBar: boolean;
         saveAction: boolean;
     };
+    persistenceStrategy: ResolvedMemoryPersistenceStrategy;
+    taskAgentModel: ResolvedTaskAgentModelConfig;
 }
 export interface ResolvedInteractionConfig {
     turnBar: boolean;
     saveAction: boolean;
 }
+export type MemoryProviderId = 'mnemon-native' | 'openviking' | 'honcho' | 'mem0' | 'hindsight' | 'holographic' | 'retaindb' | 'byterover' | 'supermemory';
+export type MemoryProviderConnectionValue = string | number | boolean;
+export type MemoryProviderConnection = Record<string, MemoryProviderConnectionValue>;
+export interface MemoryProviderConfigField {
+    key: string;
+    label: string;
+    /** Service fields are configured once in Settings; memory fields belong to each Memory Space. */
+    scope: 'service' | 'memory';
+    /** A reusable local data location presented with the same default/custom scope UI as Mnemon Native. */
+    role?: 'global-location';
+    input: 'text' | 'url' | 'secret' | 'number' | 'boolean' | 'select' | 'path';
+    required: boolean;
+    defaultValue?: MemoryProviderConnectionValue;
+    placeholder?: string;
+    help?: string;
+    options?: Array<{
+        value: string;
+        label: string;
+    }>;
+}
+export type MemoryPlacementCapability = 'graph' | 'entities' | 'related' | 'exact-write' | 'link' | 'forget';
+export type MemoryPlacementPreference = 'balanced' | 'local-first' | 'shared-first';
+export interface MemoryPlacementRules {
+    allowedProviderIds?: MemoryProviderId[];
+    dataBoundary?: 'allow-remote' | 'local-only';
+    requiredCapabilities?: MemoryPlacementCapability[];
+    preference?: MemoryPlacementPreference;
+}
+/** Persistent policy for provider selection during Agent-supervised memory distillation. */
+export interface MemoryPersistenceStrategy {
+    mode?: 'manual' | 'automatic';
+    /** Fixed provider in manual mode. */
+    providerId?: MemoryProviderId;
+    /** User-authored guidance used only after hard rules have filtered automatic candidates. */
+    prompt?: string;
+    rules?: MemoryPlacementRules;
+    /** Memory-level connection values for providers that may be selected by the policy. */
+    providerConnections?: Partial<Record<MemoryProviderId, MemoryProviderConnection>>;
+}
+export interface ResolvedMemoryPersistenceStrategy {
+    mode: 'manual' | 'automatic';
+    providerId: MemoryProviderId;
+    prompt: string;
+    rules: {
+        allowedProviderIds: MemoryProviderId[];
+        dataBoundary: 'allow-remote' | 'local-only';
+        requiredCapabilities: MemoryPlacementCapability[];
+        preference: MemoryPlacementPreference;
+    };
+    providerConnections: Partial<Record<MemoryProviderId, MemoryProviderConnection>>;
+}
+export interface AutomaticMemoryPlacementRequest {
+    mode: 'automatic';
+    /** User-authored routing guidance. Hard rules above always take precedence. */
+    prompt?: string;
+    rules?: MemoryPlacementRules;
+}
+export interface MemoryPlacementDecision {
+    mode: 'automatic';
+    providerId: MemoryProviderId;
+    decidedBy: 'rules' | 'llm';
+    reason: string;
+    confidence: 'high' | 'medium' | 'low';
+    candidateProviderIds: MemoryProviderId[];
+    appliedRules: string[];
+    decidedAt: string;
+    runId?: string;
+    subagentProvider?: string;
+}
+export interface MemoryProviderCapabilities {
+    search: boolean;
+    browse: boolean;
+    graph: boolean;
+    entities: boolean;
+    related: boolean;
+    remember: boolean;
+    link: boolean;
+    forget: boolean;
+    writeMode: 'exact' | 'async-extracting';
+    deletionMode: 'soft' | 'hard' | 'unsupported';
+}
+export interface MemoryProviderDescriptor {
+    id: MemoryProviderId;
+    label: string;
+    kind: 'local' | 'remote';
+    /** How the provider data scope reacts when DSH switches workspaces. */
+    workspaceBinding: 'automatic' | 'optional-override' | 'provider-global';
+    summary: string;
+    origin: 'native' | 'third-party';
+    capabilities: MemoryProviderCapabilities;
+    fields: MemoryProviderConfigField[];
+    /** Runtime projection: whether this scope has a usable saved service configuration. */
+    serviceConfigured?: boolean;
+}
+export interface MemoryProviderServiceView {
+    providerId: MemoryProviderId;
+    enabled: boolean;
+    configured: boolean;
+    settings: MemoryProviderConnection;
+    configuredSecrets: string[];
+    /** Present only on the settings RPC so its password inputs can use native reveal/hide behavior. */
+    secretValues?: MemoryProviderConnection;
+}
+export interface MemoryProviderServiceCatalog {
+    providers: MemoryProviderDescriptor[];
+    items: MemoryProviderServiceView[];
+    generatedAt: string;
+}
+export interface UpdateMemoryProviderServiceRequest {
+    providerId: MemoryProviderId;
+    settings: MemoryProviderConnection;
+    enabled?: boolean;
+    clearSecrets?: string[];
+}
+export interface MemoryProviderRuntimeStatus {
+    providerId: MemoryProviderId;
+    label: string;
+    enabled: boolean;
+    configured: boolean;
+    status: 'disabled' | 'idle' | 'healthy' | 'unhealthy';
+    memoryBodyCount: number;
+    activeMemoryBodyCount: number;
+    error?: string;
+}
+export interface MemoryBodyProvider {
+    id: MemoryProviderId;
+    label: string;
+    kind: 'local' | 'remote';
+    location: string;
+    targetUri?: string;
+    account?: string;
+    user?: string;
+    actorPeerId?: string;
+    apiKeyConfigured: boolean;
+    settings: MemoryProviderConnection;
+    configuredSecrets: string[];
+    capabilities: MemoryProviderCapabilities;
+}
+export interface OpenVikingBodyConnection {
+    endpoint: string;
+    targetUri: string;
+    apiKey?: string;
+    account?: string;
+    user?: string;
+    actorPeerId?: string;
+}
 export interface MemoryBody {
     id: string;
     name: string;
     description: string;
     active: boolean;
     dbPath: string;
+    provider: MemoryBodyProvider;
+    placement?: MemoryPlacementDecision;
     createdAt: string;
     updatedAt: string;
 }
@@ -132,11 +324,34 @@ export interface CreateMemoryBodyRequest {
     name: string;
     description: string;
     active?: boolean;
+    providerId?: MemoryProviderId;
+    connection?: MemoryProviderConnection;
+    /** Candidate-specific settings used only while resolving automatic placement. */
+    providerConnections?: Partial<Record<MemoryProviderId, MemoryProviderConnection>>;
+    openViking?: OpenVikingBodyConnection;
+    placement?: AutomaticMemoryPlacementRequest;
 }
 export interface UpdateMemoryBodyRequest {
     name?: string;
     description?: string;
     active?: boolean;
+    connection?: MemoryProviderConnection;
+    clearSecrets?: string[];
+    openViking?: Partial<OpenVikingBodyConnection> & {
+        clearApiKey?: boolean;
+    };
+}
+export interface MemoryBodyMetadataUpdate {
+    memoryBodyId: string;
+    title: string;
+    description: string;
+}
+export interface MemoryBodyMetadataMaintenanceResult {
+    delegated: true;
+    runId: string;
+    provider: string;
+    summary: string;
+    updates: MemoryBodyMetadataUpdate[];
 }
 export type Category = 'preference' | 'decision' | 'fact' | 'insight' | 'context' | 'general';
 export declare const CATEGORIES: readonly ["preference", "decision", "fact", "insight", "context", "general"];
@@ -155,6 +370,8 @@ export interface Insight {
     entities?: string[];
     source?: string;
     score?: number;
+    /** Comparable rank score only when results were fused across providers. */
+    federatedScore?: number;
     confidence?: string;
     intent?: string;
     matchedVia?: string;
@@ -163,6 +380,10 @@ export interface Insight {
     edgeType?: string;
     memoryBodyId?: string;
     memoryBodyName?: string;
+    memoryProviderId?: MemoryProviderId;
+    /** Owning Provider capabilities at read time; safe to expose to clients. */
+    memoryCapabilities?: MemoryProviderCapabilities;
+    externalUri?: string;
 }
 export interface SearchRequest {
     query: string;
@@ -197,12 +418,19 @@ export interface MemoryBodyStats {
 export interface MemoryBodyView extends MemoryBody {
     /** True when Mnemon's persisted active-file selection points to this Store. */
     mnemonDefault: boolean;
+    /** False when an external provider is disabled while its Memory Space registration remains preserved. */
+    providerEnabled?: boolean;
     healthy: boolean;
+    /** A fast directory response is visible while provider health resolves independently. */
+    statusLoading?: boolean;
     error?: string;
     stats?: MemoryBodyStats;
 }
 export interface MemoryBodyCatalog {
     items: MemoryBodyView[];
+    providers: MemoryProviderDescriptor[];
+    /** Sanitized policy exposed to memory workers; provider connection values are never included. */
+    persistenceStrategy?: Omit<ResolvedMemoryPersistenceStrategy, 'providerConnections'>;
     total: number;
     activeCount: number;
     directory: string;
@@ -228,6 +456,29 @@ export interface MemoryGraphSnapshot {
     edges: MemoryGraphEdge[];
     generatedAt: string;
     memoryBodies?: Array<Pick<MemoryBody, 'id' | 'name' | 'active'>>;
+    /** Per-space observation state for capability-aware overview rendering. */
+    sources?: MemoryReadSource[];
+}
+export type MemoryReadMode = 'search' | 'graph' | 'projection' | 'enumerable' | 'query-only' | 'entities' | 'unsupported';
+export type MemoryReadStatus = 'ready' | 'empty' | 'query-required' | 'unsupported' | 'unavailable';
+/**
+ * One provider-backed Memory Space participating in a read surface.
+ *
+ * The mode describes what the provider can truthfully expose; status describes
+ * the result of this particular read. Keeping those dimensions separate lets
+ * the UI distinguish an empty graph from a flat projection, a query-only
+ * engine, and an unavailable connection.
+ */
+export interface MemoryReadSource {
+    memoryBodyId: string;
+    memoryBodyName: string;
+    providerId: MemoryProviderId;
+    providerLabel: string;
+    mode: MemoryReadMode;
+    status: MemoryReadStatus;
+    itemCount: number;
+    edgeCount?: number;
+    hint?: string;
 }
 export interface MemoryListRequest {
     query?: string;
@@ -239,6 +490,8 @@ export interface MemoryListView {
     items: MemoryGraphNode[];
     total: number;
     generatedAt: string;
+    /** Omitted only when talking to a pre-provider-aware Host. */
+    sources?: MemoryReadSource[];
 }
 export interface EntityView {
     items: Array<{
@@ -247,6 +500,8 @@ export interface EntityView {
     }>;
     insights: Insight[];
     selected?: string;
+    /** Omitted only when talking to a pre-provider-aware Host. */
+    sources?: MemoryReadSource[];
 }
 export type DocumentStatus = 'active' | 'archived';
 export interface DocumentRecord {
@@ -449,12 +704,14 @@ export interface SubagentCounters {
     writes: number;
     answers: number;
     reviews: number;
+    placements: number;
     migrations: number;
     compactions: number;
     documentArchives: number;
+    metadataMaintenances: number;
     failures: number;
     lastRunId?: string;
-    lastOperation?: 'recall' | 'write' | 'review' | 'migration' | 'compaction' | 'document-archive';
+    lastOperation?: 'recall' | 'write' | 'review' | 'placement' | 'migration' | 'compaction' | 'document-archive' | 'metadata-maintenance';
     lastAt?: string;
 }
 export type LifecyclePhase = 'idle' | 'prime' | 'recall' | 'writeback' | 'review' | 'supervised' | 'error';
@@ -490,6 +747,8 @@ export interface LifecycleSnapshot {
     idleReviewMs: number;
     activeAgents: number;
     sessionAvailable: boolean;
+    /** A session-independent task Agent can be created for WebUI maintenance. */
+    taskAgentAvailable: boolean;
     counters: LifecycleCounters;
     subagents: SubagentCounters;
     current?: LifecycleAgentSnapshot;
@@ -511,6 +770,7 @@ export interface StatusView {
     defaultRecallLimit: number;
     memoryBodyDirectory: string;
     memoryBodies: MemoryBodyView[];
+    providerServices?: MemoryProviderRuntimeStatus[];
     lifecycle?: LifecycleSnapshot;
     documents?: DocumentSnapshot;
     storage?: StorageScopeCatalog;

package/lib/types/subagent.d.ts

@@ -1,11 +1,13 @@
 import type { HostAgent, HostSubagentsService } from './contracts.ts';
 import { type DocumentManager, type DocumentMutation, type DocumentMutationResult, type DocumentView } from './documents.ts';
 import { type RuntimeMemoryController, type RuntimeMemoryMutation, type RuntimeMemoryMutationResult } from './runtime-memory.ts';
-import type { Insight, RememberRequest, SearchRequest } from './service.ts';
-import type { SubagentCounters } from './shared/contracts.ts';
+import type { Insight, MnemonService, RememberRequest, SearchRequest } from './service.ts';
+import { type PreparedMemoryPlacement } from './provider-placement.ts';
+import type { MemoryBodyMetadataMaintenanceResult, MemoryPlacementDecision, SubagentCounters } from './shared/contracts.ts';
 export type { SubagentCounters } from './shared/contracts.ts';
 interface AgentRuntimeSource {
     forAgent(agent: HostAgent): {
+        service: MnemonService;
         runtimeMemory: RuntimeMemoryController;
         documents: DocumentManager;
     };
@@ -74,6 +76,11 @@ export declare class MnemonSubagentCoordinator {
     documentSearch(parent: HostAgent, query: string, includeArchived?: boolean, limit?: number): Promise<import("./documents.ts").DocumentSearchResult>;
     recall(parent: HostAgent, request: SearchRequest, signal: AbortSignal): Promise<DelegatedRecallResult>;
     related(parent: HostAgent, id: string, memoryBodyId: string | undefined, signal: AbortSignal): Promise<DelegatedRecallResult>;
+    placeProvider(parent: HostAgent, body: {
+        name: string;
+        description: string;
+    }, prepared: PreparedMemoryPlacement, signal: AbortSignal): Promise<MemoryPlacementDecision>;
+    maintainMetadata(parent: HostAgent, memoryBodyIds: readonly string[], signal: AbortSignal): Promise<MemoryBodyMetadataMaintenanceResult>;
     remember(parent: HostAgent, request: RememberRequest, signal: AbortSignal): Promise<DelegatedWriteResult>;
     runtime(parent: HostAgent, request: RuntimeMemoryMutation, signal: AbortSignal): Promise<CoordinatedRuntimeMemoryResult>;
     document(parent: HostAgent, request: DocumentMutation, signal: AbortSignal): Promise<CoordinatedDocumentResult>;
@@ -89,5 +96,6 @@ export declare class MnemonSubagentCoordinator {
     private delegate;
     private provider;
     private runtimeMemoryFor;
+    private serviceFor;
     private documentsFor;
 }

package/package.json

@@ -1,13 +1,22 @@
 {
   "name": "dsh-mnemon",
-  "version": "0.1.6",
-  "description": "Cross-agent, local-first persistent memory plugin for DeepSeek Harness (DSH), powered by Mnemon. It shares long-term memory across Mnemon-enabled agents and adds runtime memory, searchable project documents, semantic recall, knowledge graph, and a Sidebar UI.",
+  "version": "0.2.0",
+  "description": "Three-tier memory system for DeepSeek Harness with nine pluggable providers, smart routing, independent task Agents, WebUI, and headless tools.",
   "keywords": [
     "deepseek-harness",
     "deepseek-harness-plugin",
     "dsh",
     "dsh-plugin",
     "mnemon",
+    "openviking",
+    "honcho",
+    "mem0",
+    "hindsight",
+    "holographic-memory",
+    "retaindb",
+    "byterover",
+    "supermemory",
+    "memory-provider",
     "memory-system",
     "memory-plugin",
     "agent-memory",
@@ -25,7 +34,7 @@
     "semantic-recall",
     "memory-space",
     "workspace-memory",
-    "subagent",
+    "task-agent",
     "knowledge-graph",
     "ai-agent",
     "llm-agent",
@@ -35,6 +44,7 @@
     "typescript",
     "cordis",
     "web-ui",
+    "headless",
     "sidebar"
   ],
   "repository": {
@@ -71,6 +81,7 @@
     "cordis.patch.yml",
     "README.md",
     "README.zh-CN.md",
+    "THIRD_PARTY_NOTICES.md",
     "SECURITY.md",
     "LICENSE"
   ],
@@ -97,8 +108,9 @@
     "typecheck": "tsc -p tsconfig.json --noEmit",
     "test": "vitest run",
     "verify:build": "node scripts/verify-deterministic-build.mjs",
+    "verify:headless": "node scripts/verify-headless-profile.mjs",
     "verify:package": "node scripts/verify-package-contents.mjs && pnpm run lint:package",
-    "verify": "pnpm run typecheck && pnpm run test && pnpm run verify:build && pnpm run verify:package"
+    "verify": "pnpm run typecheck && pnpm run test && pnpm run verify:build && pnpm run verify:headless && pnpm run verify:package"
   },
   "dependencies": {
     "fflate": "^0.8.3",