@lssm/lib.contracts 1.41.0 → 1.42.1

package/dist/knowledge/operations.js

@@ -0,0 +1,321 @@
+import { defineCommand, defineQuery } from "../operations/operation.js";
+import "../operations/index.js";
+import { ScalarTypeEnum, SchemaModel } from "@lssm/lib.schema";
+
+//#region src/knowledge/operations.ts
+const KnowledgeSyncSchedule = new SchemaModel({
+	name: "KnowledgeSyncSchedule",
+	fields: {
+		enabled: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: false
+		},
+		cron: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		intervalMs: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: true
+		}
+	}
+});
+const KnowledgeSourceRecord = new SchemaModel({
+	name: "KnowledgeSourceRecord",
+	fields: {
+		id: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		tenantId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		spaceKey: {
+			type: ScalarTypeEnum.NonEmptyString(),
+			isOptional: false
+		},
+		spaceVersion: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: false
+		},
+		label: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		sourceType: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		syncSchedule: {
+			type: KnowledgeSyncSchedule,
+			isOptional: true
+		},
+		lastSyncStatus: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		lastSyncAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		},
+		itemsProcessed: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: true
+		},
+		createdAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		},
+		updatedAt: {
+			type: ScalarTypeEnum.DateTime(),
+			isOptional: true
+		}
+	}
+});
+const CreateKnowledgeSourceInput = new SchemaModel({
+	name: "CreateKnowledgeSourceInput",
+	fields: {
+		tenantId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		spaceKey: {
+			type: ScalarTypeEnum.NonEmptyString(),
+			isOptional: false
+		},
+		spaceVersion: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: false
+		},
+		label: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: false
+		},
+		sourceType: {
+			type: ScalarTypeEnum.NonEmptyString(),
+			isOptional: false
+		},
+		config: {
+			type: ScalarTypeEnum.JSONObject(),
+			isOptional: false
+		},
+		syncSchedule: {
+			type: KnowledgeSyncSchedule,
+			isOptional: true
+		}
+	}
+});
+const UpdateKnowledgeSourceInput = new SchemaModel({
+	name: "UpdateKnowledgeSourceInput",
+	fields: {
+		sourceId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		label: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		},
+		config: {
+			type: ScalarTypeEnum.JSONObject(),
+			isOptional: true
+		},
+		syncSchedule: {
+			type: KnowledgeSyncSchedule,
+			isOptional: true
+		}
+	}
+});
+const DeleteKnowledgeSourceInput = new SchemaModel({
+	name: "DeleteKnowledgeSourceInput",
+	fields: { sourceId: {
+		type: ScalarTypeEnum.ID(),
+		isOptional: false
+	} }
+});
+const DeleteKnowledgeSourceOutput = new SchemaModel({
+	name: "DeleteKnowledgeSourceOutput",
+	fields: { success: {
+		type: ScalarTypeEnum.Boolean(),
+		isOptional: false
+	} }
+});
+const ListKnowledgeSourcesInput = new SchemaModel({
+	name: "ListKnowledgeSourcesInput",
+	fields: {
+		tenantId: {
+			type: ScalarTypeEnum.ID(),
+			isOptional: false
+		},
+		spaceKey: {
+			type: ScalarTypeEnum.NonEmptyString(),
+			isOptional: true
+		}
+	}
+});
+const ListKnowledgeSourcesOutput = new SchemaModel({
+	name: "ListKnowledgeSourcesOutput",
+	fields: { sources: {
+		type: KnowledgeSourceRecord,
+		isOptional: false,
+		isArray: true
+	} }
+});
+const TriggerKnowledgeSyncInput = new SchemaModel({
+	name: "TriggerKnowledgeSyncInput",
+	fields: { sourceId: {
+		type: ScalarTypeEnum.ID(),
+		isOptional: false
+	} }
+});
+const TriggerKnowledgeSyncOutput = new SchemaModel({
+	name: "TriggerKnowledgeSyncOutput",
+	fields: {
+		success: {
+			type: ScalarTypeEnum.Boolean(),
+			isOptional: false
+		},
+		itemsProcessed: {
+			type: ScalarTypeEnum.Int_unsecure(),
+			isOptional: true
+		},
+		error: {
+			type: ScalarTypeEnum.String_unsecure(),
+			isOptional: true
+		}
+	}
+});
+const CreateKnowledgeSource = defineCommand({
+	meta: {
+		key: "knowledge.source.create",
+		title: "Create Knowledge Source",
+		version: 1,
+		description: "Create a knowledge source binding for a tenant.",
+		goal: "Onboard a new knowledge ingestion source such as Notion or uploads.",
+		context: "Used by Ops and App Studio to configure knowledge ingestion per tenant and space.",
+		owners: ["@platform.knowledge"],
+		tags: ["knowledge", "sources"],
+		stability: "experimental"
+	},
+	io: {
+		input: CreateKnowledgeSourceInput,
+		output: KnowledgeSourceRecord
+	},
+	policy: {
+		auth: "admin",
+		policies: [{
+			key: "platform.knowledge.manage",
+			version: 1
+		}]
+	}
+});
+const UpdateKnowledgeSource = defineCommand({
+	meta: {
+		key: "knowledge.source.update",
+		title: "Update Knowledge Source",
+		version: 1,
+		description: "Update metadata or configuration for a knowledge source.",
+		goal: "Allow rotation of credentials, sync schedules, and labels.",
+		context: "Supports editing how a tenant ingests knowledge (e.g., toggling sync cadence).",
+		owners: ["@platform.knowledge"],
+		tags: ["knowledge", "sources"],
+		stability: "experimental"
+	},
+	io: {
+		input: UpdateKnowledgeSourceInput,
+		output: KnowledgeSourceRecord
+	},
+	policy: {
+		auth: "admin",
+		policies: [{
+			key: "platform.knowledge.manage",
+			version: 1
+		}]
+	}
+});
+const DeleteKnowledgeSource = defineCommand({
+	meta: {
+		key: "knowledge.source.delete",
+		title: "Delete Knowledge Source",
+		version: 1,
+		description: "Delete a knowledge source binding for a tenant.",
+		goal: "Remove obsolete or compromised knowledge ingestion paths.",
+		context: "Ensures ephemeral or external sources can be removed cleanly without leaving residual bindings.",
+		owners: ["@platform.knowledge"],
+		tags: ["knowledge", "sources"],
+		stability: "experimental"
+	},
+	io: {
+		input: DeleteKnowledgeSourceInput,
+		output: DeleteKnowledgeSourceOutput
+	},
+	policy: {
+		auth: "admin",
+		policies: [{
+			key: "platform.knowledge.manage",
+			version: 1
+		}]
+	}
+});
+const ListKnowledgeSources = defineQuery({
+	meta: {
+		key: "knowledge.source.list",
+		title: "List Knowledge Sources",
+		version: 1,
+		description: "List knowledge sources configured for a tenant.",
+		goal: "Provide visibility into knowledge ingest configuration and schedules.",
+		context: "Used by App Studio and Ops flows to surface knowledge sources and their health.",
+		owners: ["@platform.knowledge"],
+		tags: ["knowledge", "sources"],
+		stability: "experimental"
+	},
+	io: {
+		input: ListKnowledgeSourcesInput,
+		output: ListKnowledgeSourcesOutput
+	},
+	policy: {
+		auth: "admin",
+		policies: [{
+			key: "platform.knowledge.read",
+			version: 1
+		}]
+	}
+});
+const TriggerKnowledgeSourceSync = defineCommand({
+	meta: {
+		key: "knowledge.source.triggerSync",
+		title: "Trigger Knowledge Source Sync",
+		version: 1,
+		description: "Trigger an immediate sync for a knowledge source.",
+		goal: "Support manual or automated sync retries for knowledge ingestion.",
+		context: "Invoked by Ops tooling or monitors when knowledge content must be refreshed or reprocessed.",
+		owners: ["@platform.knowledge"],
+		tags: ["knowledge", "sources"],
+		stability: "experimental"
+	},
+	io: {
+		input: TriggerKnowledgeSyncInput,
+		output: TriggerKnowledgeSyncOutput
+	},
+	policy: {
+		auth: "admin",
+		policies: [{
+			key: "platform.knowledge.manage",
+			version: 1
+		}]
+	}
+});
+const knowledgeContracts = {
+	CreateKnowledgeSource,
+	UpdateKnowledgeSource,
+	DeleteKnowledgeSource,
+	ListKnowledgeSources,
+	TriggerKnowledgeSourceSync
+};
+function registerKnowledgeContracts(registry) {
+	return registry.register(CreateKnowledgeSource).register(UpdateKnowledgeSource).register(DeleteKnowledgeSource).register(ListKnowledgeSources).register(TriggerKnowledgeSourceSync);
+}
+
+//#endregion
+export { CreateKnowledgeSource, DeleteKnowledgeSource, ListKnowledgeSources, TriggerKnowledgeSourceSync, UpdateKnowledgeSource, knowledgeContracts, registerKnowledgeContracts };

