@vascend/talos 0.1.4 → 0.1.6

package/dist/vascend/candidate-collector.d.ts

@@ -1,8 +1,9 @@
 import { type ContextCandidate } from "./context-candidate.js";
-import { type RoomRecord } from "./room-memory.js";
-import { type CastlePlan } from "./plan-store.js";
-import { type Vision } from "./vision.js";
-import { type DecisionEvent } from "./decision-promotion.js";
+import type { RoomRecord } from "./room-memory.js";
+import type { CastlePlan } from "./plan-store.js";
+import type { Vision } from "./vision.js";
+import type { DecisionEvent } from "./decision-promotion.js";
+import { ContextStoreReader } from "./context-store-reader.js";
 export interface CollectInput {
     readonly sessionDir: string;
     readonly scopeId: string;
@@ -13,7 +14,7 @@ export interface CollectInput {
     /** Preselected dependencies supplied by a coherent snapshot. */
     readonly projectScopes?: readonly string[];
 }
-export declare function collectCandidates(input: CollectInput): readonly ContextCandidate[];
+export declare function collectCandidates(input: CollectInput, reader?: ContextStoreReader): readonly ContextCandidate[];
 export declare function candidateFromRoom(r: RoomRecord, scopeId: string): ContextCandidate;
 export declare function candidatesFromCastle(castle: CastlePlan, scopeId: string): readonly ContextCandidate[];
 export declare function candidateFromVision(v: Vision, scopeId: string): ContextCandidate;

package/dist/vascend/candidate-collector.js

@@ -8,44 +8,44 @@
 // Modulo di SOLA LETTURA: apre gli store e legge; nessuna scrittura. Robusto
 // agli store mancanti (safe()).
 import { candidateFromEvent, normalizeCandidate, } from "./context-candidate.js";
-import { MemoryStore, listMemoryScopes } from "./memory-store.js";
-import { RoomMemory } from "./room-memory.js";
-import { VascendPlanStore } from "./plan-store.js";
-import { VascendVisionStore } from "./vision.js";
-import { DecisionStore } from "./decision-promotion.js";
+import { listMemoryScopes } from "./memory-store.js";
 import { listContextMemoryScopes } from "./context-fabric.js";
+import { ContextStoreReader } from "./context-store-reader.js";
 // Retrieval limits apply after ranking; explicit collector limits remain supported.
 const DEFAULT_CANDIDATE_LIMIT = Number.POSITIVE_INFINITY;
 // Raccoglie e de-duplica i candidati dal Memory OS. Deterministico a parita'
 // di store su disco.
-export function collectCandidates(input) {
+export function collectCandidates(input, reader = new ContextStoreReader(input.sessionDir)) {
     const limit = input.limit && input.limit > 0 ? input.limit : DEFAULT_CANDIDATE_LIMIT;
     const out = new Map();
     const add = (c) => {
         if (!out.has(c.id))
             out.set(c.id, c);
     };
-    // 1) Eventi del Memory OS della sessione corrente (fonte canonica).
-    for (const e of safe(() => MemoryStore.open(input.sessionDir, input.scopeId).all(), [])) {
+    const localPlan = reader.plan(input.scopeId);
+    // History remains addressable, but the materialized plan owns live state.
+    for (const e of reader.events(input.scopeId)) {
         add(candidateFromEvent(e, { scopeId: input.scopeId }));
     }
     // Le decisioni canoniche vivono in uno store dedicato. Indicizzarle solo
     // come RoomRecord le degradava a kind=room e rendeva inattivi anchor,
     // supersession e proof chain orientati alle decisioni.
-    for (const decision of safe(() => DecisionStore.open(input.sessionDir, input.scopeId).all(), [])) {
+    for (const decision of reader.decisions(input.scopeId)) {
         add(candidateFromDecision(decision, input.scopeId));
     }
     // 2) Frontiera delle stanze (RoomRecord): indice vivo del castello.
-    for (const r of safe(() => RoomMemory.open(input.sessionDir, input.scopeId).frontier(), [])) {
+    for (const r of reader.rooms(input.scopeId)) {
         add(candidateFromRoom(r, input.scopeId));
     }
     // 3) Castelli/task del piano: i task aperti sono spesso prerequisiti.
-    for (const c of safe(() => VascendPlanStore.open(input.sessionDir, input.planScopeId ?? input.scopeId).castles(), [])) {
+    const plan = !input.planScopeId || input.planScopeId === input.scopeId
+        ? localPlan : reader.plan(input.planScopeId);
+    for (const c of plan ?? []) {
         for (const cand of candidatesFromCastle(c, input.planScopeId ?? input.scopeId))
             add(cand);
     }
     // 4) Vision: stella polare, sempre dependency=true.
-    for (const v of safe(() => VascendVisionStore.open(input.sessionDir, input.scopeId).all(), [])) {
+    for (const v of reader.visions(input.scopeId)) {
         add(candidateFromVision(v, input.scopeId));
     }
     // 5) Working set da sessioni recenti (cross-scope), peso ridotto: solo eventi.
@@ -60,22 +60,23 @@ export function collectCandidates(input) {
         limit: allowedScopes ? 10_000 : projectScopeLimit,
     }).filter((scope) => !allowedScopes || allowedScopes.has(scope)).slice(0, projectScopeLimit);
     for (const scope of projectScopes) {
-        for (const e of safe(() => MemoryStore.open(input.sessionDir, scope).all(), []).slice(input.projectScopes ? 0 : -12)) {
+        const scopePlan = reader.plan(scope);
+        for (const e of reader.events(scope).slice(input.projectScopes ? 0 : -12)) {
             add(qualifyCrossScope(candidateFromEvent(e, { scopeId: scope }), scope));
         }
-        for (const decision of safe(() => DecisionStore.open(input.sessionDir, scope).all(), []).slice(input.projectScopes ? 0 : -6)) {
+        for (const decision of reader.decisions(scope).slice(input.projectScopes ? 0 : -6)) {
             add(qualifyCrossScope(candidateFromDecision(decision, scope), scope));
         }
+        if (scope !== input.planScopeId)
+            for (const castle of scopePlan ?? []) {
+                for (const candidate of candidatesFromCastle(castle, scope))
+                    add(qualifyCrossScope(candidate, scope));
+            }
         if (input.projectScopes) {
-            for (const room of safe(() => RoomMemory.open(input.sessionDir, scope).frontier(), [])) {
+            for (const room of reader.rooms(scope)) {
                 add(qualifyCrossScope(candidateFromRoom(room, scope), scope));
             }
-            if (scope !== input.planScopeId)
-                for (const castle of safe(() => VascendPlanStore.open(input.sessionDir, scope).castles(), [])) {
-                    for (const candidate of candidatesFromCastle(castle, scope))
-                        add(qualifyCrossScope(candidate, scope));
-                }
-            for (const vision of safe(() => VascendVisionStore.open(input.sessionDir, scope).all(), [])) {
+            for (const vision of reader.visions(scope)) {
                 add(qualifyCrossScope(candidateFromVision(vision, scope), scope));
             }
         }
@@ -100,20 +101,28 @@ export function candidateFromRoom(r, scopeId) {
     });
 }
 export function candidatesFromCastle(castle, scopeId) {
-    return castle.tasks.map((t) => normalizeCandidate({
-        id: `${castle.slug}/${t.id}`,
-        kind: "task",
-        domain: "plan",
-        subject: `${castle.title} :: ${t.title}`,
-        summary: `[${t.status}] ${t.title}`,
-        body: [t.title, ...(t.evidence ?? [])].join(" | "),
-        terms: tokensOf(`${castle.title} ${t.title} ${t.status} ${(t.evidence ?? []).join(" ")}`),
-        trust: "high",
-        // I task non completati sono prerequisiti per capire lo stato corrente.
-        dependency: t.status !== "completed",
-        // I task completati hanno freshness piena ma sono "fatti": status active.
-        scopeId,
-    }));
+    const after = castle.after?.trim();
+    const dependency = after ? [normalizeCandidate({
+            id: `${castle.slug}/@after`, kind: "note", domain: "plan",
+            subject: castle.slug, summary: `@after[${castle.slug}]: ${after}`,
+            body: `Dipendenza corrente: ${castle.slug} dopo ${after}`,
+            terms: tokensOf(`${castle.slug} ${after} after dipendenza`),
+            links: [after], trust: "high", dependency: true, scopeId,
+        })] : [];
+    return [...dependency, ...castle.tasks.map((t) => normalizeCandidate({
+            id: `${castle.slug}/${t.id}`,
+            kind: "task",
+            domain: "plan",
+            subject: `${castle.title} :: ${t.title}`,
+            summary: `[${t.status}] ${t.title}`,
+            body: [t.title, ...(t.evidence ?? [])].join(" | "),
+            terms: tokensOf(`${castle.title} ${t.title} ${t.status} ${(t.evidence ?? []).join(" ")}`),
+            trust: "high",
+            // I task non completati sono prerequisiti per capire lo stato corrente.
+            dependency: t.status !== "completed",
+            // I task completati hanno freshness piena ma sono "fatti": status active.
+            scopeId,
+        }))];
 }
 export function candidateFromVision(v, scopeId) {
     const features = Array.isArray(v.features) ? v.features.map((f) => featureLabel(f)).filter(Boolean) : [];
@@ -210,11 +219,3 @@ function capCandidates(candidates, limit) {
     const keep = new Set(ranked.map(({ candidate }) => candidate.id));
     return candidates.filter((candidate) => keep.has(candidate.id));
 }
-function safe(fn, fallback) {
-    try {
-        return fn();
-    }
-    catch {
-        return fallback;
-    }
-}

package/dist/vascend/context-feedback-loop.js

@@ -111,6 +111,8 @@ function snapshotFor(input) {
     return input.snapshot ?? loadContextStoreSnapshot({
         sessionDir: input.sessionDir,
         scopeId: input.scopeId,
+        sharedProjectMemory: input.sharedProjectMemory,
+        ...(input.planScopeId ? { planScopeId: input.planScopeId } : {}),
         ...(input.projectKey ? { projectKey: input.projectKey } : {}),
     });
 }

package/dist/vascend/context-lint.js

@@ -28,13 +28,33 @@ export function lintContext(input) {
     }
     // 2) DEDUP: stessa fonte/tipo e stesso contenuto. Summary uguali possono
     // contenere prove diverse nel body; il codice preserva anche il case.
+    // room.closed mirrors use E* ids and subject=R*, while RoomRecord uses
+    // id=R* and subject=title. Only collapse a proven pair in the same scope;
+    // matching titles alone must not merge different rooms or stronger evidence.
+    const roomKeys = new Map();
+    for (const candidate of active) {
+        if (candidate.kind === "room" && candidate.domain === "rooms" && candidate.subject === candidate.summary) {
+            roomKeys.set(JSON.stringify([candidate.scopeId, localRoomId(candidate)]), roomContentKey(candidate, localRoomId(candidate)));
+        }
+    }
+    const linkedIds = new Set(active.flatMap((candidate) => candidate.links));
     const seenId = new Set();
     const seenContent = new Set();
     const dedupDropped = [];
     const cleaned = [];
     for (const c of active) {
-        const contentKey = c.subject || c.summary || c.body
-            ? JSON.stringify([c.kind, c.domain, c.subject, c.summary, c.body]) : "";
+        let contentKey = c.subject || c.summary || c.body
+            ? JSON.stringify([c.kind, c.domain, c.scopeId, c.subject, c.summary, c.body,
+                c.trust, c.dependency, [...c.links].sort(), [...c.terms].sort(), c.createdAt]) : "";
+        if (c.kind === "room" && c.domain === "rooms") {
+            const mirrorKey = roomContentKey(c, c.subject);
+            const canonicalKey = roomKeys.get(JSON.stringify([c.scopeId, c.subject]));
+            contentKey = canonicalKey === mirrorKey ? mirrorKey : roomContentKey(c, localRoomId(c));
+        }
+        // Every kind can be a graph target, not only rooms. Content deduplication
+        // must not leave a dangling reference or substitute weaker evidence.
+        if (linkedIds.has(c.id))
+            contentKey = "";
         if (seenId.has(c.id) || (contentKey && seenContent.has(contentKey))) {
             dedupDropped.push(c.id);
             continue;
@@ -76,6 +96,16 @@ export function lintContext(input) {
     const ok = !findings.some((f) => f.severity === "error");
     return { findings, cleaned, ok };
 }
+function localRoomId(candidate) {
+    const prefix = candidate.scopeId ? `${candidate.scopeId}::` : "";
+    return prefix && candidate.id.startsWith(prefix) ? candidate.id.slice(prefix.length) : candidate.id;
+}
+function roomContentKey(candidate, roomId) {
+    return JSON.stringify([
+        "room", candidate.scopeId, roomId, candidate.summary, candidate.body,
+        candidate.trust, candidate.dependency, [...candidate.links].sort(),
+    ]);
+}
 // Formatta il report del lint come blocco diagnostico (per log/debug, non per
 // il prompt). Deterministico.
 export function formatLintReport(report) {

package/dist/vascend/context-market-selection.js

@@ -1,6 +1,5 @@
 import { capsuleFromCandidate, withExpansion } from "./context-capsule.js";
-import { renderCapsules, tokensAtLevel } from "./expansion-levels.js";
-import { estimateTokens } from "./budget-allocator.js";
+import { renderCapsule } from "./expansion-levels.js";
 import { runTokenMarket } from "./token-market.js";
 export function selectWithMarket(input) {
     const eligible = input.scored.filter((score) => score.tier !== "low");
@@ -18,6 +17,8 @@ export function selectWithMarket(input) {
     });
     const evidence = [];
     const memory = [];
+    let evidenceChars = 0;
+    let memoryChars = 0;
     const admitted = [];
     const dropped = [...proposed.dropped];
     for (const allocation of proposed.admitted) {
@@ -29,10 +30,16 @@ export function selectWithMarket(input) {
             const capsule = withExpansion(allocation.capsule, expansion);
             const zone = level >= 3 ? evidence : memory;
             const budget = level >= 3 ? input.evidenceBudget : input.memoryBudget;
-            if (estimateTokens(renderCapsules([...zone, capsule])) > budget)
+            const chars = renderCapsule(capsule, expansion).length;
+            const nextChars = (level >= 3 ? evidenceChars : memoryChars) + (zone.length ? 2 : 0) + chars;
+            if (Math.ceil(nextChars / 4) > budget)
                 continue;
             zone.push(capsule);
-            admitted.push({ ...allocation, capsule, level: expansion, tokensUsed: tokensAtLevel(capsule, expansion) });
+            if (level >= 3)
+                evidenceChars = nextChars;
+            else
+                memoryChars = nextChars;
+            admitted.push({ ...allocation, capsule, level: expansion, tokensUsed: Math.max(1, Math.ceil(chars / 4)) });
             placed = true;
             break;
         }
@@ -44,7 +51,7 @@ export function selectWithMarket(input) {
         memory,
         market: {
             admitted, dropped, tokenBudget: proposed.tokenBudget,
-            tokensUsed: estimateTokens(renderCapsules(evidence)) + estimateTokens(renderCapsules(memory)),
+            tokensUsed: Math.ceil(evidenceChars / 4) + Math.ceil(memoryChars / 4),
         },
     };
 }

package/dist/vascend/context-pack-render.js

@@ -3,19 +3,25 @@ export function packRendered(items, render, maxTokens, envelope = {}) {
     const included = [];
     const excluded = [];
     const blocks = [];
-    let text = "";
+    const before = envelope.before?.trim() ?? "";
+    const after = envelope.after?.trim() ?? "";
+    let count = Number(Boolean(before)) + Number(Boolean(after));
+    let chars = before.length + after.length + (count > 1 ? 2 : 0);
     for (const item of items) {
         const block = render(item).trim();
-        const next = joinBlocks(envelope.before ?? "", ...blocks, block, envelope.after ?? "");
-        if (block && estimateTokens(next) <= maxTokens) {
+        // Count the exact joined length without rebuilding every accepted prefix.
+        const nextChars = chars + block.length + (count > 0 ? 2 : 0);
+        if (block && Math.ceil(nextChars / 4) <= maxTokens) {
             blocks.push(block);
             included.push(item);
-            text = next;
+            chars = nextChars;
+            count += 1;
         }
         else {
             excluded.push(item);
         }
     }
+    const text = included.length ? joinBlocks(before, ...blocks, after) : "";
     return { text, included, excluded };
 }
 export function remainingTokens(budget, prefix) {

package/dist/vascend/context-packet-mirrors.d.ts

@@ -0,0 +1,8 @@
+import type { MemoryEvent } from "./memory-store.js";
+import type { RoomRecord } from "./room-memory.js";
+interface Scoped<T> {
+    readonly scopeId: string;
+    readonly value: T;
+}
+export declare function packetEventsWithoutMirrors(events: readonly Scoped<MemoryEvent>[], rooms: readonly Scoped<RoomRecord>[]): readonly Scoped<MemoryEvent>[];
+export {};

package/dist/vascend/context-packet-mirrors.js

@@ -0,0 +1,24 @@
+import { isDeepStrictEqual } from "node:util";
+// Only omit exact generated mirrors of rooms actually rendered earlier in the
+// packet. Unshown rooms, linked event IDs and additional metadata stay visible.
+// Storage and retrieval identities are never changed by this rendering filter.
+export function packetEventsWithoutMirrors(events, rooms) {
+    const key = (scope, id) => JSON.stringify([scope, id]);
+    const displayed = new Map(rooms.map(r => [key(r.scopeId, r.value.room), r.value]));
+    const linked = new Set();
+    for (const { scopeId, value } of events)
+        for (const link of value.links) {
+            const separator = link.target.indexOf("::");
+            linked.add(separator < 0 ? key(scopeId, link.target)
+                : key(link.target.slice(0, separator), link.target.slice(separator + 2)));
+        }
+    return events.filter(({ scopeId, value: e }) => {
+        if (e.domain !== "rooms" || !["room.closed", "rollup.created"].includes(e.type)
+            || e.links.length || linked.has(key(scopeId, e.id)))
+            return true;
+        const room = displayed.get(key(scopeId, e.subject));
+        return !room || e.summary !== room.title || e.body !== room.body
+            || e.createdAt !== room.createdAt || !isDeepStrictEqual(e.terms, room.terms)
+            || !isDeepStrictEqual(e.payload, { room });
+    });
+}

package/dist/vascend/context-plan-events.d.ts

@@ -0,0 +1,4 @@
+import type { MemoryEvent } from "./memory-store.js";
+import { type CastlePlan } from "./plan-store.js";
+export declare function loadContextPlan(sessionDir: string, scopeId: string): readonly CastlePlan[] | null;
+export declare function projectPlanEvents(events: readonly MemoryEvent[], currentPlan: readonly CastlePlan[] | null): readonly MemoryEvent[];

package/dist/vascend/context-plan-events.js

@@ -0,0 +1,44 @@
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { VascendPlanStore } from "./plan-store.js";
+// Null means unavailable, not an authoritative empty plan. A corrupt snapshot
+// must not make the only remaining evidence disappear from automatic context.
+export function loadContextPlan(sessionDir, scopeId) {
+    if (!existsSync(join(sessionDir, `${scopeId}.castle.json`)))
+        return null;
+    try {
+        return VascendPlanStore.open(sessionDir, scopeId, { strict: true }).castles();
+    }
+    catch {
+        return null;
+    }
+}
+const STATE_EVENTS = new Set([
+    "plan.castle.set", "plan.task.marked", "plan.task.evidence", "plan.tasks.added", "plan.after.set", "plan.cleared",
+]);
+// Read-only projection for automatic context, never for explicit recall.
+// The materialized plan owns current state (also after replacement/removal).
+// Event identities and complete historical evidence stay in the append-only log.
+export function projectPlanEvents(events, currentPlan) {
+    let clearedAt = -1;
+    for (let i = 0; i < events.length; i++) {
+        if (events[i]?.domain === "plan" && events[i]?.type === "plan.cleared")
+            clearedAt = i;
+    }
+    return events.map((event, index) => {
+        if (event.domain !== "plan" || !STATE_EVENTS.has(event.type))
+            return event;
+        if (currentPlan !== null || index < clearedAt) {
+            return { ...event, payload: { ...event.payload, status: "archived" } };
+        }
+        if (event.type === "plan.cleared")
+            return event;
+        // Without a trustworthy snapshot these are historical observations, not
+        // claims about the live task state. Preserve their IDs for explicit recall.
+        return {
+            ...event,
+            summary: `[cronologia; stato corrente non verificato] ${event.summary}`,
+            body: `[CRONOLOGIA_PIANO: stato corrente non verificato]\n${event.body}`,
+        };
+    });
+}

package/dist/vascend/context-snapshot.d.ts

@@ -5,6 +5,7 @@ export interface ContextSnapshotInput {
     readonly sessionDir: string;
     readonly scopeId: string;
     readonly projectKey?: string;
+    readonly sharedProjectMemory?: boolean;
     readonly indexed?: boolean;
     readonly planScopeId?: string;
 }

package/dist/vascend/context-snapshot.js

@@ -2,6 +2,7 @@ import { createHash } from "node:crypto";
 import { readdirSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { collectCandidates } from "./candidate-collector.js";
+import { ContextStoreReader } from "./context-store-reader.js";
 import { buildMemoryPacket, clampMemoryPacket } from "./memory-packet.js";
 import { retrieve } from "./context-retriever.js";
 import { ContextSearchIndex } from "./context-search-index.js";
@@ -76,11 +77,12 @@ function legacyStoreSignature(sessionDir) {
 }
 export function loadContextStoreSnapshot(input) {
     const indexed = input.indexed ?? process.env["TALOS_CONTEXT_INDEX"] !== "0";
-    const key = JSON.stringify([input.sessionDir, input.scopeId, input.projectKey, input.planScopeId, indexed]);
-    const projectScopes = indexed
+    const shared = input.sharedProjectMemory === true;
+    const key = JSON.stringify([input.sessionDir, input.scopeId, input.projectKey, input.planScopeId, indexed, shared]);
+    const projectScopes = !shared ? [] : indexed
         ? (input.projectKey ? projectMemoryScopes(input.sessionDir, input.projectKey) : []).filter((scope) => scope !== input.scopeId).sort()
         : undefined;
-    const scopes = indexed ? [input.scopeId, ...(projectScopes ?? []), ...(input.planScopeId ? [input.planScopeId] : [])] : undefined;
+    const scopes = indexed || !shared ? [input.scopeId, ...(projectScopes ?? []), ...(input.planScopeId ? [input.planScopeId] : [])] : undefined;
     const signature = storeSignature(input.sessionDir, scopes);
     const previous = cache.get(key);
     if (signature && previous?.signature === signature) {
@@ -104,8 +106,9 @@ export function loadContextStoreSnapshot(input) {
     throw new Error("gli store di contesto stanno cambiando: snapshot coerente non disponibile");
 }
 function buildSnapshot(input, key, signature, projectScopes, indexed, previous) {
+    const reader = new ContextStoreReader(input.sessionDir);
     const pool = collectCandidates({ ...input, ...(projectScopes ? { projectScopes } : {}),
-        ...(indexed ? {} : { limit: 1000 }) });
+        ...(indexed ? {} : { limit: 1000 }) }, reader);
     const index = indexed ? new ContextSearchIndex(pool, previous?.index) : undefined;
     // Eager capture: packet and candidates belong to the same checked revision.
     const recent = new Map();
@@ -114,7 +117,7 @@ function buildSnapshot(input, key, signature, projectScopes, indexed, previous)
             recent.set(candidate.scopeId, Math.max(recent.get(candidate.scopeId) ?? 0, candidate.createdAt));
     const packetScopes = projectScopes?.slice().sort((a, b) => (recent.get(b) ?? 0) - (recent.get(a) ?? 0) || a.localeCompare(b)).slice(0, 6);
     const packet = buildMemoryPacket({ ...input, maxChars: Number.MAX_SAFE_INTEGER,
-        ...(packetScopes ? { projectScopes: packetScopes } : {}) });
+        ...(packetScopes ? { projectScopes: packetScopes } : {}) }, reader);
     const retrievals = new Map();
     return {
         key, signature, pool, ...(index ? { index } : {}),

package/dist/vascend/context-store-reader.d.ts

@@ -0,0 +1,20 @@
+import { type MemoryEvent } from "./memory-store.js";
+import { type RoomRecord } from "./room-memory.js";
+import { type DecisionEvent } from "./decision-promotion.js";
+import { type Vision } from "./vision.js";
+import type { CastlePlan } from "./plan-store.js";
+export declare class ContextStoreReader {
+    private readonly sessionDir;
+    private readonly plans;
+    private readonly eventViews;
+    private readonly frontiers;
+    private readonly visionViews;
+    private readonly decisionViews;
+    constructor(sessionDir: string);
+    plan(scope: string): readonly CastlePlan[] | null;
+    events(scope: string): readonly MemoryEvent[];
+    rooms(scope: string): readonly RoomRecord[];
+    visions(scope: string): readonly Vision[];
+    decisions(scope: string): readonly DecisionEvent[];
+    private once;
+}

package/dist/vascend/context-store-reader.js

@@ -0,0 +1,46 @@
+import { MemoryStore } from "./memory-store.js";
+import { RoomMemory } from "./room-memory.js";
+import { DecisionStore } from "./decision-promotion.js";
+import { VascendVisionStore } from "./vision.js";
+import { loadContextPlan, projectPlanEvents } from "./context-plan-events.js";
+// One reader per snapshot attempt. Never reuse it across signature checks:
+// collector and packet share immutable views, not a process-wide stale cache.
+export class ContextStoreReader {
+    sessionDir;
+    plans = new Map();
+    eventViews = new Map();
+    frontiers = new Map();
+    visionViews = new Map();
+    decisionViews = new Map();
+    constructor(sessionDir) {
+        this.sessionDir = sessionDir;
+    }
+    plan(scope) {
+        return this.once(this.plans, scope, () => loadContextPlan(this.sessionDir, scope), null);
+    }
+    events(scope) {
+        return this.once(this.eventViews, scope, () => projectPlanEvents(MemoryStore.open(this.sessionDir, scope).all(), this.plan(scope)), []);
+    }
+    rooms(scope) {
+        return this.once(this.frontiers, scope, () => RoomMemory.open(this.sessionDir, scope).frontier(), []);
+    }
+    visions(scope) {
+        return this.once(this.visionViews, scope, () => VascendVisionStore.open(this.sessionDir, scope).all(), []);
+    }
+    decisions(scope) {
+        return this.once(this.decisionViews, scope, () => DecisionStore.open(this.sessionDir, scope).all(), []);
+    }
+    once(cache, scope, load, fallback) {
+        if (cache.has(scope))
+            return cache.get(scope);
+        let value;
+        try {
+            value = load();
+        }
+        catch {
+            value = fallback;
+        }
+        cache.set(scope, value);
+        return value;
+    }
+}

package/dist/vascend/context-window-compiler.d.ts

@@ -12,6 +12,7 @@ export interface CompileInput {
     readonly sessionDir: string;
     readonly scopeId: string;
     readonly projectKey?: string;
+    readonly sharedProjectMemory?: boolean;
     readonly userText: string;
     readonly retrievalQuery?: string;
     readonly totalTokens?: number;

package/dist/vascend/context-window-compiler.js

@@ -48,6 +48,7 @@ export function compileContext(input) {
     const snapshot = input.snapshot ?? loadContextStoreSnapshot({
         sessionDir: input.sessionDir,
         scopeId: input.scopeId,
+        sharedProjectMemory: input.sharedProjectMemory,
         ...(input.planScopeId ? { planScopeId: input.planScopeId } : {}),
         ...(input.projectKey ? { projectKey: input.projectKey } : {}),
     });

package/dist/vascend/file-lock.d.ts

@@ -5,3 +5,4 @@ export interface FileLockOptions {
 }
 export declare function acquireLockSync(target: string, opts?: FileLockOptions): () => void;
 export declare function withLockSync<T>(target: string, fn: () => T, opts?: FileLockOptions): T;
+export declare function withLock<T>(target: string, fn: () => T | Promise<T>, opts?: FileLockOptions, signal?: AbortSignal): Promise<T>;

package/dist/vascend/file-lock.js

@@ -1,5 +1,6 @@
 import { mkdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
 const DEFAULT_STALE_MS = 10_000;
 const DEFAULT_TIMEOUT_MS = 5_000;
 const DEFAULT_RETRY_MS = 15;
@@ -93,3 +94,28 @@ export function withLockSync(target, fn, opts) {
         release();
     }
 }
+// Interactive callers must yield while another process owns the transaction.
+// Each attempt uses the same atomic acquisition and stale-lock rules.
+export async function withLock(target, fn, opts = {}, signal) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const deadline = Date.now() + timeoutMs;
+    let release;
+    while (!release) {
+        signal?.throwIfAborted();
+        try {
+            release = acquireLockSync(target, { ...opts, timeoutMs: 0 });
+        }
+        catch (error) {
+            if (Date.now() >= deadline)
+                throw error;
+            await delay(Math.min(Math.max(1, opts.retryMs ?? DEFAULT_RETRY_MS), deadline - Date.now()), undefined, { signal });
+        }
+    }
+    try {
+        signal?.throwIfAborted();
+        return await fn();
+    }
+    finally {
+        release();
+    }
+}

package/dist/vascend/granular-kingdom.d.ts

@@ -3,6 +3,7 @@ import type { AgentEvent, ToolContext } from "../core/types.js";
 import { type FileCoordinationContext } from "../core/file-coordination.js";
 import { type TaskUnit, type TaskRunner, type GranularLaunchReport } from "./granular-launcher.js";
 export interface GranularKingdomOptions {
+    readonly retainSessions?: boolean | "queued";
     readonly harness: Harness;
     readonly kingdomId: string;
     readonly castleSlug: string;