@xopcai/xopc 0.0.248 → 0.0.249

package/dist/src/memory-maintenance/service.d.ts

@@ -0,0 +1,28 @@
+export type MemoryMaintenanceJob = 'temporal_sweep' | 'daily_reconciliation' | 'weekly_knowledge' | 'manual_repair';
+export interface MemoryMaintenanceMetrics {
+    scanned: number;
+    stale: number;
+    needsReview: number;
+    activated: number;
+    expiredPriorities: number;
+    archived: number;
+    repairedIndexes: number;
+}
+export interface MemoryMaintenanceResult {
+    runId: string;
+    jobType: MemoryMaintenanceJob;
+    status: 'running' | 'completed' | 'failed';
+    skipped: boolean;
+    metrics: MemoryMaintenanceMetrics;
+}
+export interface RunMemoryMaintenanceInput {
+    jobType: MemoryMaintenanceJob;
+    principalId?: string;
+    now?: number;
+    idempotencyKey?: string;
+    limit?: number;
+    staleRetentionDays?: number;
+    evidenceThreshold?: number;
+}
+export declare function runMemoryMaintenance(input: RunMemoryMaintenanceInput): MemoryMaintenanceResult;
+export declare function listMemoryMaintenanceRuns(limit?: number): Array<Record<string, unknown>>;

package/dist/src/memory-maintenance/service.js