package/dist/knowledge/query/index.d.ts

@@ -0,0 +1,2 @@
+import { KnowledgeAnswer, KnowledgeQueryConfig, KnowledgeQueryService } from "./service.js";
+export { KnowledgeAnswer, KnowledgeQueryConfig, KnowledgeQueryService };

package/dist/knowledge/query/index.js

@@ -1 +1,3 @@
-import{KnowledgeQueryService as e}from"./service.js";export{e as KnowledgeQueryService};
+import { KnowledgeQueryService } from "./service.js";
+
+export { KnowledgeQueryService };

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

@@ -0,0 +1,29 @@
+import { LLMProvider, LLMResponse } from "../../integrations/providers/llm.js";
+import { EmbeddingProvider } from "../../integrations/providers/embedding.js";
+import { VectorSearchResult, VectorStoreProvider } from "../../integrations/providers/vector-store.js";
+
+//#region src/knowledge/query/service.d.ts
+interface KnowledgeQueryConfig {
+  collection: string;
+  namespace?: string;
+  topK?: number;
+  systemPrompt?: string;
+}
+interface KnowledgeAnswer {
+  answer: string;
+  references: (VectorSearchResult & {
+    text?: string;
+  })[];
+  usage?: LLMResponse['usage'];
+}
+declare class KnowledgeQueryService {
+  private readonly embeddings;
+  private readonly vectorStore;
+  private readonly llm;
+  private readonly config;
+  constructor(embeddings: EmbeddingProvider, vectorStore: VectorStoreProvider, llm: LLMProvider, config: KnowledgeQueryConfig);
+  query(question: string): Promise<KnowledgeAnswer>;
+  private buildMessages;
+}
+//#endregion
+export { KnowledgeAnswer, KnowledgeQueryConfig, KnowledgeQueryService };

