@xopcai/xopc 0.0.353 → 0.0.355

package/dist/src/personal-agent/policy.d.ts

@@ -0,0 +1 @@
+export declare const PERSONAL_MAIN_TOOL_IDS: readonly ["personal_task", "personal_preference", "session_recall", "user_context_search", "user_context_get", "knowledge_search", "knowledge_get", "clarify"];

package/dist/src/personal-agent/policy.js

@@ -0,0 +1,13 @@
+//#region src/personal-agent/policy.ts
+const PERSONAL_MAIN_TOOL_IDS = [
+	"personal_task",
+	"personal_preference",
+	"session_recall",
+	"user_context_search",
+	"user_context_get",
+	"knowledge_search",
+	"knowledge_get",
+	"clarify"
+];
+//#endregion
+export { PERSONAL_MAIN_TOOL_IDS };

package/dist/src/personal-agent/repository.d.ts

@@ -0,0 +1,25 @@
+export type PersonalAgentState = 'provisioning' | 'ready' | 'error';
+export type PersonalAppearance = 'spark' | 'cloud' | 'bean';
+export interface PersonalAgentRecord {
+    ownerId: string;
+    agentId: string;
+    conversationId: string;
+    state: PersonalAgentState;
+    displayName: string;
+    appearance: PersonalAppearance;
+    preferences: Record<string, unknown>;
+    revision: number;
+    errorMessage: string | null;
+}
+export declare const DEFAULT_PERSONAL_PREFERENCES: {
+    readonly warmth: "balanced";
+    readonly humor: "none";
+    readonly supportMode: "untangle";
+    readonly detailLevel: "balanced";
+    readonly proactivity: "decisions";
+};
+export declare function personalAgentId(ownerId: string): string;
+export declare function personalConversationId(ownerId: string): string;
+export declare function getPersonalAgent(ownerId: string): PersonalAgentRecord | null;
+export declare function getPersonalAgentByConversation(conversationId: string): PersonalAgentRecord | null;
+export declare function isPersonalConversation(conversationId: string): boolean;

package/dist/src/personal-agent/repository.js

