@wrongstack/core 0.302.0 → 0.303.0

package/dist/session-catalog/protocol.d.ts

@@ -0,0 +1,284 @@
+import type { SessionRegistryEntry } from '../session-registry-types.js';
+import type { SessionSummary } from '../types/session.js';
+export declare const SESSION_CATALOG_PROTOCOL_VERSION = 1;
+export declare const SESSION_CATALOG_MAX_FRAME_CHARS: number;
+export declare const SESSION_CATALOG_DEFAULT_LEASE_MS = 30000;
+export declare const SESSION_CATALOG_DEFAULT_RESERVATION_MS = 15000;
+export declare const SESSION_CATALOG_MAX_AGENTS = 128;
+export interface SessionLeaseCredential {
+    sessionId: string;
+    leaseId: string;
+    leaseSecret: string;
+    ownerInstanceId: string;
+    expiresAt: number;
+}
+export interface ResumeReservation {
+    reservationId: string;
+    targetSessionId: string;
+    requesterInstanceId: string;
+    expiresAt: number;
+}
+export interface MaintenanceLease {
+    sessionId: string;
+    operation: 'delete' | 'prune' | 'clear' | 'truncate' | 'rewind' | 'repair';
+    holderId: string;
+    leaseId: string;
+    expiresAt: number;
+}
+export interface SessionCatalogServerInfo {
+    protocolVersion: number;
+    pid: number;
+    projectDir: string;
+    projectRoot: string;
+    endpoint: string;
+    databasePath: string;
+    instanceId: string;
+    startedAt: string;
+}
+export interface SessionCatalogHealth extends SessionCatalogServerInfo {
+    checkedAt: number;
+    uptimeMs: number;
+    clients: number;
+    activeRequests: number;
+    catalogRows: number;
+    damagedRows: number;
+    liveLeases: number;
+    reservations: number;
+    maintenanceLeases: number;
+    generation: number;
+    lastReconciliation?: string | undefined;
+    memory: {
+        rss: number;
+        heapUsed: number;
+        heapTotal: number;
+        external: number;
+    };
+    handles: number;
+}
+export interface SessionCatalogMetadata extends SessionCatalogServerInfo {
+    authToken: string;
+}
+export interface CatalogSessionRecord extends SessionSummary {
+    transcriptRelativePath: string;
+    summaryRelativePath: string;
+    transcriptSize: number;
+    transcriptMtimeMs: number;
+    summaryRevision: number;
+    indexedAt: string;
+    damaged: boolean;
+}
+export type SessionCatalogEventKind = 'session.claimed' | 'session.presence_changed' | 'session.closing' | 'session.released' | 'session.catalog_changed' | 'session.deleted' | 'session.rebuild_started' | 'session.rebuild_completed';
+export interface SessionCatalogEvent {
+    instanceId: string;
+    sequence: number;
+    kind: SessionCatalogEventKind;
+    sessionId?: string | undefined;
+    generation: number;
+    at: string;
+}
+/**
+ * NOTE: adding a field to any `args` below also requires adding it to
+ * `OPERATION_KEYS` in `project-server.ts` — the daemon validates every
+ * request against that allowlist and rejects unknown fields at runtime,
+ * which TypeScript cannot catch.
+ */
+export interface SessionCatalogOperations {
+    ping: {
+        args: Record<string, never>;
+        result: SessionCatalogHealth;
+    };
+    claim_new: {
+        args: {
+            entry: SessionRegistryEntry;
+            ownerInstanceId: string;
+            leaseMs?: number;
+        };
+        result: SessionLeaseCredential;
+    };
+    reconnect_lease: {
+        args: SessionLeaseCredential;
+        result: SessionLeaseCredential;
+    };
+    reserve_resume: {
+        args: {
+            targetSessionId: string;
+            requesterInstanceId: string;
+            currentSessionId?: string;
+            reservationMs?: number;
+        };
+        result: ResumeReservation;
+    };
+    activate_reservation: {
+        args: {
+            reservation: ResumeReservation;
+            entry: SessionRegistryEntry;
+            leaseMs?: number;
+        };
+        result: SessionLeaseCredential;
+    };
+    cancel_reservation: {
+        args: {
+            reservationId: string;
+            requesterInstanceId: string;
+        };
+        result: void;
+    };
+    heartbeat: {
+        args: {
+            credential: SessionLeaseCredential;
+            status?: SessionRegistryEntry['status'];
+        };
+        result: SessionLeaseCredential;
+    };
+    publish_agents: {
+        args: {
+            credential: SessionLeaseCredential;
+            revision: number;
+            agents: SessionRegistryEntry['agents'];
+        };
+        result: {
+            accepted: boolean;
+            revision: number;
+        };
+    };
+    mark_closing: {
+        args: {
+            credential: SessionLeaseCredential;
+        };
+        result: void;
+    };
+    release: {
+        args: {
+            credential: SessionLeaseCredential;
+        };
+        result: void;
+    };
+    list_live: {
+        args: Record<string, never>;
+        result: SessionRegistryEntry[];
+    };
+    get_live: {
+        args: {
+            sessionId: string;
+        };
+        result: SessionRegistryEntry | null;
+    };
+    subscribe: {
+        args: {
+            cursor?: number;
+        };
+        result: {
+            instanceId: string;
+            sequence: number;
+        };
+    };
+    unsubscribe: {
+        args: Record<string, never>;
+        result: void;
+    };
+    upsert_summary: {
+        args: {
+            summary: SessionSummary;
+            transcriptRelativePath?: string;
+            summaryRelativePath?: string;
+        };
+        result: CatalogSessionRecord;
+    };
+    list_catalog: {
+        args: {
+            limit?: number;
+            search?: string;
+        };
+        result: CatalogSessionRecord[];
+    };
+    resolve_id: {
+        args: {
+            query: string;
+        };
+        result: string;
+    };
+    get_summary: {
+        args: {
+            sessionId: string;
+        };
+        result: CatalogSessionRecord | null;
+    };
+    rename: {
+        args: {
+            sessionId: string;
+            name: string;
+        };
+        result: CatalogSessionRecord;
+    };
+    acquire_maintenance: {
+        args: {
+            sessionId: string;
+            operation: MaintenanceLease['operation'];
+            holderId: string;
+            leaseMs?: number;
+            /** Caller's OS pid. The server runs in the detached catalog daemon, so
+             *  it cannot use its own `process.pid` to recognise the session owner. */
+            holderPid?: number;
+        };
+        result: MaintenanceLease;
+    };
+    release_maintenance: {
+        args: {
+            lease: MaintenanceLease;
+        };
+        result: void;
+    };
+    delete: {
+        args: {
+            sessionId: string;
+            lease: MaintenanceLease;
+        };
+        result: void;
+    };
+    prune: {
+        args: {
+            maxAgeDays: number;
+            holderId: string;
+        };
+        result: number;
+    };
+    rebuild_catalog: {
+        args: Record<string, never>;
+        result: {
+            indexed: number;
+            damaged: number;
+        };
+    };
+}
+export type SessionCatalogOperationName = keyof SessionCatalogOperations;
+export type SessionCatalogClientMessage = {
+    type: 'request';
+    id: number;
+    op: SessionCatalogOperationName;
+    args: unknown;
+    authToken?: string;
+} | {
+    type: 'shutdown';
+    id: number;
+    reason?: string;
+    authToken?: string;
+};
+export type SessionCatalogServerMessage = ({
+    type: 'hello';
+} & SessionCatalogServerInfo) | {
+    type: 'event';
+    event: SessionCatalogEvent;
+} | {
+    type: 'response';
+    id: number;
+    ok: true;
+    result: unknown;
+} | {
+    type: 'response';
+    id: number;
+    ok: false;
+    error: string;
+    errorName?: string;
+};
+export declare function encodeSessionCatalogMessage(message: object): string;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/session-catalog/registry.d.ts