package/dist/knowledge/query/service.js

@@ -1,3 +1,65 @@
-var e=class{embeddings;vectorStore;llm;config;constructor(e,t,n,r){this.embeddings=e,this.vectorStore=t,this.llm=n,this.config=r}async query(e){let r=await this.embeddings.embedQuery(e),i=await this.vectorStore.search({collection:this.config.collection,vector:r.vector,topK:this.config.topK??5,namespace:this.config.namespace,filter:void 0}),a=t(i),o=this.buildMessages(e,a),s=await this.llm.chat(o);return{answer:s.message.content.map(e=>`text`in e?e.text:``).join(``),references:i.map(e=>({...e,text:n(e)})),usage:s.usage}}buildMessages(e,t){return[{role:`system`,content:[{type:`text`,text:this.config.systemPrompt??`You are a knowledge assistant that answers questions using the provided context. Cite relevant sources if possible.`}]},{role:`user`,content:[{type:`text`,text:`Question:\n${e}\n\nContext:\n${t}`}]}]}};function t(e){return e.length===0?`No relevant documents found.`:e.map((e,t)=>{let r=n(e);return`Source ${t+1} (score: ${e.score.toFixed(3)}):\n${r}`}).join(`
+//#region src/knowledge/query/service.ts
+var KnowledgeQueryService = class {
+	embeddings;
+	vectorStore;
+	llm;
+	config;
+	constructor(embeddings, vectorStore, llm, config) {
+		this.embeddings = embeddings;
+		this.vectorStore = vectorStore;
+		this.llm = llm;
+		this.config = config;
+	}
+	async query(question) {
+		const embedding = await this.embeddings.embedQuery(question);
+		const results = await this.vectorStore.search({
+			collection: this.config.collection,
+			vector: embedding.vector,
+			topK: this.config.topK ?? 5,
+			namespace: this.config.namespace,
+			filter: void 0
+		});
+		const context = buildContext(results);
+		const messages = this.buildMessages(question, context);
+		const response = await this.llm.chat(messages);
+		return {
+			answer: response.message.content.map((part) => "text" in part ? part.text : "").join(""),
+			references: results.map((result) => ({
+				...result,
+				text: extractText(result)
+			})),
+			usage: response.usage
+		};
+	}
+	buildMessages(question, context) {
+		return [{
+			role: "system",
+			content: [{
+				type: "text",
+				text: this.config.systemPrompt ?? "You are a knowledge assistant that answers questions using the provided context. Cite relevant sources if possible."
+			}]
+		}, {
+			role: "user",
+			content: [{
+				type: "text",
+				text: `Question:\n${question}\n\nContext:\n${context}`
+			}]
+		}];
+	}
+};
+function buildContext(results) {
+	if (results.length === 0) return "No relevant documents found.";
+	return results.map((result, index) => {
+		const text = extractText(result);
+		return `Source ${index + 1} (score: ${result.score.toFixed(3)}):\n${text}`;
+	}).join("\n\n");
+}
+function extractText(result) {
+	const payload = result.payload ?? {};
+	if (typeof payload.text === "string") return payload.text;
+	if (typeof payload.content === "string") return payload.content;
+	return JSON.stringify(payload);
+}
 
-`)}function n(e){let t=e.payload??{};return typeof t.text==`string`?t.text:typeof t.content==`string`?t.content:JSON.stringify(t)}export{e as KnowledgeQueryService};
+//#endregion
+export { KnowledgeQueryService };

