fluffy-context 0.5.0 → 0.7.2

package/dist/src/cognition/runtime.js

@@ -9,8 +9,11 @@ import { loadManifest } from '../runtime/init.js';
 import { atomicWriteJson } from '../storage/atomic-write.js';
 import { readJson } from '../storage/json-store.js';
 import { withLock } from '../storage/lock.js';
-import { cognitionManifestPath, cognitionPolicyPath, cognitionRuntimeLeasePath, cognitionRuntimeSecretPath, locksDirectory } from '../storage/layout.js';
+import { cognitionManifestPath, cognitionRuntimeLeasePath, cognitionRuntimeSecretPath, cognitionRuntimeStartupPath, locksDirectory } from '../storage/layout.js';
 import { appendEvent } from './journal.js';
+import { rebuildProjections } from './projections.js';
+import { loadRuntimePolicy, writeRuntimePolicy } from './policy.js';
+import { FilesystemObserver } from './filesystem-observer.js';
 import { GitObserver } from './git-observer.js';
 import { reconcileV1State } from './migration-v1.js';
 import { v1Synced } from './v1-bridge.js';
@@ -19,6 +22,8 @@ const protocolVersion = 1;
 const maxFrameBytes = 16 * 1024;
 const pollIntervalMs = 2_000;
 const cliPath = fileURLToPath(new URL('../cli/main.js', import.meta.url));
+const startupPromises = new Map();
+const startupMarkerTimeoutMs = 10_000;
 function createInstanceId() {
     return crypto.randomBytes(12).toString('hex');
 }
@@ -44,11 +49,21 @@ async function exists(filePath) {
     }
 }
 async function loadPolicy(projectRoot) {
-    return readJson(cognitionPolicyPath(projectRoot));
+    return loadRuntimePolicy(projectRoot);
 }
 async function loadLease(projectRoot) {
     return readJson(cognitionRuntimeLeasePath(projectRoot)).catch(() => null);
 }
