@aigne/afs-persona 1.11.0-beta.10

package/dist/index.mjs

@@ -0,0 +1,987 @@
+import { PersonaDB } from "./db.mjs";
+import { __decorate } from "./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { readdir } from "node:fs/promises";
+import { resolve } from "node:path";
+import { AFSBaseProvider, Actions, Explain, List, Meta, Read, Stat } from "@aigne/afs";
+import { zodParse } from "@aigne/afs/utils/zod";
+import { joinURL } from "ufo";
+import { parse, stringify } from "yaml";
+import { z } from "zod";
+
+//#region src/index.ts
+const personaOptionsSchema = z.object({
+	name: z.string().optional(),
+	description: z.string().optional(),
+	accessMode: z.enum(["readonly", "readwrite"]).optional(),
+	dataDir: z.string().describe("Root data directory for persona storage"),
+	database: z.string().optional().describe("SQLite database path (defaults to dataDir/persona.db)"),
+	model: z.string().optional().describe("Default LLM model path for ASH agent-run"),
+	ashPath: z.string().optional().describe("ASH provider mount path"),
+	tickInterval: z.number().positive().optional().describe("Tick interval in milliseconds"),
+	safety: z.object({
+		blocked_keywords: z.array(z.string()).optional(),
+		review_mode: z.enum(["auto", "manual"]).optional()
+	}).optional()
+});
+const INVALID_NAME_PATTERN = /[/\\]/;
+const MAX_NAME_LENGTH = 64;
+function validateCharacterName(name) {
+	if (typeof name !== "string" || name.length === 0) return {
+		valid: false,
+		reason: "Character name must be a non-empty string"
+	};
+	if (name === "." || name === "..") return {
+		valid: false,
+		reason: "Character name cannot be . or .."
+	};
+	if (name.includes("..")) return {
+		valid: false,
+		reason: "Character name cannot contain path traversal"
+	};
+	if (INVALID_NAME_PATTERN.test(name)) return {
+		valid: false,
+		reason: "Character name cannot contain / or \\"
+	};
+	if (name.length > MAX_NAME_LENGTH) return {
+		valid: false,
+		reason: `Character name cannot exceed ${MAX_NAME_LENGTH} characters`
+	};
+	return { valid: true };
+}
+const WORKSPACE_TOML_TEMPLATE = `[[mounts]]
+path = "/profile"
+uri = "json://./profile.yaml"
+access_mode = "readwrite"
+
+[[mounts]]
+path = "/browser"
+uri = "mcp+stdio://npx @anthropic-ai/mcp-server-playwright"
+[mounts.options]
+userDataDir = "./browser"
+
+[[mounts]]
+path = "/data"
+uri = "fs://./data"
+access_mode = "readwrite"
+`;
+var AFSPersonaProvider = class AFSPersonaProvider extends AFSBaseProvider {
+	name;
+	description;
+	accessMode;
+	dataDir;
+	database;
+	model;
+	ashPath;
+	tickInterval;
+	safety;
+	afs;
+	db;
+	tickTimer;
+	destroyed = false;
+	constructor(options) {
+		super();
+		const validated = personaOptionsSchema.parse(options);
+		this.name = validated.name || "persona";
+		this.description = validated.description || "Virtual persona management";
+		this.accessMode = validated.accessMode || "readwrite";
+		this.dataDir = resolve(validated.dataDir);
+		this.database = validated.database || resolve(this.dataDir, "persona.db");
+		this.model = validated.model || "/modules/aignehub/defaults/chat";
+		this.ashPath = validated.ashPath || "/modules/ash";
+		this.tickInterval = validated.tickInterval || 300 * 1e3;
+		this.safety = validated.safety || {};
+		if (!existsSync(this.dataDir)) mkdirSync(this.dataDir, { recursive: true });
+	}
+	static schema() {
+		return personaOptionsSchema;
+	}
+	static checkKeywords(content, keywords) {
+		if (!content || keywords.length === 0) return { blocked: false };
+		const lowerContent = content.toLowerCase();
+		for (const keyword of keywords) if (lowerContent.includes(keyword.toLowerCase())) return {
+			blocked: true,
+			keyword
+		};
+		return { blocked: false };
+	}
+	loadBlockedKeywords() {
+		const entries = this.safety.blocked_keywords || [];
+		const keywords = [];
+		for (const entry of entries) {
+			const resolved = resolve(this.dataDir, entry);
+			if (!resolved.startsWith(`${this.dataDir}/`) && resolved !== this.dataDir) continue;
+			if (!existsSync(resolved)) continue;
+			const content = readFileSync(resolved, "utf-8");
+			for (const line of content.split("\n")) {
+				const trimmed = line.trim();
+				if (trimmed) keywords.push(trimmed);
+			}
+		}
+		return keywords;
+	}
+	static manifest() {
+		return {
+			name: "persona",
+			description: "Virtual persona manager — creates isolated character workspaces, drives session-based social media interaction via ASH agent-run.",
+			uriTemplate: "persona://{dataDir}",
+			category: "agent",
+			schema: z.object({
+				dataDir: z.string(),
+				database: z.string().optional(),
+				model: z.string().optional(),
+				ashPath: z.string().optional(),
+				tickInterval: z.number().optional()
+			}),
+			tags: [
+				"persona",
+				"social",
+				"agent",
+				"automation"
+			],
+			capabilityTags: ["read-write"],
+			security: {
+				riskLevel: "external",
+				resourceAccess: ["internet", "process-spawn"],
+				requires: ["sqlite"],
+				dataSensitivity: ["personal-data"],
+				notes: ["Automates social media interactions via Playwright browser"]
+			}
+		};
+	}
+	static treeSchema() {
+		return {
+			operations: [
+				"list",
+				"read",
+				"exec",
+				"stat",
+				"explain"
+			],
+			tree: {
+				"/": {
+					kind: "persona:root",
+					operations: ["list", "read"],
+					actions: [
+						"create-character",
+						"delete-character",
+						"tick",
+						"dispatch-task"
+					]
+				},
+				"/characters": {
+					kind: "persona:collection",
+					operations: ["list"]
+				},
+				"/characters/{name}": {
+					kind: "persona:character",
+					operations: [
+						"list",
+						"read",
+						"exec"
+					],
+					actions: [
+						"session",
+						"post",
+						"reply",
+						"pause",
+						"resume"
+					]
+				}
+			},
+			bestFor: [
+				"persona management",
+				"social media automation",
+				"character orchestration"
+			],
+			notFor: ["file storage", "databases"]
+		};
+	}
+	static async load({ basePath, config } = {}) {
+		return new AFSPersonaProvider(zodParse(personaOptionsSchema, config, { prefix: basePath }));
+	}
+	onMount(afs, _mountPath) {
+		this.afs = afs;
+		this.scheduleNextTick();
+	}
+	get charactersDir() {
+		return resolve(this.dataDir, "characters");
+	}
+	async getCharacterNames() {
+		if (!existsSync(this.charactersDir)) return [];
+		return (await readdir(this.charactersDir, { withFileTypes: true })).filter((e) => e.isDirectory()).map((e) => e.name);
+	}
+	characterDir(name) {
+		return resolve(this.charactersDir, name);
+	}
+	characterProfilePath(name) {
+		return resolve(this.characterDir(name), "profile.yaml");
+	}
+	readCharacterProfile(name) {
+		const profilePath = this.characterProfilePath(name);
+		if (!existsSync(profilePath)) return null;
+		return parse(readFileSync(profilePath, "utf-8"));
+	}
+	writeCharacterProfile(name, profile) {
+		writeFileSync(this.characterProfilePath(name), stringify(profile), "utf-8");
+	}
+	getDB() {
+		if (!this.db) this.db = new PersonaDB(this.database);
+		return this.db;
+	}
+	scheduleNextTick() {
+		if (this.destroyed) return;
+		this.tickTimer = setTimeout(async () => {
+			try {
+				await this.runTick();
+			} catch {}
+			this.scheduleNextTick();
+		}, this.tickInterval);
+	}
+	shouldStartSession(gap, offlineMinutes) {
+		const gapMin = gap[0] ?? 30;
+		const gapMax = gap[1] ?? 240;
+		if (offlineMinutes >= gapMax) return true;
+		if (offlineMinutes < gapMin) return false;
+		if (gapMax <= gapMin) return true;
+		const probability = (offlineMinutes - gapMin) / (gapMax - gapMin);
+		return Math.random() < probability;
+	}
+	async runTick(characterFilter) {
+		const db = this.getDB();
+		const stale_recovered = db.markStaleSessions(60);
+		const characterNames = characterFilter ? [characterFilter] : await this.getCharacterNames();
+		let sessions_started = 0;
+		for (const name of characterNames) {
+			const profile = this.readCharacterProfile(name);
+			if (!profile) continue;
+			if (profile.status === "paused") continue;
+			if (db.getRunningSession(name)) continue;
+			const lastDone = db.getLastDoneSession(name);
+			let offlineMinutes;
+			if (!lastDone || !lastDone.ended_at) offlineMinutes = Number.POSITIVE_INFINITY;
+			else {
+				const endedAt = new Date(lastDone.ended_at).getTime();
+				offlineMinutes = (Date.now() - endedAt) / (60 * 1e3);
+			}
+			const gap = Array.isArray(profile.gap) ? profile.gap : [30, 240];
+			if (!this.shouldStartSession(gap, offlineMinutes)) continue;
+			const sessionId = db.insertSession(name);
+			db.updateSession(sessionId, {
+				status: "done",
+				ended_at: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			sessions_started++;
+		}
+		return {
+			sessions_started,
+			stale_recovered
+		};
+	}
+	async runSessionSteps(name, profile, _sessionId) {
+		const db = this.getDB();
+		const platforms = profile.platforms || [];
+		const model = profile.model || this.model;
+		const recentInteractions = db.getRecentInteractions(name, 10);
+		let steps_completed = 0;
+		let interactions_saved = 0;
+		for (const platform of platforms) {
+			const steps = this.buildStepsForPlatform(name, platform);
+			for (const step of steps) {
+				const result = await this.executeStep(name, profile, platform, step, model, recentInteractions);
+				if (result.trace) try {
+					db.insertInteraction({
+						character: name,
+						platform,
+						type: step.name,
+						content: null,
+						metadata: {
+							step: step.name,
+							trace_rounds: Array.isArray(result.trace) ? result.trace.length : 0,
+							status: result.status
+						}
+					});
+					interactions_saved++;
+				} catch {}
+				if (result.status === "error") throw new Error(`Step '${step.name}' failed`);
+				if (result.status !== "budget_exhausted") steps_completed++;
+			}
+		}
+		return {
+			steps_completed,
+			interactions_saved
+		};
+	}
+	buildStepsForPlatform(name, platform) {
+		const db = this.getDB();
+		const steps = [{
+			name: "notifications",
+			platform,
+			budget: { max_rounds: 15 }
+		}, {
+			name: "browse",
+			platform,
+			budget: { max_rounds: 25 }
+		}];
+		if (Math.random() < .3) steps.push({
+			name: "post",
+			platform,
+			budget: { max_rounds: 20 }
+		});
+		const seededTopics = db.getSeededTopics(name, "pending");
+		for (const topic of seededTopics) if (db.claimSeededTopic(topic.id, topic.task_id)) steps.push({
+			name: "seeded_topic",
+			platform,
+			topic: topic.topic,
+			angle: topic.angle,
+			budget: { max_rounds: 20 }
+		});
+		return steps;
+	}
+	async executeStep(name, profile, platform, step, model, recentInteractions) {
+		const system = this.buildSystemPrompt(name, profile, platform, recentInteractions);
+		const tools = this.buildToolsWhitelist(name);
+		const task = this.buildStepTask(step, name, platform);
+		try {
+			const result = await this.afs.exec(joinURL(this.ashPath, ".actions/agent-run"), {
+				task,
+				model,
+				system,
+				tools,
+				budget: step.budget
+			}, {});
+			if (!result.success) return {
+				status: "error",
+				error: result.error?.message
+			};
+			const data = result.data || {};
+			const trace = data.trace;
+			if (data.status === "error") return {
+				status: "error",
+				error: String(data.message || "Unknown error"),
+				trace
+			};
+			if (data.status === "budget_exhausted") return {
+				status: "budget_exhausted",
+				trace
+			};
+			return {
+				status: "completed",
+				trace
+			};
+		} catch (e) {
+			return {
+				status: "error",
+				error: e instanceof Error ? e.message : "Unknown error"
+			};
+		}
+	}
+	buildSystemPrompt(name, profile, platform, recentInteractions) {
+		const personality = profile.personality || {};
+		const interests = profile.interests || [];
+		const parts = [];
+		parts.push(`你是 ${name}。${personality.tone || "neutral"}。`);
+		parts.push(`兴趣：${interests.map((i) => i.topic).join(", ") || "广泛"}。风格：${personality.style || "简洁"}。语言：${personality.language || "en"}。`);
+		if (recentInteractions.length > 0) {
+			parts.push("最近发过的内容：");
+			for (const interaction of recentInteractions.slice(0, 5)) parts.push(`- [${interaction.type}] ${interaction.content || "(no content)"}`);
+		}
+		parts.push(`当前平台：${platform}`);
+		return parts.join("\n");
+	}
+	buildToolsWhitelist(characterName) {
+		return [
+			{
+				path: `/modules/persona/characters/${characterName}/browser/tools/*`,
+				ops: ["exec"]
+			},
+			{
+				path: `/modules/persona/characters/${characterName}/browser/tools`,
+				ops: ["list"]
+			},
+			{
+				path: `/modules/persona/characters/${characterName}/profile/**`,
+				ops: ["read", "list"],
+				maxDepth: 3
+			},
+			{
+				path: `/modules/persona/characters/${characterName}/data/**`,
+				ops: [
+					"read",
+					"write",
+					"list"
+				],
+				maxDepth: 3
+			}
+		];
+	}
+	buildStepTask(step, name, platform) {
+		switch (step.name) {
+			case "notifications": return `Check notifications on ${platform} and reply to any mentions or messages as ${name}.`;
+			case "browse": return `Browse the ${platform} feed, engage with interesting posts that match your interests.`;
+			case "post": return `Create an original post on ${platform} about something you find interesting, in character as ${name}.`;
+			case "seeded_topic": return `Create a post on ${platform} about: ${step.topic}. ${step.angle ? `Angle: ${step.angle}.` : ""} Make it natural and in-character as ${name}.`;
+			default: return `Perform ${step.name} on ${platform} as ${name}.`;
+		}
+	}
+	buildActionEntry(name, description, basePath = "/") {
+		return {
+			id: name,
+			path: joinURL(basePath, ".actions", name),
+			summary: name,
+			meta: {
+				kind: "afs:executable",
+				name,
+				description
+			},
+			actions: [{
+				name,
+				description
+			}]
+		};
+	}
+	async listRoot(_ctx) {
+		return { data: [{
+			id: "persona:characters",
+			path: "/characters",
+			meta: {
+				kind: "persona:collection",
+				childrenCount: (await this.getCharacterNames()).length
+			}
+		}] };
+	}
+	async listCharacters(_ctx) {
+		return { data: (await this.getCharacterNames()).map((name) => ({
+			id: `persona:character:${name}`,
+			path: joinURL("/characters", name),
+			meta: {
+				kind: "persona:character",
+				childrenCount: -1
+			}
+		})) };
+	}
+	async readRoot(_ctx) {
+		return {
+			id: "persona:root",
+			path: "/",
+			content: {
+				type: "persona-provider",
+				characterCount: (await this.getCharacterNames()).length
+			},
+			meta: {
+				kind: "persona:root",
+				childrenCount: 1
+			}
+		};
+	}
+	async readCharacters(_ctx) {
+		const characterNames = await this.getCharacterNames();
+		return {
+			id: "persona:characters",
+			path: "/characters",
+			content: {
+				type: "directory",
+				count: characterNames.length
+			},
+			meta: {
+				kind: "persona:collection",
+				childrenCount: characterNames.length
+			}
+		};
+	}
+	async readCharacter(ctx) {
+		const name = ctx.params?.name;
+		const profile = this.readCharacterProfile(name);
+		if (!profile) throw new Error(`Character not found: ${name}`);
+		return {
+			id: `persona:character:${name}`,
+			path: joinURL("/characters", name),
+			content: profile,
+			meta: {
+				kind: "persona:character",
+				childrenCount: -1
+			}
+		};
+	}
+	async metaRoot(_ctx) {
+		return {
+			id: "persona:root",
+			path: "/.meta",
+			content: {
+				characterCount: (await this.getCharacterNames()).length,
+				provider: "persona"
+			},
+			meta: {
+				kind: "persona:root",
+				childrenCount: 1
+			}
+		};
+	}
+	async metaCharacters(_ctx) {
+		const characterNames = await this.getCharacterNames();
+		return {
+			id: "persona:characters",
+			path: "/characters/.meta",
+			content: {
+				type: "collection",
+				count: characterNames.length
+			},
+			meta: {
+				kind: "persona:collection",
+				childrenCount: characterNames.length
+			}
+		};
+	}
+	async readCapabilities(_ctx) {
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: "persona",
+				description: "Virtual persona management — character lifecycle, session scheduling, social media automation",
+				tools: [],
+				actions: [{
+					kind: "persona:root",
+					description: "Root-level persona management actions",
+					catalog: [
+						{
+							name: "create-character",
+							description: "Create a new character workspace",
+							inputSchema: {
+								type: "object",
+								properties: {
+									name: {
+										type: "string",
+										description: "Character name"
+									},
+									profile: {
+										type: "object",
+										description: "Character profile data"
+									}
+								},
+								required: ["name", "profile"]
+							}
+						},
+						{
+							name: "delete-character",
+							description: "Remove a character and optionally archive",
+							inputSchema: {
+								type: "object",
+								properties: {
+									name: { type: "string" },
+									archive: { type: "boolean" }
+								},
+								required: ["name"]
+							}
+						},
+						{
+							name: "tick",
+							description: "Check and run due sessions",
+							inputSchema: {
+								type: "object",
+								properties: { character: {
+									type: "string",
+									description: "Optional: tick single character"
+								} }
+							}
+						},
+						{
+							name: "dispatch-task",
+							description: "Seed topic into characters' feeds",
+							inputSchema: {
+								type: "object",
+								properties: {
+									topic: { type: "string" },
+									goal: { type: "string" }
+								},
+								required: ["topic", "goal"]
+							}
+						}
+					],
+					discovery: {
+						pathTemplate: "/.actions",
+						note: "Root actions for persona management"
+					}
+				}],
+				operations: {
+					list: true,
+					read: true,
+					write: false,
+					delete: false,
+					search: false,
+					exec: true,
+					stat: true,
+					explain: true
+				}
+			},
+			meta: { kind: "afs:capabilities" }
+		};
+	}
+	async statRoot(_ctx) {
+		return { data: {
+			id: "persona:root",
+			path: "/",
+			meta: {
+				kind: "persona:root",
+				childrenCount: 1
+			}
+		} };
+	}
+	async statCharacters(_ctx) {
+		return { data: {
+			id: "persona:characters",
+			path: "/characters",
+			meta: {
+				kind: "persona:collection",
+				childrenCount: (await this.getCharacterNames()).length
+			}
+		} };
+	}
+	async explainRoot(_ctx) {
+		return {
+			format: "markdown",
+			content: [
+				"# Persona Provider",
+				"",
+				"Manages virtual characters that autonomously interact on social platforms.",
+				"",
+				"## Actions",
+				"- `create-character` — Create a new character workspace",
+				"- `delete-character` — Remove a character and optionally archive",
+				"- `tick` — Check and run due sessions",
+				"- `dispatch-task` — Seed topic into characters' feeds",
+				"",
+				"## Structure",
+				"- `/characters/` — Character workspaces"
+			].join("\n")
+		};
+	}
+	async listRootActions(_ctx) {
+		return { data: [
+			this.buildActionEntry("create-character", "Create a new character workspace"),
+			this.buildActionEntry("delete-character", "Remove a character and optionally archive"),
+			this.buildActionEntry("tick", "Check and run due sessions"),
+			this.buildActionEntry("dispatch-task", "Seed topic into characters' feeds")
+		] };
+	}
+	async execCreateCharacter(_ctx, args) {
+		const nameResult = validateCharacterName(args.name);
+		if (!nameResult.valid) return {
+			success: false,
+			error: {
+				code: "INVALID_NAME",
+				message: nameResult.reason
+			}
+		};
+		const name = args.name;
+		const charDir = this.characterDir(name);
+		if (existsSync(charDir)) return {
+			success: false,
+			error: {
+				code: "ALREADY_EXISTS",
+				message: `Character '${name}' already exists`
+			}
+		};
+		mkdirSync(charDir, { recursive: true });
+		mkdirSync(resolve(charDir, "browser"), { recursive: true });
+		mkdirSync(resolve(charDir, "data"), { recursive: true });
+		const profileInput = args.profile || {};
+		const profile = {
+			name,
+			description: profileInput.description || "",
+			model: profileInput.model || void 0,
+			timezone: profileInput.timezone || "UTC",
+			gap: profileInput.gap || [30, 240],
+			platforms: profileInput.platforms || ["x"],
+			interests: profileInput.interests || [],
+			personality: profileInput.personality || {
+				tone: "neutral",
+				style: "concise",
+				language: "en"
+			},
+			reply_policy: profileInput.reply_policy || {
+				enabled: true,
+				max_daily: 10
+			},
+			status: "active"
+		};
+		this.writeCharacterProfile(name, profile);
+		writeFileSync(resolve(charDir, ".afs-workspace.toml"), WORKSPACE_TOML_TEMPLATE, "utf-8");
+		return {
+			success: true,
+			data: {
+				name,
+				path: joinURL("/characters", name)
+			}
+		};
+	}
+	async execDeleteCharacter(_ctx, args) {
+		const nameResult = validateCharacterName(args.name);
+		if (!nameResult.valid) return {
+			success: false,
+			error: {
+				code: "INVALID_NAME",
+				message: nameResult.reason
+			}
+		};
+		const name = args.name;
+		const charDir = this.characterDir(name);
+		if (!existsSync(charDir)) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Character '${name}' not found`
+			}
+		};
+		if (args.archive) {
+			const archiveDir = resolve(this.dataDir, "archive");
+			if (!existsSync(archiveDir)) mkdirSync(archiveDir, { recursive: true });
+			renameSync(charDir, resolve(archiveDir, name));
+		} else rmSync(charDir, {
+			recursive: true,
+			force: true
+		});
+		return { success: true };
+	}
+	async execTick(_ctx, args) {
+		const characterFilter = args.character;
+		if (characterFilter) {
+			if (!this.readCharacterProfile(characterFilter)) return {
+				success: false,
+				error: {
+					code: "NOT_FOUND",
+					message: `Character '${characterFilter}' not found`
+				}
+			};
+		}
+		try {
+			return {
+				success: true,
+				data: await this.runTick(characterFilter)
+			};
+		} catch (e) {
+			return {
+				success: false,
+				error: {
+					code: "TICK_ERROR",
+					message: e instanceof Error ? e.message : "Unknown error"
+				}
+			};
+		}
+	}
+	async execDispatchTask(_ctx, args) {
+		const topic = args.topic;
+		if (!topic) return {
+			success: false,
+			error: {
+				code: "INVALID_INPUT",
+				message: "topic is required"
+			}
+		};
+		const goal = args.goal;
+		const selectCount = args.select_count;
+		const material = args.material;
+		const characterNames = await this.getCharacterNames();
+		const activeChars = [];
+		for (const name of characterNames) {
+			const profile = this.readCharacterProfile(name);
+			if (!profile || profile.status === "paused") continue;
+			const interests = profile.interests || [];
+			activeChars.push({
+				name,
+				interests
+			});
+		}
+		const topicLower = topic.toLowerCase();
+		const matched = activeChars.filter((char) => char.interests.some((i) => topicLower.includes(i.topic.toLowerCase())));
+		let selected = matched;
+		if (selectCount !== void 0 && selectCount < matched.length) selected = [...matched].sort(() => Math.random() - .5).slice(0, selectCount);
+		if (selected.length === 0) return {
+			success: true,
+			data: {
+				assigned: [],
+				angles: {},
+				warning: "No characters matched the given topic"
+			}
+		};
+		const taskId = `task-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+		const angles = {};
+		for (const char of selected) {
+			const matchingInterest = char.interests.find((i) => topicLower.includes(i.topic.toLowerCase()));
+			angles[char.name] = `From ${matchingInterest?.topic || "general"} perspective on ${topic}`;
+		}
+		const db = this.getDB();
+		const assigned = selected.map((c) => c.name);
+		db.insertTask({
+			id: taskId,
+			topic,
+			goal: goal ?? null,
+			material: material ?? null,
+			assignments: Object.fromEntries(assigned.map((n) => [n, angles[n]]))
+		});
+		for (const name of assigned) db.insertSeededTopic({
+			character: name,
+			task_id: taskId,
+			topic,
+			angle: angles[name]
+		});
+		return {
+			success: true,
+			data: {
+				task_id: taskId,
+				assigned,
+				angles
+			}
+		};
+	}
+	async listCharacterActions(ctx) {
+		const name = ctx.params?.name;
+		const basePath = joinURL("/characters", name);
+		return { data: [
+			this.buildActionEntry("session", "Run one browsing session", basePath),
+			this.buildActionEntry("post", "Manual post trigger", basePath),
+			this.buildActionEntry("reply", "Manual reply trigger", basePath),
+			this.buildActionEntry("pause", "Pause character scheduling", basePath),
+			this.buildActionEntry("resume", "Resume character scheduling", basePath)
+		] };
+	}
+	async execPause(ctx, _args) {
+		const name = ctx.params?.name;
+		const profile = this.readCharacterProfile(name);
+		if (!profile) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Character '${name}' not found`
+			}
+		};
+		profile.status = "paused";
+		this.writeCharacterProfile(name, profile);
+		return {
+			success: true,
+			data: {
+				name,
+				status: "paused"
+			}
+		};
+	}
+	async execResume(ctx, _args) {
+		const name = ctx.params?.name;
+		const profile = this.readCharacterProfile(name);
+		if (!profile) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Character '${name}' not found`
+			}
+		};
+		profile.status = "active";
+		this.writeCharacterProfile(name, profile);
+		return {
+			success: true,
+			data: {
+				name,
+				status: "active"
+			}
+		};
+	}
+	async execSession(ctx, _args) {
+		const name = ctx.params?.name;
+		const profile = this.readCharacterProfile(name);
+		if (!profile) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Character '${name}' not found`
+			}
+		};
+		if (!this.afs) return {
+			success: false,
+			error: {
+				code: "NOT_MOUNTED",
+				message: "Provider not mounted to AFS"
+			}
+		};
+		const db = this.getDB();
+		const sessionId = db.insertSession(name);
+		try {
+			const result = await this.runSessionSteps(name, profile, sessionId);
+			db.updateSession(sessionId, {
+				status: "done",
+				ended_at: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return {
+				success: true,
+				data: result
+			};
+		} catch {
+			db.updateSession(sessionId, {
+				status: "failed",
+				ended_at: (/* @__PURE__ */ new Date()).toISOString()
+			});
+			return {
+				success: false,
+				error: {
+					code: "SESSION_FAILED",
+					message: `Session failed for character '${name}'`
+				}
+			};
+		}
+	}
+	async execPost(_ctx, _args) {
+		return {
+			success: false,
+			error: {
+				code: "NOT_IMPLEMENTED",
+				message: "Not implemented yet"
+			}
+		};
+	}
+	async execReply(_ctx, _args) {
+		return {
+			success: false,
+			error: {
+				code: "NOT_IMPLEMENTED",
+				message: "Not implemented yet"
+			}
+		};
+	}
+	destroy() {
+		this.destroyed = true;
+		if (this.tickTimer) {
+			clearTimeout(this.tickTimer);
+			this.tickTimer = void 0;
+		}
+		if (this.db) {
+			this.db.close();
+			this.db = void 0;
+		}
+	}
+};
+__decorate([List("/")], AFSPersonaProvider.prototype, "listRoot", null);
+__decorate([List("/characters")], AFSPersonaProvider.prototype, "listCharacters", null);
+__decorate([Read("/")], AFSPersonaProvider.prototype, "readRoot", null);
+__decorate([Read("/characters")], AFSPersonaProvider.prototype, "readCharacters", null);
+__decorate([Read("/characters/:name")], AFSPersonaProvider.prototype, "readCharacter", null);
+__decorate([Meta("/")], AFSPersonaProvider.prototype, "metaRoot", null);
+__decorate([Meta("/characters")], AFSPersonaProvider.prototype, "metaCharacters", null);
+__decorate([Read("/.meta/.capabilities")], AFSPersonaProvider.prototype, "readCapabilities", null);
+__decorate([Stat("/")], AFSPersonaProvider.prototype, "statRoot", null);
+__decorate([Stat("/characters")], AFSPersonaProvider.prototype, "statCharacters", null);
+__decorate([Explain("/")], AFSPersonaProvider.prototype, "explainRoot", null);
+__decorate([Actions("/")], AFSPersonaProvider.prototype, "listRootActions", null);
+__decorate([Actions.Exec("/", "create-character")], AFSPersonaProvider.prototype, "execCreateCharacter", null);
+__decorate([Actions.Exec("/", "delete-character")], AFSPersonaProvider.prototype, "execDeleteCharacter", null);
+__decorate([Actions.Exec("/", "tick")], AFSPersonaProvider.prototype, "execTick", null);
+__decorate([Actions.Exec("/", "dispatch-task")], AFSPersonaProvider.prototype, "execDispatchTask", null);
+__decorate([Actions("/characters/:name")], AFSPersonaProvider.prototype, "listCharacterActions", null);
+__decorate([Actions.Exec("/characters/:name", "pause")], AFSPersonaProvider.prototype, "execPause", null);
+__decorate([Actions.Exec("/characters/:name", "resume")], AFSPersonaProvider.prototype, "execResume", null);
+__decorate([Actions.Exec("/characters/:name", "session")], AFSPersonaProvider.prototype, "execSession", null);
+__decorate([Actions.Exec("/characters/:name", "post")], AFSPersonaProvider.prototype, "execPost", null);
+__decorate([Actions.Exec("/characters/:name", "reply")], AFSPersonaProvider.prototype, "execReply", null);
+
+//#endregion
+export { AFSPersonaProvider, PersonaDB };
+//# sourceMappingURL=index.mjs.map