package/dist/knowledge/runtime.d.ts

@@ -0,0 +1,32 @@
+import { KnowledgeCategory } from "./spec.js";
+import { ResolvedAppConfig, ResolvedKnowledge } from "../app-config/runtime.js";
+
+//#region src/knowledge/runtime.d.ts
+interface KnowledgeAccessContext {
+  tenantId: string;
+  appId: string;
+  environment?: string;
+  workflowName?: string;
+  agentName?: string;
+  operation: 'read' | 'write' | 'search';
+}
+interface KnowledgeAccessResult {
+  allowed: boolean;
+  reason?: string;
+  severity?: 'error' | 'warning';
+}
+interface KnowledgeAccessGuardOptions {
+  disallowWriteCategories?: KnowledgeCategory[];
+  requireWorkflowBinding?: boolean;
+  requireAgentBinding?: boolean;
+}
+declare class KnowledgeAccessGuard {
+  private readonly disallowedWrite;
+  private readonly requireWorkflowBinding;
+  private readonly requireAgentBinding;
+  constructor(options?: KnowledgeAccessGuardOptions);
+  checkAccess(spaceBinding: ResolvedKnowledge, context: KnowledgeAccessContext, appConfig: ResolvedAppConfig): KnowledgeAccessResult;
+  private isSpaceBound;
+}
+//#endregion
+export { KnowledgeAccessContext, KnowledgeAccessGuard, KnowledgeAccessGuardOptions, KnowledgeAccessResult };