@@ -0,0 +1,59 @@
+import type { AgentEntry, SessionRegistryEntry } from '../session-registry-types.js';
+import type { ResumeReservation, SessionCatalogEvent } from './protocol.js';
+export interface SessionResumeClaim {
+    reservation: ResumeReservation;
+    activate(entry: SessionRegistryRegistration): Promise<void>;
+    cancel(): Promise<void>;
+}
+export type SessionRegistryRegistration = Omit<SessionRegistryEntry, 'status' | 'lastHeartbeatAt' | 'agentCount' | 'agents'> & {
+    agents?: AgentEntry[] | undefined;
+};
+/**
+ * Compatibility facade for the project-scoped Session Catalog service.
+ *
+ * It deliberately preserves the former SessionRegistry method names so first-
+ * party surfaces can cut over without retaining the device-global JSON file as
+ * a second ownership authority.
+ */
+export declare class ProjectSessionRegistry {
+    private readonly globalRoot;
+    private readonly instanceId;
+    private readonly clients;
+    private current;
+    private heartbeatTimer;
+    private agentRevision;
+    private pendingAgents;
+    private agentTimer;
+    private lastAgentWriteAt;
+    constructor(globalRoot: string);
+    private bindingKey;
+    private closeBinding;
+    private binding;
+    private fullEntry;
+    register(entry: SessionRegistryRegistration): Promise<void>;
+    /** Reserve before transcript hydration; activation swaps ownership only after the writer opened. */
+    reserveResume(target: {
+        sessionId: string;
+        projectSlug: string;
+        projectRoot: string;
+    }): Promise<SessionResumeClaim>;
+    updateAgents(agents: AgentEntry[]): Promise<void>;
+    private flushAgents;
+    markClosing(): Promise<void>;
+    unregister(): Promise<void>;
+    list(): Promise<SessionRegistryEntry[]>;
+    listByProject(projectSlug: string): Promise<SessionRegistryEntry[]>;
+    get(sessionId: string): Promise<SessionRegistryEntry | undefined>;
+    subscribeProject(projectSlug: string, projectRoot: string, listener: (event: SessionCatalogEvent) => void): Promise<() => Promise<void>>;
+    get registryPath(): string;
+    dispose(): Promise<void>;
+    /** Whether this facade currently owns a live session lease. */
+    ownsSession(): boolean;
+    private startHeartbeat;
+    private stopHeartbeat;
+    private cancelAgentTimer;
+    private heartbeat;
+}
+export declare function getProjectSessionRegistry(globalRoot?: string): ProjectSessionRegistry;
+export declare function hasProjectSessionRegistry(globalRoot?: string): boolean;
+//# sourceMappingURL=registry.d.ts.map

