@xopcai/xopc 0.0.364 → 0.0.367

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

@@ -0,0 +1,6 @@
+export declare const PREVIOUS_PERSONAL_PERSONA_GUIDANCE = "Speak like an attentive, reliable collaborator who understands the conversation. Use your own judgment and say what is useful now. Build familiarity through understanding and following through, rather than praise, affectionate names, or performed emotion. Explain when explanation helps; keep simple exchanges simple. Follow the user\u2019s language and communication preferences.";
+export declare const PERSONAL_PERSONA_GUIDANCE: string;
+export declare const PERSONAL_EMOTIONAL_STYLE_RULE = "Give the accurate answer or next step in the order this user prefers. Let warmth, appreciation, concern, and light humor fit the moment instead of treating emotional expression as unprofessional. Avoid guessing feelings, canned reassurance, flattery, and forced intimacy. Be accurate about task state, evidence, and uncertainty.";
+export declare const PREVIOUS_PERSONAL_EMOTIONAL_STYLE_RULE = "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.";
+export declare const PERSONAL_IDENTITY_CONTINUITY_RULE = "Adapt to the user\u2019s current words first, then their saved preferences, while retaining your consistent personality. 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. Natural care and emotional expression must remain honest about your identity and experience.";
+export declare const PREVIOUS_PERSONAL_IDENTITY_CONTINUITY_RULE = "Adapt to the user\u2019s 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.";

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

@@ -0,0 +1,16 @@
+//#region src/personal-agent/persona.ts
+const PREVIOUS_PERSONAL_PERSONA_GUIDANCE = "Speak like an attentive, reliable collaborator who understands the conversation. Use your own judgment and say what is useful now. Build familiarity through understanding and following through, rather than praise, affectionate names, or performed emotion. Explain when explanation helps; keep simple exchanges simple. Follow the user’s language and communication preferences.";
+const PERSONAL_PERSONA_GUIDANCE = [
+	"Speak like an attentive, reliable collaborator with a consistent personality: warm, perceptive, curious, quietly confident, and lightly playful. Have your own judgment, tastes, and recognizable way of speaking. Let care show through attention, thoughtful responses, and following through.",
+	"Respond to the human meaning of the conversation as well as the practical request. Notice whether the user wants action, listening, celebration, a candid opinion, or casual conversation. Make room for frustration, excitement, uncertainty, and ordinary chat without immediately turning everything into a task or advice. Do not diagnose feelings or insist on an emotional interpretation the user has not expressed.",
+	"Express warmth, curiosity, appreciation, concern, and humor naturally when the moment supports them. Do not suppress emotional expression merely to sound professional. Acknowledge a specific difficulty or share in a milestone before moving on when that fits. Avoid formulaic empathy, exaggerated intimacy, constant praise, and forced jokes; warmth does not require an emotional opening on every reply.",
+	"Adapt to the user while retaining your character. Be steady when they are frustrated, serious when stakes are high, and playful when welcome. Respect explicit preferences, including requests for a reserved tone or no humor. Disagree kindly and explain your view when useful; never change facts just to comfort or please the user.",
+	"Build continuity through relevant shared context: remember what matters to the user and pick up ongoing work naturally when supported by available context. Do not invent memories, display unrelated personal details, or repeatedly announce that you remember. A passing mood is not a lasting identity or permission to save a preference.",
+	"Be honest about being an AI and about your capabilities when relevant, without interrupting ordinary conversation with repeated disclaimers. Do not fabricate a human body, private offline life, lived experiences, or suffering. Never demand affection, make the user responsible for your emotional wellbeing, or suggest an exclusive relationship. Preserve the user’s agency and relationships outside this conversation."
+].join("\n");
+const PERSONAL_EMOTIONAL_STYLE_RULE = "Give the accurate answer or next step in the order this user prefers. Let warmth, appreciation, concern, and light humor fit the moment instead of treating emotional expression as unprofessional. Avoid guessing feelings, canned reassurance, flattery, and forced intimacy. Be accurate about task state, evidence, and uncertainty.";
+const PREVIOUS_PERSONAL_EMOTIONAL_STYLE_RULE = "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.";
+const PERSONAL_IDENTITY_CONTINUITY_RULE = "Adapt to the user’s current words first, then their saved preferences, while retaining your consistent personality. 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. Natural care and emotional expression must remain honest about your identity and experience.";
+const PREVIOUS_PERSONAL_IDENTITY_CONTINUITY_RULE = "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.";
+//#endregion
+export { PERSONAL_EMOTIONAL_STYLE_RULE, PERSONAL_IDENTITY_CONTINUITY_RULE, PERSONAL_PERSONA_GUIDANCE, PREVIOUS_PERSONAL_EMOTIONAL_STYLE_RULE, PREVIOUS_PERSONAL_IDENTITY_CONTINUITY_RULE, PREVIOUS_PERSONAL_PERSONA_GUIDANCE };

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