@@ -0,0 +1,216 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+import "../user-model/domain.js";
+import { randomUUID } from "node:crypto";
+//#region src/memory-maintenance/service.ts
+const ALGORITHM_VERSION = "user-model-maintenance-v1";
+function emptyMetrics() {
+	return {
+		scanned: 0,
+		stale: 0,
+		needsReview: 0,
+		activated: 0,
+		expiredPriorities: 0,
+		archived: 0,
+		repairedIndexes: 0
+	};
+}
+function periodKey(job, now) {
+	const date = new Date(now);
+	if (job === "temporal_sweep") return date.toISOString().slice(0, 13);
+	if (job === "daily_reconciliation") return date.toISOString().slice(0, 10);
+	if (job === "weekly_knowledge") {
+		const monday = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));
+		const day = monday.getUTCDay() || 7;
+		monday.setUTCDate(monday.getUTCDate() - day + 1);
+		return monday.toISOString().slice(0, 10);
+	}
+	return String(now);
+}
+function addDecision(db, runId, objectType, objectId, action, reason, before, after, now) {
+	db.prepare(`INSERT INTO memory_maintenance_decisions (
+    decision_id, run_id, object_type, object_id, action, reason, before_json, after_json, created_at
+  ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(randomUUID(), runId, objectType, objectId, action, reason, before === void 0 ? null : JSON.stringify(before), after === void 0 ? null : JSON.stringify(after), now);
+}
+function transitionAssertions(db, runId, now, limit, metrics) {
+	const expired = db.prepare(`SELECT assertion_id, status, valid_to FROM user_assertions
+    WHERE status = 'active' AND valid_to IS NOT NULL AND valid_to < ? LIMIT ?`).all(now, limit);
+	metrics.scanned += expired.length;
+	for (const row of expired) {
+		db.prepare("UPDATE user_assertions SET status = 'stale' WHERE assertion_id = ? AND status = 'active'").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'active', 'stale', 'maintenance', 'Validity interval ended.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "stale", "validity_ended", row, { status: "stale" }, now);
+		metrics.stale += 1;
+	}
+	const reviewDue = db.prepare(`SELECT assertion_id, status, review_at FROM user_assertions
+    WHERE status = 'active' AND review_at IS NOT NULL AND review_at <= ? LIMIT ?`).all(now, Math.max(0, limit - expired.length));
+	metrics.scanned += reviewDue.length;
+	for (const row of reviewDue) {
+		db.prepare("UPDATE user_assertions SET status = 'needs_review' WHERE assertion_id = ? AND status = 'active'").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'active', 'needs_review', 'maintenance', 'Scheduled review became due.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "needs_review", "review_due", row, { status: "needs_review" }, now);
+		metrics.needsReview += 1;
+	}
+}
+function transitionPriorities(db, runId, principalId, now, limit, metrics) {
+	const rows = db.prepare(`SELECT priority_id, status, valid_to FROM user_priority_windows
+    WHERE principal_id = ? AND status = 'active' AND valid_to < ? LIMIT ?`).all(principalId, now, limit);
+	metrics.scanned += rows.length;
+	for (const row of rows) {
+		db.prepare("UPDATE user_priority_windows SET status = 'expired', updated_at = ? WHERE priority_id = ?").run(now, row.priority_id);
+		addDecision(db, runId, "priority", row.priority_id, "expired", "priority_window_ended", row, { status: "expired" }, now);
+		metrics.expiredPriorities += 1;
+	}
+}
+function transitionKnowledge(db, runId, principalId, now, limit, metrics) {
+	const expired = db.prepare(`SELECT knowledge_id, status, expires_at FROM knowledge_items
+    WHERE principal_id = ? AND status = 'active' AND expires_at IS NOT NULL AND expires_at < ? LIMIT ?`).all(principalId, now, limit);
+	metrics.scanned += expired.length;
+	for (const row of expired) {
+		db.prepare("UPDATE knowledge_items SET status = 'stale', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "stale", "retention_expired", row, { status: "stale" }, now);
+		metrics.stale += 1;
+	}
+	const reviewDue = db.prepare(`SELECT knowledge_id, status, review_at FROM knowledge_items
+    WHERE principal_id = ? AND status = 'active' AND review_at IS NOT NULL AND review_at <= ? LIMIT ?`).all(principalId, now, Math.max(0, limit - expired.length));
+	metrics.scanned += reviewDue.length;
+	for (const row of reviewDue) {
+		db.prepare("UPDATE knowledge_items SET status = 'needs_review', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "needs_review", "review_due", row, { status: "needs_review" }, now);
+		metrics.needsReview += 1;
+	}
+}
+function reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold, metrics) {
+	const contradicted = db.prepare(`SELECT DISTINCT a.assertion_id, a.status
+    FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    JOIN user_assertion_evidence ae ON ae.assertion_id = a.assertion_id AND ae.relation = 'contradicts'
+    WHERE s.principal_id = ? AND a.status = 'active' LIMIT ?`).all(principalId, limit);
+	metrics.scanned += contradicted.length;
+	for (const row of contradicted) {
+		db.prepare("UPDATE user_assertions SET status = 'needs_review' WHERE assertion_id = ?").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'active', 'needs_review', 'maintenance', 'Contradictory evidence exists.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "needs_review", "contradictory_evidence", row, { status: "needs_review" }, now);
+		metrics.needsReview += 1;
+	}
+	const candidates = db.prepare(`SELECT a.assertion_id, a.status, COUNT(DISTINCT
+      e.source_type || ':' || COALESCE(e.source_instance_id, '') || ':' || e.source_ref
+    ) AS evidence_count
+    FROM user_assertions a
+    JOIN user_assertion_slots s ON s.slot_id = a.slot_id
+    JOIN user_assertion_evidence ae ON ae.assertion_id = a.assertion_id AND ae.relation = 'supports'
+    JOIN context_evidence e ON e.evidence_id = ae.evidence_id AND e.trust_level = 'owner'
+    WHERE s.principal_id = ? AND a.status = 'candidate'
+      AND a.authority IN ('user_observed', 'system_inferred')
+    GROUP BY a.assertion_id HAVING evidence_count >= ? LIMIT ?`).all(principalId, evidenceThreshold, limit);
+	metrics.scanned += candidates.length;
+	for (const row of candidates) {
+		db.prepare("UPDATE user_assertions SET status = 'active' WHERE assertion_id = ? AND status = 'candidate'").run(row.assertion_id);
+		db.prepare(`INSERT INTO user_assertion_status_events (
+      event_id, assertion_id, from_status, to_status, actor_type, reason, source_run_id, created_at
+    ) VALUES (?, ?, 'candidate', 'active', 'maintenance', 'Independent owner evidence threshold met.', ?, ?)`).run(randomUUID(), row.assertion_id, runId, now);
+		addDecision(db, runId, "assertion", row.assertion_id, "activated", "owner_evidence_threshold", row, { status: "active" }, now);
+		metrics.activated += 1;
+	}
+}
+function repairIndexes(db, runId, now, metrics) {
+	const assertionMissing = db.prepare(`SELECT COUNT(*) AS count FROM user_assertions a
+    LEFT JOIN user_assertions_fts f ON f.assertion_id = a.assertion_id
+    WHERE f.assertion_id IS NULL`).get();
+	const knowledgeMissing = db.prepare(`SELECT COUNT(*) AS count FROM knowledge_items k
+    LEFT JOIN knowledge_items_fts f ON f.knowledge_id = k.knowledge_id
+    WHERE f.knowledge_id IS NULL`).get();
+	if (assertionMissing.count) db.prepare(`INSERT INTO user_assertions_fts(statement, assertion_id, slot_id)
+      SELECT a.statement, a.assertion_id, a.slot_id FROM user_assertions a
+      LEFT JOIN user_assertions_fts f ON f.assertion_id = a.assertion_id WHERE f.assertion_id IS NULL`).run();
+	if (knowledgeMissing.count) db.prepare(`INSERT INTO knowledge_items_fts(content, knowledge_id)
+      SELECT k.content, k.knowledge_id FROM knowledge_items k
+      LEFT JOIN knowledge_items_fts f ON f.knowledge_id = k.knowledge_id WHERE f.knowledge_id IS NULL`).run();
+	metrics.repairedIndexes = assertionMissing.count + knowledgeMissing.count;
+	if (metrics.repairedIndexes) addDecision(db, runId, "index", "fts", "repair", "missing_index_rows", { missing: metrics.repairedIndexes }, { missing: 0 }, now);
+}
+function archiveOldKnowledge(db, runId, principalId, cutoff, now, limit, metrics) {
+	const rows = db.prepare(`SELECT knowledge_id, status, updated_at FROM knowledge_items
+    WHERE principal_id = ? AND status = 'stale' AND updated_at < ? LIMIT ?`).all(principalId, cutoff, limit);
+	metrics.scanned += rows.length;
+	for (const row of rows) {
+		db.prepare("UPDATE knowledge_items SET status = 'archived', updated_at = ? WHERE knowledge_id = ?").run(now, row.knowledge_id);
+		addDecision(db, runId, "knowledge", row.knowledge_id, "archived", "stale_retention_elapsed", row, { status: "archived" }, now);
+		metrics.archived += 1;
+	}
+}
+function runMemoryMaintenance(input) {
+	const now = input.now ?? Date.now();
+	const principalId = input.principalId ?? "local-owner";
+	const limit = Math.max(1, Math.min(1e4, input.limit ?? 1e3));
+	const evidenceThreshold = Math.max(2, Math.min(10, input.evidenceThreshold ?? 2));
+	const idempotencyKey = input.idempotencyKey ?? `${principalId}:${input.jobType}:${periodKey(input.jobType, now)}`;
+	const existing = getSqliteDatabase().prepare(`SELECT run_id, status, metrics_json
+    FROM memory_maintenance_runs WHERE idempotency_key = ?`).get(idempotencyKey);
+	if (existing && existing.status !== "failed") return {
+		runId: existing.run_id,
+		jobType: input.jobType,
+		status: existing.status,
+		skipped: true,
+		metrics: JSON.parse(existing.metrics_json)
+	};
+	const runId = existing?.run_id ?? randomUUID();
+	const metrics = emptyMetrics();
+	const snapshot = JSON.stringify({
+		limit,
+		staleRetentionDays: input.staleRetentionDays ?? 30,
+		evidenceThreshold
+	});
+	runSqliteWriteTransaction((db) => {
+		if (existing) db.prepare(`UPDATE memory_maintenance_runs SET status = 'running', config_snapshot_json = ?,
+        cursor_json = '{}', metrics_json = '{}', error_message = NULL, started_at = ?, finished_at = NULL
+        WHERE run_id = ?`).run(snapshot, now, runId);
+		else db.prepare(`INSERT INTO memory_maintenance_runs (
+        run_id, principal_id, job_type, idempotency_key, algorithm_version,
+        config_snapshot_json, status, started_at
+      ) VALUES (?, ?, ?, ?, ?, ?, 'running', ?)`).run(runId, principalId, input.jobType, idempotencyKey, ALGORITHM_VERSION, snapshot, now);
+	});
+	try {
+		runSqliteWriteTransaction((db) => {
+			transitionAssertions(db, runId, now, limit, metrics);
+			transitionPriorities(db, runId, principalId, now, limit, metrics);
+			transitionKnowledge(db, runId, principalId, now, limit, metrics);
+			if (input.jobType === "daily_reconciliation" || input.jobType === "manual_repair") {
+				reconcileEvidence(db, runId, principalId, now, limit, evidenceThreshold, metrics);
+				repairIndexes(db, runId, now, metrics);
+			}
+			if (input.jobType === "weekly_knowledge" || input.jobType === "manual_repair") archiveOldKnowledge(db, runId, principalId, now - (input.staleRetentionDays ?? 30) * 24 * 60 * 60 * 1e3, now, limit, metrics);
+			db.prepare(`UPDATE memory_maintenance_runs SET status = 'completed', metrics_json = ?, finished_at = ?
+        WHERE run_id = ?`).run(JSON.stringify(metrics), now, runId);
+		});
+		return {
+			runId,
+			jobType: input.jobType,
+			status: "completed",
+			skipped: false,
+			metrics
+		};
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		getSqliteDatabase().prepare(`UPDATE memory_maintenance_runs SET status = 'failed',
+      metrics_json = ?, error_message = ?, finished_at = ? WHERE run_id = ?`).run(JSON.stringify(metrics), message, now, runId);
+		throw error;
+	}
+}
+function listMemoryMaintenanceRuns(limit = 20) {
+	return getSqliteDatabase().prepare(`SELECT run_id AS runId, principal_id AS principalId,
+    job_type AS jobType, idempotency_key AS idempotencyKey, algorithm_version AS algorithmVersion,
+    status, metrics_json AS metricsJson, error_message AS errorMessage,
+    started_at AS startedAt, finished_at AS finishedAt
+    FROM memory_maintenance_runs ORDER BY started_at DESC LIMIT ?`).all(Math.max(1, Math.min(100, limit))).map(({ metricsJson, ...row }) => ({
+		...row,
+		metrics: typeof metricsJson === "string" ? JSON.parse(metricsJson) : {}
+	}));
+}
+//#endregion
+export { listMemoryMaintenanceRuns, runMemoryMaintenance };

package/dist/src/notes/service.d.ts

@@ -46,6 +46,7 @@ export declare class NotesService {
         offset: number;
         hasMore: boolean;
     }>;
+    listProjectSummaries(): import("./types.js").NoteProjectSummary[];
     addAttachment(noteId: string, file: {
         name: string;
         buffer: Buffer;

package/dist/src/notes/service.js

@@ -2,6 +2,7 @@ import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
 import { buildNoteAttachmentRef } from "./attachment-ref.js";
 import { parseNoteMarkdown } from "./note-markdown.js";
+import { listNoteProjectSummaries } from "../storage/sqlite/notes-repository.js";
 import { changedFieldsFromPatch, emitActivity, previewText, systemActivityActor, systemActivitySource } from "../activity/emitter.js";
 import { getDefaultModelSync, init_providers, resolveModel } from "../providers/index.js";
 import { completeWithResolvedCredentials } from "../providers/model-call.js";
@@ -280,6 +281,7 @@ var NotesService = class {
 		const contentTouched = patch.markdown !== void 0 || patch.title !== void 0;
 		if (contentTouched) await this.maybeSaveSnapshot(existing, trigger);
 		const normalizedPatch = { ...patch };
+		if (contentTouched) normalizedPatch.lastEditTrigger = trigger;
 		if (patch.markdown !== void 0) normalizedPatch.kind = patch.kind ?? inferKind(patch.markdown, Boolean(existing.attachments?.length), existing.attachments);
 		if (contentTouched || patch.attachments) {
 			normalizedPatch.remoteVersion = (existing.remoteVersion ?? 1) + 1;
@@ -483,6 +485,9 @@ var NotesService = class {
 	async listNotes(query = {}) {
 		return this.store.listNotes(query);
 	}
+	listProjectSummaries() {
+		return listNoteProjectSummaries();
+	}
 	async addAttachment(noteId, file, idempotencyKey) {
 		if (!idempotencyKey) return this.addAttachmentWithId(noteId, file, randomUUID());
 		const attachmentId = noteAttachmentId(noteId, idempotencyKey);
@@ -555,7 +560,8 @@ var NotesService = class {
 			markdown: snapshot.markdown,
 			tags: snapshot.tags,
 			kind: snapshot.kind,
-			status: snapshot.status
+			status: snapshot.status,
+			lastEditTrigger: "restore"
 		});
 	}
 	async moveToGroup(noteId, groupId) {

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

@@ -113,6 +113,8 @@ export interface Note {
     status: NoteStatus;
     /** Canonical note body. Markdown is the only content truth. */
     markdown: string;
+    /** Provenance of the latest content edit, independent of snapshot throttling. */
+    lastEditTrigger?: SnapshotTrigger;
     attachments?: NoteAttachment[];
     createdAt: number;
     updatedAt: number;
@@ -149,6 +151,18 @@ export interface NoteIndexEntry {
     taskCount?: number;
     uncheckedTaskCount?: number;
     linkCount?: number;
+    projects?: Array<{
+        id: string;
+        name: string;
+    }>;
+    lastEditTrigger?: SnapshotTrigger;
+}
+export interface NoteProjectSummary {
+    id: string;
+    name: string;
+    description?: string;
+    noteCount: number;
+    updatedAt?: number;
 }
 export interface NotesIndexFile {
     version: number;
@@ -175,6 +189,8 @@ export interface NotesListQuery {
     kind?: NoteKind;
     tag?: string;
     projectId?: string;
+    unassigned?: boolean;
+    agentEdited?: boolean;
     pinned?: boolean;
     search?: string;
     limit?: number;

package/dist/src/proactive/execution/context.d.ts

@@ -15,8 +15,8 @@ export declare class InternalObjectContextProvider implements ContextProvider {
     supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }
-export declare class UserUnderstandingContextProvider implements ContextProvider {
-    readonly id = "user_understanding";
+export declare class UserModelContextProvider implements ContextProvider {
+    readonly id = "user_model";
     supports(): boolean;
     collect(input: ContextInput): Promise<ResolvedContext>;
 }

package/dist/src/proactive/execution/context.js

@@ -1,7 +1,8 @@
 import { getSqliteDatabase } from "../../storage/sqlite/transaction.js";
-import { listUnderstandings } from "../../storage/sqlite/user-context-repository.js";
 import { getKnowledgeSourceItem } from "../../storage/sqlite/knowledge-repository.js";
 import { getConnectorSyncPolicyForConnection } from "../../storage/sqlite/connector-sync-policy-repository.js";
+import { getAssertionSlot, listUserAssertions } from "../../user-model/repository.js";
+import "../../user-model/index.js";
 import { wrapExternalContent } from "../../gateway/security/external-content.js";
 //#region src/proactive/execution/context.ts
 const MAX_EVENT_COUNT = 50;
@@ -154,28 +155,32 @@ var InternalObjectContextProvider = class {
 		};
 	}
 };
-var UserUnderstandingContextProvider = class {
-	id = "user_understanding";
+var UserModelContextProvider = class {
+	id = "user_model";
 	supports() {
 		return true;
 	}
 	async collect(input) {
 		const scope = eventRows(input.eventIds).at(-1);
 		if (!scope) return emptyContext();
-		const records = listUnderstandings(["active"]).filter((record) => {
+		const records = listUserAssertions({
+			statuses: ["active"],
+			limit: 500
+		}).filter((record) => {
 			const now = Date.now();
-			const scopeMatches = record.scope.type === "global" || record.scope.type === "workspace" && record.scope.id === scope.workspace_id || record.scope.type === "project" && record.scope.id === scope.project_id;
-			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && scopeMatches && (!record.validFrom || record.validFrom <= now) && (!record.validTo || record.validTo >= now) && (!record.expiresAt || record.expiresAt >= now) && !record.conflictGroupId && (record.explicitness === "explicit" || record.confidence >= .7);
+			const assertionScope = getAssertionSlot(record.slotId)?.scope;
+			const scopeMatches = assertionScope?.type === "global" || assertionScope?.type === "workspace" && assertionScope.id === scope.workspace_id || assertionScope?.type === "project" && assertionScope.id === scope.project_id || assertionScope?.type === "agent" && assertionScope.id === scope.agent_id;
+			return record.disclosurePolicy === "referenceable" && record.sensitivity !== "secret" && record.sensitivity !== "regulated" && scopeMatches && (!record.validFrom || record.validFrom <= now) && (!record.validTo || record.validTo >= now) && (record.authority === "user_explicit" || record.confidence >= .7);
 		}).slice(0, 20);
 		return {
 			content: { records: records.map((record) => ({
-				evidenceId: `understanding:${record.id}`,
+				evidenceId: `assertion:${record.id}`,
 				kind: record.kind,
 				content: boundedText(record.statement, 1e3),
 				confidence: record.confidence,
-				updatedAt: record.updatedAt
+				recordedAt: record.recordedAt
 			})) },
-			evidenceIds: records.map((record) => `understanding:${record.id}`)
+			evidenceIds: records.map((record) => `assertion:${record.id}`)
 		};
 	}
 };
@@ -295,7 +300,7 @@ var ContextProviderRegistry = class {
 		new EventBatchContextProvider(),
 		new ConnectedSourceContextProvider(),
 		new InternalObjectContextProvider(),
-		new UserUnderstandingContextProvider(),
+		new UserModelContextProvider(),
 		new MeetingWorkspaceContextProvider(),
 		new ProjectStateContextProvider(),
 		new AutomationStateContextProvider()
@@ -315,4 +320,4 @@ var ContextProviderRegistry = class {
 	}
 };
 //#endregion
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider };

package/dist/src/proactive/index.d.ts

@@ -8,7 +8,7 @@ export type { SignalBatch } from './routing/batch-repository.js';
 export { ProactiveEventService } from './service.js';
 export { ProactiveScenarioService } from './scenarios/service.js';
 export type { PromptRevision, ScenarioDefinition, ScenarioSubscription } from './scenarios/types.js';
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider, } from './execution/context.js';
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider, } from './execution/context.js';
 export { ReadonlyProactiveAgentExecutor } from './execution/agent-executor.js';
 export { listInsights } from './execution/repository.js';
 export { ProactiveWorker } from './execution/worker.js';

package/dist/src/proactive/index.js

@@ -3,11 +3,11 @@ import { normalizeEventEnvelope } from "./events/envelope.js";
 import { mapProductEventToProactive } from "./events/product-event-bridge.js";
 import { matchScenario, matchesCondition } from "./routing/matcher.js";
 import { ProactiveEventService } from "./service.js";
-import { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserUnderstandingContextProvider } from "./execution/context.js";
+import { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProjectStateContextProvider, UserModelContextProvider } from "./execution/context.js";
 import { ReadonlyProactiveAgentExecutor } from "./execution/agent-executor.js";
 import { listInsights } from "./execution/repository.js";
 import { ProactiveWorker } from "./execution/worker.js";
 import { ProactiveTemporalWorker } from "./temporal/worker.js";
 import { ProactiveInboxService } from "./inbox/service.js";
 import { ProactiveInboxWorker } from "./inbox/worker.js";
-export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, UserUnderstandingContextProvider, listInsights, mapProductEventToProactive, matchScenario, matchesCondition, normalizeEventEnvelope };
+export { AutomationStateContextProvider, ConnectedSourceContextProvider, ContextProviderRegistry, EventBatchContextProvider, InternalObjectContextProvider, MeetingWorkspaceContextProvider, ProactiveEventService, ProactiveInboxService, ProactiveInboxWorker, ProactiveScenarioService, ProactiveTemporalWorker, ProactiveWorker, ProjectStateContextProvider, ReadonlyProactiveAgentExecutor, UserModelContextProvider, listInsights, mapProductEventToProactive, matchScenario, matchesCondition, normalizeEventEnvelope };

package/dist/src/projects/index.d.ts

@@ -9,6 +9,6 @@ export * from './project-loop.js';
 export * from './session-bind.js';
 export * from './workflow-bind.js';
 export * from './automation-bind.js';
-export * from './memory-bind.js';
+export * from './knowledge-bind.js';
 export * from './workspace.js';
 export * from './workspace-project.js';

package/dist/src/projects/index.js

@@ -10,5 +10,5 @@ import { CODING_PROJECT_AGENT_ID, inferSuggestedProjectDefaultAgentId, suggestPr
 import { buildProjectLoopOverview } from "./project-loop.js";
 import { bindWorkflowRunToProject } from "./workflow-bind.js";
 import { bindAutomationToProject } from "./automation-bind.js";
-import { bindMemoryRecordToProject } from "./memory-bind.js";
-export { CODING_PROJECT_AGENT_ID, ProjectService, ProjectSkillError, ProjectSkillService, ProjectStore, ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, bindAutomationToProject, bindMemoryRecordToProject, bindSessionToProject, bindSessionsToProject, bindWorkflowRunToProject, buildProjectLoopOverview, canonicalWorkspacePath, ensureWorkspaceDirectory, getProjectForSession, getProjectWorkspacePathForSession, inferProjectExecutionMode, inferProjectKind, inferProjectNameFromWorkspaceRoot, inferSuggestedProjectDefaultAgentId, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, isValidProjectAgentId, listProjectSessionKeys, moveSessionToProject, normalizeProjectAgentId, resolveProjectAgentId, resolveProjectWorkspacePath, resolveWorkspaceProjectRoot, slugifyProjectName, suggestProjectDefaultAgentId, unbindSessionFromProject, workspaceDirectoryExists };
+import { bindKnowledgeItemToProject } from "./knowledge-bind.js";
+export { CODING_PROJECT_AGENT_ID, ProjectService, ProjectSkillError, ProjectSkillService, ProjectStore, ProjectWorkspaceConflictError, ProjectWorkspaceMissingError, bindAutomationToProject, bindKnowledgeItemToProject, bindSessionToProject, bindSessionsToProject, bindWorkflowRunToProject, buildProjectLoopOverview, canonicalWorkspacePath, ensureWorkspaceDirectory, getProjectForSession, getProjectWorkspacePathForSession, inferProjectExecutionMode, inferProjectKind, inferProjectNameFromWorkspaceRoot, inferSuggestedProjectDefaultAgentId, isPathSameOrInsideWorkspace, isSafeAutoCreateWorkspaceRoot, isValidProjectAgentId, listProjectSessionKeys, moveSessionToProject, normalizeProjectAgentId, resolveProjectAgentId, resolveProjectWorkspacePath, resolveWorkspaceProjectRoot, slugifyProjectName, suggestProjectDefaultAgentId, unbindSessionFromProject, workspaceDirectoryExists };

package/dist/src/projects/knowledge-bind.d.ts

@@ -0,0 +1 @@
+export declare function bindKnowledgeItemToProject(knowledgeId: string, projectId: string): void;

package/dist/src/projects/knowledge-bind.js

@@ -0,0 +1,15 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "../storage/sqlite/transaction.js";
+//#region src/projects/knowledge-bind.ts
+function bindKnowledgeItemToProject(knowledgeId, projectId) {
+	const db = getSqliteDatabase();
+	if (!db.prepare("SELECT 1 FROM projects WHERE project_id = ?").get(projectId)) throw new Error(`Project not found: ${projectId}`);
+	if (!db.prepare("SELECT 1 FROM knowledge_items WHERE knowledge_id = ?").get(knowledgeId)) throw new Error(`Knowledge item not found: ${knowledgeId}`);
+	runSqliteWriteTransaction((tx) => {
+		const now = Date.now();
+		tx.prepare(`UPDATE knowledge_items SET scope_type = 'project', scope_id = ?, updated_at = ?
+      WHERE knowledge_id = ?`).run(projectId, now, knowledgeId);
+		tx.prepare("UPDATE projects SET last_active_at = ?, updated_at = ? WHERE project_id = ?").run(now, now, projectId);
+	});
+}
+//#endregion
+export { bindKnowledgeItemToProject };

package/dist/src/projects/project-loop.d.ts

@@ -1,4 +1,4 @@
-import type { MemoryRecord } from '../agent/memory/types.js';
+import type { KnowledgeItem } from '../knowledge-memory/index.js';
 import type { ProjectWithDetails } from './types.js';
 export type ProjectWorkflowRunBrief = {
     runId: string;
@@ -18,7 +18,7 @@ export type ProjectAttentionItem = {
 };
 export type ProjectTimelineItem = {
     id: string;
-    kind: 'session' | 'task' | 'workflow' | 'memory';
+    kind: 'session' | 'task' | 'workflow' | 'knowledge';
     title: string;
     detail?: string;
     timestamp: number;
@@ -60,7 +60,7 @@ export declare function buildProjectLoopOverview(input: {
     tasks: ProjectTask[];
     recentWorkflowRuns: ProjectWorkflowRunBrief[];
     failedWorkflowRuns?: ProjectWorkflowRunBrief[];
-    memoryRecords?: MemoryRecord[];
+    knowledgeItems?: KnowledgeItem[];
     nowMs?: number;
     staleAfterMs?: number;
 }): ProjectLoopOverview;

package/dist/src/projects/project-loop.js

@@ -78,12 +78,12 @@ function buildProjectLoopOverview(input) {
 			status: run.status,
 			href: `/workflows?run=${encodeURIComponent(run.runId)}`
 		})),
-		...(input.memoryRecords ?? []).slice(0, 5).map((record) => ({
-			id: `memory:${record.id}`,
-			kind: "memory",
+		...(input.knowledgeItems ?? []).slice(0, 5).map((record) => ({
+			id: `knowledge:${record.id}`,
+			kind: "knowledge",
 			title: record.kind,
 			detail: compactText(record.content),
-			timestamp: Date.parse(record.updatedAt),
+			timestamp: record.updatedAt,
 			status: record.status
 		}))
 	].filter((item) => Number.isFinite(item.timestamp)).sort((left, right) => right.timestamp - left.timestamp).slice(0, 12);

package/dist/src/projects/project-store.js

@@ -308,7 +308,8 @@ var ProjectStore = class {
 			db.prepare(`UPDATE tasks SET project_id = NULL WHERE project_id = ?`).run(id);
 			db.prepare(`UPDATE workflow_runs SET project_id = NULL WHERE project_id = ?`).run(id);
 			db.prepare(`UPDATE automations SET project_id = NULL WHERE project_id = ?`).run(id);
-			db.prepare(`UPDATE memory_records SET project_id = NULL WHERE project_id = ?`).run(id);
+			db.prepare(`UPDATE knowledge_items SET status = 'archived', updated_at = ?
+        WHERE scope_type = 'project' AND scope_id = ?`).run(Date.now(), id);
 			db.prepare(`DELETE FROM projects_fts WHERE project_id = ?`).run(id);
 			db.prepare(`DELETE FROM projects WHERE project_id = ?`).run(id);
 		});

package/dist/src/realtime/runtime.js

@@ -30,6 +30,7 @@ function isAuthorizedTopic(topic, scopes) {
 	if (topic === "logs") return hasGatewayScope(scopes, "gateway.admin");
 	if (topic === "sessions" || topic.startsWith("session:")) return hasGatewayScope(scopes, "sessions.read");
 	if (topic.startsWith("run:")) return hasGatewayScope(scopes, "agents.run");
+	if (topic.startsWith("side-chat:")) return hasGatewayScope(scopes, "agents.run");
 	if (topic.startsWith("workflow:")) return hasGatewayScope(scopes, "automations.read");
 	return false;
 }

package/dist/src/runtime-tools/manager.js

@@ -14,8 +14,8 @@ import { bundledPythonArchiveName, resolveOfflineBundleArtifact } from "./offlin
 import { normalizeRuntimeVersionRequest, parseRuntimeVersion, probeSystemRuntime, resolveInstallVersion, versionSatisfies } from "./probe.js";
 import { dirname, join } from "node:path";
 import { randomUUID } from "node:crypto";
-import { access, mkdir, realpath, rename, rm } from "node:fs/promises";
 import { EventEmitter } from "node:events";
+import { access, mkdir, realpath, rename, rm } from "node:fs/promises";
 //#region src/runtime-tools/manager.ts
 init_logger();
 const log = createLogger("RuntimeManager");

package/dist/src/storage/sqlite/collaboration-rule-repository.d.ts

@@ -0,0 +1,17 @@
+import { type UserModelScope } from '../../user-model/domain.js';
+export interface CollaborationRule {
+    id: string;
+    category: 'communication' | 'execution' | 'boundary' | 'routine' | 'proactive';
+    status: 'active' | 'disabled' | 'archived';
+    priority: number;
+    scope: UserModelScope;
+    conditions: Record<string, unknown>;
+    statement: string;
+    revisionId: string;
+    createdAt: number;
+    updatedAt: number;
+}
+export declare function getCollaborationRule(id: string): CollaborationRule | undefined;
+export declare function listCollaborationRules(principalId?: string): CollaborationRule[];
+export declare function createCollaborationRule(input: Pick<CollaborationRule, 'category' | 'priority' | 'scope' | 'conditions' | 'statement'>): CollaborationRule;
+export declare function setCollaborationRuleStatus(id: string, status: CollaborationRule['status']): CollaborationRule | undefined;

package/dist/src/storage/sqlite/collaboration-rule-repository.js

@@ -0,0 +1,54 @@
+import { getSqliteDatabase, runSqliteWriteTransaction } from "./transaction.js";
+import { USER_MODEL_PRINCIPAL_ID } from "../../user-model/domain.js";
+import { randomUUID } from "node:crypto";
+//#region src/storage/sqlite/collaboration-rule-repository.ts
+function fromRow(row) {
+	return {
+		id: row.rule_id,
+		category: row.category,
+		status: row.status,
+		priority: row.priority,
+		scope: {
+			type: row.scope_type,
+			...row.scope_id ? { id: row.scope_id } : {}
+		},
+		conditions: JSON.parse(row.conditions_json),
+		statement: row.statement,
+		revisionId: row.current_revision_id,
+		createdAt: row.created_at,
+		updatedAt: row.updated_at
+	};
+}
+function getCollaborationRule(id) {
+	const row = getSqliteDatabase().prepare(`SELECT r.*, v.statement FROM collaboration_rules r
+    JOIN collaboration_rule_revisions v ON v.revision_id = r.current_revision_id
+    WHERE r.rule_id = ?`).get(id);
+	return row ? fromRow(row) : void 0;
+}
+function listCollaborationRules(principalId = USER_MODEL_PRINCIPAL_ID) {
+	return getSqliteDatabase().prepare(`SELECT r.*, v.statement FROM collaboration_rules r
+    JOIN collaboration_rule_revisions v ON v.revision_id = r.current_revision_id
+    WHERE r.principal_id = ? ORDER BY r.priority, r.updated_at DESC`).all(principalId).map(fromRow);
+}
+function createCollaborationRule(input) {
+	if (!input.statement.trim()) throw new Error("Collaboration rule statement is required.");
+	if (input.scope.type === "agent") throw new Error("Agent-scoped collaboration rules are not supported.");
+	const id = randomUUID();
+	const revisionId = randomUUID();
+	const now = Date.now();
+	runSqliteWriteTransaction((db) => {
+		db.prepare(`INSERT INTO collaboration_rules (
+      rule_id, principal_id, category, status, priority, scope_type, scope_id,
+      conditions_json, current_revision_id, created_at, updated_at
+    ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?)`).run(id, USER_MODEL_PRINCIPAL_ID, input.category, input.priority, input.scope.type, input.scope.id ?? null, JSON.stringify(input.conditions), revisionId, now, now);
+		db.prepare(`INSERT INTO collaboration_rule_revisions (
+      revision_id, rule_id, statement, created_by, created_at
+    ) VALUES (?, ?, ?, 'user', ?)`).run(revisionId, id, input.statement.trim(), now);
+	});
+	return getCollaborationRule(id);
+}
+function setCollaborationRuleStatus(id, status) {
+	return getSqliteDatabase().prepare(`UPDATE collaboration_rules SET status = ?, updated_at = ? WHERE rule_id = ?`).run(status, Date.now(), id).changes ? getCollaborationRule(id) : void 0;
+}
+//#endregion
+export { createCollaborationRule, getCollaborationRule, listCollaborationRules, setCollaborationRuleStatus };