package/dist/session-catalog/store.d.ts

@@ -0,0 +1,71 @@
+import type { SessionRegistryEntry } from '../session-registry-types.js';
+import type { SessionSummary } from '../types/session.js';
+import type { CatalogSessionRecord, MaintenanceLease, ResumeReservation, SessionCatalogHealth, SessionLeaseCredential } from './protocol.js';
+export declare class SessionCatalogStore {
+    readonly projectDir: string;
+    readonly databasePath: string;
+    readonly sessionsDir: string;
+    private db;
+    private readonly scrubber;
+    constructor(projectDir: string);
+    private configureDatabase;
+    close(): void;
+    private initialize;
+    private transaction;
+    private bumpGeneration;
+    generation(): number;
+    private reapExpired;
+    private maintenanceExists;
+    private leaseRow;
+    /**
+     * True when `sessionId` has a live `session_leases` row owned by a
+     * different OS process than the *caller*. Used by
+     * `acquireMaintenance` to distinguish "another running wstack" (which
+     * must be fenced off) from "this very TUI owning its own session"
+     * (which is allowed to claim a non-destructive maintenance lease on
+     * its own transcript).
+     *
+     * `callerPid` must be the pid of the process that asked for the lease,
+     * NOT `process.pid`. In the built runtime this store lives inside the
+     * detached project-catalog daemon, so `process.pid` is the daemon's and
+     * would mark every lease — including the caller's own session — foreign,
+     * making `/clear` and `/rewind` fail with "Session … is live". Callers
+     * that run the store in-process may omit it.
+     */
+    private foreignLiveLease;
+    private verifyCredential;
+    private createLease;
+    claimNew(entry: SessionRegistryEntry, ownerInstanceId: string, leaseMs?: number): SessionLeaseCredential;
+    reconnectLease(credential: SessionLeaseCredential): SessionLeaseCredential;
+    reserveResume(targetSessionId: string, requesterInstanceId: string, currentSessionId?: string, reservationMs?: number): ResumeReservation;
+    activateReservation(reservation: ResumeReservation, entry: SessionRegistryEntry, leaseMs?: number): SessionLeaseCredential;
+    cancelReservation(reservationId: string, requesterInstanceId: string): void;
+    heartbeat(credential: SessionLeaseCredential, status?: SessionRegistryEntry['status']): SessionLeaseCredential;
+    publishAgents(credential: SessionLeaseCredential, revision: number, agents: SessionRegistryEntry['agents']): {
+        accepted: boolean;
+        revision: number;
+    };
+    markClosing(credential: SessionLeaseCredential): void;
+    release(credential: SessionLeaseCredential): void;
+    listLive(): SessionRegistryEntry[];
+    getLive(sessionId: string): SessionRegistryEntry | null;
+    private containedPath;
+    upsertSummary(summary: SessionSummary, transcriptRelativePath?: string, summaryRelativePath?: string): CatalogSessionRecord;
+    private catalogRecord;
+    listCatalog(limit?: number, search?: string): CatalogSessionRecord[];
+    getSummary(sessionId: string): CatalogSessionRecord | null;
+    resolveId(query: string): string;
+    rename(sessionId: string, name: string): Promise<CatalogSessionRecord>;
+    acquireMaintenance(sessionId: string, operation: MaintenanceLease['operation'], holderId: string, leaseMs?: number, holderPid?: number): MaintenanceLease;
+    releaseMaintenance(lease: MaintenanceLease): void;
+    delete(sessionId: string, lease: MaintenanceLease): void;
+    prune(maxAgeDays: number, holderId: string): number;
+    rebuildCatalog(): {
+        indexed: number;
+        damaged: number;
+    };
+    private walkFiles;
+    private summarizeTranscript;
+    health(base: Omit<SessionCatalogHealth, 'catalogRows' | 'damagedRows' | 'liveLeases' | 'reservations' | 'maintenanceLeases' | 'generation' | 'lastReconciliation'>): SessionCatalogHealth;
+}
+//# sourceMappingURL=store.d.ts.map

