@wrongstack/core 0.302.2 → 0.305.0

package/dist/storage/memory-consolidator.d.ts

@@ -9,7 +9,7 @@ import type { Provider } from '../types/provider.js';
  * rememberSage rather than the legacy MemoryStore.remember(),
  * making them visible to searchSage/turn-middleware.
  */
-type ConsolidatorSageKind = 'fact' | 'decision' | 'convention' | 'preference' | 'anti_pattern' | 'warning' | 'workflow' | 'bug_root_cause' | 'file_note' | 'symbol_note' | 'command_note';
+type ConsolidatorSageKind = 'fact' | 'decision' | 'convention' | 'preference' | 'anti_pattern' | 'warning' | 'workflow' | 'bug_root_cause' | 'file_note' | 'symbol_note' | 'command_note' | 'session_digest';
 interface ConsolidatorMemoryAnchor {
     type: 'file' | 'directory' | 'symbol' | 'package' | 'command' | 'test' | 'git';
     path?: string | undefined;
@@ -25,12 +25,14 @@ export interface ConsolidatorSage {
         priority?: string | undefined;
         importance?: number | undefined;
         confidence?: number | undefined;
-        persistence?: 'long_lived' | undefined;
+        persistence?: 'long_lived' | 'short_lived' | undefined;
         anchors?: ConsolidatorMemoryAnchor[] | undefined;
         sources?: Array<{
             type: string;
             sessionId?: string | undefined;
         }> | undefined;
+        ownerSessionId?: string | undefined;
+        expiresAt?: string | undefined;
     }): Promise<unknown>;
     listSage?(statuses?: Array<'active'>): Promise<unknown[]>;
     searchSage?(query: string, opts?: {

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

@@ -1,5 +1,5 @@
-import type { EventBus } from '../kernel/events.js';
 import type { ConversationState } from '../core/conversation-state.js';
+import type { EventBus } from '../kernel/events.js';
 /**
  * Plan items are the strategic counterpart to todos. Where `ctx.todos`
  * is the moment-to-moment task board the LLM mutates per-turn, a plan

package/dist/storage/session-resume-validation.d.ts

@@ -1,6 +1,30 @@
 import type { ResumeValidation, SessionEvent } from '../types/session.js';
 /** Revalidate the latest persisted hash for every distinct observed path. */
 export declare function validateResumeFileObservations(events: readonly SessionEvent[], projectRoot: string): Promise<ResumeValidation>;
+/**
+ * Headers of the system messages `resume()` injects.
+ *
+ * They are described as ephemeral, but every consumer hands the resumed
+ * message list to `replaceMessages`, which journals it as a
+ * `messages_replaced` snapshot — so a notice written on one resume is replayed
+ * as ordinary conversation on the next one, and a fresh notice is added on top.
+ * Three resumes with the same modified file left three copies, all but the last
+ * describing a check that had already been superseded. `resume()` therefore
+ * strips previous notices from the replayed conversation before appending the
+ * current ones; these prefixes are how it recognizes them.
+ */
+export declare const RESUME_NOTICE_HEADERS: readonly ['[SESSION RESUME FILE VALIDATION]', '[SESSION RESUME INTERRUPTED WORK]'];
+/**
+ * True for a system message this module produced on an earlier resume.
+ *
+ * Deliberately narrow: only a `system` message whose text *starts* with one of
+ * the headers matches, so a user or model quoting a notice back is never
+ * mistaken for one.
+ */
+export declare function isResumeNoticeMessage(message: {
+    role: string;
+    content: unknown;
+}): boolean;
 /** Build the ephemeral system message injected into the first resumed turn. */
 export declare function formatResumeValidationNotice(validation: ResumeValidation, projectRoot: string): string | null;
 /**

package/dist/storage/session-store/directory-scan.d.ts

@@ -1,3 +1,7 @@
 export declare function shouldSkipSessionDirectoryEntry(name: string): boolean;
-export declare function isSessionJsonlFileName(name: string): boolean;
+/**
+ * Re-exported under the store's own name; the rule itself lives with
+ * `sessionScopedPath`, which is what writes the sidecars this excludes.
+ */
+export { isSessionTranscriptFileName as isSessionJsonlFileName } from '../../utils/session-scoped-path.js';
 //# sourceMappingURL=directory-scan.d.ts.map

package/dist/storage/session-store/fork-session.d.ts

@@ -1,8 +1,20 @@
-import type { ForkedSession, SessionData, SessionForkOptions, SessionMetadata, SessionWriter } from '../../types/session.js';
+import type { ForkedSession, SessionData, SessionEvent, SessionForkOptions, SessionMetadata, SessionWriter } from '../../types/session.js';
 export interface SessionForkHost {
     load(id: string): Promise<SessionData>;
     create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
     delete(id: string): Promise<void>;
+    /**
+     * Every persisted event of `id`, exactly as it sits on disk.
+     *
+     * `load()` is NOT a substitute. Its loader strips the payload out of every
+     * superseded `messages_replaced` / `context_snapshot` to bound heap, in
+     * place, on the array it returns. Forking from that array copies the
+     * emptied snapshots into the child journal, where replay reads them as
+     * "the conversation is now zero messages" and the child loses every turn
+     * that preceded the newest snapshot inside the fork boundary. A fork is a
+     * byte-level inheritance of the parent prefix, so it has to read the bytes.
+     */
+    readRawEvents(id: string): Promise<SessionEvent[]>;
 }
 export declare function forkSession(host: SessionForkHost, id: string, opts?: SessionForkOptions): Promise<ForkedSession>;
 //# sourceMappingURL=fork-session.d.ts.map

package/dist/storage/session-store/load-cache.d.ts

@@ -9,6 +9,17 @@ export declare class SessionLoadCache {
     constructor(entries?: Map<string, LoadCacheEntry>);
     private bytes;
     clear(sessionId?: string): void;
+    /**
+     * A hit hands back fresh `messages` / `events` arrays over the cached
+     * contents.
+     *
+     * The entry outlives every caller, and callers treat what they get as their
+     * own: `resume()` passes `messages` straight into a live conversation, and
+     * anything walking `events` may splice it. Returning the cached arrays
+     * themselves let one caller's edit rewrite what the next one loads. The
+     * elements are still shared — copying them would defeat the cache — so
+     * entries remain read-only *contents* behind private containers.
+     */
     getFresh(id: string, stat: FileStatSnapshot, full: boolean): SessionData | null;
     set(id: string, stat: FileStatSnapshot, data: SessionData): void;
     private delete;

package/dist/storage/session-store/prune-helpers.d.ts

@@ -1,3 +1,8 @@
+/**
+ * Prunable === is a transcript. This module held the only complete sidecar
+ * list in the codebase while the listing scans held shorter ones; sharing the
+ * predicate is what stops them disagreeing again.
+ */
 export declare function isPrunableSessionJsonl(name: string): boolean;
 export declare function pruneSessionFiles(storeDir: string, maxAgeDays: number, deleteSession: (id: string) => Promise<void>): Promise<number>;
 //# sourceMappingURL=prune-helpers.d.ts.map

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

@@ -57,6 +57,18 @@ export declare class DefaultSessionStore implements SessionStore {
     private ensureShardDir;
     create(meta: Omit<SessionMetadata, 'startedAt'>): Promise<SessionWriter>;
     fork(id: string, opts?: SessionForkOptions): Promise<ForkedSession>;
+    /**
+     * Implements {@link SessionForkHost.readRawEvents} — the parent stream a fork
+     * inherits, unmodified.
+     *
+     * Deliberately NOT `load()`: that loader empties superseded snapshot payloads
+     * in place and front-drops events past its retention budget, both of which
+     * are correct for reconstructing a conversation and wrong for copying a
+     * journal prefix into a child. Streaming with an accept-everything predicate
+     * keeps the scrubbing contract (`searchEvents` scrubs each line the same way
+     * `load()` does) without either transformation.
+     */
+    readRawEvents(id: string): Promise<SessionEvent[]>;
     /**
      * Capture the deterministic post-tool workspace identity through the store-owned CAS.
      */
@@ -167,6 +179,12 @@ export declare class DefaultSessionStore implements SessionStore {
     private listFromDirectoryScan;
     private collectShardKeys;
     private readOrBuildShardManifest;
+    /**
+     * Shard manifests are invalidated by other store processes via atomic
+     * delete/rebuild. Validate the in-memory projection against the persisted
+     * file so one long-lived process cannot retain another process's stale view.
+     */
+    private freshShardManifestCacheEntry;
     private collectSessionFilesInShard;
     private collectSessionFiles;
     /** Recursively collect session IDs from date-shard subdirectories.

package/dist/tasking/index.js

@@ -367,6 +367,11 @@ var TaskTracker = class _TaskTracker {
     if (!this.graph) return false;
     const node = this.graph.nodes.get(id);
     if (!node) return false;
+    if (node.specRequirementId && this.graph.requiredRequirementIds?.includes(node.specRequirementId) && !Array.from(this.graph.nodes.values()).some(
+      (candidate) => candidate.id !== id && candidate.specRequirementId === node.specRequirementId
+    )) {
+      return false;
+    }
     this.graph.nodes.delete(id);
     this.graph.edges = this.graph.edges.filter((e) => e.from !== id && e.to !== id);
     this.graph.rootNodes = this.graph.rootNodes.filter((r) => r !== id);