package/dist/knowledge/runtime.js

@@ -1 +1,49 @@
-const e=[`external`,`ephemeral`];var t=class{disallowedWrite;requireWorkflowBinding;requireAgentBinding;constructor(t={}){this.disallowedWrite=new Set(t.disallowWriteCategories??e),this.requireWorkflowBinding=t.requireWorkflowBinding??!0,this.requireAgentBinding=t.requireAgentBinding??!1}checkAccess(e,t,n){let{binding:r,space:i}=e;if(r.required!==!1&&!this.isSpaceBound(e,n))return{allowed:!1,reason:`Knowledge space "${i.meta.key}" is not bound in the resolved app config.`};if(t.operation===`write`&&this.disallowedWrite.has(i.meta.category))return{allowed:!1,reason:`Knowledge space "${i.meta.key}" is category "${i.meta.category}" and is read-only.`};if(this.requireWorkflowBinding&&t.workflowName){let e=r.scope?.workflows;if(e&&!e.includes(t.workflowName))return{allowed:!1,reason:`Workflow "${t.workflowName}" is not authorized to access knowledge space "${i.meta.key}".`}}if(this.requireAgentBinding&&t.agentName){let e=r.scope?.agents;if(e&&!e.includes(t.agentName))return{allowed:!1,reason:`Agent "${t.agentName}" is not authorized to access knowledge space "${i.meta.key}".`}}return i.meta.category===`ephemeral`?{allowed:!0,severity:`warning`,reason:`Knowledge space "${i.meta.key}" is ephemeral; results may be transient.`}:{allowed:!0}}isSpaceBound(e,t){return t.knowledge.some(t=>t.space.meta.key===e.space.meta.key&&(e.space.meta.version==null||t.space.meta.version===e.space.meta.version))}};export{t as KnowledgeAccessGuard};
+//#region src/knowledge/runtime.ts
+const DEFAULT_DISALLOWED_WRITE = ["external", "ephemeral"];
+var KnowledgeAccessGuard = class {
+	disallowedWrite;
+	requireWorkflowBinding;
+	requireAgentBinding;
+	constructor(options = {}) {
+		this.disallowedWrite = new Set(options.disallowWriteCategories ?? DEFAULT_DISALLOWED_WRITE);
+		this.requireWorkflowBinding = options.requireWorkflowBinding ?? true;
+		this.requireAgentBinding = options.requireAgentBinding ?? false;
+	}
+	checkAccess(spaceBinding, context, appConfig) {
+		const { binding, space } = spaceBinding;
+		if (binding.required !== false && !this.isSpaceBound(spaceBinding, appConfig)) return {
+			allowed: false,
+			reason: `Knowledge space "${space.meta.key}" is not bound in the resolved app config.`
+		};
+		if (context.operation === "write" && this.disallowedWrite.has(space.meta.category)) return {
+			allowed: false,
+			reason: `Knowledge space "${space.meta.key}" is category "${space.meta.category}" and is read-only.`
+		};
+		if (this.requireWorkflowBinding && context.workflowName) {
+			const allowedWorkflows = binding.scope?.workflows;
+			if (allowedWorkflows && !allowedWorkflows.includes(context.workflowName)) return {
+				allowed: false,
+				reason: `Workflow "${context.workflowName}" is not authorized to access knowledge space "${space.meta.key}".`
+			};
+		}
+		if (this.requireAgentBinding && context.agentName) {
+			const allowedAgents = binding.scope?.agents;
+			if (allowedAgents && !allowedAgents.includes(context.agentName)) return {
+				allowed: false,
+				reason: `Agent "${context.agentName}" is not authorized to access knowledge space "${space.meta.key}".`
+			};
+		}
+		if (space.meta.category === "ephemeral") return {
+			allowed: true,
+			severity: "warning",
+			reason: `Knowledge space "${space.meta.key}" is ephemeral; results may be transient.`
+		};
+		return { allowed: true };
+	}
+	isSpaceBound(resolved, appConfig) {
+		return appConfig.knowledge.some((entry) => entry.space.meta.key === resolved.space.meta.key && (resolved.space.meta.version == null || entry.space.meta.version === resolved.space.meta.version));
+	}
+};
+
+//#endregion
+export { KnowledgeAccessGuard };