package/dist/storage/index.d.ts

@@ -1,44 +1,48 @@
-export { DefaultSessionStore, type SessionStoreOptions, } from './session-store.js';
-export { SessionCheckpointCas, type CheckpointGitResult, type SessionCheckpointCasOptions, } from './session-checkpoint-cas.js';
-export { generateSessionId, sanitizeModel } from './session-id.js';
-export { resolveSessionId, sessionIdResolutionError, type SessionIdResolution, } from './session-id-resolver.js';
-export { QUEUE_MAX_BYTES, QUEUE_MAX_ITEM_BYTES, QUEUE_MAX_ITEMS, QueueStore, retainPersistedQueueItems, type PersistedQueueItem, } from './queue-store.js';
-export { DefaultAttachmentStore, type AttachmentStoreOptions, } from './attachment-store.js';
+export { AgentStatusTracker, type AgentStatusTrackerOptions, } from '../agent-status-tracker.js';
+export { FleetNotifier, type FleetNotifierOptions, } from '../fleet-notifier.js';
+export { type CatalogSessionRecord, type MaintenanceLease, type ResumeReservation, type SessionCatalogHealth, SessionCatalogProjectClient, type SessionCatalogProjectClientOptions, type SessionLeaseCredential, type SessionResumeClaim, } from '../session-catalog/index.js';
+export { getProjectSessionRegistry as getSessionRegistry, hasProjectSessionRegistry as hasSessionRegistry, ProjectSessionRegistry as SessionRegistry, } from '../session-catalog/registry.js';
+export type { AgentEntry, AgentLiveStatus, SessionLiveStatus, SessionRegistryEntry, SessionWebUIEndpointHint, } from '../session-registry.js';
+/** @deprecated Test/migration adapter; production ownership uses SessionRegistry above. */
+export { SessionRegistry as LegacySessionRegistry } from '../session-registry.js';
+export type { SyncCategory, SyncConfig } from '../types/config.js';
+export type { DefaultSessionReaderOptions, SessionReader } from '../types/session-reader.js';
+export { type Annotation, AnnotationsStore, type AnnotationsStoreOptions, } from './annotations-store.js';
+export { type AttachmentStoreOptions, DefaultAttachmentStore, } from './attachment-store.js';
+export { applyNamespacePayload, buildNamespacePayloads, CLOUD_SYNC_CONTRACT, CLOUD_SYNC_NAMESPACES, CloudConfigSync, type CloudConfigSyncDeps, type CloudConfigSyncSettings, type CloudSyncPassSummary, LOCAL_ONLY_TOP_LEVEL, NAMESPACE_SCHEMA_VERSIONS, stripSecretMaterial, } from './cloud-config-sync.js';
+export { ALL_SYNC_CATEGORIES, CloudSync, type SyncResult, } from './cloud-sync.js';
+export { type CompletedWorkCheckpointFile, loadCompletedWorkCheckpoint, saveCompletedWorkCheckpoint, } from './completed-work-checkpoint.js';
+export { CONFIG_BEHAVIOR_DEFAULTS, type ConfigDefaultRepair, type ConfigDefaultRepairReport, type ConfigLoaderOptions, type ConfigSource, DefaultConfigLoader, repairConfigDefaults, } from './config-loader.js';
+export { type ConfigMigration, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, type MigrationContext, type MigrationResult, runConfigMigrations, } from './config-migration.js';
+export { DefaultConfigStore } from './config-store.js';
+export { DirectorStateCheckpoint, type DirectorStateSnapshot, type DirectorSubagentState, type DirectorTaskState, loadDirectorState, } from './director-state.js';
+export { applyGoalDeliverableCompletions, type CompletedGoalDeliverable, type CoordinateGoalIterationOptions, coordinateGoalIteration, type GoalCoordinationResult, isGoalDeliverableComplete, parseCompletedGoalDeliverables, recomputeGoalProgress, stripGoalDeliverableMarker, } from './goal-coordination.js';
+export { createGoalKanbanBoard, deleteGoalKanbanBoard, findGoalBoardByTag, findGoalKanbanBoard, formatGoalAutonomyChoice, formatGoalEvent, formatGoalKanbanPreview, type GoalFileWithKanban, parseAutonomyChoice, } from './goal-kanban.js';
+export { appendJournal, emptyGoal, formatGoal, type GoalFile, goalFilePath, type JournalEntry, loadGoal, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, type ProgressSnapshot, parseProgressFromText, recordProgress, saveGoal, setProgress, summarizeUsage, } from './goal-store.js';
+export { INPUT_HISTORY_DEFAULT_MAX, InputHistoryStore, } from './input-history-store.js';
 export { FileMemoryBackend, type FileMemoryBackendOptions, type MemoryBackend, parseEntries, } from './memory-backend.js';