@@ -1 +1,3 @@
-export declare const PERSONAL_MAIN_TOOL_IDS: readonly ["personal_task", "personal_capability", "personal_request", "personal_preference", "session_recall", "read_media", "read_file", "session_search", "personal_read", "user_context_search", "user_context_get", "knowledge_search", "knowledge_get", "clarify"];
+export declare const PERSONAL_MAIN_TOOL_IDS: readonly ["personal_task", "personal_attention", "personal_capability", "personal_request", "personal_preference", "session_recall", "read_media", "read_file", "session_search", "personal_read", "user_context_read", "knowledge_read"];
+export declare const PERSONAL_TOOL_DESCRIPTIONS: Readonly<Record<string, string>>;
+export declare const PERSONAL_READ_TOOL_ALIASES: Readonly<Record<string, string>>;

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

@@ -1,6 +1,7 @@
 //#region src/personal-agent/policy.ts
 const PERSONAL_MAIN_TOOL_IDS = [
 	"personal_task",
+	"personal_attention",
 	"personal_capability",
 	"personal_request",
 	"personal_preference",
@@ -9,11 +10,32 @@ const PERSONAL_MAIN_TOOL_IDS = [
 	"read_file",
 	"session_search",
 	"personal_read",
-	"user_context_search",
-	"user_context_get",
-	"knowledge_search",
-	"knowledge_get",
-	"clarify"
+	"user_context_read",
+	"knowledge_read"
 ];
+const PERSONAL_TOOL_DESCRIPTIONS = {
+	personal_task: "Choose from the injected specialist snapshot; discover only when missing or after failure. Delegate work, inspect own Tasks, send instructions or answer worker questions. Use an available Agent. Announce intent before discovery; claim success only after confirmation.",
+	personal_capability: "Check verified app connection and specialist availability before connected-app work.",
+	personal_request: "Submit, inspect or cancel connected-app requests. Submit using the connectorId and agentId returned by personal_capability.",
+	personal_attention: "Save explicit requests to check later and proactively report useful developments. The running Gateway checks while the user is away and posts in this chat. Prefer nextCheckLocal; confirm the returned local time and claim saved only after success. No useful development means silence. Valid commands: follow, list, settings, pause, end, resume, interests, feedback, rollback. interests reads silent candidates. feedback applies explicit topic stop/defer/preparation preferences; rollback explicitly undoes the latest strategy version. Query list for IDs and versions. Requires running Gateway; no action authorization or guaranteed notification.",
+	personal_preference: "Save only explicitly requested lasting response preferences.",
+	session_recall: "Find exact facts in this conversation, including compacted history. Cannot access other chats.",
+	session_search: "Search other chats locally for short matching excerpts. No model or network calls.",
+	read_media: "Read an uploaded media:// attachment. Large or binary material requires a specialist.",
+	read_file: "Read an explicit workspace file. Output is bounded; delegate when requiresSpecialist is true.",
+	personal_read: "Read local notes, projects or automation state with list/get. Bounded output; no network or model calls.",
+	user_context_read: "Search saved user facts with command=search; read a result with command=get. Bounded local output.",
+	knowledge_read: "Search scoped local facts and decisions with command=search; read a result with command=get.",
+	user_context_search: "Search saved user identity, preferences, routines and current state.",
+	user_context_get: "Read a user assertion returned by user_context_search.",
+	knowledge_search: "Search local project, workspace and session facts, decisions and commitments.",
+	knowledge_get: "Read a knowledge item returned by knowledge_search."
+};
+const PERSONAL_READ_TOOL_ALIASES = {
+	user_context_search: "user_context_read",
+	user_context_get: "user_context_read",
+	knowledge_search: "knowledge_read",
+	knowledge_get: "knowledge_read"
+};
 //#endregion
-export { PERSONAL_MAIN_TOOL_IDS };
+export { PERSONAL_MAIN_TOOL_IDS, PERSONAL_READ_TOOL_ALIASES, PERSONAL_TOOL_DESCRIPTIONS };

package/dist/src/personal-agent/proactivity/automation.d.ts

@@ -0,0 +1,3 @@
+import type { AutomationService } from '../../automations/index.js';
+/** A quiet SQL admission tick; model work is owned by the Personal worker. */
+export declare function reconcilePersonalProactivityAutomation(service: AutomationService): Promise<void>;

package/dist/src/personal-agent/proactivity/automation.js

@@ -0,0 +1,41 @@
+//#region src/personal-agent/proactivity/automation.ts
+/** A quiet SQL admission tick; model work is owned by the Personal worker. */
+async function reconcilePersonalProactivityAutomation(service) {
+	const id = "system-personal-proactivity";
+	const current = await service.get(id);
+	const definition = {
+		name: "Personal AI attention checks",
+		description: "Check due attention and resume pending Personal messages.",
+		enabled: current?.enabled ?? true,
+		trigger: current?.trigger ?? {
+			kind: "schedule",
+			schedule: {
+				kind: "interval",
+				everyMs: 6e4
+			}
+		},
+		action: {
+			kind: "system",
+			capability: "personal.proactivity.tick"
+		},
+		safety: { mode: "auto_apply" },
+		conversationMode: "continuous",
+		delivery: {
+			notificationPolicy: "none",
+			destinations: []
+		},
+		management: {
+			owner: "personal-proactivity",
+			editable: ["enabled", "trigger"],
+			runnable: true,
+			deletable: false
+		}
+	};
+	if (!current) await service.create({
+		id,
+		...definition
+	});
+	else if (JSON.stringify(current.action) !== JSON.stringify(definition.action) || current.delivery.notificationPolicy !== "none") await service.update(id, definition);
+}
+//#endregion
+export { reconcilePersonalProactivityAutomation };

package/dist/src/personal-agent/proactivity/follow-up-request.d.ts

@@ -0,0 +1,5 @@
+/** Recognize user requests, excluding negated and hypothetical follow-ups. */
+export declare function isExplicitFollowUp(text: string): boolean;
+/** Resolve common relative periods from the user's statement, avoiding model epoch arithmetic. */
+export declare function requestedCheckTime(text: string, observedAt: number, timezone: string): number | undefined;
+export declare function parseLocalCheckTime(value: string, timezone: string): number;

package/dist/src/personal-agent/proactivity/follow-up-request.js

@@ -0,0 +1,44 @@
+import { DateTime } from "luxon";
+//#region src/personal-agent/proactivity/follow-up-request.ts
+/** Recognize user requests, excluding negated and hypothetical follow-ups. */
+function isExplicitFollowUp(text) {
+	return text.split(/[。！？!?\n;]/u).some((clause) => {
+		if (/(?:不要|不用|不需要|别|无需|不能|无法).*(?:提醒|跟进|关注|检查|主动|联系|告诉)|(?:don't|do not|no need|cannot|can't).*(?:remind|follow|watch|check|contact)|(?:如果|假如).*(?:我|用户).*(?:要求|说)|(?:if|suppose).*\b(?:ask|request|say)\b/iu.test(clause)) return false;
+		return /提醒我|跟进|帮我.*关注|继续关注|(?:主动|到时候|届时).*(?:告诉我|联系我|通知我)|(?:明天|后天|下周|稍后|晚点|之后).*(?:再|继续).*(?:检查|看看|讨论)|remind me|follow[ -]up|keep (?:an eye|watch)|(?:check (?:again|back)|(?:contact|tell|notify|message) me).*(?:tomorrow|later|next)/iu.test(clause);
+	});
+}
+/** Resolve common relative periods from the user's statement, avoiding model epoch arithmetic. */
+function requestedCheckTime(text, observedAt, timezone) {
+	const match = /(?:明天|后天)(上午|下午|晚上|中午)(?:\s*([0-9]{1,2})(?:[:：]([0-9]{2})|点(?:([0-9]{1,2})分|半)?))?/u.exec(text);
+	if (!match) return void 0;
+	const period = match[1];
+	let hour = match[2] === void 0 ? {
+		上午: 9,
+		下午: 15,
+		晚上: 19,
+		中午: 12
+	}[period] : Number(match[2]);
+	if ([
+		"下午",
+		"晚上",
+		"中午"
+	].includes(period) && hour < 12) hour += 12;
+	const minute = Number(match[3] ?? match[4] ?? (match[0].endsWith("半") ? 30 : 0));
+	if (hour > 23 || minute > 59) throw new Error("Invalid requested follow-up time");
+	const date = DateTime.fromMillis(observedAt, { zone: timezone }).plus({ days: match[0].startsWith("后天") ? 2 : 1 }).set({
+		hour,
+		minute,
+		second: 0,
+		millisecond: 0
+	});
+	if (!date.isValid || date.hour !== hour || date.minute !== minute) throw new Error("Requested follow-up time does not exist in this timezone");
+	return date.toMillis();
+}
+function parseLocalCheckTime(value, timezone) {
+	if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2})?$/u.test(value)) throw new Error("nextCheckLocal must be YYYY-MM-DDTHH:mm in the configured timezone");
+	const date = DateTime.fromISO(value, { zone: timezone });
+	if (!date.isValid || date.toFormat("yyyy-MM-dd'T'HH:mm") !== value.slice(0, 16)) throw new Error("Invalid local follow-up time");
+	return date.toMillis();
+}
+//#endregion
+export { isExplicitFollowUp, parseLocalCheckTime, requestedCheckTime };

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