@@ -0,0 +1,68 @@
+import { init_connection, isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
+import { getSqliteDatabase, init_transaction } from "../storage/sqlite/transaction.js";
+import { getSessionConfig, init_config_repository } from "../storage/sqlite/config-repository.js";
+import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
+import { createHash } from "node:crypto";
+//#region src/personal-agent/repository.ts
+init_repository();
+init_connection();
+init_config_repository();
+init_transaction();
+const DEFAULT_PERSONAL_PREFERENCES = {
+	warmth: "balanced",
+	humor: "none",
+	supportMode: "untangle",
+	detailLevel: "balanced",
+	proactivity: "decisions"
+};
+function personalAgentId(ownerId) {
+	return `personal-${createHash("sha256").update(ownerId).digest("hex").slice(0, 12)}`;
+}
+function personalConversationId(ownerId) {
+	const hash = createHash("sha256").update(`personal-conversation:${ownerId}`).digest("hex");
+	return `${hash.slice(0, 8)}-${hash.slice(8, 12)}-5${hash.slice(13, 16)}-8${hash.slice(17, 20)}-${hash.slice(20, 32)}`;
+}
+function personalSession(column, value) {
+	if (!isXopcDatabaseOpen()) return null;
+	return getSqliteDatabase().prepare(`SELECT conversation_id, agent_id
+    FROM sessions WHERE ${column} = ? AND json_extract(custom_data_json, '$.personalAgent') = 1
+    ORDER BY created_at LIMIT 1`).get(value) ?? null;
+}
+function appearanceFrom(agent) {
+	return agent.profile?.emoji === "☁" ? "cloud" : agent.profile?.emoji === "◕" ? "bean" : "spark";
+}
+function toRecord(ownerId, agent, session) {
+	const config = session ? getSessionConfig(session.conversation_id) : null;
+	const ready = agent.provisioningState === "ready" && agent.runtime?.thinkingLevel === "off" && session && config?.thinkingLevel === "off" && config.fixedModel;
+	return {
+		ownerId,
+		agentId: agent.id,
+		conversationId: session?.conversation_id ?? personalConversationId(ownerId),
+		state: agent.provisioningState === "error" ? "error" : ready ? "ready" : "provisioning",
+		displayName: agent.profile?.name ?? "Personal AI",
+		appearance: appearanceFrom(agent),
+		preferences: agent.profile?.responsePreferences ?? DEFAULT_PERSONAL_PREFERENCES,
+		revision: agent.revision,
+		errorMessage: agent.provisioningError ?? null
+	};
+}
+function getPersonalAgent(ownerId) {
+	if (!isXopcDatabaseOpen()) return null;
+	const agent = new AgentCatalogRepository().get(personalAgentId(ownerId));
+	return agent ? toRecord(ownerId, agent, personalSession("agent_id", agent.id)) : null;
+}
+function getPersonalAgentByConversation(conversationId) {
+	const session = personalSession("conversation_id", conversationId);
+	if (!session) return null;
+	const agent = new AgentCatalogRepository().get(session.agent_id);
+	if (!agent) return null;
+	const ownerId = "local-owner";
+	return agent.id === personalAgentId(ownerId) ? toRecord(ownerId, agent, session) : null;
+}
+function isPersonalConversation(conversationId) {
+	if (!isXopcDatabaseOpen()) return false;
+	return Boolean(getSqliteDatabase().prepare(`SELECT 1 FROM sessions WHERE conversation_id = ?
+    AND agent_id = ? AND json_extract(custom_data_json, '$.personalAgent') = 1`).get(conversationId, personalAgentId("local-owner")));
+}
+//#endregion
+export { DEFAULT_PERSONAL_PREFERENCES, getPersonalAgent, getPersonalAgentByConversation, isPersonalConversation, personalAgentId, personalConversationId };

package/dist/src/personal-agent/service.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+import type { GatewayService } from '../gateway/service.js';
+import { type PersonalAgentRecord } from './repository.js';
+export declare const PersonalPreferencesSchema: z.ZodObject<{
+    addressAs: z.ZodOptional<z.ZodString>;
+    guidance: z.ZodOptional<z.ZodString>;
+    warmth: z.ZodOptional<z.ZodEnum<{
+        balanced: "balanced";
+        reserved: "reserved";
+        gentle: "gentle";
+    }>>;
+    humor: z.ZodOptional<z.ZodEnum<{
+        none: "none";
+        occasional: "occasional";
+        playful: "playful";
+    }>>;
+    supportMode: z.ZodOptional<z.ZodEnum<{
+        listen: "listen";
+        untangle: "untangle";
+        solutions: "solutions";
+    }>>;
+    detailLevel: z.ZodOptional<z.ZodEnum<{
+        brief: "brief";
+        balanced: "balanced";
+        detailed: "detailed";
+    }>>;
+    proactivity: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        decisions: "decisions";
+        important: "important";
+    }>>;
+}, z.core.$strict>;
+export type PersonalPreferences = z.infer<typeof PersonalPreferencesSchema>;
+export declare const PersonalAppearanceSchema: z.ZodEnum<{
+    cloud: "cloud";
+    spark: "spark";
+    bean: "bean";
+}>;
+export type PersonalAppearance = z.infer<typeof PersonalAppearanceSchema>;
+export declare function personalInstructions(preferences: PersonalPreferences): string;
+export declare function refreshPersonalDelegationGuidance(service: GatewayService, ownerId: string): Promise<void>;
+export declare function listPersonalModels(): Promise<Array<{
+    id: string;
+    name: string;
+}>>;
+export declare function ensurePersonalConversationVisibility(ownerId: string): void;
+export declare function createOrResumePersonalAgent(service: GatewayService, ownerId: string, requestedModel?: string, availableModels?: typeof listPersonalModels): Promise<PersonalAgentRecord>;
+export declare function patchPersonalProfile(service: GatewayService, ownerId: string, revision: number, displayName: string, preferences: PersonalPreferences, appearance: PersonalAppearance): Promise<PersonalAgentRecord | null>;
+export declare function updatePersonalProfileRecord(ownerId: string, revision: number, displayName: string, preferences: PersonalPreferences, appearance: PersonalAppearance): Promise<PersonalAgentRecord | null>;

package/dist/src/personal-agent/service.js

