qlogicagent 0.5.3 → 1.0.0

package/dist/types/protocol/notifications.d.ts

@@ -0,0 +1,296 @@
+/**
+ * Centralized Notification Event Protocol — all JSON-RPC notification types
+ * that qlogicagent emits to external apps.
+ *
+ * This is the SINGLE SOURCE OF TRUTH for the agent's outbound event contract.
+ * Frontend, Electron, Hub, and test harness all consume these types.
+ *
+ * Reference: Codex app-server events, Claude Code streaming events,
+ *            DeerFlow LangGraph stream modes.
+ */
+import type { TokenUsage } from "../agent/types.js";
+import type { TodoItem } from "../contracts/todo.js";
+/** Embedded thread item for clients using the Thread protocol. */
+export interface NotificationThreadItem {
+    id: string;
+    type: string;
+    role: "user" | "assistant" | "system";
+    text?: string;
+    toolName?: string;
+    toolCallId?: string;
+    arguments?: string;
+    output?: string;
+    approved?: boolean;
+    strategy?: string;
+    createdAt: string;
+}
+/** Turn started — always emitted first. */
+export interface TurnStartNotification {
+    turnId: string;
+    /** Model being used for this turn (Codex parity). */
+    model?: string;
+    /** Provider id. */
+    provider?: string;
+}
+/** Streaming text chunk from the main agent. */
+export interface TurnDeltaNotification {
+    turnId: string;
+    text: string;
+    item?: NotificationThreadItem;
+}
+/** Turn completed successfully. */
+export interface TurnEndNotification {
+    turnId: string;
+    content: string;
+    usage?: TokenUsage;
+    model?: string;
+    provider?: string;
+    item?: NotificationThreadItem;
+}
+/** Turn failed. */
+export interface TurnErrorNotification {
+    turnId: string;
+    error: string;
+    code?: string;
+}
+/** Agent self-recovered from an error (retry, conversation repair, etc.). */
+export interface TurnRecoveryNotification {
+    turnId: string;
+    action: string;
+    detail?: string;
+    item?: NotificationThreadItem;
+}
+/** Tool invocation started — includes arguments for UI display. */
+export interface TurnToolCallNotification {
+    turnId: string;
+    callId: string;
+    name: string;
+    /** Serialized arguments JSON. Enables UI to display "searching for X", "reading file Y". */
+    arguments?: string;
+    item?: NotificationThreadItem;
+}
+/**
+ * Tool execution completed.
+ * Includes truncated output for "Used X sources" style panels.
+ */
+export interface TurnToolResultNotification {
+    turnId: string;
+    callId: string;
+    name: string;
+    ok: boolean;
+    error?: string;
+    /** Truncated tool output (max 2000 chars). Enables source preview panels. */
+    outputPreview?: string;
+    item?: NotificationThreadItem;
+}
+/** Tool execution blocked by permission system. */
+export interface TurnToolBlockedNotification {
+    turnId: string;
+    callId: string;
+    name: string;
+    reason: string;
+    item?: NotificationThreadItem;
+}
+/**
+ * Reasoning/thinking token stream — separate from main delta.
+ * Enables DeerFlow-style collapsible thinking blocks.
+ *
+ * For models that support extended thinking (Claude, DeepSeek-R1, o1),
+ * reasoning content is streamed via this event instead of turn.delta.
+ */
+export interface TurnReasoningDeltaNotification {
+    turnId: string;
+    text: string;
+}
+/** Plan/strategy update — rendered as DeerFlow Plan component. */
+export interface TurnPlanUpdateNotification {
+    turnId: string;
+    slug: string;
+    content: string;
+    item?: NotificationThreadItem;
+}
+/** Suggestion items — interactive quick-action buttons. */
+export interface TurnSuggestionsNotification {
+    turnId: string;
+    items: Array<{
+        text: string;
+        icon?: string;
+        action?: string;
+    }>;
+}
+/** Sub-agent (fork, skill, dream) started execution. */
+export interface TurnSubagentStartedNotification {
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    prompt?: string;
+}
+/** Sub-agent streaming text chunk. */
+export interface TurnSubagentDeltaNotification {
+    agentType: string;
+    subagentId?: string;
+    text: string;
+}
+/** Sub-agent completed execution. */
+export interface TurnSubagentEndedNotification {
+    turnId: string;
+    subagentId: string;
+    agentType: string;
+    ok: boolean;
+    /** Truncated result (max 2000 chars). */
+    outputPreview?: string;
+    error?: string;
+}
+export type MediaResultType = "image" | "tts" | "video";
+/** Structured media generation result — enables media preview cards. */
+export interface TurnMediaResultNotification {
+    turnId: string;
+    mediaType: MediaResultType;
+    /** Local file path or URL. */
+    url: string;
+    /** Model used for generation. */
+    model?: string;
+    /** Provider id. */
+    provider?: string;
+    /** Duration in seconds (for TTS/video). */
+    durationSeconds?: number;
+    /** Image dimensions. */
+    width?: number;
+    height?: number;
+    /** MIME type (e.g. "audio/mpeg", "image/png"). */
+    mimeType?: string;
+    /** Billing info. */
+    billingUnit?: string;
+    billingQuantity?: number;
+}
+/** Full todo list updated — enables DeerFlow-style todo panel sync. */
+export interface TurnTodosUpdatedNotification {
+    turnId?: string;
+    items: TodoItem[];
+    summary: {
+        total: number;
+        completed: number;
+        inProgress: number;
+        notStarted: number;
+    };
+}
+/** Infrastructure task state change (bash, agent fork, dream). */
+export interface TaskUpdatedNotification {
+    taskId: string;
+    type: string;
+    lifecycle: string;
+    label?: string;
+}
+/** Long-running command execution progress (shell, script). */
+export interface TurnExecProgressNotification {
+    output: string;
+    elapsedTimeSeconds: number;
+    totalLines: number;
+    totalBytes: number;
+}
+export type ArtifactType = "code" | "file" | "image" | "document" | "diagram" | "table";
+/** Structured artifact produced by the agent — enables Canvas-style rendering. */
+export interface TurnArtifactNotification {
+    turnId: string;
+    artifactId: string;
+    type: ArtifactType;
+    title: string;
+    /** File path (for file/code artifacts). */
+    filePath?: string;
+    /** Language id (for code artifacts). */
+    language?: string;
+    /** Content body (may be truncated for large artifacts). */
+    content?: string;
+    /** MIME type. */
+    mimeType?: string;
+}
+/** Agent requests user approval before executing a restricted tool. */
+export interface ToolApprovalRequestNotification {
+    approvalId: string;
+    callId: string;
+    toolName: string;
+    arguments: string;
+    message?: string;
+    suggestions?: string[];
+}
+/** Skill instruction directive. */
+export interface TurnSkillInstructionNotification {
+    turnId: string;
+    instruction: unknown;
+}
+/** Memory content changed (local md or QMemory). */
+export interface MemoryUpdatedNotification {
+    source: string;
+    /** Memory target (memory, user, etc.). */
+    target?: string;
+    /** Number of entries. */
+    entryCount?: number;
+    /** Human-readable summary of what changed. */
+    summary?: string;
+}
+/** Session metadata changed (title, model, etc.). */
+export interface SessionInfoNotification {
+    sessionId: string;
+    title?: string;
+    model?: string;
+    provider?: string;
+    cwd?: string;
+    turnCount?: number;
+}
+/** Permission rule saved/updated. */
+export interface PermissionRuleUpdatedNotification {
+    /** Tool name glob pattern. */
+    pattern: string;
+    /** New permission behavior (allow, deny, ask). */
+    behavior: string;
+}
+/** Team created, updated, or destroyed. */
+export interface TeamUpdatedNotification {
+    teamName: string;
+    action: "created" | "destroyed" | "member_joined" | "member_left";
+    members?: Array<{
+        agentName: string;
+        role: string;
+    }>;
+}
+export interface PongNotification {
+}
+/** Real-time token usage update (emitted after each LLM call within a turn). */
+export interface TurnUsageUpdateNotification {
+    turnId: string;
+    usage: TokenUsage;
+    model?: string;
+    /** Cumulative cost estimate for this session (USD). */
+    sessionCostUSD?: number;
+}
+export interface NotificationMethodMap {
+    "turn.start": TurnStartNotification;
+    "turn.delta": TurnDeltaNotification;
+    "turn.end": TurnEndNotification;
+    "turn.error": TurnErrorNotification;
+    "turn.recovery": TurnRecoveryNotification;
+    "turn.tool_call": TurnToolCallNotification;
+    "turn.tool_result": TurnToolResultNotification;
+    "turn.tool_blocked": TurnToolBlockedNotification;
+    "turn.reasoning_delta": TurnReasoningDeltaNotification;
+    "turn.plan_update": TurnPlanUpdateNotification;
+    "turn.suggestions": TurnSuggestionsNotification;
+    "turn.subagent_started": TurnSubagentStartedNotification;
+    "turn.subagent_delta": TurnSubagentDeltaNotification;
+    "turn.subagent_ended": TurnSubagentEndedNotification;
+    "turn.media_result": TurnMediaResultNotification;
+    "turn.todos_updated": TurnTodosUpdatedNotification;
+    "task.updated": TaskUpdatedNotification;
+    "turn.exec_progress": TurnExecProgressNotification;
+    "turn.artifact": TurnArtifactNotification;
+    "tool.approval.request": ToolApprovalRequestNotification;
+    "turn.skill_instruction": TurnSkillInstructionNotification;
+    "memory.updated": MemoryUpdatedNotification;
+    "session.info": SessionInfoNotification;
+    "permission.rule_updated": PermissionRuleUpdatedNotification;
+    "team.updated": TeamUpdatedNotification;
+    "turn.usage_update": TurnUsageUpdateNotification;
+    "pong": PongNotification;
+}
+/** All known notification method names. */
+export type NotificationMethod = keyof NotificationMethodMap;

