recallx 1.0.0

package/app/server/semantic/vector-store.js

@@ -0,0 +1,169 @@
+export class VectorIndexStoreError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "VectorIndexStoreError";
+    }
+}
+function encodeVectorBlob(vector) {
+    return new Uint8Array(new Float32Array(vector).buffer);
+}
+function decodeVectorBlob(blob) {
+    return new Float32Array(blob.buffer, blob.byteOffset, blob.byteLength / Float32Array.BYTES_PER_ELEMENT);
+}
+function buildEmbeddingByOrdinal(embeddings) {
+    return new Map(embeddings.map((embedding) => [embedding.chunkOrdinal, embedding]));
+}
+function computeCosineSimilarity(left, right) {
+    const length = Math.min(left.length, right.length);
+    let dot = 0;
+    let leftMagnitude = 0;
+    let rightMagnitude = 0;
+    for (let index = 0; index < length; index += 1) {
+        const leftValue = Number(left[index] ?? 0);
+        const rightValue = Number(right[index] ?? 0);
+        dot += leftValue * rightValue;
+        leftMagnitude += leftValue * leftValue;
+        rightMagnitude += rightValue * rightValue;
+    }
+    if (!leftMagnitude || !rightMagnitude) {
+        return 0;
+    }
+    return dot / (Math.sqrt(leftMagnitude) * Math.sqrt(rightMagnitude));
+}
+class SqliteVectorIndexStore {
+    db;
+    backend = "sqlite";
+    constructor(db) {
+        this.db = db;
+    }
+    async upsertNodeChunks(input) {
+        const embeddingsByOrdinal = buildEmbeddingByOrdinal(input.embeddings);
+        const ledgerRows = [];
+        for (const chunk of input.chunks) {
+            const embedding = embeddingsByOrdinal.get(chunk.ordinal);
+            if (!embedding) {
+                continue;
+            }
+            ledgerRows.push({
+                chunkOrdinal: chunk.ordinal,
+                vectorRef: null,
+                vectorBlob: encodeVectorBlob(embedding.vector)
+            });
+        }
+        return ledgerRows;
+    }
+    async deleteNode(_nodeId) { }
+    async searchCandidates(input) {
+        if (!input.candidateNodeIds.length) {
+            return [];
+        }
+        const rows = this.db
+            .prepare(`SELECT owner_id, chunk_ordinal, vector_ref, vector_blob
+         FROM node_embeddings
+         WHERE owner_type = 'node'
+           AND status = 'ready'
+           AND vector_blob IS NOT NULL
+           AND embedding_provider = ?
+           AND embedding_model ${input.embeddingModel === null ? "IS NULL" : "= ?"}
+           AND embedding_version ${input.embeddingVersion === null ? "IS NULL" : "= ?"}
+           AND owner_id IN (${input.candidateNodeIds.map(() => "?").join(", ")})`)
+            .all(...[
+            input.embeddingProvider,
+            ...(input.embeddingModel === null ? [] : [input.embeddingModel]),
+            ...(input.embeddingVersion === null ? [] : [input.embeddingVersion]),
+            ...input.candidateNodeIds
+        ]);
+        const matches = [];
+        for (const row of rows) {
+            if (!(row.vector_blob instanceof Uint8Array)) {
+                continue;
+            }
+            const similarity = computeCosineSimilarity(input.queryVector, decodeVectorBlob(row.vector_blob));
+            if (!Number.isFinite(similarity)) {
+                continue;
+            }
+            matches.push({
+                nodeId: String(row.owner_id),
+                chunkOrdinal: Number(row.chunk_ordinal ?? 0),
+                similarity,
+                vectorRef: row.vector_ref ? String(row.vector_ref) : null
+            });
+        }
+        return matches;
+    }
+}
+class SqliteVecVectorIndexStore {
+    db;
+    backend = "sqlite-vec";
+    constructor(db) {
+        this.db = db;
+    }
+    async upsertNodeChunks(input) {
+        const embeddingsByOrdinal = buildEmbeddingByOrdinal(input.embeddings);
+        const ledgerRows = [];
+        for (const chunk of input.chunks) {
+            const embedding = embeddingsByOrdinal.get(chunk.ordinal);
+            if (!embedding) {
+                continue;
+            }
+            ledgerRows.push({
+                chunkOrdinal: chunk.ordinal,
+                vectorRef: null,
+                vectorBlob: encodeVectorBlob(embedding.vector)
+            });
+        }
+        return ledgerRows;
+    }
+    async deleteNode(_nodeId) { }
+    async searchCandidates(input) {
+        if (!input.queryVector.length || !input.candidateNodeIds.length) {
+            return [];
+        }
+        const queryVectorBlob = encodeVectorBlob(input.queryVector);
+        const rows = this.db
+            .prepare(`SELECT
+           owner_id,
+           chunk_ordinal,
+           vector_ref,
+           vector_blob,
+           1 - vec_distance_cosine(vector_blob, ?) AS similarity
+         FROM node_embeddings
+         WHERE owner_type = 'node'
+           AND status = 'ready'
+           AND vector_blob IS NOT NULL
+           AND embedding_provider = ?
+           AND embedding_model ${input.embeddingModel === null ? "IS NULL" : "= ?"}
+           AND embedding_version ${input.embeddingVersion === null ? "IS NULL" : "= ?"}
+           AND owner_id IN (${input.candidateNodeIds.map(() => "?").join(", ")})
+         ORDER BY similarity DESC`)
+            .all(...[
+            queryVectorBlob,
+            input.embeddingProvider,
+            ...(input.embeddingModel === null ? [] : [input.embeddingModel]),
+            ...(input.embeddingVersion === null ? [] : [input.embeddingVersion]),
+            ...input.candidateNodeIds
+        ]);
+        return rows
+            .map((row) => {
+            const similarity = Number(row.similarity);
+            if (!Number.isFinite(similarity)) {
+                return null;
+            }
+            return {
+                nodeId: String(row.owner_id),
+                chunkOrdinal: Number(row.chunk_ordinal ?? 0),
+                similarity,
+                vectorRef: row.vector_ref ? String(row.vector_ref) : null
+            };
+        })
+            .filter((item) => item !== null);
+    }
+}
+export function createVectorIndexStore(db, input) {
+    if (input.backend === "sqlite-vec") {
+        return new SqliteVecVectorIndexStore(db);
+    }
+    return new SqliteVectorIndexStore(db);
+}

