@wrongstack/core 0.309.1 → 0.310.1

package/dist/storage/board-store-port.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Kanban board-store port for the storage area (goal coordination).
+ *
+ * `goal-kanban.ts` and `goal-coordination.ts` previously imported the
+ * concrete functions from `@wrongstack/kanban` directly, keeping a
+ * core → kanban runtime edge (the layering inversion catalogued as
+ * roadmap #11 / report §2.1). This port is the leaf contract the storage
+ * area codes against; the CLI composition root registers the real
+ * implementation at boot (TOKENS-style dependency injection).
+ *
+ * Type-only imports of kanban's data shapes remain permitted — they erase
+ * at compile time and do not create a runtime edge. Only *callable*
+ * surface is ported.
+ *
+ * Un-registered default: goal features fail soft (board sync disabled)
+ * exactly as before the extraction, so embedding contexts without kanban
+ * keep working.
+ */
+import type { CreateKanbanBoardInput, CreateKanbanTaskInput, KanbanBoard, KanbanBoardSummary, KanbanEventContext, KanbanTask, UpdateKanbanTaskInput } from '@wrongstack/kanban';
+export interface BoardStorePort {
+    createBoard(projectRoot: string, input: CreateKanbanBoardInput): Promise<KanbanBoard>;
+    listBoards(projectRoot: string): Promise<KanbanBoardSummary[]>;
+    getBoard(projectRoot: string, boardId: string): Promise<KanbanBoard | null>;
+    removeBoard(projectRoot: string, boardId: string): Promise<boolean>;
+    addTask(projectRoot: string, boardId: string, input: CreateKanbanTaskInput, eventContext?: KanbanEventContext): Promise<{
+        board: KanbanBoard;
+        task: KanbanTask;
+    } | null>;
+    updateTask(projectRoot: string, boardId: string, taskId: string, input: UpdateKanbanTaskInput, eventContext?: KanbanEventContext): Promise<KanbanBoard | null>;
+}
+/** Composition-root hook: register the real kanban-backed implementation. */
+export declare function setBoardStorePort(impl: BoardStorePort): void;
+/**
+ * Resolve the board-store port. Callers that must fail soft should catch
+ * the not-wired error, same semantics as kanban being absent.
+ */
+export declare function boardStore(): BoardStorePort;
+/**
+ * Fail-soft resolver: the port when wired, otherwise `null`. For code paths
+ * whose documented behavior when kanban is absent is a no-op or empty
+ * result (goal sync, previews) — avoids the synchronous throw breaking
+ * `.catch()` fail-soft chains in non-CLI embeddings.
+ */
+export declare function tryBoardStore(): BoardStorePort | null;
+//# sourceMappingURL=board-store-port.d.ts.map

package/dist/storage/completed-work-checkpoint.d.ts

@@ -1,4 +1,4 @@
-import type { EventBus } from '../kernel/events.js';
+import type { EventBus } from './event-bus-port.js';
 import type { CompletedWorkEvidence } from '../types/context-evidence.js';
 export interface CompletedWorkCheckpointFile {
     version: 1;

package/dist/storage/config-loader/types.d.ts

@@ -1,4 +1,4 @@
-import type { EventBus } from '../../kernel/events.js';
+import type { EventBus } from '../event-bus-port.js';
 import type { Config } from '../../types/config.js';
 import type { Logger } from '../../types/logger.js';
 import type { SecretVault } from '../../types/secret-vault.js';

package/dist/storage/event-bus-port.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Event-bus port for the storage area.
+ *
+ * Storage modules receive a bus instance from the composition root and use
+ * it only to *emit* `storage.*` events (verified: zero subscribe/logger/
+ * constructor calls across packages/core/src/storage). Importing the concrete
+ * `EventBus` class from `../kernel/events.js` kept a storage → kernel edge in
+ * the dependency graph; this port severs it.
+ *
+ * Structurally satisfied by the kernel `EventBus` class (its typed-generic
+ * `emit` is compatible with this loose signature via method-bivariance), so
+ * composition-root wiring needs no adapter.
+ *
+ * Surface policy: emit-only. If a storage consumer ever needs to subscribe,
+ * widen this port deliberately instead of re-importing the kernel type.
+ */
+export interface EventBus {
+    /**
+     * Emit a storage-domain event onto the bus.
+     *
+     * Loose parameter typing is deliberate: the concrete kernel bus carries the
+     * full `EventMap` typing; storage call sites pass literal `'storage.*'`
+     * names whose payloads the kernel map validates at the wiring boundary.
+     */
+    emit(event: string, payload?: unknown): void;
+}
+//# sourceMappingURL=event-bus-port.d.ts.map

package/dist/storage/file-session-writer.d.ts

@@ -1,5 +1,5 @@
 import * as fsp from 'node:fs/promises';
-import type { EventBus } from '../kernel/events.js';
+import type { EventBus } from './event-bus-port.js';
 import type { SecretScrubber } from '../types/secret-scrubber.js';
 import type { FileSnapshot, SessionEvent, SessionMetadata, SessionSummary, SessionWriter } from '../types/session.js';
 import type { SessionCheckpointCas } from './session-checkpoint-cas.js';
@@ -46,6 +46,15 @@ export declare class FileSessionWriter implements SessionWriter {
     get onAppendBatch(): ((events: SessionEvent[]) => void) | undefined;
     set onAppendBatch(cb: ((events: SessionEvent[]) => void) | undefined);
     private readonly onCloseCb?;
+    /** Mid-session metadata checkpoint throttle. 0 disables checkpointing. */
+    private readonly metadataCheckpointMs;
+    /** One-shot guard for the "interval set but no sink" warning below. */
+    private _checkpointNoSinkWarned;
+    private readonly onMetadataCheckpointCb?;
+    /** Set whenever summary counters changed since the last metadata checkpoint. */
+    private metadataDirty;
+    private metadataTimer;
+    private metadataCheckpointInFlight;
     /** Implements SessionWriter.traceId — propagated from ContextInit.traceId. */
     traceId: string | undefined;
     /**
@@ -104,15 +113,47 @@ export declare class FileSessionWriter implements SessionWriter {
         onClose?: ((summary: SessionSummary) => void | Promise<void>) | undefined;
         /** Reconcile an explicit name changed while this writer remained open. */
         resolveName?: (() => Promise<Pick<SessionSummary, 'name'> | null>) | undefined;
+        /**
+         * Mid-session metadata checkpoint throttle (ms). While the session is
+         * live and dirty, the summary sidecar + index row are refreshed at most
+         * this often, so a SIGKILLed process still leaves accurate listing
+         * metadata instead of its create-time stub. 0 disables checkpointing —
+         * killed sessions then stay visible through the store's list()-union
+         * scan, but only with analyzer-derived metadata rather than tracked
+         * counters. Default 10_000.
+         */
+        metadataCheckpointMs?: number | undefined;
+        /**
+         * Persists a mid-session summary snapshot (store-level index row /
+         * catalog upsert). The sidecar file itself is written by the writer
+         * under its manifest lock; this callback covers the index side.
+         */
+        onMetadataCheckpoint?: ((summary: SessionSummary) => void | Promise<void>) | undefined;
     }, traceId?: string | undefined);
     get pendingToolUses(): string[];
     private writeSessionStartLazy;
+    /**
+     * Arm the mid-session metadata checkpoint timer if it is not already armed.
+     * Called after every observed event; the timer itself is unref'd so an idle
+     * session never keeps the process alive for a cosmetic sidecar refresh.
+     */
+    private scheduleMetadataCheckpoint;
+    /**
+     * Persist a mid-session summary snapshot: the `.summary.json` sidecar under
+     * the manifest lock, then the store-level index row / catalog upsert via
+     * `onMetadataCheckpoint`. Runs at most once per throttle interval and only
+     * when summary counters changed since the last checkpoint; a failed
+     * checkpoint stays dirty and retries on the next armed tick.
+     */
+    private runMetadataCheckpoint;
     append(event: SessionEvent): Promise<void>;
     appendBatch(events: SessionEvent[]): Promise<void>;
     /**
      * Flush buffered events to disk immediately. Critical events
-     * (user_input, llm_response) call this so they survive SIGKILL/crash
-     * instead of sitting in the in-memory buffer for up to 500ms.
+     * (user_input, llm_response, checkpoint, in_flight_*) already flush
+     * themselves inside append()/appendBatch(), so calling this matters for
+     * non-critical tails that would otherwise sit in the in-memory buffer
+     * for up to 500ms.
      *
      * Idempotent — cancels any pending timer, writes whatever has accumulated,
      * then asks the OS to synchronize the file data before resolving. Even an
@@ -123,8 +164,9 @@ export declare class FileSessionWriter implements SessionWriter {
      * Last-gasp synchronous drain for hard-exit paths (process.exit after
      * rapid Ctrl+C). The async write chain cannot be awaited when the process
      * is about to die, but whatever still sits in the in-memory buffer CAN be
-     * saved with a blocking append. Best-effort: an in-flight async write may
-     * be cut off by the exit regardless; errors here are swallowed.
+     * saved with a blocking append. A failed sync append leaves the buffer
+     * intact so a subsequent close()/flush() can retry. An in-flight async
+     * write may still be cut off by a hard exit.
      */
     flushSync(): void;
     close(): Promise<void>;

package/dist/storage/goal-coordination.d.ts

@@ -1,5 +1,5 @@
 import type { BrainArbiter } from '../coordination/brain.js';
-import type { EventBus } from '../kernel/events.js';
+import type { EventBus } from './event-bus-port.js';
 import { type GoalFile } from './goal-store.js';
 export interface CompletedGoalDeliverable {
     index: number;

package/dist/storage/goal-store.d.ts

@@ -1,4 +1,4 @@
-import type { EventBus } from '../kernel/events.js';
+import type { EventBus } from './event-bus-port.js';
 /**
  * Long-running autonomous mission. A goal survives across sessions and
  * drives the EternalAutonomyEngine — every iteration of the engine

package/dist/storage/index.d.ts

@@ -1,10 +1,9 @@
-export { AgentStatusTracker, type AgentStatusTrackerOptions, } from '../agent-status-tracker.js';
-export { FleetNotifier, type FleetNotifierOptions, } from '../fleet-notifier.js';
+export { type BoardStorePort, boardStore, setBoardStorePort, } from './board-store-port.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';
+export type { AgentEntry, AgentLiveStatus, SessionLiveStatus, SessionRegistryEntry, SessionWebUIEndpointHint, } from '../session-catalog/session-registry.js';
 /** @deprecated Test/migration adapter; production ownership uses SessionRegistry above. */
-export { SessionRegistry as LegacySessionRegistry } from '../session-registry.js';
+export { SessionRegistry as LegacySessionRegistry } from '../session-catalog/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';