package/dist/types/runtime/execution/dream-agent.d.ts

@@ -10,7 +10,7 @@
  *
  * Reference: claude-code src/services/autoDream/
  */
-import type { DreamTaskState, DreamTurn } from "../../orchestration/task-types.js";
+import type { DreamTaskState, DreamTurn } from "../../orchestration/subagent/task-types.js";
 import type { ToolDefinition, ToolInvoker, AgentLogger, HookRegistry } from "../../agent/types.js";
 import type { LLMTransport } from "../../llm/transport.js";
 export interface DreamTriggerConfig {

package/dist/types/runtime/execution/forked-agent.d.ts

@@ -77,10 +77,8 @@ export interface ForkedAgentParams {
     skipTranscript?: boolean;
     /** Token budget for this sub-agent. 0 or undefined = no limit. */
     budgetTokens?: number;
-    /** Parent sidechain depth (propagated to child tool loop) */
+    /** Parent fork depth (propagated to child tool loop) */
     parentDepth?: number;
-    /** Sidechain type for tool access policy (default "code-repair" = full) */
-    sidechainType?: import("../../orchestration/index.js").SidechainType;
 }
 /**
  * Result of a forked agent run.

package/dist/types/runtime/hooks/context-compression.d.ts

@@ -6,7 +6,7 @@ import type { LLMTransport } from "../../llm/transport.js";
 export declare function estimateTokens(msg: CompressibleMessage): number;
 /** Estimate total tokens for a message array. */
 export declare function estimateTotalTokens(messages: CompressibleMessage[]): number;
-export declare function getCompressionMetrics(): import("../../orchestration/context-compression.js").CompressionMetricsSnapshot;
+export declare function getCompressionMetrics(): import("../../orchestration/index.js").CompressionMetricsSnapshot;
 export declare function getContextEngineRegistry(): ContextEngineRegistry;
 /**
  * Create a summarization callback using an injected LLM transport.

package/dist/types/runtime/infra/agent-paths.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Agent Paths — Centralized dot-directory name and path helpers.
+ *
+ * All filesystem paths under `~/.qlogicagent/` (user-level) or
+ * `<project>/.qlogicagent/` (project-level) must go through these
+ * helpers so the dot-dir name is defined in exactly one place.
+ */
+/** Dot-directory name used for both user-level and project-level storage. */
+export declare const AGENT_DOT_DIR = ".qlogicagent";
+/** `~/.qlogicagent/` */
+export declare function getUserAgentHome(): string;
+/** `~/.qlogicagent/sessions/` */
+export declare function getUserSessionsRoot(): string;
+/** `~/.qlogicagent/sessions/{sessionId}` */
+export declare function getUserSessionDir(sessionId: string): string;
+/** `~/.qlogicagent/.credentials.json` */
+export declare function getUserCredentialsPath(): string;
+/** `~/.qlogicagent/plugins/` */
+export declare function getUserPluginsDir(): string;
+/** `~/.qlogicagent/skills/` */
+export declare function getUserSkillsDir(): string;
+/** `~/.qlogicagent/settings.json` */
+export declare function getUserSettingsPath(): string;
+/** `~/.qlogicagent/cache/` */
+export declare function getUserCacheDir(): string;
+/** `~/.qlogicagent/debug-logs/` */
+export declare function getUserDebugLogsDir(): string;
+/** `~/.qlogicagent/checkpoints/` or `~/.qlogicagent/checkpoints/{sessionId}` */
+export declare function getUserCheckpointsDir(sessionId?: string): string;
+/** `~/.qlogicagent/plugin-cache/` */
+export declare function getUserPluginCacheDir(): string;
+/** `~/.qlogicagent/mcp.json` */
+export declare function getUserMcpConfigPath(): string;
+/** `~/.qlogicagent/marketplace.json` */
+export declare function getUserMarketplaceConfigPath(): string;
+/** `~/.qlogicagent/workflows/` */
+export declare function getUserWorkflowsDir(): string;
+/** `~/.qlogicagent/INSTRUCTIONS.md` */
+export declare function getUserInstructionsPath(): string;
+/** `~/.qlogicagent/rules/` */
+export declare function getUserRulesDir(): string;
+/** `<cwd>/.qlogicagent/` */
+export declare function getProjectAgentDir(cwd?: string): string;
+/** `<cwd>/.qlogicagent/workflows/` */
+export declare function getProjectWorkflowsDir(cwd?: string): string;
+/** `<cwd>/.qlogicagent/plugins/` */
+export declare function getProjectPluginsDir(cwd?: string): string;
+/** `<cwd>/.qlogicagent/skills/` */
+export declare function getProjectSkillsDir(cwd?: string): string;
+/** `<cwd>/.qlogicagent/settings.json` */
+export declare function getProjectSettingsPath(cwd?: string): string;
+/** `<cwd>/.qlogicagent/INSTRUCTIONS.md` */
+export declare function getProjectInstructionsPath(cwd?: string): string;
+/** `<cwd>/.qlogicagent/rules/` */
+export declare function getProjectRulesDir(cwd?: string): string;
+/** `<gitRoot>/.qlogicagent/hooks/` */
+export declare function getGitRootHooksDir(gitRoot: string): string;

package/dist/types/runtime/infra/checkpoint-backend.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Local Checkpoint Backend — git-based shadow repo implementation.
+ *
+ * Creates and manages checkpoint snapshots in `~/.qlogicagent/checkpoints/<sessionId>/`
+ * using a shadow git repository independent of the user's project .git.
+ */
+import type { CheckpointToolDeps } from "../../skills/tools/checkpoint-tool.js";
+export declare function createLocalCheckpointBackend(projectRoot: string, sessionId: string): CheckpointToolDeps;

package/dist/types/runtime/infra/disk-storage.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Disk Storage Manager — unified atomic file I/O for agent self-managed storage.
+ *
+ * Provides:
+ * - Atomic write (tmp + rename) with dir auto-creation
+ * - JSON read/write helpers
+ * - MemoryStore disk persistence (auto-save on mutation)
+ */
+/**
+ * Write data atomically: write to a temp file in the same directory,
+ * then rename over the target. This prevents partial/corrupted reads.
+ */
+export declare function atomicWriteFile(filePath: string, data: string | Buffer): Promise<void>;
+/**
+ * Read a JSON file. Returns `undefined` if the file does not exist.
+ */
+export declare function readJsonFile<T = unknown>(filePath: string): Promise<T | undefined>;
+/**
+ * Write a JSON file atomically.
+ */
+export declare function writeJsonFile(filePath: string, data: unknown): Promise<void>;
+/** Path to user-level memory file: `~/.qlogicagent/memory.json` */
+export declare function getMemoryFilePath(): string;
+export interface PersistedMemory {
+    memory: string;
+    user: string;
+    /** ISO 8601 timestamp of last save. */
+    savedAt: string;
+}
+/** Load persisted memory from disk. Returns undefined if no file exists. */
+export declare function loadPersistedMemory(): Promise<PersistedMemory | undefined>;
+/** Save memory to disk atomically. */
+export declare function savePersistedMemory(data: {
+    memory: string;
+    user: string;
+}): Promise<void>;

package/dist/types/runtime/infra/file-watcher.d.ts

@@ -10,8 +10,8 @@
  * this is a lightweight change-awareness system.
  *
  * Watched paths:
- *   - .openclaw/settings.json → permission hot-reload
- *   - INSTRUCTIONS.md / .openclaw/INSTRUCTIONS.md → instruction re-load
+ *   - .qlogicagent/settings.json → permission hot-reload
+ *   - INSTRUCTIONS.md / .qlogicagent/INSTRUCTIONS.md → instruction re-load
  *   - configurable additional patterns
  *
  * Reference: claude-code file-watcher usage throughout lifecycle

package/dist/types/runtime/infra/index.d.ts

@@ -1,6 +1,8 @@
+export { AGENT_DOT_DIR, getUserAgentHome, getUserSessionDir, getUserCredentialsPath, getUserPluginsDir, getUserSkillsDir, getUserSettingsPath, getUserCacheDir, getUserDebugLogsDir, getUserCheckpointsDir, getUserPluginCacheDir, getUserMcpConfigPath, getUserMarketplaceConfigPath, getUserWorkflowsDir, getUserInstructionsPath, getProjectAgentDir, getProjectWorkflowsDir, getProjectPluginsDir, getProjectSkillsDir, getProjectSettingsPath, getProjectInstructionsPath, getProjectRulesDir, getGitRootHooksDir, } from "./agent-paths.js";
 export { getBudgetContinuationMessage } from "./token-budget.js";
 export { type SecureStorage, saveApiKey, loadApiKey } from "./secure-storage.js";
 export { createFileWatcher, FileWatcher } from "./file-watcher.js";
 export { TaskStore } from "./task-runtime.js";
 export { createWorktreeBackend } from "./worktree-backend.js";
 export { registerCleanup, runCleanupFunctions } from "./cleanup-registry.js";
+export { atomicWriteFile, readJsonFile, writeJsonFile, loadPersistedMemory, savePersistedMemory, getMemoryFilePath, type PersistedMemory, } from "./disk-storage.js";

package/dist/types/runtime/infra/secure-storage.d.ts

@@ -7,7 +7,7 @@
  *   - macOS Keychain / Windows Credential Manager can be added as plugins
  *
  * Storage layout:
- *   ~/.openclaw/.credentials.json  — API keys, OAuth tokens
+ *   ~/.qlogicagent/.credentials.json  — API keys, OAuth tokens
  *
  * Reference: claude-code-haha/src/utils/secureStorage/
  */

package/dist/types/runtime/infra/task-runtime.d.ts

@@ -9,7 +9,7 @@
  * Architecture note: CC uses React-style setAppState(prev => next). We use
  * a simple Map-based store since we're in a subprocess (no React).
  */
-import type { TaskState, TaskType, TaskLifecycle, PermissionRole, IsolationMode, LocalAgentTaskState, LocalBashTaskState } from "../../orchestration/task-types.js";
+import type { TaskState, TaskType, TaskLifecycle, PermissionRole, IsolationMode, LocalAgentTaskState, LocalBashTaskState } from "../../orchestration/subagent/task-types.js";
 import type { HookRegistry } from "../../contracts/hooks.js";
 /** Polling interval for running tasks (ms) */
 export declare const POLL_INTERVAL_MS = 1000;

package/dist/types/runtime/prompt/environment-context.d.ts

@@ -20,4 +20,4 @@ export type ShellType = "bash" | "powershell" | "zsh" | "cmd" | "fish" | "unknow
  * Create a system prompt section that provides environment context.
  * Memoized — computed once per session (environment doesn't change mid-session).
  */
-export declare function createEnvironmentContextSection(): SystemPromptSection;
+export declare function createEnvironmentContextSection(cwdOverride?: string): SystemPromptSection;

package/dist/types/runtime/prompt/instruction-loader.d.ts

@@ -2,9 +2,9 @@
  * Instruction Loader — CC claudemd.ts parity (adapted for qlogicagent).
  *
  * Discovers and loads instruction files following CC's load order:
- *   1. User instructions (~/.openclaw/INSTRUCTIONS.md)
- *   2. Project instructions (INSTRUCTIONS.md, .openclaw/INSTRUCTIONS.md,
- *      .openclaw/rules/*.md — walkup from cwd to git root)
+ *   1. User instructions (~/.qlogicagent/INSTRUCTIONS.md)
+ *   2. Project instructions (INSTRUCTIONS.md, .qlogicagent/INSTRUCTIONS.md,
+ *      .qlogicagent/rules/*.md — walkup from cwd to git root)
  *   3. Local instructions (INSTRUCTIONS.local.md — private, not checked in)
  *
  * Features ported from CC:
@@ -33,11 +33,11 @@ export interface InstructionFileInfo {
  * Load all instruction files following CC's discovery order.
  *
  * Discovery order (priority: last loaded = highest):
- *   1. User: ~/.openclaw/INSTRUCTIONS.md, ~/.openclaw/rules/*.md
+ *   1. User: ~/.qlogicagent/INSTRUCTIONS.md, ~/.qlogicagent/rules/*.md
  *   2. Project: Walk from git root → cwd, each dir:
  *      - INSTRUCTIONS.md
- *      - .openclaw/INSTRUCTIONS.md
- *      - .openclaw/rules/*.md (unconditional)
+ *      - .qlogicagent/INSTRUCTIONS.md
+ *      - .qlogicagent/rules/*.md (unconditional)
  *   3. Local: INSTRUCTIONS.local.md (per dir, walkup)
  *
  * @param cwd - Starting directory for walkup discovery

package/dist/types/runtime/session/index.d.ts

@@ -1,2 +1,2 @@
-export { SessionState, type SessionCostSnapshot } from "./session-state.js";
+export { SessionState, type SessionUsageSnapshot, type SessionCostSnapshot } from "./session-state.js";
 export { appendMessage, saveSessionState, loadSessionForResume, listSessions, deleteSession, pruneOldSessions, shouldGenerateTaskSummary, maybeGenerateTaskSummary, type SessionMetadata, type PersistedSession, type SessionListEntry, type TaskSummaryDeps, } from "./session-persistence.js";

package/dist/types/runtime/session/session-memory.d.ts

@@ -44,7 +44,6 @@ export type ForkedAgentRunner = (params: {
     log: AgentLogger;
     hooks?: HookRegistry;
     forkLabel: string;
-    sidechainType?: "planner" | "research" | "plan-repair" | "code-repair" | "media-prep";
     maxTurns?: number;
     parentSignal?: AbortSignal;
     skipTranscript?: boolean;

package/dist/types/runtime/session/session-persistence.d.ts

@@ -7,7 +7,7 @@
  *   3. Session metadata (model, cwd, agent mode)
  *
  * Storage layout:
- *   ~/.openclaw/sessions/<session-id>/
+ *   ~/.qlogicagent/sessions/<session-id>/
  *     transcript.jsonl   — append-only message log
  *     state.json          — cost snapshot + metadata
  *

package/dist/types/runtime/session/session-state.d.ts

@@ -21,18 +21,24 @@ export interface ModelUsage {
     outputTokens: number;
     cacheRead: number;
     cacheCreation: number;
-    costUSD: number;
+    /** Media generation call count (image/video/music/tts/3d) */
+    mediaCalls: number;
+    /** Total seconds of media output (video, music) */
+    mediaDurationSeconds: number;
+    /** Total characters processed (TTS) */
+    mediaCharacters: number;
 }
 /** Snapshot of the session state for persistence / restore */
-export interface SessionCostSnapshot {
+export interface SessionUsageSnapshot {
     sessionId: string;
-    totalCostUSD: number;
     modelUsage: Record<string, ModelUsage>;
     totalInputTokens: number;
     totalOutputTokens: number;
     turnCount: number;
     lastSavedAt: number;
 }
+/** @deprecated Use SessionUsageSnapshot. Kept for persistence compat. */
+export type SessionCostSnapshot = SessionUsageSnapshot;
 /** Thresholds for background memory extraction — CC sessionMemory.ts parity */
 export interface MemoryExtractionThresholds {
     /** Token threshold before FIRST extraction (default 10000) */
@@ -45,7 +51,6 @@ export interface MemoryExtractionThresholds {
 export declare class SessionState {
     readonly sessionId: string;
     private _trustAccepted;
-    private _totalCostUSD;
     private _modelUsage;
     private _totalInputTokens;
     private _totalOutputTokens;
@@ -60,7 +65,6 @@ export declare class SessionState {
     constructor(sessionId: string, thresholds?: Partial<MemoryExtractionThresholds>);
     get trustAccepted(): boolean;
     setTrustAccepted(accepted: boolean): void;
-    get totalCostUSD(): number;
     get totalInputTokens(): number;
     get totalOutputTokens(): number;
     get turnCount(): number;
@@ -71,12 +75,17 @@ export declare class SessionState {
     getAllModelUsage(): Record<string, ModelUsage>;
     /**
      * Add usage from an API response — CC addToTotalSessionCost() parity.
+     * Tracks token counts only; pricing is handled by Hub/Admin.
      *
      * @param usage - Token counts from the API response
      * @param model - Model identifier
-     * @param costUSD - Calculated cost (caller computes based on pricing)
      */
-    addUsage(usage: TokenUsage, model: string, costUSD?: number): void;
+    addUsage(usage: TokenUsage, model: string): void;
+    /**
+     * Add usage from a media generation call (non-token billing).
+     * Tracks quantities only (calls, seconds, characters); pricing is Hub/Admin's job.
+     */
+    addMediaUsage(model: string, billingUnit: string, quantity: number): void;
     /** Record a tool call (for extraction threshold tracking) */
     recordToolCall(): void;
     /** Increment turn count */
@@ -98,7 +107,7 @@ export declare class SessionState {
      * Create a snapshot for persistence.
      * CC saveCurrentSessionCosts() parity.
      */
-    createSnapshot(): SessionCostSnapshot;
+    createSnapshot(): SessionUsageSnapshot;
     /**
      * Restore from a previous snapshot.
      * CC setCostStateForRestore() parity.
@@ -106,7 +115,7 @@ export declare class SessionState {
      * GUARD: Only restores if the snapshot's sessionId matches this session.
      * Prevents cross-session cost leakage (CC's lastSessionId guard).
      */
-    restoreFromSnapshot(snapshot: SessionCostSnapshot): boolean;
+    restoreFromSnapshot(snapshot: SessionUsageSnapshot): boolean;
     /** Register a state change listener. Returns unsubscribe function. */
     onStateChange(listener: () => void): () => void;
     private notifyListeners;