package/dist/knowledge/source.d.ts

@@ -0,0 +1,32 @@
+//#region src/knowledge/source.d.ts
+type KnowledgeSourceType = 'notion' | 'url' | 'file_upload' | 'email' | 'api' | 'manual';
+interface KnowledgeSourceMeta {
+  id: string;
+  tenantId: string;
+  spaceKey: string;
+  spaceVersion: number;
+  label: string;
+  sourceType: KnowledgeSourceType;
+  createdAt: string | Date;
+  updatedAt: string | Date;
+}
+interface KnowledgeSourceConfig {
+  meta: KnowledgeSourceMeta;
+  /** Source-specific configuration (URLs, credentials, filters). */
+  config: Record<string, unknown>;
+  /** Sync schedule (cron or interval). */
+  syncSchedule?: {
+    enabled: boolean;
+    cron?: string;
+    intervalMs?: number;
+  };
+  /** Last sync status. */
+  lastSync?: {
+    timestamp: Date;
+    success: boolean;
+    itemsProcessed?: number;
+    error?: string;
+  };
+}
+//#endregion
+export { KnowledgeSourceConfig, KnowledgeSourceMeta, KnowledgeSourceType };

package/dist/knowledge/spaces/email-threads.d.ts

@@ -0,0 +1,7 @@
+import { KnowledgeSpaceRegistry, KnowledgeSpaceSpec } from "../spec.js";
+
+//#region src/knowledge/spaces/email-threads.d.ts
+declare const emailThreadsKnowledgeSpace: KnowledgeSpaceSpec;
+declare function registerEmailThreadsKnowledgeSpace(registry: KnowledgeSpaceRegistry): KnowledgeSpaceRegistry;
+//#endregion
+export { emailThreadsKnowledgeSpace, registerEmailThreadsKnowledgeSpace };

package/dist/knowledge/spaces/email-threads.js

@@ -1 +1,37 @@
-import{StabilityEnum as e}from"../../ownership.js";const t={meta:{key:`knowledge.email-threads`,version:1,category:`operational`,displayName:`Email Threads`,title:`Operational Email Threads`,description:`Indexed copies of operational email threads used for support, onboarding, and workflows.`,domain:`operations`,owners:[`platform.operations`],tags:[`email`,`operations`],stability:e.Beta},retention:{ttlDays:365},access:{policy:{name:`knowledge.access.email-threads`,version:1},trustLevel:`medium`,automationWritable:!0},indexing:{embeddingModel:`mistral-embed`,chunkSize:600,vectorDbIntegration:`vectordb.qdrant`},description:`Operational email threads synchronized from Gmail to support automations and contextual assistance.`};function n(e){return e.register(t)}export{t as emailThreadsKnowledgeSpace,n as registerEmailThreadsKnowledgeSpace};
+import { StabilityEnum } from "../../ownership.js";
+
+//#region src/knowledge/spaces/email-threads.ts
+const emailThreadsKnowledgeSpace = {
+	meta: {
+		key: "knowledge.email-threads",
+		version: 1,
+		category: "operational",
+		title: "Operational Email Threads",
+		description: "Indexed copies of operational email threads used for support, onboarding, and workflows.",
+		domain: "operations",
+		owners: ["platform.operations"],
+		tags: ["email", "operations"],
+		stability: StabilityEnum.Beta
+	},
+	retention: { ttlDays: 365 },
+	access: {
+		policy: {
+			key: "knowledge.access.email-threads",
+			version: 1
+		},
+		trustLevel: "medium",
+		automationWritable: true
+	},
+	indexing: {
+		embeddingModel: "mistral-embed",
+		chunkSize: 600,
+		vectorDbIntegration: "vectordb.qdrant"
+	},
+	description: "Operational email threads synchronized from Gmail to support automations and contextual assistance."
+};
+function registerEmailThreadsKnowledgeSpace(registry) {
+	return registry.register(emailThreadsKnowledgeSpace);
+}
+
+//#endregion
+export { emailThreadsKnowledgeSpace, registerEmailThreadsKnowledgeSpace };