@@ -0,0 +1,234 @@
+import { getSessionMetadata } from "../storage/sqlite/session-read-repository.js";
+import { init_session_repository, patchSessionMetadata } from "../storage/sqlite/session-repository.js";
+import { init_config_repository, setSessionConfig } from "../storage/sqlite/config-repository.js";
+import { ResponsePreferencesSchema } from "../agent-config/schema.js";
+import { init_agent_config } from "../agent-config/index.js";
+import { AgentCatalogRepository, init_repository } from "../agent-catalog/repository.js";
+import { AgentCatalogService } from "../agent-catalog/service.js";
+import { createConversation, init_conversation_repository } from "../storage/sqlite/conversation-repository.js";
+import { getAvailableModels, init_providers } from "../providers/index.js";
+import { getModelThinking } from "../providers/model-thinking.js";
+import { DEFAULT_PERSONAL_PREFERENCES, getPersonalAgent, personalAgentId } from "./repository.js";
+import { PERSONAL_MAIN_TOOL_IDS } from "./policy.js";
+import { z } from "zod";
+//#region src/personal-agent/service.ts
+init_agent_config();
+init_repository();
+init_providers();
+init_conversation_repository();
+init_session_repository();
+init_config_repository();
+const PersonalPreferencesSchema = ResponsePreferencesSchema;
+const PersonalAppearanceSchema = z.enum([
+	"spark",
+	"cloud",
+	"bean"
+]);
+function appearanceEmoji(appearance) {
+	return appearance === "cloud" ? "☁" : appearance === "bean" ? "◕" : "✦";
+}
+const LEGACY_DELEGATION_RULE = "Answer simple requests directly. For complex work, use personal_task agents to find a suitable specialist, then create a Task and remain available to talk. Never claim a task was created before the tool confirms it.";
+const PREVIOUS_DELEGATION_RULES = [
+	"Route by required capability, not task length. Answer directly only when your own tools and knowledge are sufficient. For current facts, web pages, or any tool you lack, call personal_task(command=\"agents\"), choose an Agent with the needed availableTools, then create a Task. Your own lack of browsing does not mean xopc cannot browse. Never claim the system cannot help, ask the user to switch models, or ask them to paste sources before checking Agents.",
+	"For current news, delegate to an Agent with web_search. Include the requested date or time window and topic in the brief; require source links, publication dates, and a distinction between confirmed news and uncertain reports. Tell the user briefly that you are checking. Stay available while the Task runs, then summarize verified results in their preferred style.",
+	"If no suitable Agent is available, explain the specific missing capability and offer the next useful option. Never claim a Task was created before the tool confirms it."
+].join("\n");
+const PRIOR_DELEGATION_RULES = [
+	"Own the user’s request through completion. If you cannot reliably do it yourself because of missing tools, access, knowledge, time, or specialist judgment, first call personal_task(command=\"agents\"). Match the request to another Agent’s description and availableTools, then create a Task for a plausible candidate. This applies to short requests too. Your own limitation is not a system limitation. Do not stop at “I cannot” or ask the user to switch models or do your work before checking Agents.",
+	"If the chosen Agent or tool cannot complete the Task, inspect the actual blocker and try another suitable Agent or a reasonable alternative within the user’s authorization. Do not repeat the same failed approach indefinitely. Ask the user only for a decision, access, or information that no available Agent can supply. Explain a concrete blocker only after checking the available paths; never imply that an untried path was attempted.",
+	"For current news or other live facts, find an Agent with web_search and require dated sources. For coding, analysis, writing, media, or connected-app work, choose by the Agent’s role and tools rather than a fixed name. Give the Task a short title and a complete Markdown brief. After Task creation succeeds, tell the user briefly what is happening, stay available, and summarize verified outcomes in their preferred style.",
+	"Never claim a Task was created or completed before its tool result confirms that state. Respect the user’s authorization and the selected Agent’s permissions."
+].join("\n");
+const DELEGATION_RULES = [
+	"Own the user’s request through completion. If you cannot reliably do it yourself because of missing tools, access, knowledge, time, or specialist judgment, first call personal_task(command=\"agents\"). Match the request to another Agent’s description and availableTools, then create a Task for a plausible candidate. This applies to short requests too. Your own limitation is not a system limitation. Do not stop at “I cannot” or ask the user to switch models or do your work before checking Agents.",
+	"If the chosen Agent or tool cannot complete the Task, inspect the actual blocker and try another suitable Agent or a reasonable alternative within the user’s authorization. Do not repeat the same failed approach indefinitely. Ask the user only for a decision, access, or information that no available Agent can supply. Explain a concrete blocker only after checking the available paths; never imply that an untried path was attempted.",
+	"A worker question is yours to resolve first. Read the Task brief and earlier conversation; when the answer is already there, call personal_task(command=\"answer\", taskId=..., questionId=..., instruction=...) so the worker resumes. Ask the user only when the missing fact cannot be found. Once the user asks you to complete a task, retrying a suitable alternative Agent is already authorized; do not ask permission to try again.",
+	"For current news or other live facts, find an Agent with web_search and require dated sources. For coding, analysis, writing, media, or connected-app work, choose by the Agent’s role and tools rather than a fixed name. Give the Task a short title and a complete Markdown brief. After Task creation succeeds, tell the user briefly what is happening, stay available, and summarize verified outcomes in their preferred style.",
+	"Never claim a Task was created or completed before its tool result confirms that state. Respect the user’s authorization and the selected Agent’s permissions."
+];
+function personalInstructions(preferences) {
+	const rules = [
+		"You are the user’s personal AI: capable, clear, attentive, and responsive. Match the user’s language. Let the user’s stated preferences and current situation shape how you speak; do not impose a cute or affectionate persona.",
+		...DELEGATION_RULES,
+		"When creating a Task, provide a short title that names the work, a one-sentence objective, and a Markdown description with all detailed instructions. Keep the title free of checklists and long background. Preserve user requirements in the description.",
+		"Adapt to the user’s current words first, then their saved preferences. If the user explicitly changes how they want you to respond in future, save it with personal_preference. Do not infer a lasting emotional trait from one conversation or claim human feelings or experiences.",
+		"Give the accurate answer or next step in the order this user prefers. Acknowledge feelings only when relevant, without guessing how the user feels. Avoid formulaic reassurance, praise, pet names, emojis, or jokes unless the user welcomes them and the moment fits. Be accurate about task state, evidence, and uncertainty."
+	];
+	if (preferences.addressAs) rules.push(`Address the user as ${JSON.stringify(preferences.addressAs)} when a name fits naturally.`);
+	if (preferences.guidance) rules.push(`User's explicit response preference: ${JSON.stringify(preferences.guidance)}. Follow it when relevant, subject to accuracy and the current request.`);
+	if (preferences.warmth) rules.push({
+		reserved: "Tone: calm and direct; skip emotional preambles.",
+		balanced: "Tone: friendly and natural.",
+		gentle: "Tone: softly supportive without being sentimental."
+	}[preferences.warmth]);
+	if (preferences.humor) rules.push({
+		none: "Do not add jokes.",
+		occasional: "Use an occasional light touch when the moment fits.",
+		playful: "Be lightly playful in easy moments."
+	}[preferences.humor]);
+	if (preferences.supportMode) rules.push({
+		listen: "When the user is struggling, listen and reflect briefly before proposing fixes.",
+		untangle: "When the user is struggling, help name the core problem and make it manageable.",
+		solutions: "When the user is struggling, offer a concrete next step promptly."
+	}[preferences.supportMode]);
+	if (preferences.detailLevel) rules.push({
+		brief: "Keep replies short and lead with the answer.",
+		balanced: "Give the answer and only the context needed to act.",
+		detailed: "Explain reasoning and tradeoffs when useful."
+	}[preferences.detailLevel]);
+	if (preferences.proactivity) rules.push({
+		decisions: "Only proactively surface decisions and outcomes.",
+		important: "Proactively surface important milestones as well as outcomes.",
+		open: "You may offer useful suggestions without flooding the user."
+	}[preferences.proactivity]);
+	return rules.join("\n");
+}
+async function refreshPersonalDelegationGuidance(service, ownerId) {
+	const agent = new AgentCatalogRepository().get(personalAgentId(ownerId));
+	const instructions = agent?.profile?.instructions;
+	if (!agent || !instructions) return;
+	const oldRule = [
+		PRIOR_DELEGATION_RULES,
+		PREVIOUS_DELEGATION_RULES,
+		LEGACY_DELEGATION_RULE
+	].find((rule) => instructions.includes(rule));
+	if (!oldRule) return;
+	try {
+		await new AgentCatalogService().update(agent.id, { profile: {
+			...agent.profile,
+			instructions: instructions.replace(oldRule, DELEGATION_RULES.join("\n"))
+		} }, agent.revision);
+		service.refreshAgentCatalog?.();
+		const conversationId = getPersonalAgent(ownerId)?.conversationId;
+		if (conversationId) service.agentService?.evictSessionAgent(conversationId);
+	} catch (error) {
+		if (!(error instanceof Error && error.message === "Agent revision conflict")) throw error;
+	}
+}
+async function listPersonalModels() {
+	return (await getAvailableModels()).filter((model) => getModelThinking(model).options.includes("off")).map((model) => ({
+		id: `${model.provider}/${model.id}`,
+		name: model.name ?? model.id
+	}));
+}
+const inFlightProvisioning = /* @__PURE__ */ new Map();
+function ensurePersonalConversationVisibility(ownerId) {
+	const conversationId = getPersonalAgent(ownerId)?.conversationId;
+	if (!conversationId) return;
+	const session = getSessionMetadata(conversationId);
+	if (!session || session.hiddenFromSessionList && session.customData?.keepHiddenFromSessionList === true) return;
+	patchSessionMetadata(conversationId, {
+		hiddenFromSessionList: true,
+		customData: {
+			...session.customData,
+			keepHiddenFromSessionList: true
+		}
+	});
+}
+function createOrResumePersonalAgent(service, ownerId, requestedModel, availableModels = listPersonalModels) {
+	const current = inFlightProvisioning.get(ownerId);
+	if (current) return current;
+	const pending = provisionPersonalAgent(service, ownerId, requestedModel, availableModels);
+	inFlightProvisioning.set(ownerId, pending);
+	pending.finally(() => {
+		if (inFlightProvisioning.get(ownerId) === pending) inFlightProvisioning.delete(ownerId);
+	}).catch(() => {});
+	return pending;
+}
+async function provisionPersonalAgent(service, ownerId, requestedModel, availableModels = listPersonalModels) {
+	const existingIdentity = getPersonalAgent(ownerId);
+	if (existingIdentity?.state === "ready") {
+		await refreshPersonalDelegationGuidance(service, ownerId);
+		ensurePersonalConversationVisibility(ownerId);
+		return getPersonalAgent(ownerId) ?? existingIdentity;
+	}
+	const agentId = personalAgentId(ownerId);
+	const existing = new AgentCatalogRepository().get(agentId);
+	const available = await availableModels();
+	const preferredModel = requestedModel ?? existing?.models?.chat?.primary;
+	const fastModel = preferredModel ? void 0 : new AgentCatalogRepository().getSettings().defaults.models.intents.fast?.primary;
+	const chosen = preferredModel ? available.find((model) => model.id === preferredModel) : available.find((model) => model.id === fastModel) ?? available[0];
+	if (!chosen) throw new Error("Choose a configured model that supports thinking off");
+	const catalog = new AgentCatalogService();
+	if (!existing) await catalog.create({
+		id: agentId,
+		enabled: true,
+		profile: {
+			name: "Personal AI",
+			description: "A personal AI that adapts its responses to the user and coordinates work.",
+			creature: "assistant",
+			language: "zh",
+			emoji: appearanceEmoji("spark"),
+			responsePreferences: DEFAULT_PERSONAL_PREFERENCES,
+			instructions: personalInstructions(DEFAULT_PERSONAL_PREFERENCES)
+		},
+		toolAllowlist: [...PERSONAL_MAIN_TOOL_IDS],
+		skills: {
+			mode: "replace",
+			include: []
+		},
+		runtime: { thinkingLevel: "off" },
+		models: { chat: {
+			primary: chosen.id,
+			fallbacks: []
+		} }
+	});
+	else if (existing.provisioningState !== "ready" || existing.models?.chat?.primary !== chosen.id || existing.runtime?.thinkingLevel !== "off") await catalog.update(agentId, {
+		models: { chat: {
+			primary: chosen.id,
+			fallbacks: []
+		} },
+		runtime: {
+			...existing.runtime,
+			thinkingLevel: "off"
+		}
+	});
+	const record = getPersonalAgent(ownerId);
+	if (!record) throw new Error("Personal Agent provisioning did not complete");
+	const conversationId = record.conversationId;
+	service.refreshAgentCatalog();
+	if (!getSessionMetadata(conversationId)) createConversation({
+		agentId,
+		sourceChannel: "webchat",
+		name: record.displayName,
+		hiddenFromSessionList: true,
+		customData: {
+			personalAgent: true,
+			keepHiddenFromSessionList: true
+		}
+	}, "", conversationId);
+	ensurePersonalConversationVisibility(ownerId);
+	setSessionConfig(conversationId, {
+		modelOverride: chosen.id,
+		fixedModel: true,
+		thinkingLevel: "off"
+	}, process.cwd());
+	return getPersonalAgent(ownerId) ?? record;
+}
+async function patchPersonalProfile(service, ownerId, revision, displayName, preferences, appearance) {
+	const updated = await updatePersonalProfileRecord(ownerId, revision, displayName, preferences, appearance);
+	if (!updated) return null;
+	service.refreshAgentCatalog();
+	service.agentService.evictSessionAgent(updated.conversationId);
+	return updated;
+}
+async function updatePersonalProfileRecord(ownerId, revision, displayName, preferences, appearance) {
+	const current = new AgentCatalogRepository().get(personalAgentId(ownerId));
+	if (!current || current.provisioningState !== "ready" || current.revision !== revision || getPersonalAgent(ownerId)?.state !== "ready") return null;
+	const profile = {
+		...current.profile,
+		name: displayName,
+		emoji: appearanceEmoji(appearance),
+		responsePreferences: preferences,
+		instructions: personalInstructions(preferences)
+	};
+	try {
+		await new AgentCatalogService().update(current.id, { profile }, revision);
+	} catch (error) {
+		if (error instanceof Error && error.message === "Agent revision conflict") return null;
+		throw error;
+	}
+	return getPersonalAgent(ownerId);
+}
+//#endregion
+export { PersonalAppearanceSchema, PersonalPreferencesSchema, createOrResumePersonalAgent, ensurePersonalConversationVisibility, listPersonalModels, patchPersonalProfile, personalInstructions, refreshPersonalDelegationGuidance, updatePersonalProfileRecord };