+export { type ConsolidationOp, type ConsolidatorSage, type MemoryConsolidatorOptions, SessionMemoryConsolidator, } from './memory-consolidator.js';
 export { GraphMemoryBackend, type GraphMemoryBackendOptions, } from './memory-graph-backend.js';
-export { SessionMemoryConsolidator, type MemoryConsolidatorOptions, type ConsolidationOp, type ConsolidatorSage, } from './memory-consolidator.js';
-export { DefaultConfigStore } from './config-store.js';
-export { readProviderSnapshot, watchProviderConfig, type ProviderConfigSnapshot, type WatchProviderConfigOptions, } from './provider-config-watcher.js';
-export { CONFIG_BEHAVIOR_DEFAULTS, type ConfigDefaultRepair, type ConfigDefaultRepairReport, type ConfigLoaderOptions, type ConfigSource, DefaultConfigLoader, repairConfigDefaults, } from './config-loader.js';
-export { runConfigMigrations, ConfigMigrationError, DEFAULT_CONFIG_MIGRATIONS, type ConfigMigration, type MigrationContext, type MigrationResult, } from './config-migration.js';
-export { RecoveryLock, type RecoveryLockOptions, type AbandonedSession, } from './recovery-lock.js';
-export { DefaultSessionReader } from './session-reader.js';
-export type { SessionReader, DefaultSessionReaderOptions } from '../types/session-reader.js';
-export { scrubPersistedSessionData, scrubPersistedSessionEvent, scrubPersistedSessionSummary, } from './session-read-scrubber.js';
-export { AnnotationsStore, type Annotation, type AnnotationsStoreOptions, } from './annotations-store.js';
-export { ReplayLogStore, type ReplayEntry, type ReplayLogStoreOptions, } from './replay-log-store.js';
-export { SessionRecovery, type StaleSession, type RecoveryPlan, } from './session-recovery.js';
-export { ToolAuditLog, type AuditEntry, type ToolAuditLogOptions, type VerifyResult, } from './tool-audit-log.js';
+export { addPlanItem, attachPlanCheckpoint, clearPlan, deriveTodosFromPlanItem, emptyPlan, formatPlan, loadPlan, mutatePlan, type PlanFile, type PlanItem, removePlanItem, savePlan, setPlanItemStatus, } from './plan-store.js';
+export { formatPlanTemplates, getPlanTemplate, listPlanTemplates, type PlanTemplate, } from './plan-templates.js';
+export { DefaultPromptStore, migratePromptEntry, type PromptEntry, type PromptStore, promptChecksum, } from './prompt-store.js';
+export { type PromptUsage, PromptUsageStore } from './prompt-usage-store.js';
+export { type ProviderConfigSnapshot, readProviderSnapshot, type WatchProviderConfigOptions, watchProviderConfig, } from './provider-config-watcher.js';
+export { type PersistedQueueItem, QUEUE_MAX_BYTES, QUEUE_MAX_ITEM_BYTES, QUEUE_MAX_ITEMS, QueueStore, retainPersistedQueueItems, } from './queue-store.js';
+export { type AbandonedSession, RecoveryLock, type RecoveryLockOptions, } from './recovery-lock.js';
+export { type ReplayEntry, ReplayLogStore, type ReplayLogStoreOptions, } from './replay-log-store.js';
 export { SessionAnalyzer } from './session-analyzer.js';