+async function loadStartupMarker(projectRoot) {
+    return readJson(cognitionRuntimeStartupPath(projectRoot)).catch(() => null);
+}
+async function removeOwnedRuntimeFiles(projectRoot, instanceId) {
+    const current = await loadLease(projectRoot);
+    if (current?.instanceId !== instanceId)
+        return;
+    await rm(cognitionRuntimeLeasePath(projectRoot), { force: true });
+    await rm(cognitionRuntimeSecretPath(projectRoot), { force: true });
+}
 async function request(projectRoot, lease, method) {
     let secret;
     try {
@@ -92,23 +107,52 @@ async function liveLease(projectRoot, lease) {
 async function writeLease(projectRoot, lease) {
     await atomicWriteJson(cognitionRuntimeLeasePath(projectRoot), lease);
 }
-async function closeServer(projectRoot, server, observer, heartbeat, poller, inactivity, lease, reason) {
-    clearInterval(heartbeat);
-    clearInterval(poller);
-    clearTimeout(inactivity);
-    await observer.drain();
-    await new Promise((resolve) => server.close(() => resolve()));
-    await new Promise((resolve) => setImmediate(resolve));
-    await rm(cognitionRuntimeLeasePath(projectRoot), { force: true });
-    await rm(cognitionRuntimeSecretPath(projectRoot), { force: true });
-    await appendEvent(projectRoot, {
-        type: 'runtime.stopped',
-        source: { kind: 'cli', instanceId: lease.instanceId },
-        idempotencyKey: `runtime:stopped:${lease.instanceId}`,
-        payload: { reason },
-    });
+async function closeServer(projectRoot, server, observer, filesystem, heartbeat, poller, inactivity, background, leaseWrite, lease, reason) {
+    if (heartbeat)
+        clearInterval(heartbeat);
+    if (poller)
+        clearInterval(poller);
+    if (inactivity)
+        clearTimeout(inactivity);
+    let failure;
+    try {
+        filesystem.stop();
+        await filesystem.flush();
+        await observer.drain();
+        await filesystem.drain();
+        await background;
+        await rebuildProjections(projectRoot);
+        await leaseWrite;
+    }
+    catch (error) {
+        failure = error;
+    }
+    finally {
+        await new Promise((resolve) => {
+            if (!server.listening) {
+                resolve();
+                return;
+            }
+            server.close(() => resolve());
+        });
+        await new Promise((resolve) => setImmediate(resolve));
+        await removeOwnedRuntimeFiles(projectRoot, lease.instanceId);
+    }
+    try {
+        await appendEvent(projectRoot, {
+            type: 'runtime.stopped',
+            source: { kind: 'cli', instanceId: lease.instanceId },
+            idempotencyKey: `runtime:stopped:${lease.instanceId}`,
+            payload: { reason },
+        });
+    }
+    catch (error) {
+        failure ??= error;
+    }
+    if (failure)
+        throw failure;
 }
-function attachProtocol(projectRoot, server, observer, secret, lease, touch, close) {
+function attachProtocol(server, secret, lease, touch, observe, close) {
     server.on('connection', (socket) => {
         socket.setEncoding('utf8');
         let buffer = '';
@@ -142,7 +186,7 @@ function attachProtocol(projectRoot, server, observer, secret, lease, touch, clo
             }
             if (request.method === 'observe') {
                 try {
-                    const result = await observer.observeNow();
+                    const result = await observe();
                     socket.end(`${JSON.stringify({ ok: true, result: { changed: result.changed } })}\n`);
                 }
                 catch {
@@ -159,11 +203,14 @@ function attachProtocol(projectRoot, server, observer, secret, lease, touch, clo
         });
     });
 }
-export async function serveRuntime(startPath) {
+export async function serveRuntime(startPath, options = {}) {
     const projectRoot = await resolveProjectRoot(startPath);
     const currentPolicy = await loadPolicy(projectRoot);
     if (!currentPolicy.enabled)
         throw new Error('runtime is disabled; run ctx runtime enable first');
+    const inactivityTimeoutMs = options.inactivityTimeoutMs ?? currentPolicy.inactivityTimeoutMs;
+    const heartbeatIntervalMs = options.heartbeatIntervalMs ?? 5_000;
+    const runtimePollIntervalMs = options.pollIntervalMs ?? pollIntervalMs;
     const existing = await liveLease(projectRoot);
     if (existing)
         throw new Error('runtime is already running');
@@ -182,21 +229,55 @@ export async function serveRuntime(startPath) {
     const lease = { schemaVersion: 2, protocolVersion, projectId: manifest.projectId, instanceId: createInstanceId(), pid: process.pid, host, port: address.port, startedAt: now, heartbeatAt: now };
     const secret = createToken();
     const observer = new GitObserver(projectRoot);
-    let closed = false;
-    let heartbeat;
-    let poller;
-    let inactivity;
+    let filesystem;
+    let heartbeat = null;
+    let poller = null;
+    let inactivity = null;
+    let background = Promise.resolve();
+    let leaseWrite = Promise.resolve();
+    let filesystemEventPending = false;
+    let closing = null;
+    const enqueueObservation = (operation) => {
+        const next = background.then(operation, operation);
+        background = next.then(() => undefined, () => undefined);
+        return next;
+    };
     const close = async (reason) => {
-        if (closed)
-            return;
-        closed = true;
-        await closeServer(projectRoot, server, observer, heartbeat, poller, inactivity, lease, reason);
+        if (closing)
+            return closing;
+        closing = closeServer(projectRoot, server, observer, filesystem, heartbeat, poller, inactivity, background, leaseWrite, lease, reason);
+        return closing;
     };
     const touch = () => {
-        clearTimeout(inactivity);
-        inactivity = setTimeout(() => { void close('inactivity'); }, currentPolicy.inactivityTimeoutMs);
+        if (inactivity)
+            clearTimeout(inactivity);
+        inactivity = setTimeout(() => { void close('inactivity').catch(() => undefined); }, inactivityTimeoutMs);
     };
-    attachProtocol(projectRoot, server, observer, secret, lease, touch, close);
+    const observe = () => enqueueObservation(async () => {
+        const [gitResult, filesystemResult] = await Promise.all([
+            observer.observeNow(),
+            filesystem.observeNow(),
+        ]);
+        const synced = await v1Synced(projectRoot);
+        if (!synced)
+            await reconcileV1State(projectRoot);
+        if (gitResult.changed || filesystemResult.changed || filesystemEventPending || !synced) {
+            await rebuildProjections(projectRoot);
+            filesystemEventPending = false;
+        }
+        const changed = gitResult.changed || filesystemResult.changed || filesystemEventPending || !synced;
+        if (changed)
+            touch();
+        return { changed };
+    });
+    filesystem = new FilesystemObserver(projectRoot, {
+        anchor: () => ({ worktreeId: observer.current?.worktreeId ?? null, branch: observer.current?.branch ?? null, ref: observer.current?.ref ?? null, head: observer.current?.commit ?? null }),
+        onChanged: () => {
+            filesystemEventPending = true;
+            touch();
+        },
+    });
+    attachProtocol(server, secret, lease, touch, observe, close);
     try {
         await withLock(`${locksDirectory(projectRoot)}/cognition-runtime-start.lock`, async () => {
             const live = await liveLease(projectRoot);
@@ -213,16 +294,18 @@ export async function serveRuntime(startPath) {
     }
     heartbeat = setInterval(() => {
         lease.heartbeatAt = new Date().toISOString();
-        void writeLease(projectRoot, lease);
-    }, 5_000);
+        leaseWrite = leaseWrite.then(() => writeLease(projectRoot, lease)).catch(() => undefined);
+    }, heartbeatIntervalMs);
     poller = setInterval(() => {
-        void observer.observeNow();
-        void v1Synced(projectRoot).then((synced) => { if (!synced)
-            return reconcileV1State(projectRoot); });
-    }, pollIntervalMs);
-    touch();
+        void observe().catch(() => undefined);
+    }, runtimePollIntervalMs);
     await appendEvent(projectRoot, { type: 'runtime.started', source: { kind: 'cli', instanceId: lease.instanceId }, idempotencyKey: `runtime:started:${lease.instanceId}`, payload: {} });
-    await observer.observeNow();
+    if (currentPolicy.filesystemEventsEnabled)
+        filesystem.start();
+    await observe();
+    await writeLease(projectRoot, lease);
+    await rm(cognitionRuntimeStartupPath(projectRoot), { force: true });
+    touch();
     return { lease, close };
 }
 export async function runtimeStatus(startPath) {
@@ -240,8 +323,8 @@ export async function enableRuntime(startPath) {
     if (!await exists(cognitionManifestPath(projectRoot)))
         throw new Error('v2 migration is required before enabling the runtime');
     const current = await loadPolicy(projectRoot);
-    if (!current.enabled) {
-        await atomicWriteJson(cognitionPolicyPath(projectRoot), { ...current, enabled: true });
+    if (!current.enabled || !current.autoStart) {
+        await writeRuntimePolicy(projectRoot, { ...current, enabled: true, autoStart: true });
         await appendEvent(projectRoot, { type: 'runtime.enabled', source: { kind: 'cli' }, idempotencyKey: 'runtime:enabled', payload: {} });
     }
     return runtimeStatus(projectRoot);
@@ -252,25 +335,106 @@ export async function disableRuntime(startPath) {
         throw new Error('v2 migration is required before disabling the runtime');
     await stopRuntime(projectRoot);
     const current = await loadPolicy(projectRoot);
-    await atomicWriteJson(cognitionPolicyPath(projectRoot), { ...current, enabled: false });
+    await writeRuntimePolicy(projectRoot, { ...current, enabled: false, autoStart: false });
     return runtimeStatus(projectRoot);
 }
+export async function setFilesystemEvents(startPath, enabled) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    if (!await exists(cognitionManifestPath(projectRoot)))
+        throw new Error('v2 migration is required before configuring filesystem events');
+    const wasRunning = (await runtimeStatus(projectRoot)).running;
+    if (wasRunning)
+        await stopRuntime(projectRoot);
+    const current = await loadPolicy(projectRoot);
+    await writeRuntimePolicy(projectRoot, { ...current, filesystemEventsEnabled: enabled });
+    if (wasRunning)
+        return startRuntime(projectRoot);
+    return runtimeStatus(projectRoot);
+}
+async function waitForRuntime(projectRoot, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while (Date.now() < deadline) {
+        const status = await runtimeStatus(projectRoot);
+        if (status.running && !await loadStartupMarker(projectRoot))
+            return status;
+        await new Promise((resolve) => setTimeout(resolve, 50));
+    }
+    return null;
+}
+async function startRuntimeCoordinated(projectRoot, timeoutMs) {
+    const existing = await liveLease(projectRoot);
+    if (existing)
+        return runtimeStatus(projectRoot);
+    const attemptId = createInstanceId();
+    let owner = false;
+    try {
+        await withLock(`${locksDirectory(projectRoot)}/cognition-runtime-start.lock`, async () => {
+            const live = await liveLease(projectRoot);
+            if (live)
+                return;
+            const marker = await loadStartupMarker(projectRoot);
+            if (marker && Date.now() - Date.parse(marker.createdAt) <= startupMarkerTimeoutMs)
+                return;
+            await atomicWriteJson(cognitionRuntimeStartupPath(projectRoot), { attemptId, pid: process.pid, createdAt: new Date().toISOString() });
+            owner = true;
+        });
+    }
+    catch {
+        // Another process owns the startup lock; it will publish the lease or the marker will expire.
+    }
+    if (owner) {
+        const child = spawn(process.execPath, [cliPath, 'runtime', 'serve', '--path', projectRoot], { detached: true, stdio: 'ignore', windowsHide: true });
+        child.unref();
+    }
+    const status = await waitForRuntime(projectRoot, timeoutMs);
+    const marker = await loadStartupMarker(projectRoot);
+    if (marker?.attemptId === attemptId)
+        await rm(cognitionRuntimeStartupPath(projectRoot), { force: true });
+    if (status)
+        return status;
+    throw new Error('runtime failed to start');
+}
 export async function startRuntime(startPath) {
     const projectRoot = await resolveProjectRoot(startPath);
     const current = await loadPolicy(projectRoot);
     if (!current.enabled)
         throw new Error('runtime is disabled; run ctx runtime enable first');
+    const pending = startupPromises.get(projectRoot);
+    if (pending)
+        return pending;
+    const operation = startRuntimeCoordinated(projectRoot, 1_500).finally(() => startupPromises.delete(projectRoot));
+    startupPromises.set(projectRoot, operation);
+    return operation;
+}
+export async function ensureRuntimeForSession(startPath, options = {}) {
+    const projectRoot = await resolveProjectRoot(startPath);
+    if (!await exists(cognitionManifestPath(projectRoot)))
+        return { projectRoot, started: false, running: false, skipped: 'not-migrated' };
+    const current = await loadPolicy(projectRoot);
+    if (!current.enabled || !current.autoStart || (options.source === 'claude-hook' && !current.allowHookStartup))
+        return { projectRoot, started: false, running: false, skipped: 'disabled' };
     if (await liveLease(projectRoot))
-        return runtimeStatus(projectRoot);
-    const child = spawn(process.execPath, [cliPath, 'runtime', 'serve', '--path', projectRoot], { detached: true, stdio: 'ignore', windowsHide: true });
-    child.unref();
-    for (let attempt = 0; attempt < 20; attempt += 1) {
-        await new Promise((resolve) => setTimeout(resolve, 50));
-        const status = await runtimeStatus(projectRoot);
-        if (status.running)
-            return status;
+        return { projectRoot, started: false, running: true, skipped: 'already-running' };
+    const pending = startupPromises.get(projectRoot);
+    if (pending) {
+        try {
+            const status = await pending;
+            return { projectRoot, started: false, running: status.running, skipped: 'startup-in-progress' };
+        }
+        catch {
+            return { projectRoot, started: false, running: false, skipped: 'unavailable' };
+        }
+    }
+    const operation = startRuntimeCoordinated(projectRoot, options.timeoutMs ?? 1_000)
+        .finally(() => startupPromises.delete(projectRoot));
+    startupPromises.set(projectRoot, operation);
+    try {
+        const status = await operation;
+        return { projectRoot, started: true, running: status.running, skipped: null };
+    }
+    catch {
+        return { projectRoot, started: false, running: false, skipped: 'unavailable' };
     }
-    throw new Error('runtime failed to start');
 }
 export async function stopRuntime(startPath) {
     const projectRoot = await resolveProjectRoot(startPath);
@@ -278,10 +442,10 @@ export async function stopRuntime(startPath) {
     if (!lease)
         return runtimeStatus(projectRoot);
     await request(projectRoot, lease, 'stop');
-    for (let attempt = 0; attempt < 20; attempt += 1) {
+    for (let attempt = 0; attempt < 40; attempt += 1) {
         await new Promise((resolve) => setTimeout(resolve, 50));
         const status = await runtimeStatus(projectRoot);
-        if (!status.running)
+        if (!status.running && !status.lease)
             return status;
     }
     throw new Error('runtime failed to stop');
@@ -293,3 +457,15 @@ export async function observeRuntime(startPath) {
         return false;
     return Boolean((await request(projectRoot, lease, 'observe'))?.ok);
 }
+export async function touchRuntime(startPath) {
+    try {
+        const projectRoot = await resolveProjectRoot(startPath);
+        const lease = await loadLease(projectRoot);
+        if (!lease)
+            return false;
+        return Boolean((await request(projectRoot, lease, 'ping'))?.ok);
+    }
+    catch {
+        return false;
+    }
+}

package/dist/src/cognition/types.d.ts

@@ -1,6 +1,6 @@
 export declare const COGNITION_LAYOUT_VERSION: "event-journal-v2";
 export type CognitionEventSource = 'cli' | 'claude-hook' | 'mcp' | 'git-observer' | 'fs-observer' | 'migration';
-export type CognitionEventType = 'runtime.enabled' | 'runtime.started' | 'runtime.stopped' | 'host.session.started' | 'host.prompt.submitted' | 'git.state.observed' | 'git.branch.changed' | 'git.head.changed' | 'workspace.paths.changed' | 'context.checkpoint.imported' | 'context.state.recorded' | 'note.recorded' | 'note.resolved' | 'note.absorbed' | 'knowledge.proposed' | 'knowledge.verified' | 'knowledge.deprecated' | 'deadend.proposed' | 'deadend.verified' | 'deadend.obsoleted' | 'projection.advanced' | 'projection.failed';
+export type CognitionEventType = 'runtime.enabled' | 'runtime.started' | 'runtime.stopped' | 'host.session.started' | 'host.prompt.submitted' | 'git.state.observed' | 'git.branch.changed' | 'git.head.changed' | 'workspace.paths.changed' | 'context.checkpoint.imported' | 'context.state.recorded' | 'note.recorded' | 'note.resolved' | 'note.absorbed' | 'knowledge.proposed' | 'knowledge.verified' | 'knowledge.deprecated' | 'knowledge.rejected' | 'deadend.proposed' | 'deadend.verified' | 'deadend.obsoleted' | 'deadend.rejected' | 'record.used' | 'projection.advanced' | 'projection.failed';
 export interface CognitionGitAnchor {
     worktreeId: string | null;
     branch: string | null;
@@ -32,6 +32,7 @@ export interface CognitionEvent<T = Record<string, unknown>> {
 export interface CognitionRuntimePolicy {
     schemaVersion: 2;
     enabled: boolean;
+    autoStart: boolean;
     allowHookStartup: boolean;
     inactivityTimeoutMs: number;
     promptIntentMaxChars: number;
@@ -53,6 +54,44 @@ export interface Applicability {
     sourceCommit?: string | null;
     dependencyConstraints?: string[];
 }
+export interface CognitionLifecycleTransition {
+    entity: 'knowledge' | 'deadend';
+    entityId: string;
+    from: 'candidate' | 'verified';
+    to: 'verified' | 'deprecated' | 'rejected' | 'obsolete';
+    reason?: string;
+}
+export interface CognitionUseFeedback {
+    feedbackId: string;
+    entity: 'knowledge' | 'deadend';
+    entityId: string;
+    outcome: 'used';
+}
+export interface CognitionRetrievalEntry {
+    entity: 'knowledge' | 'deadend';
+    entityId: string;
+    status: string;
+    record: Record<string, unknown>;
+    applicability: Applicability;
+    searchable: Record<string, string>;
+    normalizedTerms: string[];
+    provenance: {
+        eventId: string;
+        eventType: CognitionEventType;
+        occurredAt: string;
+        git: CognitionGitAnchor;
+        anchorProvenance?: CognitionRecordPayload['anchorProvenance'];
+    };
+    feedback: {
+        usedCount: number;
+        latestUsedAt: string | null;
+    };
+}
+export interface CognitionRetrievalProjection {
+    schemaVersion: 2;
+    entries: Record<string, CognitionRetrievalEntry>;
+    terms: Record<string, string[]>;
+}
 export interface BranchWorkspace {
     schemaVersion: 2;
     workspaceKey: string;
@@ -103,6 +142,21 @@ export interface CognitionRecordPayload<T extends Record<string, unknown> = Reco
     sourceHash?: string;
     anchorProvenance?: 'snapshot' | 'live' | 'global';
 }
+export interface WorkspacePathChange {
+    path: string;
+    kind: 'created' | 'modified' | 'deleted' | 'renamed' | 'unknown';
+    fileType: 'file';
+    sizeBytes?: number;
+    mtimeMs?: number;
+}
+export interface WorkspacePathsChangedPayload {
+    schemaVersion: 1;
+    paths: string[];
+    changes: WorkspacePathChange[];
+    pathCount: number;
+    coalesced: boolean;
+    truncated: boolean;
+}
 export interface CognitionProjection {
     schemaVersion: 2;
     contexts: Record<string, CognitionRecordPayload>;

package/dist/src/cognition/v1-bridge.js

@@ -2,11 +2,12 @@ import crypto from 'node:crypto';
 import path from 'node:path';
 import { access, readFile, readdir } from 'node:fs/promises';
 import { readGitWorktreeState } from '../git/git-adapter.js';
-import { cognitionManifestPath, cognitionPolicyPath, cognitionV1SyncPath, contextsRoot, deadendsPath, knowledgePath, notesPath, snapshotsDirectory } from '../storage/layout.js';
+import { cognitionManifestPath, cognitionV1SyncPath, contextsRoot, deadendsPath, knowledgePath, notesPath, snapshotsDirectory } from '../storage/layout.js';
 import { readJson } from '../storage/json-store.js';
 import { atomicWriteJson } from '../storage/atomic-write.js';
 import { appendEvent } from './journal.js';
 import { rebuildProjections } from './projections.js';
+import { loadRuntimePolicy } from './policy.js';
 function digest(record) {
     return crypto.createHash('sha256').update(JSON.stringify(record)).digest('hex');
 }
@@ -34,7 +35,7 @@ export async function v1Synced(projectRoot) {
 async function enabled(projectRoot) {
     try {
         await access(cognitionManifestPath(projectRoot));
-        return (await readJson(cognitionPolicyPath(projectRoot))).enabled;
+        return (await loadRuntimePolicy(projectRoot)).enabled;
     }
     catch {
         return false;
@@ -67,8 +68,16 @@ export async function mirrorNote(projectRoot, note, absorbed = false) {
     await mirror(projectRoot, absorbed ? 'note.absorbed' : 'note.recorded', note, note.noteId);
 }
 export async function mirrorKnowledge(projectRoot, knowledge) {
-    await mirror(projectRoot, knowledge.status === 'verified' ? 'knowledge.verified' : 'knowledge.proposed', knowledge, knowledge.knowledgeId);
+    const type = knowledge.status === 'verified' ? 'knowledge.verified'
+        : knowledge.status === 'deprecated' ? 'knowledge.deprecated'
+            : knowledge.status === 'rejected' ? 'knowledge.rejected'
+                : 'knowledge.proposed';
+    await mirror(projectRoot, type, knowledge, knowledge.knowledgeId);
 }
 export async function mirrorDeadend(projectRoot, deadend) {
-    await mirror(projectRoot, deadend.status === 'verified' ? 'deadend.verified' : 'deadend.proposed', deadend, deadend.deadendId);
+    const type = deadend.status === 'verified' ? 'deadend.verified'
+        : deadend.status === 'obsolete' ? 'deadend.obsoleted'
+            : deadend.status === 'rejected' ? 'deadend.rejected'
+                : 'deadend.proposed';
+    await mirror(projectRoot, type, deadend, deadend.deadendId);
 }

package/dist/src/compiler/activity.d.ts

@@ -0,0 +1,3 @@
+import type { BranchWorkspace, CognitionEvent } from '../cognition/types.js';
+import type { ContextActivityRecord, ContextAnchor } from './types.js';
+export declare function extractActivity(projectRoot: string, events: CognitionEvent[], anchor: ContextAnchor, workspace: BranchWorkspace | null, limit: number): Promise<ContextActivityRecord[]>;

package/dist/src/compiler/activity.js

@@ -0,0 +1,79 @@
+import { filterPaths } from '../capture/context-filter.js';
+import { workspaceKey } from '../cognition/projections.js';
+const changeKinds = new Set(['created', 'modified', 'deleted', 'renamed', 'unknown']);
+function normalizedPath(value) {
+    if (typeof value !== 'string')
+        return null;
+    const normalized = value.replaceAll('\\', '/');
+    return normalized.length > 0 ? normalized : null;
+}
+function stableCompare(left, right) {
+    return left < right ? -1 : left > right ? 1 : 0;
+}
+function metadataNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value >= 0 ? value : undefined;
+}
+function parsePayload(event) {
+    const payload = event.payload;
+    return payload.schemaVersion === 1 && typeof payload === 'object' && payload !== null ? payload : null;
+}
+async function activityForEvent(projectRoot, event, focus) {
+    const payload = parsePayload(event);
+    if (!payload)
+        return null;
+    const rawPaths = Array.isArray(payload.paths) ? payload.paths.map(normalizedPath).filter((value) => value !== null) : [];
+    const rawChanges = Array.isArray(payload.changes) ? payload.changes : [];
+    const changePaths = rawChanges.map((change) => normalizedPath(change?.path)).filter((value) => value !== null);
+    const allowed = await filterPaths(projectRoot, [...new Set([...rawPaths, ...changePaths])]);
+    if (allowed.length === 0)
+        return null;
+    const allowedSet = new Set(allowed);
+    const changes = [];
+    for (const change of rawChanges) {
+        const path = normalizedPath(change?.path);
+        if (!path || !allowedSet.has(path))
+            continue;
+        changes.push({
+            path,
+            kind: changeKinds.has(change?.kind) ? change.kind : 'unknown',
+            fileType: 'file',
+            ...(metadataNumber(change?.sizeBytes) !== undefined ? { sizeBytes: metadataNumber(change?.sizeBytes) } : {}),
+            ...(metadataNumber(change?.mtimeMs) !== undefined ? { mtimeMs: metadataNumber(change?.mtimeMs) } : {}),
+        });
+    }
+    const fallbackChanges = changes.length > 0 ? changes : allowed.map((path) => ({ path, kind: 'unknown', fileType: 'file' }));
+    const paths = [...new Set(fallbackChanges.map((change) => change.path))].sort(stableCompare);
+    return {
+        eventId: event.eventId,
+        occurredAt: event.occurredAt,
+        anchor: {
+            projectRoot,
+            worktreeId: event.git.worktreeId,
+            branch: event.git.branch,
+            ref: event.git.ref,
+            head: event.git.head,
+        },
+        paths,
+        changes: fallbackChanges.sort((left, right) => stableCompare(left.path, right.path)),
+        pathCount: typeof payload.pathCount === 'number' && Number.isSafeInteger(payload.pathCount) && payload.pathCount >= paths.length ? payload.pathCount : paths.length,
+        coalesced: payload.coalesced === true,
+        truncated: payload.truncated === true,
+        focusMatch: paths.some((path) => focus.includes(path)),
+    };
+}
+export async function extractActivity(projectRoot, events, anchor, workspace, limit) {
+    if (limit <= 0 || !workspace)
+        return [];
+    const currentWorkspace = workspaceKey(anchor);
+    const matching = events
+        .filter((event) => event.type === 'workspace.paths.changed' && workspaceKey(event.git) === currentWorkspace)
+        .sort((left, right) => right.occurredAt.localeCompare(left.occurredAt) || right.eventId.localeCompare(left.eventId))
+        .slice(0, limit);
+    const records = [];
+    for (const event of matching) {
+        const record = await activityForEvent(projectRoot, event, workspace.pathFocus);
+        if (record)
+            records.push(record);
+    }
+    return records;
+}

package/dist/src/compiler/compile.d.ts

@@ -0,0 +1,2 @@
+import type { ContextCompileOptions, ContextManifest } from './types.js';
+export declare function compileContext(startPath?: string, options?: ContextCompileOptions): Promise<ContextManifest>;