package/dist/knowledge/spaces/financial-docs.d.ts

@@ -0,0 +1,7 @@
+import { KnowledgeSpaceRegistry, KnowledgeSpaceSpec } from "../spec.js";
+
+//#region src/knowledge/spaces/financial-docs.d.ts
+declare const financialDocsKnowledgeSpace: KnowledgeSpaceSpec;
+declare function registerFinancialDocsKnowledgeSpace(registry: KnowledgeSpaceRegistry): KnowledgeSpaceRegistry;
+//#endregion
+export { financialDocsKnowledgeSpace, registerFinancialDocsKnowledgeSpace };

package/dist/knowledge/spaces/financial-docs.js

@@ -1 +1,37 @@
-import{StabilityEnum as e}from"../../ownership.js";const t={meta:{key:`knowledge.financial-docs`,version:1,category:`canonical`,displayName:`Financial Documents`,title:`Household Financial Documents`,description:`Invoices, bills, and contracts powering Pocket Family Office financial automation.`,domain:`finance`,owners:[`platform.finance`],tags:[`finance`,`documents`],stability:e.Beta},retention:{ttlDays:null},access:{policy:{name:`knowledge.access.financial-docs`,version:1},trustLevel:`high`,automationWritable:!0},indexing:{embeddingModel:`mistral-embed`,chunkSize:700,vectorDbIntegration:`vectordb.qdrant`},description:`Normalized financial documents enabling bill pay automation, reminders, and summaries.`};function n(e){return e.register(t)}export{t as financialDocsKnowledgeSpace,n as registerFinancialDocsKnowledgeSpace};
+import { StabilityEnum } from "../../ownership.js";
+
+//#region src/knowledge/spaces/financial-docs.ts
+const financialDocsKnowledgeSpace = {
+	meta: {
+		key: "knowledge.financial-docs",
+		version: 1,
+		category: "canonical",
+		title: "Household Financial Documents",
+		description: "Invoices, bills, and contracts powering Pocket Family Office financial automation.",
+		domain: "finance",
+		owners: ["platform.finance"],
+		tags: ["finance", "documents"],
+		stability: StabilityEnum.Beta
+	},
+	retention: { ttlDays: null },
+	access: {
+		policy: {
+			key: "knowledge.access.financial-docs",
+			version: 1
+		},
+		trustLevel: "high",
+		automationWritable: true
+	},
+	indexing: {
+		embeddingModel: "mistral-embed",
+		chunkSize: 700,
+		vectorDbIntegration: "vectordb.qdrant"
+	},
+	description: "Normalized financial documents enabling bill pay automation, reminders, and summaries."
+};
+function registerFinancialDocsKnowledgeSpace(registry) {
+	return registry.register(financialDocsKnowledgeSpace);
+}
+
+//#endregion
+export { financialDocsKnowledgeSpace, registerFinancialDocsKnowledgeSpace };

package/dist/knowledge/spaces/financial-overview.d.ts

@@ -0,0 +1,7 @@
+import { KnowledgeSpaceRegistry, KnowledgeSpaceSpec } from "../spec.js";
+
+//#region src/knowledge/spaces/financial-overview.d.ts
+declare const financialOverviewKnowledgeSpace: KnowledgeSpaceSpec;
+declare function registerFinancialOverviewKnowledgeSpace(registry: KnowledgeSpaceRegistry): KnowledgeSpaceRegistry;
+//#endregion
+export { financialOverviewKnowledgeSpace, registerFinancialOverviewKnowledgeSpace };