-export { SessionRegistry, getSessionRegistry, hasSessionRegistry, type SessionRegistryEntry, type SessionWebUIEndpointHint, type AgentEntry, type AgentLiveStatus, type SessionLiveStatus, } from '../session-registry.js';
-export { AgentStatusTracker, type AgentStatusTrackerOptions, } from '../agent-status-tracker.js';
-export { FleetNotifier, type FleetNotifierOptions, } from '../fleet-notifier.js';
+export { type CheckpointGitResult, SessionCheckpointCas, type SessionCheckpointCasOptions, } from './session-checkpoint-cas.js';
+export { type AuditLevel, CORE_RECONSTRUCT_EVENTS, createSessionEventBridge, resolveAuditLevel, resolveSessionLoggingConfig, type SessionEventBridge, type SessionEventBridgeOptions, type SessionSamplingOptions, STANDARD_AUDIT_EVENTS, type ToolProgressSamplingOptions, } from './session-event-bridge.js';
+export { generateSessionId, sanitizeModel } from './session-id.js';
+export { resolveSessionId, type SessionIdResolution, sessionIdResolutionError, } from './session-id-resolver.js';
+export { scrubPersistedSessionData, scrubPersistedSessionEvent, scrubPersistedSessionSummary, } from './session-read-scrubber.js';
+export { DefaultSessionReader } from './session-reader.js';
+export { type RecoveryPlan, SessionRecovery, type StaleSession, } from './session-recovery.js';
+export { type ApplyRewindOptions, type ApplyRewindResult, applyRewindToConversation, type RewindableConversation, } from './session-rewind-apply.js';
 export { DefaultSessionRewinder, type SessionRewinderOptions, } from './session-rewinder.js';