package/app/server/utils.js

@@ -0,0 +1,43 @@
+import { createHash } from "node:crypto";
+import path from "node:path";
+import { ulid } from "ulid";
+export function createId(prefix) {
+    return `${prefix}_${ulid().toLowerCase()}`;
+}
+export function nowIso() {
+    return new Date().toISOString();
+}
+export function parseJson(raw, fallback) {
+    if (!raw) {
+        return fallback;
+    }
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return fallback;
+    }
+}
+export function stableSummary(title, body) {
+    const content = [title, body].filter(Boolean).join(". ").replace(/\s+/g, " ").trim();
+    if (!content) {
+        return "No summary yet.";
+    }
+    return content.slice(0, 220);
+}
+export function countTokensApprox(text) {
+    if (!text) {
+        return 0;
+    }
+    return text
+        .trim()
+        .split(/\s+/)
+        .filter(Boolean).length;
+}
+export function checksumText(value) {
+    return createHash("sha256").update(value).digest("hex");
+}
+export function isPathWithinRoot(rootPath, candidatePath) {
+    const relative = path.relative(path.resolve(rootPath), path.resolve(candidatePath));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}

package/app/server/workspace-session.js

@@ -0,0 +1,128 @@
+import { existsSync } from "node:fs";
+import path from "node:path";
+import { workspaceInfo } from "./config.js";
+import { openDatabase } from "./db.js";
+import { AppError } from "./errors.js";
+import { bootstrapAutomaticGovernance } from "./governance.js";
+import { RecallXRepository } from "./repositories.js";
+import { defaultWorkspaceName, ensureWorkspace } from "./workspace.js";
+import { RECALLX_VERSION } from "../shared/version.js";
+export class WorkspaceSessionManager {
+    serverConfig;
+    authMode;
+    currentState;
+    history = new Map();
+    constructor(serverConfig, initialWorkspaceRoot, authMode) {
+        this.serverConfig = serverConfig;
+        this.authMode = authMode;
+        this.currentState = this.loadWorkspace(initialWorkspaceRoot, {
+            workspaceName: serverConfig.workspaceName,
+            requireExistingRoot: false,
+        });
+        this.remember(this.currentState);
+    }
+    getCurrent() {
+        return this.currentState;
+    }
+    listWorkspaces() {
+        const currentRoot = this.currentState.workspaceRoot;
+        return [...this.history.values()]
+            .map((item) => ({
+            ...item,
+            isCurrent: item.rootPath === currentRoot,
+        }))
+            .sort((left, right) => right.lastOpenedAt.localeCompare(left.lastOpenedAt));
+    }
+    createWorkspace(rootPath, workspaceName) {
+        return this.swapWorkspace(rootPath, {
+            workspaceName,
+            requireExistingRoot: false,
+        });
+    }
+    openWorkspace(rootPath) {
+        return this.swapWorkspace(rootPath, {
+            requireExistingRoot: true,
+        });
+    }
+    swapWorkspace(rootPath, options) {
+        const nextState = this.loadWorkspace(rootPath, options);
+        const previousState = this.currentState;
+        this.currentState = nextState;
+        this.remember(nextState);
+        previousState.db.close();
+        return this.getWorkspaceCatalogItem(nextState);
+    }
+    loadWorkspace(rootPath, options) {
+        const resolvedRoot = path.resolve(rootPath);
+        if (options.requireExistingRoot && !existsSync(resolvedRoot)) {
+            throw new AppError(404, "WORKSPACE_NOT_FOUND", `Workspace root not found: ${resolvedRoot}`);
+        }
+        const paths = ensureWorkspace(resolvedRoot);
+        const db = openDatabase(paths);
+        const repository = new RecallXRepository(db, resolvedRoot);
+        const storedSettings = repository.getSettings(["workspace.name"]);
+        const resolvedName = typeof storedSettings["workspace.name"] === "string" && storedSettings["workspace.name"].trim()
+            ? String(storedSettings["workspace.name"])
+            : options.workspaceName?.trim() || defaultWorkspaceName(resolvedRoot);
+        repository.setSetting("workspace.name", resolvedName);
+        repository.setSetting("workspace.version", RECALLX_VERSION);
+        repository.setSetting("api.bind", `${this.serverConfig.bindAddress}:${this.serverConfig.port}`);
+        repository.setSetting("api.auth.mode", this.authMode);
+        repository.ensureBaseSettings({
+            "search.semantic.enabled": false,
+            "search.semantic.provider": "disabled",
+            "search.semantic.model": "none",
+            "search.semantic.indexBackend": "sqlite-vec",
+            "search.semantic.chunk.enabled": false,
+            "search.semantic.chunk.aggregation": "max",
+            "search.semantic.workspaceFallback.enabled": false,
+            "search.semantic.augmentation.minSimilarity": 0.2,
+            "search.semantic.augmentation.maxBonus": 18,
+            "search.semantic.last_backfill_at": null,
+            "search.semantic.autoIndex.enabled": true,
+            "search.semantic.autoIndex.debounceMs": 1500,
+            "search.semantic.autoIndex.batchLimit": 20,
+            "search.semantic.autoIndex.lastRunAt": null,
+            "search.tagIndex.version": 0,
+            "search.activityFts.version": 0,
+            "relations.autoRefresh.enabled": true,
+            "relations.autoRefresh.debounceMs": 150,
+            "relations.autoRefresh.maxStalenessMs": 2_000,
+            "relations.autoRefresh.batchLimit": 24,
+            "relations.autoRecompute.enabled": true,
+            "relations.autoRecompute.eventThreshold": 12,
+            "relations.autoRecompute.debounceMs": 30_000,
+            "relations.autoRecompute.maxStalenessMs": 300_000,
+            "relations.autoRecompute.batchLimit": 100,
+            "relations.autoRecompute.lastRunAt": null,
+            "observability.enabled": false,
+            "observability.retentionDays": 14,
+            "observability.slowRequestMs": 250,
+            "observability.capturePayloadShape": true,
+            "export.defaultFormat": "markdown",
+        });
+        repository.ensureSearchTagIndex();
+        repository.ensureActivitySearchIndex();
+        bootstrapAutomaticGovernance(repository);
+        return {
+            db,
+            repository,
+            paths,
+            workspaceRoot: resolvedRoot,
+            workspaceInfo: workspaceInfo(resolvedRoot, {
+                ...this.serverConfig,
+                workspaceName: resolvedName,
+            }, this.authMode),
+        };
+    }
+    remember(state) {
+        this.history.set(state.workspaceRoot, this.getWorkspaceCatalogItem(state));
+    }
+    getWorkspaceCatalogItem(state) {
+        return {
+            ...state.workspaceInfo,
+            isCurrent: state.workspaceRoot === this.currentState?.workspaceRoot,
+            lastOpenedAt: new Date().toISOString(),
+        };
+    }
+}

