@pellux/goodvibes-sdk 0.33.10 → 0.33.11

package/dist/platform/knowledge/projections.js

@@ -1,4 +1,5 @@
 import { generatedKnowledgeCanonicalUri, generatedKnowledgeSourceId, isGeneratedKnowledgeSource, materializeGeneratedKnowledgeProjection, } from './generated-projections.js';
+import { isInKnowledgeSpaceScope, resolveKnowledgeSpaceScope, } from './spaces.js';
 import { buildBulletList, dedupe, formatDateTime, joinSections, materializedTargetReference, quote, slugify, sortByTitle, } from './projection-utils.js';
 export class KnowledgeProjectionService {
     store;
@@ -9,16 +10,16 @@ export class KnowledgeProjectionService {
         this.artifactStore = artifactStore;
         this.getConnectors = options.connectors ?? (() => []);
     }
-    async listTargets(limit = 25) {
+    async listTargets(limit = 25, scope = {}) {
         await this.store.init();
         const max = Math.max(1, limit);
-        const targets = [this.createPresetTarget('overview'), this.createPresetTarget('bundle')];
+        const targets = [this.createPresetTarget('overview', scope), this.createPresetTarget('bundle', scope)];
         const remaining = Math.max(1, max - targets.length);
         const perKind = Math.max(1, Math.ceil(remaining / 4));
-        const sources = this.store.listSources(perKind).map((source) => this.createSourceTarget(source));
-        const nodes = this.store.listNodes(perKind).map((node) => this.createNodeTarget(node));
-        const issues = this.store.listIssues(perKind).map((issue) => this.createIssueTarget(issue));
-        const rollups = this.store.listNodes(Number.MAX_SAFE_INTEGER)
+        const sources = this.scopedSources(scope, perKind).map((source) => this.createSourceTarget(source));
+        const nodes = this.scopedNodes(scope, perKind).map((node) => this.createNodeTarget(node));
+        const issues = this.scopedIssues(scope, perKind).map((issue) => this.createIssueTarget(issue));
+        const rollups = this.scopedNodes(scope)
             .filter((node) => node.kind === 'domain' || node.kind === 'topic' || node.kind === 'bookmark_folder')
             .slice(0, Math.max(2, perKind))
             .map((node) => this.createRollupTarget(node));
@@ -28,27 +29,28 @@ export class KnowledgeProjectionService {
     async render(input) {
         await this.store.init();
         const limit = Math.max(1, input.limit ?? 12);
-        const target = this.resolveTarget(input.kind, input.id);
+        const scope = projectionScope(input);
+        const target = this.resolveTarget(input.kind, input.id, scope);
         if (!target) {
             throw new Error(`Unknown knowledge projection target: ${input.kind}${input.id ? `/${input.id}` : ''}`);
         }
         switch (target.kind) {
             case 'overview':
-                return this.bundleFromPages(target, [this.renderOverviewPage(target, limit)], { preset: 'overview' });
+                return this.bundleFromPages(target, [this.renderOverviewPage(target, limit, scope)], { preset: 'overview' }, scope);
             case 'bundle':
-                return this.renderBundleTarget(target, limit);
+                return this.renderBundleTarget(target, limit, scope);
             case 'source':
-                return this.bundleFromPages(target, [this.renderSourcePage(target.itemId)], {});
+                return this.bundleFromPages(target, [this.renderSourcePage(target.itemId, scope)], {}, scope);
             case 'node':
-                return this.bundleFromPages(target, [this.renderNodePage(target.itemId)], {});
+                return this.bundleFromPages(target, [this.renderNodePage(target.itemId, scope)], {}, scope);
             case 'issue':
-                return this.bundleFromPages(target, [this.renderIssuePage(target.itemId)], {});
+                return this.bundleFromPages(target, [this.renderIssuePage(target.itemId, scope)], {}, scope);
             case 'dashboard':
-                return this.bundleFromPages(target, [this.renderDashboardPage(target, limit)], { preset: 'dashboard' });
+                return this.bundleFromPages(target, [this.renderDashboardPage(target, limit, scope)], { preset: 'dashboard' }, scope);
             case 'rollup':
-                return this.bundleFromPages(target, [this.renderRollupPage(target.itemId, target)], { preset: 'rollup' });
+                return this.bundleFromPages(target, [this.renderRollupPage(target.itemId, target, scope)], { preset: 'rollup' }, scope);
             default:
-                return this.bundleFromPages(target, [this.renderOverviewPage(this.createPresetTarget('overview'), limit)], {});
+                return this.bundleFromPages(target, [this.renderOverviewPage(this.createPresetTarget('overview', scope), limit, scope)], {}, scope);
         }
     }
     async materialize(input) {
@@ -91,31 +93,33 @@ export class KnowledgeProjectionService {
             artifactCreated: generated.artifactCreated,
         };
     }
-    resolveTarget(kind, id) {
+    resolveTarget(kind, id, scope) {
         if (kind === 'overview' || kind === 'bundle')
-            return this.createPresetTarget(kind);
+            return this.createPresetTarget(kind, scope);
         if (kind === 'dashboard')
             return this.createDashboardTarget(id ?? 'source-health');
         if (kind === 'rollup') {
             if (!id?.trim())
                 return null;
             const node = this.store.getNode(id);
-            return node ? this.createRollupTarget(node) : null;
+            return node && isInKnowledgeSpaceScope(node, scope) ? this.createRollupTarget(node) : null;
         }
         if (!id?.trim())
             return null;
         if (kind === 'source') {
             const source = this.store.getSource(id);
-            return source ? this.createSourceTarget(source) : null;
+            return source && isInKnowledgeSpaceScope(source, scope) ? this.createSourceTarget(source) : null;
         }
         if (kind === 'node') {
             const node = this.store.getNode(id);
-            return node ? this.createNodeTarget(node) : null;
+            return node && isInKnowledgeSpaceScope(node, scope) ? this.createNodeTarget(node) : null;
         }
         const issue = this.store.getIssue(id);
-        return issue ? this.createIssueTarget(issue) : null;
+        return issue && isInKnowledgeSpaceScope(issue, scope) ? this.createIssueTarget(issue) : null;
     }
-    createPresetTarget(kind) {
+    createPresetTarget(kind, scope) {
+        const spaceId = resolveKnowledgeSpaceScope(scope);
+        const metadata = spaceId === null ? { includeAllSpaces: true } : { knowledgeSpaceId: spaceId };
         if (kind === 'overview') {
             return {
                 targetId: 'overview',
@@ -124,7 +128,7 @@ export class KnowledgeProjectionService {
                 description: 'A compact markdown projection of the current structured knowledge store.',
                 defaultPath: 'wiki/index.md',
                 defaultFilename: 'knowledge-overview.md',
-                metadata: {},
+                metadata,
             };
         }
         return {
@@ -134,7 +138,7 @@ export class KnowledgeProjectionService {
             description: 'A multi-page markdown bundle containing indexes, dashboards, and recent records.',
             defaultPath: 'wiki/bundle/index.md',
             defaultFilename: 'knowledge-bundle.md',
-            metadata: {},
+            metadata,
         };
     }
     createDashboardTarget(id) {
@@ -221,21 +225,25 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderOverviewPage(target, limit) {
-        const status = this.store.status();
-        const sources = this.store.listSources(limit);
-        const nodes = this.store.listNodes(limit);
-        const issues = this.store.listIssues(limit);
+    renderOverviewPage(target, limit, scope) {
+        const sources = this.scopedSources(scope, limit);
+        const nodes = this.scopedNodes(scope, limit);
+        const issues = this.scopedIssues(scope, limit);
+        const allSources = this.scopedSources(scope);
+        const allNodes = this.scopedNodes(scope);
+        const allIssues = this.scopedIssues(scope);
+        const edgeCount = this.store.listEdges().filter((edge) => this.edgeInScope(edge, scope)).length;
+        const extractionCount = this.scopedExtractions(scope).length;
         const connectors = this.getConnectors();
         const runs = this.store.listJobRuns(5);
         const content = joinSections(`# ${target.title}`, 'Structured knowledge is canonical in SQL. This markdown page is a derived projection for clients, exports, and future wiki-style surfaces.', [
             '## Counts',
-            `- sources: ${status.sourceCount}`,
-            `- nodes: ${status.nodeCount}`,
-            `- edges: ${status.edgeCount}`,
-            `- issues: ${status.issueCount}`,
-            `- extractions: ${status.extractionCount}`,
-            `- job runs: ${status.jobRunCount}`,
+            `- sources: ${allSources.length}`,
+            `- nodes: ${allNodes.length}`,
+            `- edges: ${edgeCount}`,
+            `- issues: ${allIssues.length}`,
+            `- extractions: ${extractionCount}`,
+            `- job runs: ${this.store.listJobRuns(Number.MAX_SAFE_INTEGER).length}`,
         ].join('\n'), [
             '## Connectors',
             buildBulletList(connectors.map((connector) => `\`${connector.id}\` - ${connector.description}`)),
@@ -263,8 +271,8 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderSourceIndexPage(limit) {
-        const sources = sortByTitle(this.store.listSources(Number.MAX_SAFE_INTEGER).slice(0, limit));
+    renderSourceIndexPage(limit, scope) {
+        const sources = sortByTitle(this.scopedSources(scope).slice(0, limit));
         const lines = [
             '# Sources Index',
             '',
@@ -285,8 +293,8 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderNodeIndexPage(limit) {
-        const nodes = sortByTitle(this.store.listNodes(Number.MAX_SAFE_INTEGER).slice(0, limit));
+    renderNodeIndexPage(limit, scope) {
+        const nodes = sortByTitle(this.scopedNodes(scope).slice(0, limit));
         const grouped = new Map();
         for (const node of nodes) {
             const bucket = grouped.get(node.kind) ?? [];
@@ -308,8 +316,8 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderIssueDashboardPage(limit) {
-        const issues = this.store.listIssues(limit);
+    renderIssueDashboardPage(limit, scope) {
+        const issues = this.scopedIssues(scope, limit);
         const severityGroups = ['error', 'warning', 'info'].map((severity) => [
             `## ${severity.toUpperCase()}`,
             buildBulletList(issues
@@ -327,10 +335,11 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderBacklinksPage(limit) {
-        const items = this.store.listSources(limit).map((source) => {
+    renderBacklinksPage(limit, scope) {
+        const items = this.scopedSources(scope, limit).map((source) => {
             const incoming = this.store.listEdges()
-                .filter((edge) => edge.toKind === 'source' && edge.toId === source.id);
+                .filter((edge) => edge.toKind === 'source' && edge.toId === source.id)
+                .filter((edge) => this.edgeInScope(edge, scope));
             return { source, incoming };
         }).filter((entry) => entry.incoming.length > 0);
         const content = [
@@ -341,11 +350,11 @@ export class KnowledgeProjectionService {
                 buildBulletList(entry.incoming.map((edge) => {
                     if (edge.fromKind === 'source') {
                         const linked = this.store.getSource(edge.fromId);
-                        return linked ? `${this.linkToTarget(this.createSourceTarget(linked))} via \`${edge.relation}\`` : `source:${edge.fromId}`;
+                        return linked && isInKnowledgeSpaceScope(linked, scope) ? `${this.linkToTarget(this.createSourceTarget(linked))} via \`${edge.relation}\`` : `source:${edge.fromId}`;
                     }
                     if (edge.fromKind === 'node') {
                         const node = this.store.getNode(edge.fromId);
-                        return node ? `${this.linkToTarget(this.createNodeTarget(node))} via \`${edge.relation}\`` : `node:${edge.fromId}`;
+                        return node && isInKnowledgeSpaceScope(node, scope) ? `${this.linkToTarget(this.createNodeTarget(node))} via \`${edge.relation}\`` : `node:${edge.fromId}`;
                     }
                     return `${edge.fromKind}:${edge.fromId} via \`${edge.relation}\``;
                 })),
@@ -362,8 +371,8 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderHealthDashboardPage(limit) {
-        const sources = this.store.listSources(limit);
+    renderHealthDashboardPage(limit, scope) {
+        const sources = this.scopedSources(scope, limit);
         const staleThreshold = Date.now() - (14 * 24 * 60 * 60 * 1000);
         const unhealthy = sources.filter((source) => (source.status !== 'indexed'
             || Boolean(source.crawlError)
@@ -395,19 +404,20 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderSourcePage(id) {
+    renderSourcePage(id, scope) {
         const source = this.store.getSource(id);
-        if (!source)
+        if (!source || !isInKnowledgeSpaceScope(source, scope))
             throw new Error(`Unknown knowledge source: ${id}`);
         const extraction = this.store.getExtractionBySourceId(id);
         const view = this.store.getItem(id);
         const target = this.createSourceTarget(source);
         const relatedNodes = view?.linkedNodes ?? [];
         const relatedSources = view?.linkedSources.filter((entry) => (entry.id !== source.id && !isGeneratedKnowledgeSource(entry))) ?? [];
-        const issues = this.store.listIssues(Number.MAX_SAFE_INTEGER).filter((issue) => issue.sourceId === source.id);
+        const issues = this.scopedIssues(scope).filter((issue) => issue.sourceId === source.id);
         const incoming = this.store.listEdges().filter((edge) => (edge.toKind === 'source'
             && edge.toId === source.id
-            && !this.isGeneratedSourceReference(edge.fromKind, edge.fromId)));
+            && !this.isGeneratedSourceReference(edge.fromKind, edge.fromId)
+            && this.edgeInScope(edge, scope)));
         const content = joinSections(`# ${target.title}`, extraction?.summary ?? source.summary, [
             '## Metadata',
             `- id: \`${source.id}\``,
@@ -428,10 +438,10 @@ export class KnowledgeProjectionService {
             ...(extraction.links.length > 0 ? [`- links: ${extraction.links.join(', ')}`] : []),
         ].join('\n') : null, extraction?.excerpt ? ['## Excerpt', extraction.excerpt].join('\n') : null, [
             '## Related Nodes',
-            buildBulletList(relatedNodes.map((node) => this.linkToTarget(this.createNodeTarget(node), `${node.title} (${node.kind})`))),
+            buildBulletList(relatedNodes.filter((node) => isInKnowledgeSpaceScope(node, scope)).map((node) => this.linkToTarget(this.createNodeTarget(node), `${node.title} (${node.kind})`))),
         ].join('\n'), [
             '## Related Sources',
-            buildBulletList(relatedSources.map((entry) => this.linkToTarget(this.createSourceTarget(entry)))),
+            buildBulletList(relatedSources.filter((entry) => isInKnowledgeSpaceScope(entry, scope)).map((entry) => this.linkToTarget(this.createSourceTarget(entry)))),
         ].join('\n'), [
             '## Backlinks',
             buildBulletList(incoming.map((edge) => `${edge.fromKind}:${edge.fromId} via \`${edge.relation}\``)),
@@ -452,13 +462,13 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderNodePage(id) {
+    renderNodePage(id, scope) {
         const node = this.store.getNode(id);
-        if (!node)
+        if (!node || !isInKnowledgeSpaceScope(node, scope))
             throw new Error(`Unknown knowledge node: ${id}`);
         const view = this.store.getItem(id);
         const target = this.createNodeTarget(node);
-        const incoming = this.store.listEdges().filter((edge) => edge.toKind === 'node' && edge.toId === node.id);
+        const incoming = this.store.listEdges().filter((edge) => edge.toKind === 'node' && edge.toId === node.id && this.edgeInScope(edge, scope));
         const content = joinSections(`# ${target.title}`, node.summary, [
             '## Metadata',
             `- id: \`${node.id}\``,
@@ -472,10 +482,11 @@ export class KnowledgeProjectionService {
             '## Linked Sources',
             buildBulletList((view?.linkedSources ?? [])
                 .filter((source) => !isGeneratedKnowledgeSource(source))
+                .filter((source) => isInKnowledgeSpaceScope(source, scope))
                 .map((source) => this.linkToTarget(this.createSourceTarget(source)))),
         ].join('\n'), [
             '## Linked Nodes',
-            buildBulletList((view?.linkedNodes ?? []).filter((entry) => entry.id !== node.id).map((entry) => this.linkToTarget(this.createNodeTarget(entry), `${entry.title} (${entry.kind})`))),
+            buildBulletList((view?.linkedNodes ?? []).filter((entry) => entry.id !== node.id && isInKnowledgeSpaceScope(entry, scope)).map((entry) => this.linkToTarget(this.createNodeTarget(entry), `${entry.title} (${entry.kind})`))),
         ].join('\n'), [
             '## Backlinks',
             buildBulletList(incoming
@@ -483,7 +494,7 @@ export class KnowledgeProjectionService {
                 .map((edge) => `${edge.fromKind}:${edge.fromId} via \`${edge.relation}\``)),
         ].join('\n'), [
             '## Issues',
-            buildBulletList(this.store.listIssues(Number.MAX_SAFE_INTEGER)
+            buildBulletList(this.scopedIssues(scope)
                 .filter((issue) => issue.nodeId === node.id)
                 .map((issue) => this.linkToTarget(this.createIssueTarget(issue), `${issue.severity.toUpperCase()} ${issue.code}: ${issue.message}`))),
         ].join('\n'));
@@ -499,13 +510,15 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderIssuePage(id) {
+    renderIssuePage(id, scope) {
         const issue = this.store.getIssue(id);
-        if (!issue)
+        if (!issue || !isInKnowledgeSpaceScope(issue, scope))
             throw new Error(`Unknown knowledge issue: ${id}`);
         const target = this.createIssueTarget(issue);
-        const source = issue.sourceId ? this.store.getSource(issue.sourceId) : null;
-        const node = issue.nodeId ? this.store.getNode(issue.nodeId) : null;
+        const linkedSource = issue.sourceId ? this.store.getSource(issue.sourceId) : null;
+        const linkedNode = issue.nodeId ? this.store.getNode(issue.nodeId) : null;
+        const source = linkedSource && isInKnowledgeSpaceScope(linkedSource, scope) ? linkedSource : null;
+        const node = linkedNode && isInKnowledgeSpaceScope(linkedNode, scope) ? linkedNode : null;
         const content = joinSections(`# ${target.title}`, [
             '## Metadata',
             `- id: \`${issue.id}\``,
@@ -536,15 +549,15 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderDashboardPage(target, limit) {
+    renderDashboardPage(target, limit, scope) {
         if (target.itemId === 'backlinks') {
-            return this.renderBacklinksPage(limit);
+            return this.renderBacklinksPage(limit, scope);
         }
-        return this.renderHealthDashboardPage(limit);
+        return this.renderHealthDashboardPage(limit, scope);
     }
-    renderRollupPage(nodeId, target) {
+    renderRollupPage(nodeId, target, scope) {
         const node = this.store.getNode(nodeId);
-        if (!node)
+        if (!node || !isInKnowledgeSpaceScope(node, scope))
             throw new Error(`Unknown rollup node: ${nodeId}`);
         const edges = this.store.edgesFor('node', node.id);
         const sources = edges
@@ -555,7 +568,7 @@ export class KnowledgeProjectionService {
                 return this.store.getSource(edge.toId);
             return null;
         })
-            .filter((source) => Boolean(source));
+            .filter((source) => Boolean(source) && isInKnowledgeSpaceScope(source, scope));
         const linkedNodes = edges
             .map((edge) => {
             if (edge.fromKind === 'node' && edge.fromId !== node.id)
@@ -564,7 +577,7 @@ export class KnowledgeProjectionService {
                 return this.store.getNode(edge.toId);
             return null;
         })
-            .filter((entry) => Boolean(entry));
+            .filter((entry) => Boolean(entry) && isInKnowledgeSpaceScope(entry, scope));
         const content = joinSections(`# ${target.title}`, node.summary, [
             '## Included Sources',
             buildBulletList(sortByTitle(dedupe(sources, (source) => source.id)).map((source) => this.linkToTarget(this.createSourceTarget(source)))),
@@ -584,42 +597,46 @@ export class KnowledgeProjectionService {
             },
         };
     }
-    renderBundleTarget(target, limit) {
-        const overview = this.renderOverviewPage(this.createPresetTarget('overview'), limit);
-        const sourceIndex = this.renderSourceIndexPage(Math.max(limit * 2, 24));
-        const nodeIndex = this.renderNodeIndexPage(Math.max(limit * 2, 24));
-        const issueDashboard = this.renderIssueDashboardPage(Math.max(limit * 2, 24));
-        const backlinks = this.renderBacklinksPage(Math.max(limit * 2, 16));
-        const health = this.renderHealthDashboardPage(Math.max(limit * 2, 16));
+    renderBundleTarget(target, limit, scope) {
+        const overview = this.renderOverviewPage(this.createPresetTarget('overview', scope), limit, scope);
+        const sourceIndex = this.renderSourceIndexPage(Math.max(limit * 2, 24), scope);
+        const nodeIndex = this.renderNodeIndexPage(Math.max(limit * 2, 24), scope);
+        const issueDashboard = this.renderIssueDashboardPage(Math.max(limit * 2, 24), scope);
+        const backlinks = this.renderBacklinksPage(Math.max(limit * 2, 16), scope);
+        const health = this.renderHealthDashboardPage(Math.max(limit * 2, 16), scope);
         const pages = [overview, sourceIndex, nodeIndex, issueDashboard, backlinks, health];
         const perKind = Math.max(1, Math.ceil(limit / 3));
-        for (const node of this.store.listNodes(Number.MAX_SAFE_INTEGER).filter((entry) => entry.kind === 'domain' || entry.kind === 'topic').slice(0, 4)) {
-            pages.push(this.renderRollupPage(node.id, this.createRollupTarget(node)));
+        for (const node of this.scopedNodes(scope).filter((entry) => entry.kind === 'domain' || entry.kind === 'topic').slice(0, 4)) {
+            pages.push(this.renderRollupPage(node.id, this.createRollupTarget(node), scope));
         }
-        for (const source of this.store.listSources(perKind)) {
-            pages.push(this.renderSourcePage(source.id));
+        for (const source of this.scopedSources(scope, perKind)) {
+            pages.push(this.renderSourcePage(source.id, scope));
         }
-        for (const node of this.store.listNodes(perKind)) {
-            pages.push(this.renderNodePage(node.id));
+        for (const node of this.scopedNodes(scope, perKind)) {
+            pages.push(this.renderNodePage(node.id, scope));
         }
-        for (const issue of this.store.listIssues(perKind)) {
-            pages.push(this.renderIssuePage(issue.id));
+        for (const issue of this.scopedIssues(scope, perKind)) {
+            pages.push(this.renderIssuePage(issue.id, scope));
         }
         return this.bundleFromPages(target, pages, {
             preset: 'bundle',
-            sourceCount: this.store.status().sourceCount,
-            nodeCount: this.store.status().nodeCount,
-            issueCount: this.store.status().issueCount,
-        });
+            sourceCount: this.scopedSources(scope).length,
+            nodeCount: this.scopedNodes(scope).length,
+            issueCount: this.scopedIssues(scope).length,
+        }, scope);
     }
-    bundleFromPages(target, pages, metadata) {
+    bundleFromPages(target, pages, metadata, scope) {
+        const spaceId = resolveKnowledgeSpaceScope(scope);
         return {
             id: `projection-${slugify(target.targetId)}`,
             target,
             generatedAt: Date.now(),
             pageCount: pages.length,
             pages,
-            metadata,
+            metadata: {
+                ...metadata,
+                ...(spaceId === null ? { includeAllSpaces: true } : { knowledgeSpaceId: spaceId }),
+            },
         };
     }
     linkToTarget(target, label) {
@@ -650,4 +667,49 @@ export class KnowledgeProjectionService {
         const source = this.store.getSource(id);
         return source ? isGeneratedKnowledgeSource(source) : false;
     }
+    edgeInScope(edge, scope) {
+        return this.recordReferenceInScope(edge.fromKind, edge.fromId, scope)
+            && this.recordReferenceInScope(edge.toKind, edge.toId, scope);
+    }
+    recordReferenceInScope(kind, id, scope) {
+        if (kind === 'source') {
+            const source = this.store.getSource(id);
+            return Boolean(source && isInKnowledgeSpaceScope(source, scope));
+        }
+        if (kind === 'node') {
+            const node = this.store.getNode(id);
+            return Boolean(node && isInKnowledgeSpaceScope(node, scope));
+        }
+        if (kind === 'issue') {
+            const issue = this.store.getIssue(id);
+            return Boolean(issue && isInKnowledgeSpaceScope(issue, scope));
+        }
+        return true;
+    }
+    scopedSources(scope, limit = Number.MAX_SAFE_INTEGER) {
+        return this.store.listSources(Number.MAX_SAFE_INTEGER)
+            .filter((source) => isInKnowledgeSpaceScope(source, scope))
+            .slice(0, Math.max(1, limit));
+    }
+    scopedNodes(scope, limit = Number.MAX_SAFE_INTEGER) {
+        return this.store.listNodes(Number.MAX_SAFE_INTEGER)
+            .filter((node) => isInKnowledgeSpaceScope(node, scope))
+            .slice(0, Math.max(1, limit));
+    }
+    scopedIssues(scope, limit = Number.MAX_SAFE_INTEGER) {
+        return this.store.listIssues(Number.MAX_SAFE_INTEGER)
+            .filter((issue) => isInKnowledgeSpaceScope(issue, scope))
+            .slice(0, Math.max(1, limit));
+    }
+    scopedExtractions(scope, limit = Number.MAX_SAFE_INTEGER) {
+        return this.store.listExtractions(Number.MAX_SAFE_INTEGER)
+            .filter((extraction) => isInKnowledgeSpaceScope(extraction, scope))
+            .slice(0, Math.max(1, limit));
+    }
+}
+function projectionScope(input = {}) {
+    return {
+        ...(input.knowledgeSpaceId ? { knowledgeSpaceId: input.knowledgeSpaceId } : {}),
+        ...(input.includeAllSpaces === true ? { includeAllSpaces: true } : {}),
+    };
 }

package/dist/platform/knowledge/service.d.ts

@@ -9,6 +9,7 @@ import { KnowledgeStore } from './store.js';
 import type { BrowserKnowledgeIngestOptions, BrowserKnowledgeProfile } from './browser-history/index.js';
 import type { KnowledgeBatchIngestResult, KnowledgeBookmarkSeed, KnowledgeConnector, KnowledgeConnectorDoctorReport, KnowledgeConsolidationCandidateRecord, KnowledgeConsolidationReportRecord, KnowledgeEdgeRecord, KnowledgeExtractionRecord, KnowledgeIssueRecord, KnowledgeJobMode, KnowledgeJobRecord, KnowledgeJobRunRecord, KnowledgeMaterializedProjection, KnowledgeItemView, KnowledgeMapResult, KnowledgeNodeRecord, KnowledgePacket, KnowledgePacketDetail, KnowledgeProjectionBundle, KnowledgeProjectionTarget, KnowledgeProjectionTargetKind, KnowledgeRefinementTaskRecord, KnowledgeRefinementTaskState, KnowledgeScheduleRecord, KnowledgeSearchResult, KnowledgeSourceRecord, KnowledgeSourceType, KnowledgeStatus, KnowledgeUsageRecord } from './types.js';
 import { type KnowledgeIssueReviewInput, type KnowledgeIssueReviewResult } from './review.js';
+import { type KnowledgeSpaceScopeInput } from './spaces.js';
 export interface KnowledgeServiceConfig {
     readonly configManager?: {
         getControlPlaneConfigDir?: (() => string) | undefined;
@@ -34,7 +35,7 @@ export declare class KnowledgeService {
     private getPacketContext;
     private getConsolidationContext;
     attachRuntimeBus(runtimeBus: RuntimeEventBus | null | undefined): void;
-    getStatus(): Promise<KnowledgeServiceStatus>;
+    getStatus(scope?: KnowledgeSpaceScopeInput): Promise<KnowledgeServiceStatus>;
     listUsageRecords(limit?: number, input?: {
         readonly targetKind?: KnowledgeUsageRecord['targetKind'] | undefined;
         readonly targetId?: string | undefined;
@@ -54,6 +55,8 @@ export declare class KnowledgeService {
     querySources(input?: {
         readonly limit?: number | undefined;
         readonly offset?: number | undefined;
+        readonly knowledgeSpaceId?: string | undefined;
+        readonly includeAllSpaces?: boolean | undefined;
         readonly status?: string | undefined;
         readonly connectorId?: string | undefined;
         readonly sourceType?: string | undefined;
@@ -67,6 +70,8 @@ export declare class KnowledgeService {
     queryNodes(input?: {
         readonly limit?: number | undefined;
         readonly offset?: number | undefined;
+        readonly knowledgeSpaceId?: string | undefined;
+        readonly includeAllSpaces?: boolean | undefined;
         readonly kind?: string | undefined;
         readonly status?: string | undefined;
         readonly query?: string | undefined;
@@ -78,6 +83,8 @@ export declare class KnowledgeService {
     queryIssues(input?: {
         readonly limit?: number | undefined;
         readonly offset?: number | undefined;
+        readonly knowledgeSpaceId?: string | undefined;
+        readonly includeAllSpaces?: boolean | undefined;
         readonly severity?: string | undefined;
         readonly status?: string | undefined;
         readonly code?: string | undefined;
@@ -87,7 +94,7 @@ export declare class KnowledgeService {
         items: KnowledgeIssueRecord[];
     };
     reviewIssue(input: KnowledgeIssueReviewInput): Promise<KnowledgeIssueReviewResult>;
-    listExtractions(limit?: number, sourceId?: string): KnowledgeExtractionRecord[];
+    listExtractions(limit?: number, sourceId?: string, scope?: KnowledgeSpaceScopeInput): KnowledgeExtractionRecord[];
     getExtraction(id: string): KnowledgeExtractionRecord | null;
     getSourceExtraction(sourceId: string): KnowledgeExtractionRecord | null;
     listConnectors(): readonly KnowledgeConnector[];
@@ -97,7 +104,10 @@ export declare class KnowledgeService {
         replace?: boolean;
     }): void;
     getItem(id: string): KnowledgeItemView | null;
+    getItemScoped(id: string, scope?: KnowledgeSpaceScopeInput): KnowledgeItemView | null;
     getItems(ids: readonly string[]): KnowledgeItemView[];
+    private edgeInKnowledgeSpaceScope;
+    private recordReferenceInKnowledgeSpaceScope;
     recordUsage(input: {
         readonly targetKind: KnowledgeUsageRecord['targetKind'];
         readonly targetId: string;
@@ -172,17 +182,21 @@ export declare class KnowledgeService {
     syncBrowserHistory(input?: BrowserKnowledgeIngestOptions): Promise<KnowledgeBatchIngestResult & {
         readonly profiles: readonly BrowserKnowledgeProfile[];
     }>;
-    listProjectionTargets(limit?: number): Promise<KnowledgeProjectionTarget[]>;
+    listProjectionTargets(limit?: number, scope?: KnowledgeSpaceScopeInput): Promise<KnowledgeProjectionTarget[]>;
     renderProjection(input: {
         readonly kind: KnowledgeProjectionTargetKind;
         readonly id?: string | undefined;
         readonly limit?: number | undefined;
+        readonly knowledgeSpaceId?: string | undefined;
+        readonly includeAllSpaces?: boolean | undefined;
     }): Promise<KnowledgeProjectionBundle>;
     materializeProjection(input: {
         readonly kind: KnowledgeProjectionTargetKind;
         readonly id?: string | undefined;
         readonly limit?: number | undefined;
         readonly filename?: string | undefined;
+        readonly knowledgeSpaceId?: string | undefined;
+        readonly includeAllSpaces?: boolean | undefined;
     }): Promise<KnowledgeMaterializedProjection>;
     map(input?: KnowledgeMapRenderOptions): Promise<KnowledgeMapResult>;
     reindex(): Promise<{
@@ -190,6 +204,12 @@ export declare class KnowledgeService {
         issues: readonly KnowledgeIssueRecord[];
     }>;
     search(query: string, limit?: number): KnowledgeSearchResult[];
+    searchScoped(input: {
+        readonly query: string;
+        readonly limit?: number | undefined;
+        readonly knowledgeSpaceId?: string | undefined;
+        readonly includeAllSpaces?: boolean | undefined;
+    }): KnowledgeSearchResult[];
     ask(input: {
         readonly query: string;
         readonly limit?: number | undefined;
@@ -202,19 +222,19 @@ export declare class KnowledgeService {
     buildPacket(task: string, writeScope?: readonly string[], limit?: number, options?: {
         readonly detail?: KnowledgePacketDetail;
         readonly budgetLimit?: number;
-    }): Promise<KnowledgePacket>;
+    } & KnowledgeSpaceScopeInput): Promise<KnowledgePacket>;
     buildPacketSync(task: string, writeScope?: readonly string[], limit?: number, options?: {
         readonly detail?: KnowledgePacketDetail;
         readonly budgetLimit?: number;
-    }): KnowledgePacket | null;
+    } & KnowledgeSpaceScopeInput): KnowledgePacket | null;
     buildPromptPacketSync(task: string, writeScope?: readonly string[], limit?: number, options?: {
         readonly detail?: KnowledgePacketDetail;
         readonly budgetLimit?: number;
-    }): string | null;
+    } & KnowledgeSpaceScopeInput): string | null;
     buildPromptPacket(task: string, writeScope?: readonly string[], limit?: number, options?: {
         readonly detail?: KnowledgePacketDetail;
         readonly budgetLimit?: number;
-    }): Promise<string | null>;
+    } & KnowledgeSpaceScopeInput): Promise<string | null>;
     listJobs(): readonly KnowledgeJobRecord[];
     getJob(id: string): KnowledgeJobRecord | null;
     saveSchedule(input: {