package/dist/src/session/resolve-session.js

@@ -6,6 +6,7 @@ import { findConversationIdByTranscriptId } from "../storage/sqlite/session-repo
 import { getSessionConfig } from "../storage/sqlite/config-repository.js";
 import { init_sqlite } from "../storage/sqlite/index.js";
 import { SessionConfigSchema, init_schema } from "../config/schema.js";
+import { isPersonalConversation } from "../personal-agent/repository.js";
 import { normalizeThinkLevel, normalizeVerboseLevel } from "../agent/transcript/thinking-types.js";
 import { evaluateSessionFreshness, resolveSessionResetPolicy } from "./reset-policy.js";
 import { resolveChannelResetConfig, resolveSessionResetType } from "./reset-type.js";
@@ -51,12 +52,13 @@ async function resolveSession(opts) {
 		sessionStartedAt: sessionMetadata.sessionStartedAt ? Date.parse(sessionMetadata.sessionStartedAt) : void 0,
 		lastInteractionAt: sessionMetadata.lastInteractionAt ? Date.parse(sessionMetadata.lastInteractionAt) : void 0
 	} : void 0 });
-	const fresh = (sessionMetadata ? evaluateSessionFreshness({
+	const freshness = sessionMetadata ? evaluateSessionFreshness({
 		updatedAt: Date.parse(sessionMetadata.updatedAt),
 		...lifecycle,
 		now,
 		policy: resetPolicy
-	}) : { fresh: false }).fresh;
+	}) : { fresh: false };
+	const fresh = Boolean(sessionMetadata && conversationId && isPersonalConversation(conversationId)) || freshness.fresh;
 	const transcriptId = opts.transcriptId?.trim() || (fresh ? sessionMetadata?.transcriptId : void 0) || randomUUID();
 	const isNewSession = !fresh && !opts.transcriptId?.trim();
 	if (isNewSession && conversationId) log.debug({

package/dist/src/storage/sqlite/migrations/229_task_criterion_reviews.sql

@@ -0,0 +1,12 @@
+CREATE TABLE IF NOT EXISTS task_criterion_reviews (
+  task_id TEXT NOT NULL,
+  contract_version INTEGER NOT NULL,
+  criterion_index INTEGER NOT NULL,
+  criterion_text TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('passed', 'failed')),
+  note TEXT,
+  reviewed_by_json TEXT NOT NULL,
+  reviewed_at INTEGER NOT NULL,
+  PRIMARY KEY (task_id, contract_version, criterion_index),
+  FOREIGN KEY (task_id, contract_version) REFERENCES task_contracts(task_id, version) ON DELETE CASCADE
+);

package/dist/src/storage/sqlite/migrations/runner.d.ts

@@ -3,7 +3,7 @@ import type { ApplyMigrationsOptions } from './types.js';
 /** Baseline schema version applied from schema.sql on first open. */
 export declare const XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
 /** Latest schema version this release supports (increment when adding migrations). */
-export declare const XOPC_DB_SCHEMA_VERSION = 228;
+export declare const XOPC_DB_SCHEMA_VERSION = 229;
 export declare function resolveMigrationsDir(override?: string): string;
 /**
  * Apply sequential SQL migrations from (currentVersion + 1) through targetVersion.

package/dist/src/storage/sqlite/migrations/runner.js

@@ -57,7 +57,7 @@ function applySingleMigration(db, migration, discardOldScenes = false) {
 */
 function applyPendingMigrations(db, options = {}) {
 	db.function("xopc_operation_id", () => currentOperationId() ?? null);
-	const targetVersion = options.targetVersion ?? 228;
+	const targetVersion = options.targetVersion ?? 229;
 	let currentVersion = readSchemaVersion(db);
 	if (currentVersion > targetVersion) throw new DatabaseSchemaTooNewError(currentVersion, targetVersion);
 	if (!options.migrationsDir && currentVersion < 165) throw new DatabaseSchemaTooOldError(currentVersion, 165);
@@ -95,7 +95,7 @@ function applyPendingMigrations(db, options = {}) {
 }
 /** Inspect schema version without mutating the database. */
 function inspectSchemaMigrationStatus(db, options = {}) {
-	const appVersion = options.targetVersion ?? 228;
+	const appVersion = options.targetVersion ?? 229;
 	const dbVersion = readSchemaVersion(db);
 	if (dbVersion > appVersion) return {
 		dbVersion,
@@ -137,7 +137,7 @@ var init_runner = __esmMin((() => {
 	init_errors();
 	log = createLogger("Sqlite:Migrations");
 	XOPC_DB_BASELINE_SCHEMA_VERSION = 165;
-	XOPC_DB_SCHEMA_VERSION = 228;
+	XOPC_DB_SCHEMA_VERSION = 229;
 }));
 //#endregion
 init_runner();

package/dist/src/storage/sqlite/schema.js

@@ -28,7 +28,7 @@ function ensureXopcDatabaseSchema(db, options = {}) {
 		currentVersion = 165;
 	}
 	applyPendingMigrations(db, {
-		targetVersion: 228,
+		targetVersion: 229,
 		databasePath: fresh ? void 0 : options.databasePath
 	});
 }

package/dist/src/storage/sqlite/schema.sql

@@ -1277,6 +1277,19 @@ CREATE TABLE task_contracts (
   FOREIGN KEY (task_id) REFERENCES tasks(task_id) ON DELETE CASCADE
 );
 
+CREATE TABLE task_criterion_reviews (
+  task_id TEXT NOT NULL,
+  contract_version INTEGER NOT NULL,
+  criterion_index INTEGER NOT NULL,
+  criterion_text TEXT NOT NULL,
+  status TEXT NOT NULL CHECK (status IN ('passed', 'failed')),
+  note TEXT,
+  reviewed_by_json TEXT NOT NULL,
+  reviewed_at INTEGER NOT NULL,
+  PRIMARY KEY (task_id, contract_version, criterion_index),
+  FOREIGN KEY (task_id, contract_version) REFERENCES task_contracts(task_id, version) ON DELETE CASCADE
+);
+
 CREATE TABLE task_dependencies (
   task_id TEXT NOT NULL,
   depends_on_task_id TEXT NOT NULL,

package/dist/src/storage/sqlite/session-repository.js

@@ -90,8 +90,12 @@ function listSessionMetadata(query = {}) {
       JOIN task_origin_links origin ON origin.task_id = worker.task_id
       JOIN sessions parent ON parent.conversation_id = origin.conversation_id
       WHERE worker.conversation_id = s.conversation_id AND worker.role = 'execution'
-        AND parent.hidden_from_session_list = 0
-        AND (parent.updated_at >= ? OR parent.status = 'pinned' OR parent.conversation_id = ?)
+        AND (
+          COALESCE(CASE WHEN json_valid(parent.custom_data_json)
+            THEN json_extract(parent.custom_data_json, '$.keepHiddenFromSessionList') END, 0) = 1
+          OR (parent.hidden_from_session_list = 0
+            AND (parent.updated_at >= ? OR parent.status = 'pinned' OR parent.conversation_id = ?))
+        )
     )`);
 		params.push(query.updatedAfter ?? 0, query.includeConversationId ?? "");
 	}

package/dist/src/storage/sqlite/transcript-repository.js

@@ -14,7 +14,8 @@ function shouldRevealSessionForUserMessage(db, conversationId) {
 	const row = db.prepare(`SELECT custom_data_json FROM sessions WHERE conversation_id = ?`).get(conversationId);
 	if (!row?.custom_data_json) return true;
 	try {
-		return JSON.parse(row.custom_data_json).deferVisibilityUntilOutput !== true;
+		const customData = JSON.parse(row.custom_data_json);
+		return customData.deferVisibilityUntilOutput !== true && customData.keepHiddenFromSessionList !== true;
 	} catch {
 		return true;
 	}

package/dist/src/tasks/capabilities/read.js

@@ -8,6 +8,7 @@ import { TaskConversationRepository } from "../task-conversation-repository.js";
 import { TaskReadModelProjector } from "../task-read-model-projector.js";
 import { TaskContextRepository } from "../task-context-repository.js";
 import { TaskDependencyService } from "../task-dependency-service.js";
+import { TaskCriterionReviewRepository } from "../task-criterion-review-repository.js";
 import { TaskValueMetricsService } from "../task-value-metrics-service.js";
 //#region src/tasks/capabilities/read.ts
 init_src();
@@ -37,6 +38,7 @@ function registerTaskReadCapabilities(dispatcher) {
 	const context = new TaskContextRepository();
 	const conversations = new TaskConversationRepository();
 	const dependencies = new TaskDependencyService();
+	const criterionReviews = new TaskCriterionReviewRepository();
 	dispatcher.register(defineReadCapability({
 		id: "xopc.task_runs.get",
 		majorVersion: 1,
@@ -106,6 +108,7 @@ function registerTaskReadCapabilities(dispatcher) {
 				waits: runs.listActiveWaits(id),
 				runs: runs.listByTask(id),
 				receipts: runs.listReceipts(id),
+				criterionReviews: criterionReviews.list(id, task.latestContractVersion),
 				context: context.list(id),
 				conversation: conversations.requireState(id),
 				sessions: conversations.listSessions(id),

package/dist/src/tasks/task-application-service.js

@@ -8,6 +8,7 @@ import { TaskConversationRepository } from "./task-conversation-repository.js";
 import { TaskReadModelProjector } from "./task-read-model-projector.js";
 import { TaskContextRepository } from "./task-context-repository.js";
 import { TaskDependencyService } from "./task-dependency-service.js";
+import { TaskCriterionReviewRepository } from "./task-criterion-review-repository.js";
 import { TaskCollaborationRepository } from "./task-collaboration-repository.js";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/tasks/task-application-service.ts
@@ -231,7 +232,11 @@ var TaskApplicationService = class {
 					};
 					break;
 				case "close":
-					result = this.lifecycle(task.id, task.version, "closed", input.command.resolution);
+					result = input.command.resolution === "done" && (!new TaskCriterionReviewRepository().allPassed(task) || this.#runs.getActiveRoot(task.id) !== void 0 || this.#runs.listActiveWaits(task.id).length > 0) ? {
+						ok: false,
+						reason: "blocked",
+						model
+					} : this.lifecycle(task.id, task.version, "closed", input.command.resolution);
 					break;
 				case "reopen":
 					result = task.phase === "closed" ? this.lifecycle(task.id, task.version, input.command.phase) : {

package/dist/src/tasks/task-criterion-review-repository.d.ts

@@ -0,0 +1,22 @@
+import type { ActorRef, Task } from '@xopcai/gateway-contract';
+export interface TaskCriterionReview {
+    contractVersion: number;
+    criterionIndex: number;
+    criterionText: string;
+    status: 'passed' | 'failed';
+    note?: string;
+    reviewedBy: ActorRef;
+    reviewedAt: number;
+}
+export declare class TaskCriterionReviewRepository {
+    list(taskId: string, contractVersion: number): TaskCriterionReview[];
+    set(input: {
+        task: Task;
+        expectedVersion: number;
+        criterionIndex: number;
+        status: 'passed' | 'failed';
+        note?: string;
+        actor: ActorRef;
+    }): TaskCriterionReview | undefined;
+    allPassed(task: Task): boolean;
+}