package/app/server/workspace.js

@@ -0,0 +1,79 @@
+import { cpSync, mkdirSync, existsSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+export function recallxHomeDir() {
+    return path.join(os.homedir(), ".recallx");
+}
+function sanitizeWorkspaceName(value) {
+    return value.replace(/[<>:"/\\|?*\x00-\x1f]+/g, "-").replace(/\s+/g, " ").trim() || "RecallX";
+}
+function preferredWorkspaceName() {
+    const configured = process.env.RECALLX_WORKSPACE_NAME;
+    if (typeof configured === "string" && configured.trim()) {
+        return sanitizeWorkspaceName(configured);
+    }
+    return sanitizeWorkspaceName(path.basename(process.cwd()) || "RecallX");
+}
+export function resolveWorkspaceRoot(options) {
+    const configured = process.env.RECALLX_WORKSPACE_ROOT;
+    if (configured) {
+        return path.resolve(configured);
+    }
+    const preferredRoot = path.join(recallxHomeDir(), preferredWorkspaceName());
+    const allowLegacyProjectRoot = options?.allowLegacyProjectRoot ?? true;
+    const legacyRoot = path.resolve(options?.legacyProjectRoot ?? process.cwd(), ".recallx-workspace");
+    if (existsSync(preferredRoot)) {
+        return preferredRoot;
+    }
+    if (allowLegacyProjectRoot && existsSync(legacyRoot)) {
+        try {
+            mkdirSync(path.dirname(preferredRoot), { recursive: true });
+            cpSync(legacyRoot, preferredRoot, { recursive: true, errorOnExist: false, force: false });
+            return preferredRoot;
+        }
+        catch {
+            return legacyRoot;
+        }
+    }
+    return preferredRoot;
+}
+export function ensureWorkspace(root) {
+    const paths = {
+        root,
+        dbPath: path.join(root, "workspace.db"),
+        artifactsDir: path.join(root, "artifacts"),
+        exportsDir: path.join(root, "exports"),
+        importsDir: path.join(root, "imports"),
+        backupsDir: path.join(root, "backups"),
+        logsDir: path.join(root, "logs"),
+        configDir: path.join(root, "config"),
+        cacheDir: path.join(root, "cache"),
+        embeddingsDir: path.join(root, "cache", "embeddings"),
+        searchCacheDir: path.join(root, "cache", "search")
+    };
+    for (const directory of [
+        paths.root,
+        paths.artifactsDir,
+        paths.exportsDir,
+        paths.importsDir,
+        paths.backupsDir,
+        paths.logsDir,
+        paths.configDir,
+        paths.cacheDir,
+        paths.embeddingsDir,
+        paths.searchCacheDir
+    ]) {
+        if (!existsSync(directory)) {
+            mkdirSync(directory, { recursive: true });
+        }
+    }
+    return paths;
+}
+export function defaultWorkspaceName(root) {
+    const resolved = path.resolve(root);
+    const base = path.basename(resolved);
+    if (base.startsWith(".")) {
+        return path.basename(path.dirname(resolved)) || "RecallX";
+    }
+    return base.replace(/^\.*/, "") || "RecallX";
+}

package/app/shared/contracts.js

@@ -0,0 +1,268 @@
+import { z } from "zod";
+export const nodeTypes = [
+    "note",
+    "project",
+    "idea",
+    "question",
+    "decision",
+    "reference",
+    "artifact_ref",
+    "conversation"
+];
+export const nodeStatuses = ["active", "draft", "contested", "archived"];
+export const canonicalities = [
+    "canonical",
+    "appended",
+    "suggested",
+    "imported",
+    "generated"
+];
+export const relationTypes = [
+    "related_to",
+    "supports",
+    "contradicts",
+    "elaborates",
+    "depends_on",
+    "relevant_to",
+    "derived_from",
+    "produced_by"
+];
+export const relationStatuses = ["active", "suggested", "rejected", "archived"];
+export const inferredRelationStatuses = ["active", "muted", "hidden", "expired"];
+export const relationSources = ["canonical", "inferred"];
+export const relationUsageEventTypes = [
+    "bundle_included",
+    "bundle_clicked",
+    "bundle_used_in_output",
+    "bundle_skipped",
+    "retrieval_confirmed",
+    "retrieval_muted",
+    "manual_hide"
+];
+export const searchFeedbackResultTypes = ["node", "activity"];
+export const searchFeedbackVerdicts = ["useful", "not_useful", "uncertain"];
+export const governanceEntityTypes = ["node", "relation"];
+export const governanceStates = ["healthy", "low_confidence", "contested"];
+export const governanceEventTypes = [
+    "evaluated",
+    "promoted",
+    "contested",
+    "demoted",
+    "migrated"
+];
+export const activityTypes = [
+    "note_appended",
+    "agent_run_summary",
+    "import_completed",
+    "artifact_attached",
+    "decision_recorded",
+    "review_action",
+    "context_bundle_generated"
+];
+export const sourceTypes = ["human", "agent", "import", "system", "integration"];
+export const captureModes = ["auto", "activity", "node", "decision"];
+export const bundleModes = ["micro", "compact", "standard", "deep"];
+export const bundlePresets = [
+    "for-coding",
+    "for-research",
+    "for-decision",
+    "for-writing",
+    "for-assistant"
+];
+export const sourceSchema = z.object({
+    actorType: z.enum(sourceTypes),
+    actorLabel: z.string().min(1),
+    toolName: z.string().min(1),
+    toolVersion: z.string().optional()
+});
+export const nodeSearchSchema = z.object({
+    query: z.string().default(""),
+    filters: z
+        .object({
+        types: z.array(z.enum(nodeTypes)).optional(),
+        status: z.array(z.enum(nodeStatuses)).optional(),
+        sourceLabels: z.array(z.string()).optional(),
+        tags: z.array(z.string()).optional()
+    })
+        .default({}),
+    limit: z.number().int().min(1).max(100).default(10),
+    offset: z.number().int().min(0).default(0),
+    sort: z.enum(["relevance", "updated_at"]).default("relevance")
+});
+export const activitySearchSchema = z.object({
+    query: z.string().default(""),
+    filters: z
+        .object({
+        targetNodeIds: z.array(z.string()).optional(),
+        activityTypes: z.array(z.enum(activityTypes)).optional(),
+        sourceLabels: z.array(z.string()).optional(),
+        createdAfter: z.string().optional(),
+        createdBefore: z.string().optional()
+    })
+        .default({}),
+    limit: z.number().int().min(1).max(100).default(10),
+    offset: z.number().int().min(0).default(0),
+    sort: z.enum(["relevance", "updated_at"]).default("relevance")
+});
+export const workspaceSearchSchema = z.object({
+    query: z.string().default(""),
+    scopes: z.array(z.enum(["nodes", "activities"])).min(1).default(["nodes", "activities"]),
+    nodeFilters: nodeSearchSchema.shape.filters.optional(),
+    activityFilters: activitySearchSchema.shape.filters.optional(),
+    limit: z.number().int().min(1).max(100).default(10),
+    offset: z.number().int().min(0).default(0),
+    sort: z.enum(["relevance", "updated_at", "smart"]).default("relevance")
+});
+export const governanceIssuesQuerySchema = z.object({
+    states: z.array(z.enum(governanceStates)).optional(),
+    limit: z.number().int().min(1).max(100).default(20)
+});
+export const recomputeGovernanceSchema = z.object({
+    entityType: z.enum(governanceEntityTypes).optional(),
+    entityIds: z.array(z.string().min(1)).max(200).optional(),
+    limit: z.number().int().min(1).max(500).default(100)
+});
+export const createNodeSchema = z.object({
+    type: z.enum(nodeTypes),
+    title: z.string().min(1),
+    body: z.string().default(""),
+    summary: z.string().optional(),
+    tags: z.array(z.string()).default([]),
+    canonicality: z.enum(canonicalities).optional(),
+    status: z.enum(nodeStatuses).optional(),
+    source: sourceSchema,
+    metadata: z.record(z.any()).default({})
+});
+export const createNodesSchema = z.object({
+    nodes: z.array(createNodeSchema).min(1).max(100)
+});
+export const updateNodeSchema = z.object({
+    title: z.string().min(1).optional(),
+    body: z.string().optional(),
+    summary: z.string().optional(),
+    tags: z.array(z.string()).optional(),
+    metadata: z.record(z.any()).optional(),
+    status: z.enum(nodeStatuses).optional()
+});
+export const createRelationSchema = z.object({
+    fromNodeId: z.string().min(1),
+    toNodeId: z.string().min(1),
+    relationType: z.enum(relationTypes),
+    status: z.enum(relationStatuses).optional(),
+    source: sourceSchema,
+    metadata: z.record(z.any()).default({})
+});
+export const updateRelationSchema = z.object({
+    status: z.enum(relationStatuses),
+    source: sourceSchema,
+    metadata: z.record(z.any()).default({}),
+    notes: z.string().optional()
+});
+export const appendActivitySchema = z.object({
+    targetNodeId: z.string().min(1),
+    activityType: z.enum(activityTypes),
+    body: z.string().default(""),
+    source: sourceSchema,
+    metadata: z.record(z.any()).default({})
+});
+export const captureMemorySchema = z.object({
+    mode: z.enum(captureModes).default("auto"),
+    body: z.string().min(1),
+    title: z.string().min(1).optional(),
+    targetNodeId: z.string().min(1).optional(),
+    nodeType: z.enum(nodeTypes).default("note"),
+    tags: z.array(z.string()).default([]),
+    source: sourceSchema.optional(),
+    metadata: z.record(z.any()).default({})
+});
+export const upsertInferredRelationSchema = z.object({
+    fromNodeId: z.string().min(1),
+    toNodeId: z.string().min(1),
+    relationType: z.enum(relationTypes),
+    baseScore: z.number(),
+    usageScore: z.number().default(0),
+    finalScore: z.number(),
+    status: z.enum(inferredRelationStatuses).default("active"),
+    generator: z.string().min(1),
+    evidence: z.record(z.any()).default({}),
+    expiresAt: z.string().optional(),
+    metadata: z.record(z.any()).default({})
+});
+export const appendRelationUsageEventSchema = z.object({
+    relationId: z.string().min(1),
+    relationSource: z.enum(relationSources),
+    eventType: z.enum(relationUsageEventTypes),
+    sessionId: z.string().optional(),
+    runId: z.string().optional(),
+    source: sourceSchema.optional(),
+    delta: z.number(),
+    metadata: z.record(z.any()).default({})
+});
+export const appendSearchFeedbackSchema = z.object({
+    resultType: z.enum(searchFeedbackResultTypes),
+    resultId: z.string().min(1),
+    verdict: z.enum(searchFeedbackVerdicts),
+    query: z.string().optional(),
+    sessionId: z.string().optional(),
+    runId: z.string().optional(),
+    source: sourceSchema.optional(),
+    confidence: z.number().min(0).max(1).default(1),
+    metadata: z.record(z.any()).default({})
+});
+export const recomputeInferredRelationsSchema = z.object({
+    relationIds: z.array(z.string().min(1)).max(200).optional(),
+    generator: z.string().min(1).optional(),
+    limit: z.number().int().min(1).max(500).default(100)
+});
+export const reindexInferredRelationsSchema = z.object({
+    limit: z.number().int().min(1).max(1000).default(250)
+});
+export const attachArtifactSchema = z.object({
+    nodeId: z.string().min(1),
+    path: z.string().min(1),
+    mimeType: z.string().optional(),
+    source: sourceSchema,
+    metadata: z.record(z.any()).default({})
+});
+export const buildContextBundleSchema = z.object({
+    target: z
+        .object({
+        id: z.string().min(1)
+    })
+        .optional(),
+    mode: z.enum(bundleModes).default("compact"),
+    preset: z.enum(bundlePresets).default("for-assistant"),
+    options: z
+        .object({
+        includeRelated: z.boolean().default(true),
+        includeInferred: z.boolean().default(true),
+        includeRecentActivities: z.boolean().default(true),
+        includeDecisions: z.boolean().default(true),
+        includeOpenQuestions: z.boolean().default(true),
+        maxInferred: z.number().int().min(0).max(10).default(4),
+        maxItems: z.number().int().min(1).max(30).default(10)
+    })
+        .default({})
+});
+export const registerIntegrationSchema = z.object({
+    name: z.string().min(1),
+    kind: z.string().min(1),
+    capabilities: z.array(z.string()).default([]),
+    config: z.record(z.any()).default({})
+});
+export const updateIntegrationSchema = z.object({
+    name: z.string().min(1).optional(),
+    status: z.string().min(1).optional(),
+    capabilities: z.array(z.string()).optional(),
+    config: z.record(z.any()).optional()
+});
+export const updateSettingsSchema = z.object({
+    values: z.record(z.any())
+});
+export const createWorkspaceSchema = z.object({
+    rootPath: z.string().min(1),
+    workspaceName: z.string().min(1).optional()
+});
+export const openWorkspaceSchema = z.object({
+    rootPath: z.string().min(1)
+});