@theihtisham/agent-shadow-brain 7.2.0 → 7.22.0

package/dist/dashboard/v6-dashboard-html.js.map

@@ -1 +1 @@
-{"version":3,"file":"v6-dashboard-html.js","sourceRoot":"","sources":["../../src/dashboard/v6-dashboard-html.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,sFAAsF;AACtF,wFAAwF;AAExF,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqtIzB,CAAC"}
+{"version":3,"file":"v6-dashboard-html.js","sourceRoot":"","sources":["../../src/dashboard/v6-dashboard-html.ts"],"names":[],"mappings":"AAAA,qFAAqF;AACrF,sFAAsF;AACtF,wFAAwF;AAExF,MAAM,CAAC,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAqqIzB,CAAC"}

package/dist/dashboard/workspace-api.d.ts

@@ -1,9 +1,21 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { type GlobalBrain } from '../brain/global-brain.js';
 import { type FeatureSettingsStore } from '../brain/feature-settings.js';
+import { type MemoryAnnotationsStore } from '../brain/memory-annotations.js';
+import { type ActivityJournal } from '../brain/activity-journal.js';
+import { WorkspaceRuntime } from './workspace-status.js';
+import type { ProjectHubService } from '../brain/project-hub.js';
 export interface WorkspaceDependencies {
     brain?: GlobalBrain;
     settings?: FeatureSettingsStore;
+    annotations?: MemoryAnnotationsStore;
+    projectDir?: string;
+    journal?: ActivityJournal;
+    demo?: boolean;
+    localProject?: boolean;
+    runtime?: WorkspaceRuntime;
+    hub?: ProjectHubService;
+    prepareStorage?: () => Promise<string | null>;
 }
 /** The workspace API reads only the memory store and dedicated feature settings. */
 export declare function handleWorkspaceRequest(req: IncomingMessage, res: ServerResponse, dependencies?: WorkspaceDependencies): Promise<void>;

package/dist/dashboard/workspace-api.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"workspace-api.d.ts","sourceRoot":"","sources":["../../src/dashboard/workspace-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAG5E,OAAO,EAA2C,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAMlH,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;CACjC;AAuED,oFAAoF;AACpF,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,YAAY,GAAE,qBAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAqG/I"}
+{"version":3,"file":"workspace-api.d.ts","sourceRoot":"","sources":["../../src/dashboard/workspace-api.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEjE,OAAO,EAAkB,KAAK,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAS5E,OAAO,EAA2C,KAAK,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AAClH,OAAO,EAAqC,KAAK,sBAAsB,EAAiC,MAAM,gCAAgC,CAAC;AAG/I,OAAO,EAAsB,KAAK,eAAe,EAAE,MAAM,8BAA8B,CAAC;AAMxF,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAOzD,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAKjE,MAAM,WAAW,qBAAqB;IACpC,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,QAAQ,CAAC,EAAE,oBAAoB,CAAC;IAChC,WAAW,CAAC,EAAE,sBAAsB,CAAC;IACrC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,eAAe,CAAC;IAC1B,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,GAAG,CAAC,EAAE,iBAAiB,CAAC;IACxB,cAAc,CAAC,EAAE,MAAM,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;CAC/C;AAwFD,oFAAoF;AACpF,wBAAsB,sBAAsB,CAAC,GAAG,EAAE,eAAe,EAAE,GAAG,EAAE,cAAc,EAAE,YAAY,GAAE,qBAA0B,GAAG,OAAO,CAAC,IAAI,CAAC,CAkU/I"}

package/dist/dashboard/workspace-api.js

@@ -1,18 +1,39 @@
+import { randomUUID } from 'node:crypto';
 import { getGlobalBrain } from '../brain/global-brain.js';
 import { getBrainBus } from '../brain/brain-bus.js';
-import { assembleContext } from '../brain/context-assembly.js';
+import { assembleContextWithEfficiency } from '../brain/context-efficiency.js';
+import { ProjectPolicyStore } from '../brain/project-policy.js';
+import { MCPPresenceStore } from '../brain/mcp-presence.js';
+import { enforceProjectContext } from '../brain/project-policy-delivery.js';
+import { projectPolicyRequest } from './project-policy-api.js';
+import { parseContextRequest } from '../brain/context-request.js';
+import { inspectMemoryHealth } from '../brain/memory-inspection.js';
 import { FEATURE_DEFINITIONS, getFeatureSettings } from '../brain/feature-settings.js';
+import { memoryAnnotationsFor, memoryState } from '../brain/memory-annotations.js';
+import { normalizeMemorySources } from '../brain/memory-sources.js';
+import { inspectClientIntegrations } from '../brain/client-integrations.js';
+import { activityJournalFor } from '../brain/activity-journal.js';
+import { reportAgentActivity } from '../brain/activity-reporting.js';
+import { inspectProject, planProjectSkill, applyProjectSkill } from '../brain/project-kit.js';
+import { requireProjectStore, addProjectKnowledge } from '../brain/project-memory.js';
+import { ProjectFeedbackStore } from '../brain/project-feedback.js';
+import { WorkspaceRuntime } from './workspace-status.js';
+import { isProjectHubRoute, handleProjectHubRequest } from './project-hub-api.js';
+import { ModelUsageStore } from '../brain/model-usage.js';
+import { isSourceRoute, sourceRequest } from './project-source-api.js';
+import { isProjectSessionRoute, projectSessionRequest } from './project-session-api.js';
+import { isManagedSkillsRoute, managedSkillsRequest } from './managed-project-skills-api.js';
+import { isNativeCodexRoute, nativeCodexRequest } from './native-codex-api.js';
 const INVENTORY_LIMIT = 2500;
+const sharedRuntime = new WorkspaceRuntime('shared');
 function sources(entry) {
-    const metadata = entry.metadata ?? {};
-    const candidates = [metadata.source, metadata.sourceFile, metadata.filePath, ...(Array.isArray(metadata.sources) ? metadata.sources : [])];
-    return [...new Set(candidates.filter((item) => typeof item === 'string' && !!item.trim()))].slice(0, 8);
+    return normalizeMemorySources(entry.metadata, { limit: 8, maxChars: 500 });
 }
 function date(value) {
     const time = value instanceof Date ? value.getTime() : typeof value === 'string' || typeof value === 'number' ? new Date(value).getTime() : NaN;
     return Number.isFinite(time) ? new Date(time).toISOString() : null;
 }
-function summary(entry) {
+function summary(entry, annotations) {
     const confidence = 'confidence' in entry ? entry.confidence : undefined;
     const matched = confidence?.explanation?.matchedKeywords ?? [];
     const refs = sources(entry);
@@ -21,6 +42,7 @@ function summary(entry) {
         category: entry.category, agent: entry.agentTool, project: entry.projectId, projectName: entry.projectName,
         source: refs[0] ?? '', sources: refs, updatedAt: date(entry.createdAt), score: confidence?.score,
         reasons: confidence ? [matched.length ? 'Matches: ' + matched.join(', ') : 'Ranked by importance, age, and recorded use.'] : [],
+        effectiveState: annotations ? memoryState(annotations, entry.projectId, entry.id) : 'active',
     };
 }
 function bounded(value, fallback, max, min = 1) {
@@ -75,6 +97,26 @@ async function body(req) {
 function settingsResponse(store) {
     return { ...store.get(), definitions: FEATURE_DEFINITIONS };
 }
+async function portalActivity(dependencies, tool, projectId) {
+    const correlationId = randomUUID();
+    const journal = dependencies.journal;
+    const record = async (outcome, durationMs) => {
+        try {
+            if (!journal || !(dependencies.settings ?? getFeatureSettings()).get().features.activityRecording)
+                return false;
+            await journal.append({ kind: outcome ? 'tool-end' : 'tool-start', source: 'reported', transport: 'host',
+                projectId, agent: 'portal', sessionId: 'project-portal', tool, correlationId, ...(outcome ? { outcome, durationMs } : {}) });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    };
+    if (!await record())
+        return undefined;
+    const started = performance.now();
+    return (outcome) => record(outcome, Math.max(0, performance.now() - started));
+}
 /** The workspace API reads only the memory store and dedicated feature settings. */
 export async function handleWorkspaceRequest(req, res, dependencies = {}) {
     const send = (data, status = 200) => {
@@ -85,9 +127,156 @@ export async function handleWorkspaceRequest(req, res, dependencies = {}) {
         const url = new URL(req.url ?? '/', 'http://localhost');
         const route = url.pathname.slice('/api/workspace/'.length);
         const method = req.method ?? 'GET';
-        if (!['GET', 'POST'].includes(method) || (method === 'POST' && !['context', 'features'].includes(route)))
+        const expectedProject = req.headers['x-shadow-brain-project'];
+        if (method === 'POST' && expectedProject !== undefined && expectedProject !== dependencies.runtime?.project?.id) {
+            return send({ error: 'This port now serves a different project. Reload the portal before making changes.', code: 'WORKSPACE_PROJECT_CHANGED' }, 409);
+        }
+        const storageError = await dependencies.prepareStorage?.();
+        if (route === 'status' && method === 'GET')
+            return send((dependencies.runtime ?? sharedRuntime).status(dependencies.brain, !!dependencies.hub && !storageError, storageError));
+        if (storageError)
+            return send({ error: storageError, code: 'WORKSPACE_STORAGE_UNAVAILABLE' }, 503);
+        if (isProjectHubRoute(url.pathname)) {
+            const section = url.pathname.split('/')[4];
+            const tool = 'hub-' + (['documents', 'rooms', 'lessons'].includes(section) ? section : 'overview');
+            const end = method === 'POST' ? await portalActivity(dependencies, tool, dependencies.runtime?.project?.id) : undefined;
+            let outcome = 'error';
+            try {
+                await handleProjectHubRequest(req, res, dependencies.hub, url);
+                if (res.writableEnded && res.statusCode < 400)
+                    outcome = 'success';
+            }
+            finally {
+                await end?.(outcome);
+            }
+            return;
+        }
+        const local = dependencies.localProject && dependencies.projectDir && dependencies.brain
+            ? requireProjectStore(dependencies.projectDir, dependencies.brain) : undefined;
+        if (route === 'presence') {
+            if (method !== 'GET')
+                return send({ error: 'Use GET to inspect project MCP presence.' }, 405);
+            if (!local)
+                return send({ error: 'Open a project-local workspace to inspect MCP connections.' }, 409);
+            if ((req.headers.origin && req.headers.origin !== 'http://' + req.headers.host) ||
+                ['cross-site', 'same-site'].includes(String(req.headers['sec-fetch-site'])))
+                return send({ error: 'MCP presence is available to same-origin requests.' }, 403);
+            const enabled = (dependencies.settings ?? getFeatureSettings()).get().features.activityRecording;
+            return send(new MCPPresenceStore(local.root, local.projectId).read(enabled));
+        }
+        if (isManagedSkillsRoute(route)) {
+            if (!local)
+                return send({ error: 'Open a project-local workspace to manage Project Kit skills.', code: 'MANAGED_SKILL_PROJECT_REQUIRED' }, 409);
+            return send(await managedSkillsRequest(req, route, local.root, () => body(req)));
+        }
+        if (route === 'project-policy') {
+            if (!local)
+                return send({ error: 'Open a project-local workspace to use project controls.' }, 409);
+            return send(await projectPolicyRequest(req, local.root, local.projectId, dependencies.brain, () => body(req)));
+        }
+        if (isProjectSessionRoute(route)) {
+            if (!local)
+                return send({ error: 'Open a project-local workspace to use shared sessions.', code: 'SESSION_LOCAL_PROJECT_REQUIRED' }, 409);
+            if (isNativeCodexRoute(route))
+                return send(await nativeCodexRequest(req, route, url, local.root, dependencies.brain, () => body(req)));
+            return send(await projectSessionRequest(req, route, url, local.root, dependencies.brain, () => body(req)));
+        }
+        if (isSourceRoute(route) || route === 'usage' || route === 'usage-report') {
+            if (!local)
+                return send({ error: 'Open a project-local workspace to use project sources and usage receipts.' }, 409);
+            if (isSourceRoute(route)) {
+                const end = method === 'POST' ? await portalActivity(dependencies, route === 'sources' ? 'source-preview' : 'source-review', local.projectId) : undefined;
+                let result;
+                try {
+                    result = await sourceRequest(req, url, local.root, dependencies.brain);
+                }
+                catch (error) {
+                    await end?.('error');
+                    throw error;
+                }
+                await end?.('success');
+                return send(result);
+            }
+            const settings = dependencies.settings ?? getFeatureSettings();
+            const usage = new ModelUsageStore(local.root, local.projectId);
+            if (route === 'usage' && method === 'GET')
+                return send({ ...usage.read(), recording: settings.get().features.activityRecording });
+            if (route === 'usage-report' && method === 'POST') {
+                if (!settings.get().features.activityRecording)
+                    return send({ error: 'Activity recording is disabled for this project.' }, 409);
+                if (req.headers['sec-fetch-site'] === 'cross-site')
+                    return send({ error: 'Cross-origin changes are not accepted.' }, 403);
+                return send({ receipt: usage.report(await body(req)) });
+            }
+            return send({ error: 'Method not allowed.' }, 405);
+        }
+        const projectRoutes = ['project-profile', 'project-knowledge', 'project-skill-preview', 'project-skill-apply', 'project-feedback'];
+        const writes = ['memory-review', 'memory-link', 'memory-unlink'];
+        if (!['GET', 'POST'].includes(method) || (method === 'POST' && !['context', 'context-compare', 'features', 'activity-report', ...writes, ...projectRoutes.slice(1)].includes(route)))
             return send({ error: 'Method not allowed.' }, 405);
         const settings = dependencies.settings ?? getFeatureSettings();
+        const localActivity = () => {
+            const enabled = settings.get().features.liveActivity;
+            if (!local)
+                return activity(enabled);
+            const journal = dependencies.journal ?? activityJournalFor(dependencies.brain);
+            return { enabled, activity: enabled ? journal.read({ projectId: local.projectId, limit: 200 }).events.slice(-30).reverse().map(event => ({
+                    id: event.id, type: event.kind, label: [event.tool, event.phase, event.outcome].filter(Boolean).join(' · ') || event.kind,
+                    agent: event.agent ?? '', project: local.projectName, timestamp: event.timestamp,
+                })) : [] };
+        };
+        if (projectRoutes.includes(route)) {
+            if (!local)
+                return send({ error: 'Open shadow-brain project workspace for project-local knowledge and skills.' }, 409);
+            if (route === 'project-profile')
+                return send(inspectProject(local.root));
+            if (route === 'project-feedback') {
+                const feedback = new ProjectFeedbackStore(local.root, dependencies.brain);
+                if (method === 'GET')
+                    return send(feedback.get());
+                const input = await body(req);
+                const { expectedRevision, kind, ...params } = input;
+                await dependencies.brain.init();
+                dependencies.brain.refresh();
+                if (dependencies.brain.getStorageHealth().lastError)
+                    throw new Error('Project memory could not be read; feedback was not changed.');
+                const command = { kind: kind === 'record' ? 'upsert' : kind === 'enable' ? 'toggle' : kind, ...params };
+                return send(await feedback.update(command, expectedRevision, 'user'));
+            }
+            if (method !== 'POST')
+                return send({ error: 'Use POST for project knowledge and skill requests.' }, 405);
+            const input = await body(req);
+            if (route === 'project-skill-preview')
+                return send(planProjectSkill(local.root, input));
+            const started = Date.now();
+            const correlationId = randomUUID();
+            const recordOperation = async (outcome) => {
+                if (!settings.get().features.activityRecording)
+                    return;
+                try {
+                    await (dependencies.journal ?? activityJournalFor(dependencies.brain)).append({ projectId: local.projectId,
+                        kind: outcome ? 'tool-end' : 'tool-start', source: 'reported', transport: 'host', agent: 'user', sessionId: 'project-portal',
+                        tool: route, correlationId, ...(outcome ? { outcome, durationMs: Math.max(0, Date.now() - started) } : {}) });
+                }
+                catch { /* The committed result remains valid when optional activity recording is unavailable. */ }
+            };
+            await recordOperation();
+            let result;
+            try {
+                if (route === 'project-knowledge')
+                    result = await addProjectKnowledge(local.root, dependencies.brain, input);
+                else {
+                    const { expectedPlanHash, ...params } = input;
+                    result = await applyProjectSkill(local.root, params, expectedPlanHash);
+                }
+            }
+            catch (error) {
+                await recordOperation('error');
+                throw error;
+            }
+            await recordOperation('success');
+            return send(result);
+        }
         if (route === 'features') {
             if (method === 'POST') {
                 const input = await body(req);
@@ -100,73 +289,193 @@ export async function handleWorkspaceRequest(req, res, dependencies = {}) {
             return send(settingsResponse(settings));
         }
         if (route === 'activity')
-            return send(activity(settings.get().features.liveActivity));
-        if (!['overview', 'memories', 'graph', 'context'].includes(route))
+            return send(localActivity());
+        if (route === 'telemetry') {
+            const flags = settings.get().features;
+            const common = { checkedAt: new Date().toISOString(), liveEnabled: flags.liveActivity, recordingEnabled: flags.activityRecording, demo: dependencies.demo === true };
+            if (!flags.liveActivity)
+                return send({ ...common, events: [], journalId: null, revision: 0, oldestSequence: null, latestSequence: 0,
+                    nextAfterSequence: 0, cursor: 0, hasMore: false, gap: false, reset: false, retainedCount: 0, droppedCount: 0 });
+            const qs = url.searchParams;
+            const cursor = qs.get('cursor');
+            const journal = dependencies.journal ?? activityJournalFor(dependencies.brain ?? getGlobalBrain());
+            const page = journal.read({ afterSequence: cursor === null ? undefined : bounded(cursor, 0, Number.MAX_SAFE_INTEGER, 0),
+                journalId: query(qs, 'journalId'), projectId: local?.projectId ?? query(qs, 'project'), limit: bounded(qs.get('limit'), 200, 200) });
+            return send({ ...common, ...page, cursor: page.nextAfterSequence });
+        }
+        if (route === 'activity-report') {
+            if (method !== 'POST')
+                return send({ error: 'Use POST to report activity.' }, 405);
+            const input = await body(req);
+            if (local && input.projectId !== undefined && input.projectId !== local.projectId)
+                throw new TypeError('This portal is pinned to its local project.');
+            if (local)
+                input.projectId = local.projectId;
+            return send(await reportAgentActivity(dependencies.brain ?? getGlobalBrain(), settings, input, dependencies.journal));
+        }
+        if (!['overview', 'memories', 'graph', 'context', 'context-compare', 'memory', 'memory-health', 'integrations', ...writes].includes(route))
             return send({ error: 'Not found.' }, 404);
-        if (route === 'context' && method !== 'POST')
+        if (['context', 'context-compare'].includes(route) && method !== 'POST')
             return send({ error: 'Use POST for context assembly.' }, 405);
+        if (writes.includes(route) && method !== 'POST')
+            return send({ error: 'Use POST for memory changes.' }, 405);
+        const mutationInput = writes.includes(route) ? await body(req) : undefined;
+        if (mutationInput) {
+            if (local && mutationInput.projectId !== local.projectId)
+                throw new TypeError('This portal is pinned to its local project.');
+            if (!Number.isSafeInteger(mutationInput.expectedRevision) || Number(mutationInput.expectedRevision) < 0)
+                throw new TypeError('A current expectedRevision is required.');
+            const allowed = route === 'memory-review' ? ['projectId', 'memoryId', 'state', 'note', 'expectedRevision'] :
+                route === 'memory-link' ? ['projectId', 'fromId', 'toId', 'type', 'note', 'expectedRevision'] : ['projectId', 'memoryId', 'linkId', 'expectedRevision'];
+            if (Object.keys(mutationInput).some(key => !allowed.includes(key)))
+                throw new TypeError('Unknown memory change field.');
+        }
         const brain = dependencies.brain ?? getGlobalBrain();
+        if (route === 'integrations')
+            return send(inspectClientIntegrations({ projectDir: dependencies.projectDir, brain, localProjectId: local?.projectId }));
+        const annotationStore = dependencies.annotations ?? memoryAnnotationsFor(brain);
         const refresh = async () => {
             await brain.init();
-            await brain.sync();
+            brain.refresh();
             if (brain.getStorageHealth().lastError)
                 throw new Error('The memory store could not be read. Check storage health.');
         };
-        if (route === 'context') {
+        if (route === 'context' || route === 'context-compare') {
             const input = await body(req);
-            if (Object.keys(input).some(key => !['projectId', 'query', 'tokenBudget', 'includeCrossProject'].includes(key)))
-                throw new TypeError('Unknown context request field.');
-            if (typeof input.projectId !== 'string' || !input.projectId.trim())
-                throw new TypeError('Choose a project.');
-            if (input.query !== undefined && typeof input.query !== 'string')
-                throw new TypeError('Task must be text.');
-            if (input.includeCrossProject !== undefined && typeof input.includeCrossProject !== 'boolean')
-                throw new TypeError('Cross-project choice must be boolean.');
-            if (input.tokenBudget !== undefined && (!Number.isSafeInteger(input.tokenBudget) || Number(input.tokenBudget) < 0 || Number(input.tokenBudget) > 12000))
-                throw new TypeError('Token budget must be an integer from 0 to 12000.');
+            const options = parseContextRequest(input);
+            if (local && (options.projectId !== local.projectId || options.includeCrossProject === true))
+                throw new TypeError('This portal is pinned to its local project.');
             const flags = settings.get().features;
             if (flags.contextAssembly)
                 await refresh();
-            const pack = assembleContext(brain, { projectId: input.projectId, query: input.query,
-                tokenBudget: input.tokenBudget, includeCrossProject: input.includeCrossProject,
-                features: flags });
-            return send(pack);
+            const requested = { ...options, features: flags, annotations: flags.contextAssembly ? annotationStore.get() : undefined,
+                feedback: flags.contextAssembly && local ? new ProjectFeedbackStore(local.root, brain).get() : undefined };
+            const common = local ? enforceProjectContext(local.root, brain, new ProjectPolicyStore(local.root, local.projectId).get(), requested) : requested;
+            if (route === 'context')
+                return send(assembleContextWithEfficiency(brain, common));
+            const legacy = assembleContextWithEfficiency(brain, { ...common, profile: 'legacy' });
+            const adaptive = assembleContextWithEfficiency(brain, { ...common, profile: 'adaptive' });
+            const oldIds = new Set(legacy.entries.map(entry => entry.id));
+            const newIds = new Set(adaptive.entries.map(entry => entry.id));
+            return send({ legacy, adaptive, delta: { addedIds: [...newIds].filter(id => !oldIds.has(id)),
+                    removedIds: [...oldIds].filter(id => !newIds.has(id)), sharedIds: [...newIds].filter(id => oldIds.has(id)) },
+                warnings: ['Both profiles use the same memory view. Their token estimators differ; selection changes are not proof of higher accuracy.'] });
         }
         await refresh();
-        const inventory = brain.timeline({ limit: INVENTORY_LIMIT });
+        const annotations = annotationStore.get();
+        const qs = url.searchParams;
+        const requestedProject = local?.projectId ?? query(qs, 'project');
+        if (local && query(qs, 'project') && query(qs, 'project') !== local.projectId)
+            throw new TypeError('This portal is pinned to its local project.');
+        if (route === 'memory-health')
+            return send(inspectMemoryHealth(brain, annotations, { projectId: requestedProject, limit: bounded(qs.get('limit'), 30, 100) }));
+        if (route === 'memory') {
+            const id = query(qs, 'id');
+            if (!id || !requestedProject)
+                throw new TypeError('Memory ID and project are required.');
+            const memory = brain.getEntry(id);
+            if (!memory || memory.projectId !== requestedProject)
+                return send({ error: 'Memory not found in the selected project.' }, 404);
+            const endpoint = (memoryId) => {
+                const value = brain.getEntry(memoryId);
+                return value?.projectId === requestedProject ? value : undefined;
+            };
+            const links = annotations.links.filter(link => link.projectId === requestedProject && [link.fromId, link.toId].includes(id))
+                .map(link => ({ ...link, fromTitle: endpoint(link.fromId)?.content.slice(0, 130) ?? 'Unavailable memory',
+                toTitle: endpoint(link.toId)?.content.slice(0, 130) ?? 'Unavailable memory',
+                orphaned: !endpoint(link.fromId) || !endpoint(link.toId) }));
+            const history = annotations.history.filter(event => event.projectId === requestedProject &&
+                ((event.command.kind === 'review' && event.command.memoryId === id) ||
+                    (event.command.kind === 'link' && [event.command.fromId, event.command.toId].includes(id)) ||
+                    (event.relation && [event.relation.fromId, event.relation.toId].includes(id))));
+            const review = annotations.reviews[id]?.projectId === requestedProject ? annotations.reviews[id] : null;
+            return send({ memory: { ...summary(memory, annotations), content: memory.content, importance: memory.importance, createdAt: date(memory.createdAt) },
+                review, effectiveState: memoryState(annotations, requestedProject, id), links, revision: annotations.revision, history,
+                warnings: links.some(link => link.orphaned) ? ['A linked memory is no longer available. Recorded supersession remains until explicitly removed.'] : [] });
+        }
+        if (writes.includes(route)) {
+            const input = mutationInput;
+            let command;
+            if (route === 'memory-review')
+                command = { kind: 'review', projectId: input.projectId, memoryId: input.memoryId, state: input.state, ...(input.note !== undefined ? { note: input.note } : {}) };
+            else if (route === 'memory-link')
+                command = { kind: 'link', projectId: input.projectId, fromId: input.fromId, toId: input.toId, type: input.type, ...(input.note !== undefined ? { note: input.note } : {}) };
+            else {
+                const memory = typeof input.memoryId === 'string' ? brain.getEntry(input.memoryId) : undefined;
+                const link = annotations.links.find(item => item.id === input.linkId && item.projectId === input.projectId && [item.fromId, item.toId].includes(String(input.memoryId)));
+                if (!memory || memory.projectId !== input.projectId || !link)
+                    return send({ error: 'Relationship not found in the selected memory and project.' }, 404);
+                command = { kind: 'unlink', linkId: input.linkId };
+            }
+            const committed = await annotationStore.update(command, input.expectedRevision);
+            return send({ revision: committed.revision, updatedAt: committed.updatedAt });
+        }
+        const recentInventory = brain.timeline({ limit: INVENTORY_LIMIT, ...(local ? { projectId: local.projectId } : {}) });
+        const inventory = requestedProject ? brain.timeline({ projectId: requestedProject, limit: INVENTORY_LIMIT }) : recentInventory;
         const projectMap = new Map();
-        for (const entry of inventory) {
+        if (local)
+            projectMap.set(local.projectId, { id: local.projectId, name: local.projectName, memories: 0, updatedAt: null });
+        for (const entry of recentInventory) {
             const project = projectMap.get(entry.projectId) ?? { id: entry.projectId, name: entry.projectName || entry.projectId, memories: 0, updatedAt: date(entry.createdAt) };
             project.memories++;
             projectMap.set(entry.projectId, project);
         }
+        if (requestedProject && inventory.length)
+            projectMap.set(requestedProject, {
+                id: requestedProject, name: inventory[0].projectName || requestedProject, memories: inventory.length, updatedAt: date(inventory[0].createdAt),
+            });
         const projects = [...projectMap.values()].sort((a, b) => a.name.localeCompare(b.name));
         const facets = { projects, categories: [...new Set(inventory.map(entry => entry.category))].sort(), agents: [...new Set(inventory.map(entry => entry.agentTool))].sort() };
-        const inventoryTruncated = brain.getStats().totalEntries > inventory.length;
+        const inventoryTruncated = requestedProject ? brain.timeline({ projectId: requestedProject, limit: INVENTORY_LIMIT + 1 }).length > INVENTORY_LIMIT : brain.getStats().totalEntries > inventory.length;
         if (route === 'overview') {
-            return send({ version: '7.2.0', totals: { projects: projects.length, memories: brain.getStats().totalEntries, agents: facets.agents.length },
-                projects, ...activity(settings.get().features.liveActivity), storageHealth: brain.getStorageHealth(),
-                features: settings.get().features, recentMemories: inventory.slice(0, 5).map(summary), truncated: inventoryTruncated,
+            const scoped = inventory.filter(entry => !requestedProject || entry.projectId === requestedProject);
+            const quality = { total: scoped.length, sourceBacked: 0, active: 0, contested: 0, archived: 0, superseded: 0, reviewed: 0 };
+            for (const entry of scoped) {
+                quality[memoryState(annotations, entry.projectId, entry.id)]++;
+                if (sources(entry).length)
+                    quality.sourceBacked++;
+                if (annotations.reviews[entry.id]?.projectId === entry.projectId)
+                    quality.reviewed++;
+            }
+            return send({ version: '7.22.0', demo: dependencies.demo === true,
+                projectKit: local ? { available: true, projectId: local.projectId, projectName: local.projectName, root: local.root, storagePath: local.storagePath } : { available: false },
+                totals: { projects: projects.length, memories: local ? inventory.length : brain.getStats().totalEntries, agents: facets.agents.length },
+                projects, ...localActivity(), storageHealth: brain.getStorageHealth(),
+                features: settings.get().features, recentMemories: scoped.slice(0, 5).map(entry => summary(entry, annotations)), truncated: inventoryTruncated,
+                quality, scope: { projectId: requestedProject ?? null, basis: 'recent-inventory' },
                 inventoryLimit: INVENTORY_LIMIT });
         }
-        const qs = url.searchParams;
-        const projectId = query(qs, 'project');
+        const projectId = requestedProject;
         const category = query(qs, 'category');
         const agentTool = query(qs, 'agent');
         const search = query(qs, 'q');
-        const entries = search ? brain.recallScored({ projectId, category, agentTool, keywords: search.split(/\s+/), limit: INVENTORY_LIMIT })
+        let entries = search ? brain.recallScored({ projectId, category, agentTool, keywords: search.split(/\s+/), limit: INVENTORY_LIMIT })
             : inventory.filter(entry => (!projectId || entry.projectId === projectId) && (!category || entry.category === category) && (!agentTool || entry.agentTool === agentTool));
+        const stateFilter = query(qs, 'state');
+        if (stateFilter && stateFilter !== 'all') {
+            if (!['active', 'archived', 'contested', 'superseded'].includes(stateFilter))
+                throw new TypeError('Unknown memory state.');
+            entries = entries.filter(entry => memoryState(annotations, entry.projectId, entry.id) === stateFilter);
+        }
         if (route === 'memories') {
             const limit = bounded(qs.get('limit'), 30, 100);
             const offset = bounded(qs.get('offset'), 0, INVENTORY_LIMIT, 0);
-            return send({ items: entries.slice(offset, offset + limit).map(summary), total: entries.length, facets, truncated: inventoryTruncated, inventoryLimit: INVENTORY_LIMIT });
+            return send({ items: entries.slice(offset, offset + limit).map(entry => summary(entry, annotations)), total: entries.length, facets, truncated: inventoryTruncated, inventoryLimit: INVENTORY_LIMIT });
         }
-        const limit = bounded(qs.get('limit'), 100, 180);
+        const limit = bounded(qs.get('limit'), 100, 500);
         const nodes = [];
         const edges = [];
+        const selectedId = query(qs, 'memory');
+        const selected = selectedId ? brain.getEntry(selectedId) : undefined;
+        const shown = entries.slice(0, limit);
+        if (selected && (!projectId || selected.projectId === projectId) && !shown.some(entry => entry.id === selected.id)) {
+            if (shown.length >= limit)
+                shown.pop();
+            shown.unshift(selected);
+        }
         const usedProjects = new Set();
         const usedAgents = new Set();
-        for (const entry of entries.slice(0, limit)) {
+        for (const entry of shown) {
             const projectNode = 'project:' + entry.projectId;
             const agentNode = 'agent:' + entry.agentTool;
             const memoryNode = 'memory:' + entry.id;
@@ -178,16 +487,25 @@ export async function handleWorkspaceRequest(req, res, dependencies = {}) {
                 usedAgents.add(agentNode);
                 nodes.push({ id: agentNode, kind: 'agent', label: entry.agentTool });
             }
-            const detail = summary(entry);
+            const detail = summary(entry, annotations);
             nodes.push({ id: memoryNode, kind: 'memory', label: detail.title, project: entry.projectId, category: entry.category,
-                snippet: detail.snippet, source: detail.source, agent: entry.agentTool, updatedAt: detail.updatedAt });
+                memoryId: entry.id, effectiveState: detail.effectiveState, snippet: detail.snippet, source: detail.source, sources: detail.sources, agent: entry.agentTool, updatedAt: detail.updatedAt });
             edges.push({ source: projectNode, target: memoryNode, kind: 'belongs-to' }, { source: agentNode, target: memoryNode, kind: 'recorded-by' });
         }
-        return send({ nodes, edges, truncated: entries.length > limit || inventoryTruncated, shownMemories: Math.min(entries.length, limit), totalMemories: entries.length, facets });
+        const shownById = new Map(shown.map(entry => [entry.id, entry.projectId]));
+        for (const link of annotations.links) {
+            if (shownById.get(link.fromId) !== link.projectId || shownById.get(link.toId) !== link.projectId)
+                continue;
+            edges.push({ id: link.id, source: 'memory:' + link.fromId, target: 'memory:' + link.toId, kind: link.type, note: link.note });
+        }
+        return send({ nodes, edges, truncated: entries.length > limit || inventoryTruncated, shownMemories: shown.length, totalMemories: entries.length, facets });
     }
     catch (error) {
         const code = error.code;
-        send({ error: error instanceof Error ? error.message : String(error), ...(code ? { code } : {}) }, code === 'FEATURE_SETTINGS_CONFLICT' ? 409 : code === 'FEATURE_SETTINGS_INVALID_PATCH' || error instanceof TypeError || error instanceof RangeError ? 400 : 500);
+        send({ error: error instanceof Error ? error.message : String(error), ...(code ? { code } : {}) }, Number.isInteger(error.status) ? error.status :
+            code === 'FEATURE_SETTINGS_CONFLICT' || code === 'ANNOTATIONS_CONFLICT' || code?.includes('CONFLICT') || code?.includes('STALE') ? 409 : code === 'ANNOTATIONS_NOT_FOUND' ? 404 :
+                code === 'FEATURE_SETTINGS_INVALID_PATCH' || code === 'ANNOTATIONS_INVALID_COMMAND' || code === 'ACTIVITY_JOURNAL_INVALID_EVENT' ||
+                    code === 'ACTIVITY_JOURNAL_INVALID_CURSOR' || error instanceof TypeError || error instanceof RangeError ? 400 : 500);
     }
 }
 //# sourceMappingURL=workspace-api.js.map