-export { applyRewindToConversation, type ApplyRewindOptions, type ApplyRewindResult, type RewindableConversation, } from './session-rewind-apply.js';
+export { DefaultSessionStore, type SessionStoreOptions, } from './session-store.js';
+export { emptyTaskFile, loadTasks, mutateTasks, saveTasks, type TaskFile, } from './task-store.js';
 export { attachTodosCheckpoint, loadTodosCheckpoint, saveTodosCheckpoint, type TodosCheckpointFile, } from './todos-checkpoint.js';
-export { loadCompletedWorkCheckpoint, saveCompletedWorkCheckpoint, type CompletedWorkCheckpointFile, } from './completed-work-checkpoint.js';
-export { attachPlanCheckpoint, loadPlan, savePlan, emptyPlan, addPlanItem, removePlanItem, setPlanItemStatus, clearPlan, formatPlan, deriveTodosFromPlanItem, mutatePlan, type PlanItem, type PlanFile, } from './plan-store.js';
-export { listPlanTemplates, getPlanTemplate, formatPlanTemplates, type PlanTemplate, } from './plan-templates.js';
-export { loadTasks, saveTasks, emptyTaskFile, mutateTasks, type TaskFile, } from './task-store.js';
-export { DirectorStateCheckpoint, loadDirectorState, type DirectorStateSnapshot, type DirectorTaskState, type DirectorSubagentState, } from './director-state.js';
-export { loadGoal, saveGoal, emptyGoal, appendJournal, formatGoal, setProgress, recordProgress, parseProgressFromText, goalFilePath, summarizeUsage, MAX_JOURNAL_ENTRIES, MAX_PROGRESS_HISTORY, type GoalFile, type JournalEntry, type ProgressSnapshot, } from './goal-store.js';
-export { createGoalKanbanBoard, findGoalKanbanBoard, deleteGoalKanbanBoard, findGoalBoardByTag, formatGoalKanbanPreview, formatGoalEvent, formatGoalAutonomyChoice, parseAutonomyChoice, type GoalFileWithKanban, } from './goal-kanban.js';
-export { applyGoalDeliverableCompletions, coordinateGoalIteration, isGoalDeliverableComplete, parseCompletedGoalDeliverables, recomputeGoalProgress, stripGoalDeliverableMarker, type CompletedGoalDeliverable, type CoordinateGoalIterationOptions, type GoalCoordinationResult, } from './goal-coordination.js';
-export { DefaultPromptStore, migratePromptEntry, promptChecksum, type PromptStore, type PromptEntry, } from './prompt-store.js';
-export { PromptUsageStore, type PromptUsage } from './prompt-usage-store.js';
-export { InputHistoryStore, INPUT_HISTORY_DEFAULT_MAX, } from './input-history-store.js';
-export { CloudSync, type SyncResult, ALL_SYNC_CATEGORIES, } from './cloud-sync.js';
-export { applyNamespacePayload, buildNamespacePayloads, CLOUD_SYNC_CONTRACT, CLOUD_SYNC_NAMESPACES, CloudConfigSync, type CloudConfigSyncDeps, type CloudConfigSyncSettings, type CloudSyncPassSummary, LOCAL_ONLY_TOP_LEVEL, NAMESPACE_SCHEMA_VERSIONS, stripSecretMaterial, } from './cloud-config-sync.js';
-export { createSessionEventBridge, resolveAuditLevel, resolveSessionLoggingConfig, type SessionEventBridge, type AuditLevel, type SessionEventBridgeOptions, type SessionSamplingOptions, type ToolProgressSamplingOptions, CORE_RECONSTRUCT_EVENTS, STANDARD_AUDIT_EVENTS, } from './session-event-bridge.js';
-export type { SyncConfig, SyncCategory } from '../types/config.js';
+export { type AuditEntry, ToolAuditLog, type ToolAuditLogOptions, type VerifyResult, } from './tool-audit-log.js';
 //# sourceMappingURL=index.d.ts.map