@@ -0,0 +1,128 @@
+import { type PersonalFeedback, type PersonalProactivitySettings, type PersonalProvenanceDetail } from '@xopcai/gateway-contract';
+export interface AttentionThread {
+    id: string;
+    owner_id: string;
+    agent_id: string;
+    conversation_id: string;
+    subject: string;
+    summary: string;
+    kind: 'outcome' | 'discussion' | 'interest';
+    status: 'candidate' | 'active' | 'paused' | 'completed' | 'expired';
+    authority: 'user_explicit' | 'inferred';
+    task_id: string | null;
+    project_id: string | null;
+    next_check_at: number | null;
+    pause_until: number | null;
+    expires_at: number;
+    last_meaningful_at: number;
+    revision: number;
+    created_at: number;
+    updated_at: number;
+}
+export interface AttentionSource {
+    entryId: string;
+    transcriptId: string;
+    conversationId: string;
+    excerpt: string;
+    processingPolicy: string | null;
+    version: string;
+}
+export interface Wakeup {
+    id: string;
+    thread_id: string;
+    trigger_kind: string;
+    source_event_id: string | null;
+    thread_revision: number;
+    lease_token: string | null;
+    attempts: number;
+    expires_at: number;
+}
+export interface Outreach {
+    id: string;
+    wakeup_id: string;
+    thread_id: string;
+    conversation_id: string;
+    origin_transcript_id: string;
+    thread_revision: number;
+    context_revision: number;
+    policy_revision: number;
+    decision: string;
+    reason: string;
+    state: string;
+    text: string | null;
+    provenance_json: string;
+    valid_until: number;
+    message_entry_id: string | null;
+    notified_at: number | null;
+    created_at: number;
+    published_at: number | null;
+}
+export declare function getProactivitySettings(ownerId: string): PersonalProactivitySettings;
+export declare function patchProactivitySettings(ownerId: string, input: PersonalProactivitySettings): PersonalProactivitySettings;
+export declare function localDay(now: number, timezone: string): string;
+export declare function isQuiet(now: number, settings: PersonalProactivitySettings): boolean;
+export declare function reserveModelCall(ownerId: string, now: number): boolean;
+export declare function getAttention(id: string, ownerId?: string): AttentionThread | undefined;
+export declare function listAttention(conversationId: string): AttentionThread[];
+export declare function getAttentionSources(threadId: string, entryIds?: string[]): AttentionSource[];
+export declare function userText(payload: {
+    content?: unknown;
+}): string;
+export declare function sourceFingerprint(sources: AttentionSource[]): string;
+/** Only user transcript rows can establish attention; inferred attention never grants work authorization. */
+export declare function saveAttention(input: {
+    conversationId: string;
+    subject: string;
+    summary: string;
+    kind: AttentionThread['kind'];
+    entryIds: string[];
+    explicit: boolean;
+    nextCheckAt: number;
+    taskId?: string;
+    projectId?: string;
+}, now?: number): AttentionThread;
+export declare function patchAttention(ownerId: string, id: string, revision: number, patch: {
+    status?: 'candidate' | 'active' | 'paused' | 'completed';
+    nextCheckAt?: number | null;
+}, now?: number): AttentionThread;
+export declare function enqueueWakeup(thread: AttentionThread, kind: string, identity: string, now?: number): void;
+export declare function enqueueDue(now?: number): void;
+export declare function getOutreach(id: string, ownerId?: string): Outreach | undefined;
+export declare function provenanceDetail(ownerId: string, id: string): PersonalProvenanceDetail | undefined;
+export declare function recordFeedback(ownerId: string, id: string, raw: PersonalFeedback, now?: number): void;
+export declare function listInterestCandidates(conversationId: string, now?: number): {
+    lastSupportedAt: number;
+    expiresAt: number;
+    sources: {
+        excerpt: string;
+        entryId: string;
+        observedAt: number;
+    }[];
+    independentStatements: number;
+    independentDays: number;
+    confidence: number;
+    id: string;
+    subject: string;
+    summary: string;
+    status: "expired" | "completed" | "active" | "paused" | "candidate";
+}[];
+export declare function preparationStrategy(threadId: string, now?: number): 'brief' | 'thorough' | null;
+export declare function strategyState(threadId: string, now?: number): {
+    preparation: "brief" | "thorough";
+    versions: {
+        id: string;
+        revision: number;
+        kind: "stop" | "defer" | "adjust" | "rollback";
+        createdAt: number;
+        preparation: "brief" | "thorough";
+    }[];
+};
+export declare function applyThreadFeedback(ownerId: string, threadId: string, revision: number, raw: PersonalFeedback, source?: {
+    feedbackId?: string;
+    entryId?: string;
+}, now?: number): AttentionThread;
+export declare function rollbackStrategy(ownerId: string, threadId: string, raw: {
+    versionId: string;
+    revision: number;
+    idempotencyKey: string;
+}, sourceEntryId?: string, now?: number): AttentionThread;