elanous 0.2.12 → 0.2.13

package/src/memory.ts

@@ -63,6 +63,16 @@ export function writeFileDurable(path: string, data: string, fsync: (fd: number)
 
 export type MemoryType = 'user' | 'feedback' | 'project' | 'reference';
 
+/** Context-condense metadata travels with the existing curated memory file, not a parallel store. */
+export interface ContextMemoryCard {
+  project: string;
+  seat: string;
+  topic: string;
+  source: string;
+  updatedAt: string;
+  status: 'active' | 'retired';
+}
+
 export interface MemoryEntry {
   id: string;                 // uuid v4
   filename: string;           // "<uuid>-<slug>.md"
@@ -89,6 +99,7 @@ export interface MemoryEntry {
   pinned: boolean;
   /** Optional pinned-memory freshness window; absent memories retain their original injection text. */
   staleAfterMinutes?: number;
+  contextCard?: ContextMemoryCard;
 }
 
 // ── Paths ────────────────────────────────────────────────────────────
@@ -192,6 +203,7 @@ export interface SaveMemoryOpts {
   staleAfterMinutes?: number;
   /** Override the generated id (tests). */
   id?: string;
+  contextCard?: ContextMemoryCard;
 }
 
 export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): MemoryEntry {
@@ -207,6 +219,7 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
   let existingPriority: number | undefined;
   let existingPinned: boolean | undefined;
   let existingStaleAfterMinutes: number | undefined;
+  let existingContextCard: ContextMemoryCard | undefined;
   if (existsSync(path)) {
     try {
       const parsed = parseFrontmatter(readFileSync(path, 'utf-8'));
@@ -214,6 +227,7 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
       if (parsed.fm.priority) existingPriority = parseInt(parsed.fm.priority, 10) || 0;
       if (parsed.fm.pinned) existingPinned = parsed.fm.pinned === 'true';
       existingStaleAfterMinutes = parseStaleAfterMinutes(parsed.fm['stale-after-minutes']);
+      existingContextCard = parseContextCard(parsed.fm['context-card']);
     } catch { /* keep new createdAt */ }
   }
   const priority = opts.priority ?? existingPriority ?? 0;
@@ -229,6 +243,8 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
   if (priority > 0) frontmatter.priority = String(Math.floor(priority));
   if (pinned) frontmatter.pinned = 'true';
   if (staleAfterMinutes !== undefined) frontmatter['stale-after-minutes'] = String(staleAfterMinutes);
+  const contextCard = opts.contextCard ?? existingContextCard;
+  if (contextCard) frontmatter['context-card'] = JSON.stringify(contextCard);
   const raw = renderFrontmatter(frontmatter, opts.body);
   writeFileDurable(path, raw);
 
@@ -248,9 +264,23 @@ export function saveMemory(opts: SaveMemoryOpts, root: string = memoryRoot()): M
     priority,
     pinned,
     staleAfterMinutes,
+    ...(contextCard ? { contextCard } : {}),
   };
 }
 
+function parseContextCard(raw: string | undefined): ContextMemoryCard | undefined {
+  if (!raw) return undefined;
+  try {
+    const card: unknown = JSON.parse(raw);
+    if (card && typeof card === 'object' && !Array.isArray(card)) {
+      const c = card as Record<string, unknown>;
+      if (['project', 'seat', 'topic', 'source', 'updatedAt'].every(key => typeof c[key] === 'string')
+        && (c.status === 'active' || c.status === 'retired')) return c as unknown as ContextMemoryCard;
+    }
+  } catch { /* malformed metadata is not a context memory */ }
+  return undefined;
+}
+
 /** Parse one memory file. Returns null on read/parse error. */
 function parseMemoryFile(path: string): MemoryEntry | null {
   if (!existsSync(path)) return null;
@@ -261,6 +291,7 @@ function parseMemoryFile(path: string): MemoryEntry | null {
   const basename = path.split(/[\\/]/).pop() ?? '';
   const match = basename.match(/^([0-9a-f-]{36})-(.+)\.md$/i);
   const id = match ? match[1] : createHash('sha1').update(basename).digest('hex').slice(0, 36);
+  const contextCard = parseContextCard(fm['context-card']);
   return {
     id,
     filename: basename,
@@ -274,6 +305,7 @@ function parseMemoryFile(path: string): MemoryEntry | null {
     priority: fm.priority ? (parseInt(fm.priority, 10) || 0) : 0,
     pinned: fm.pinned === 'true',
     staleAfterMinutes: parseStaleAfterMinutes(fm['stale-after-minutes']),
+    ...(contextCard ? { contextCard } : {}),
   };
 }
 
@@ -364,6 +396,7 @@ export function searchMemories(
   const entries = listMemories({ type: opts.type }, root);
   const hits: SearchHit[] = [];
   for (const entry of entries) {
+    if (entry.contextCard?.status === 'retired') continue;
     // 정확-토큰 매칭(2026-07-19) — 이전 substring `includes(kw)` 는 "ref"가 "reference"·
     // "prefer" 안에까지 걸려 오차용(false-recall)을 냈다(openclaw tool-search.ts 이식:
     // tokenize→Set.has 전체토큰 동등). name/description 은 토큰집합 정확매칭, body 는
@@ -415,7 +448,7 @@ export function rebuildIndex(root: string = memoryRoot()): void {
   const byType: Record<MemoryType, MemoryEntry[]> = {
     user: [], feedback: [], project: [], reference: [],
   };
-  for (const e of entries) byType[e.type].push(e);
+  for (const e of entries) if (e.contextCard?.status !== 'retired') byType[e.type].push(e);
 
   const lines: string[] = [];
   lines.push('# elanous memory index');
@@ -515,7 +548,7 @@ export function buildMemoryInjection(
 
   // 📌 pinned 기억 — 키워드 무관 항상 주입(relevance gate bypass · Letta pinned block /
   //    claude-code MEMORY.md tier 동형). priority 높은 순. core/safety/ref-location 사실용.
-  const pinnedMems = listMemories({}, root).filter(m => m.pinned).sort((a, b) => b.priority - a.priority);
+  const pinnedMems = listMemories({}, root).filter(m => m.pinned && m.contextCard?.status !== 'retired').sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
     const chunk = pinnedChunk(e);
@@ -678,7 +711,7 @@ export async function buildMemoryInjectionLLM(
   }
 
   // pinned 항상주입(키워드/판정 무관).
-  const pinnedMems = listMemories({}, root).filter((m) => m.pinned).sort((a, b) => b.priority - a.priority);
+  const pinnedMems = listMemories({}, root).filter((m) => m.pinned && m.contextCard?.status !== 'retired').sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
     const chunk = pinnedChunk(e);
@@ -693,7 +726,7 @@ export async function buildMemoryInjectionLLM(
   let judged: MemoryEntry[] = [];
   if (!lowContext) {
     const candidates = listMemories({}, root)
-      .filter((m) => !m.pinned && !injected.includes(m.id))
+      .filter((m) => !m.pinned && m.contextCard?.status !== 'retired' && !injected.includes(m.id))
       .slice(0, opts.maxCandidates ?? 60);
     if (candidates.length > 0) {
       try {

package/src/nexus/api/card-followup-route.ts

@@ -0,0 +1,118 @@
+import { randomUUID } from 'node:crypto';
+import { chmodSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from 'node:fs';
+import { isAbsolute, join, relative, sep } from 'node:path';
+import { defaultAttachmentBaseDir, resolveAttachmentPath } from '../../boot/attachment-store.js';
+import { detectCard, NotACardError, runCardFollowup } from '../../card-followup/core.js';
+import { debug } from '../../debug/log.js';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { localOcrText } from '../../telegram-card-followup.js';
+import { jsonResponse } from './json-response.js';
+
+export const CARD_FOLLOWUP_PATH = '/v1/card-followup';
+
+type CardJob = { id: string; status: 'judging' | 'running' | 'done' | 'not-card' | 'failed'; updatedAt: number; replies?: [string, string, string]; error?: string };
+type CardDeps = {
+  rootDir?: string;
+  resolveAttachment?: typeof resolveAttachmentPath;
+  ocr?: typeof localOcrText;
+  detect?: typeof detectCard;
+  run?: typeof runCardFollowup;
+  now?: () => number;
+};
+
+function withinAttachmentStore(path: string): boolean {
+  try {
+    const relativePath = relative(realpathSync(defaultAttachmentBaseDir()), realpathSync(path));
+    return relativePath !== '' && relativePath !== '..' && !relativePath.startsWith(`..${sep}`) && !isAbsolute(relativePath);
+  } catch { return false; }
+}
+
+/** The in-memory set identifies only work launched by this daemon; disk is the pollable ledger. */
+export function createCardFollowupJobs({
+  rootDir = effectiveInstanceRoot(),
+  resolveAttachment = resolveAttachmentPath,
+  ocr = localOcrText,
+  detect = detectCard,
+  run = runCardFollowup,
+  now = Date.now,
+}: CardDeps = {}) {
+  const base = join(rootDir, 'graph-runs', 'card-followup');
+  const active = new Set<string>();
+  const unavailable = new Set<string>();
+  const file = (id: string) => join(base, `${id}.pwa.json`);
+  const save = (job: CardJob) => {
+    mkdirSync(base, { recursive: true, mode: 0o700 });
+    chmodSync(base, 0o700);
+    writeFileSync(file(job.id), JSON.stringify(job), { mode: 0o600 });
+    chmodSync(file(job.id), 0o600);
+  };
+
+  return {
+    async post(req: Request): Promise<Response> {
+      let body: unknown;
+      try { body = await req.json(); } catch { body = null; }
+      if (!body || typeof body !== 'object' || Array.isArray(body)) return jsonResponse({ error: 'bad_request' }, 400);
+      const { attachmentId, context } = body as Record<string, unknown>;
+      if (context !== undefined && typeof context !== 'string') return jsonResponse({ error: 'bad_request' }, 400);
+      const imagePath = typeof attachmentId === 'string' ? resolveAttachment(attachmentId) : null;
+      if (!imagePath || (resolveAttachment === resolveAttachmentPath && !withinAttachmentStore(imagePath))) {
+        return jsonResponse({ error: 'attachment-not-found' }, 400);
+      }
+
+      const id = randomUUID();
+      const update = (status: CardJob['status'], fields: Partial<Pick<CardJob, 'replies' | 'error'>> = {}) =>
+        save({ id, status, updatedAt: now(), ...fields });
+      update('judging');
+      active.add(id);
+      debug.log('card-followup.pwa', 'started', { id });
+      // Start OCR on the next event-loop turn so the acceptance response precedes the work.
+      setTimeout(() => {
+        void (async () => {
+          try {
+            const ocrText = await ocr(imagePath);
+            if (detect({ ocrText }).decision !== 'card') {
+              update('not-card');
+              debug.log('card-followup.pwa', 'not-card', { id });
+              return;
+            }
+            update('running');
+            const result = await run({ imagePath, ocrText, rootDir, runId: id, ...(context === undefined ? {} : { context }) });
+            update('done', { replies: result.replies });
+            debug.log('card-followup.pwa', 'done', { id });
+          } catch (cause) {
+            const notCard = cause instanceof NotACardError;
+            // OCR·그래프 예외 문구엔 명함 원문이 섞일 수 있다 — 원장·응답엔 고정 코드만 싣는다(리뷰 must-fix).
+            try {
+              update(notCard ? 'not-card' : 'failed', notCard ? {} : { error: 'card-followup-failed' });
+              debug.log('card-followup.pwa', notCard ? 'not-card' : 'failed', { id });
+            } catch {
+              unavailable.add(id);
+              debug.log('card-followup.pwa', 'failed', { id });
+            }
+          } finally {
+            active.delete(id);
+          }
+        })().catch(() => {
+          unavailable.add(id);
+          active.delete(id);
+        });
+      });
+      return jsonResponse({ id }, 202);
+    },
+    get(id: string): Response {
+      if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) return jsonResponse({ error: 'not-found' }, 404);
+      if (unavailable.has(id)) return jsonResponse({ id, status: 'failed', error: 'card-followup-failed' });
+      let job: CardJob;
+      try { job = JSON.parse(readFileSync(file(id), 'utf8')) as CardJob; }
+      catch { return jsonResponse({ error: 'not-found' }, 404); }
+      if (job.id !== id) return jsonResponse({ error: 'not-found' }, 404);
+      if ((job.status === 'judging' || job.status === 'running') && !active.has(id)) {
+        return jsonResponse({ id, status: 'failed', error: 'daemon-restarted' });
+      }
+      const { status, replies, error } = job;
+      return jsonResponse({ id, status, ...(replies ? { replies } : {}), ...(error ? { error } : {}) });
+    },
+  };
+}
+
+export type CardFollowupJobs = ReturnType<typeof createCardFollowupJobs>;

package/src/nexus/api/decisions-route.ts

@@ -0,0 +1,68 @@
+import { debug } from '../../debug/log.js';
+import { DecisionLedger, type DecisionEntry } from '../../decisions/decision-ledger.js';
+import { jsonResponse } from './json-response.js';
+
+export const DECISIONS_PATH = '/v1/decisions';
+
+export interface DecisionsRouteDeps {
+  authorize?: (request: Request) => boolean;
+  ledger?: Pick<DecisionLedger, 'list' | 'decide'>;
+}
+
+export async function handleDecisions(req: Request, deps: DecisionsRouteDeps = {}): Promise<Response> {
+  const pathname = new URL(req.url).pathname;
+  if (pathname !== DECISIONS_PATH && !/^\/v1\/decisions\/[^/]+\/decide$/.test(pathname)) return jsonResponse({ error: 'not-found' }, 404);
+  if (!deps.authorize?.(req)) {
+    debug.log('decisions.api', 'rejected', { reason: 'unauthorized' });
+    return jsonResponse({ error: 'unauthorized' }, 401);
+  }
+  const ledger = deps.ledger ?? new DecisionLedger();
+  if (pathname === DECISIONS_PATH) {
+    if (req.method !== 'GET') return jsonResponse({ error: 'method-not-allowed' }, 405);
+    if (new URL(req.url).searchParams.get('status') !== 'open') {
+      debug.log('decisions.api', 'rejected', { reason: 'invalid-status' });
+      return jsonResponse({ error: 'bad_request' }, 400);
+    }
+    const decisions = ledger.list({ status: 'open' }).map(entry => ({
+      id: entry.id,
+      title: entry.title,
+      situation: entry.scqa.s.slice(0, 200),
+      options: entry.options.map(option => ({ id: option.key, label: option.label })),
+      recommendation: entry.recommendation,
+      raisedAt: entry.raisedAt,
+      dueAt: entry.dueAt,
+    }));
+    debug.log('decisions.api', 'listed', { count: decisions.length });
+    return jsonResponse({ decisions });
+  }
+  if (req.method !== 'POST') return jsonResponse({ error: 'method-not-allowed' }, 405);
+  let id: string;
+  try { id = decodeURIComponent(pathname.slice(DECISIONS_PATH.length + 1, -'/decide'.length)); }
+  catch {
+    debug.log('decisions.api', 'rejected', { reason: 'invalid-id' });
+    return jsonResponse({ error: 'not-found' }, 404);
+  }
+  let body: unknown;
+  try { body = await req.json(); } catch { body = null; }
+  if (!body || typeof body !== 'object' || Array.isArray(body)
+    || !('choice' in body) || typeof body.choice !== 'string' || !body.choice
+    || ('note' in body && body.note !== undefined && typeof body.note !== 'string')) {
+    debug.log('decisions.api', 'rejected', { id, reason: 'invalid-body' });
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  const { choice, note } = body as { choice: string; note?: string };
+  try {
+    const entry: DecisionEntry = ledger.decide(id, choice, { kind: 'human' }, note);
+    debug.log('decisions.api', 'decided', { id });
+    return jsonResponse(entry);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : '';
+    const status = message.startsWith('decision not found:') ? 404
+      : message.startsWith('decision already closed:') ? 409
+      : message.startsWith('option not found:') || message.startsWith('note ') ? 400 : 0;
+    if (!status) throw error;
+    const reason = status === 404 ? 'not-found' : status === 409 ? 'already-decided' : 'bad_request';
+    debug.log('decisions.api', 'rejected', { id, reason });
+    return jsonResponse({ error: reason }, status);
+  }
+}

package/src/nexus/api/http-server.ts

@@ -22,6 +22,9 @@ import { spawnSync } from 'node:child_process';
 import { isAbsolute } from 'node:path';
 import { createProject, listProjects } from '../../project/project-store.js';
 import { handleOutputsGet, type OutputsDeps } from './outputs-route.js';
+import { DECISIONS_PATH, handleDecisions, type DecisionsRouteDeps } from './decisions-route.js';
+import { CARD_FOLLOWUP_PATH, createCardFollowupJobs, type CardFollowupJobs } from './card-followup-route.js';
+import { SKILL_EXEC_PATH, createSkillExecJobs, type SkillExecJobs } from './skill-exec-route.js';
 import { compareTokenConstTime } from '../../acp/transport/auth.js';
 import { ensureAuthToken } from '../../auth/acp-token.js';
 import type { NexusState } from '../state/state.js';
@@ -472,6 +475,9 @@ export interface NexusHttpServerOpts {
   /** Optional installer state root for isolated API consumers and tests. */
   pluginStateRoot?: string;
   outputs?: OutputsDeps;
+  decisions?: Pick<DecisionsRouteDeps, 'ledger'>;
+  cardFollowup?: CardFollowupJobs;
+  skillExec?: SkillExecJobs;
   execRequests?: ExecRequestRunner;
   seatRequests?: SeatRequestsDeps;
   consultRequests?: ConsultRequestsDeps;
@@ -852,6 +858,16 @@ function execRequestRunner(): ExecRequestRunner {
   return execRequestRunnerInstance;
 }
 
+let cardFollowupJobs: CardFollowupJobs | undefined;
+function defaultCardFollowupJobs(): CardFollowupJobs {
+  return cardFollowupJobs ??= createCardFollowupJobs();
+}
+
+let skillExecJobs: SkillExecJobs | undefined;
+function defaultSkillExecJobs(): SkillExecJobs {
+  return skillExecJobs ??= createSkillExecJobs();
+}
+
 export async function routeRequest(
   req: Request,
   opts: NexusHttpServerOpts,
@@ -1338,6 +1354,23 @@ export async function routeRequest(
     return method === 'GET' ? handleProjectsGet() : handleProjectsPost(req);
   }
 
+  // Polling must remain outside the non-GET dispatch below.
+  if (method === 'GET' && pathname.startsWith(`${SKILL_EXEC_PATH}/`) && !pathname.slice(SKILL_EXEC_PATH.length + 1).includes('/')) {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return (opts.skillExec ?? defaultSkillExecJobs()).get(pathname.slice(SKILL_EXEC_PATH.length + 1));
+  }
+  if (method === 'GET' && pathname.startsWith(`${CARD_FOLLOWUP_PATH}/`) && !pathname.slice(CARD_FOLLOWUP_PATH.length + 1).includes('/')) {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return (opts.cardFollowup ?? defaultCardFollowupJobs()).get(pathname.slice(CARD_FOLLOWUP_PATH.length + 1));
+  }
+
+  if (method === 'GET' && pathname === DECISIONS_PATH) {
+    return handleDecisions(req, {
+      authorize: request => !!opts.metaApi && checkAuth(request, opts.metaApi),
+      ...opts.decisions,
+    });
+  }
+
   if (method === 'GET' && pathname === '/v1/outputs') {
     if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
     return handleOutputsGet(req, opts.outputs);
@@ -1371,6 +1404,20 @@ export async function routeRequest(
   // Templates POST handled here too (PR κ).
   // Config / secrets PUT/POST/DELETE here too (PR μ).
   if (method !== 'GET') {
+    if (method === 'POST' && pathname === SKILL_EXEC_PATH) {
+      if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+      return (opts.skillExec ?? defaultSkillExecJobs()).post(req);
+    }
+    if (method === 'POST' && pathname === CARD_FOLLOWUP_PATH) {
+      if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+      return (opts.cardFollowup ?? defaultCardFollowupJobs()).post(req);
+    }
+    if (method === 'POST' && /^\/v1\/decisions\/[^/]+\/decide$/.test(pathname)) {
+      return handleDecisions(req, {
+        authorize: request => !!opts.metaApi && checkAuth(request, opts.metaApi),
+        ...opts.decisions,
+      });
+    }
     if (method === 'POST' && pathname === '/v1/plugins/install') {
       if (!opts.metaApi) return jsonResponse({ error: 'unauthorized' }, 401);
       return handlePluginsInstall(req, opts.metaApi, opts.pluginStateRoot);

package/src/nexus/api/personas.ts

@@ -8,6 +8,7 @@ import {
   resolveStatePersonaDir,
 } from '../../persona/global-registry.js';
 import { clonePreset, editPersona, loadPresets } from '../../persona/presets.js';
+import { resolvePersonaAddress } from '../../intake-plane/persona-answer.js';
 import type { PersonaRegistryEvent } from '../../persona/registry.js';
 import type { PersonaProfile } from '../../persona/types.js';
 import {
@@ -99,7 +100,7 @@ export async function handlePersonaGet(
   }
   await awaitGlobalPersonaLoad();
   const registry = getGlobalPersonaRegistry();
-  const persona = registry.get(personaId);
+  const persona = resolvePersonaAddress(personaId, registry);
   if (!persona) return notFound(`persona ${personaId} not found`);
   return jsonResponse({ persona: toWire(persona) }, 200);
 }

package/src/nexus/api/skill-exec-route.ts

@@ -0,0 +1,97 @@
+import { randomUUID } from 'node:crypto';
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { debug } from '../../debug/log.js';
+import { effectiveInstanceRoot } from '../../instance/resolve.js';
+import { dispatchSkillExec } from '../../tool-runtime/skill-exec-runtime.js';
+import { jsonResponse } from './json-response.js';
+
+export const SKILL_EXEC_PATH = '/v1/skills/exec';
+
+type SkillJob = {
+  id: string;
+  skill: string;
+  status: 'running' | 'done' | 'rejected' | 'failed';
+  updatedAt: number;
+  ok?: boolean;
+  output?: string;
+  reason?: 'not-allowlisted';
+  error?: string;
+};
+
+type SkillExecDeps = {
+  rootDir?: string;
+  exec?: typeof dispatchSkillExec;
+  now?: () => number;
+};
+
+export function createSkillExecJobs({ rootDir = effectiveInstanceRoot(), exec = dispatchSkillExec, now = Date.now }: SkillExecDeps = {}) {
+  const base = join(rootDir, 'skill-exec');
+  const active = new Set<string>();
+  const unavailable = new Set<string>();
+  const file = (id: string) => join(base, `${id}.json`);
+  const save = (job: SkillJob) => {
+    mkdirSync(base, { recursive: true, mode: 0o700 });
+    chmodSync(base, 0o700);
+    writeFileSync(file(job.id), JSON.stringify(job), { mode: 0o600 });
+    chmodSync(file(job.id), 0o600);
+  };
+
+  return {
+    async post(req: Request): Promise<Response> {
+      let body: unknown;
+      try { body = await req.json(); } catch { body = null; }
+      if (!body || typeof body !== 'object' || Array.isArray(body)) return jsonResponse({ error: 'bad_request' }, 400);
+      const { skill, task } = body as Record<string, unknown>;
+      if (typeof skill !== 'string' || !skill.trim() || typeof task !== 'string' || !task.trim() || task.length > 4000) {
+        return jsonResponse({ error: 'bad_request' }, 400);
+      }
+      const id = randomUUID();
+      const update = (status: SkillJob['status'], fields: Partial<Pick<SkillJob, 'ok' | 'output' | 'reason' | 'error'>> = {}) =>
+        save({ id, skill, status, updatedAt: now(), ...fields });
+      update('running');
+      active.add(id);
+      debug.log('skill-exec.pwa', 'started', { id, skill });
+      setTimeout(() => {
+        void (async () => {
+          try {
+            const result = await exec({ skill, task });
+            if (!result.ok && result.output.startsWith(`자동 실행 대상 아님: ${skill}.`)) {
+              update('rejected', { reason: 'not-allowlisted' });
+              debug.log('skill-exec.pwa', 'rejected', { id, skill });
+            } else {
+              update('done', { ok: result.ok, output: result.output.slice(0, 20_000) });
+              debug.log('skill-exec.pwa', 'done', { id, skill });
+            }
+          } catch {
+            try {
+              update('failed', { error: 'skill-exec-failed' });
+            } catch {
+              unavailable.add(id);
+            }
+            debug.log('skill-exec.pwa', 'failed', { id, skill });
+          } finally {
+            active.delete(id);
+          }
+        })().catch(() => {
+          unavailable.add(id);
+          active.delete(id);
+        });
+      });
+      return jsonResponse({ id }, 202);
+    },
+    get(id: string): Response {
+      if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) return jsonResponse({ error: 'not-found' }, 404);
+      if (unavailable.has(id)) return jsonResponse({ id, status: 'failed', error: 'skill-exec-failed' });
+      let job: SkillJob;
+      try { job = JSON.parse(readFileSync(file(id), 'utf8')) as SkillJob; }
+      catch { return jsonResponse({ error: 'not-found' }, 404); }
+      if (job.id !== id) return jsonResponse({ error: 'not-found' }, 404);
+      if (job.status === 'running' && !active.has(id)) return jsonResponse({ id, status: 'failed', error: 'daemon-restarted' });
+      const { status, ok, output, reason, error } = job;
+      return jsonResponse({ id, status, ...(ok !== undefined ? { ok } : {}), ...(output !== undefined ? { output } : {}), ...(reason ? { reason } : {}), ...(error ? { error } : {}) });
+    },
+  };
+}
+
+export type SkillExecJobs = ReturnType<typeof createSkillExecJobs>;

package/src/persona/loader.ts

@@ -138,6 +138,22 @@ export function validatePersonaShape(
     models = mr.models;
   }
 
+  let seat: string | undefined;
+  if (Object.hasOwn(obj, 'seat')) {
+    if (typeof obj['seat'] !== 'string' || !obj['seat'].trim()) {
+      return err(path, 'seat must be a non-empty string');
+    }
+    seat = obj['seat'];
+  }
+
+  let todo: string | undefined;
+  if (Object.hasOwn(obj, 'todo')) {
+    if (typeof obj['todo'] !== 'string' || !/^[a-z0-9_][a-z0-9_-]*\.todo\.jsonl$/i.test(obj['todo'])) {
+      return err(path, 'todo must be a per-persona .todo.jsonl filename');
+    }
+    todo = obj['todo'];
+  }
+
   let mentionPatterns: readonly string[] | undefined;
   if (obj['mentionPatterns'] !== undefined) {
     if (!Array.isArray(obj['mentionPatterns'])
@@ -149,6 +165,8 @@ export function validatePersonaShape(
 
   const profile: PersonaProfile = {
     personaId, displayName,
+    ...(seat !== undefined ? { seat } : {}),
+    ...(todo !== undefined ? { todo } : {}),
     ...(description.value !== undefined ? { description: description.value } : {}),
     ...(systemPrompt.value !== undefined ? { systemPrompt: systemPrompt.value } : {}),
     ...(brand !== undefined ? { brand } : {}),

package/src/persona/persona-todo.ts

@@ -6,6 +6,8 @@ export interface PersonaTodo {
   title: string;
   status: 'open' | 'done';
   createdAt: string;
+  priority?: number;
+  dueAt?: string;
 }
 
 export interface PersonaTodoReadResult {
@@ -28,7 +30,9 @@ function isPersonaTodo(value: unknown): value is PersonaTodo {
     && typeof item.title === 'string' && item.title.length > 0
     && (item.status === 'open' || item.status === 'done')
     && typeof item.createdAt === 'string'
-    && Number.isFinite(Date.parse(item.createdAt));
+    && Number.isFinite(Date.parse(item.createdAt))
+    && (item.priority === undefined || (typeof item.priority === 'number' && Number.isInteger(item.priority) && item.priority >= 0))
+    && (item.dueAt === undefined || (typeof item.dueAt === 'string' && Number.isFinite(Date.parse(item.dueAt))));
 }
 
 /** Missing files are empty; malformed lines are skipped and returned for observation. */
@@ -67,13 +71,14 @@ export function writePersonaTodos(dir: string, personaId: string, todos: readonl
   writeFileSync(path, todos.map(todo => JSON.stringify(todo)).join('\n') + (todos.length ? '\n' : ''), 'utf8');
 }
 
-/** Earliest created open item; original order breaks equal-timestamp ties. */
+/** Higher priority first, then earlier deadline, then earlier creation; file order breaks ties. */
+export function orderedPersonaTodos(todos: readonly PersonaTodo[]): PersonaTodo[] {
+  return [...todos].filter((todo) => todo.status === 'open').sort((a, b) =>
+    (b.priority ?? 0) - (a.priority ?? 0)
+    || (a.dueAt && b.dueAt ? Date.parse(a.dueAt) - Date.parse(b.dueAt) : a.dueAt ? -1 : b.dueAt ? 1 : 0)
+    || Date.parse(a.createdAt) - Date.parse(b.createdAt));
+}
+
 export function nextPersonaTodo(todos: readonly PersonaTodo[]): PersonaTodo | null {
-  let oldest: PersonaTodo | null = null;
-  for (const todo of todos) {
-    if (todo.status === 'open' && (!oldest || Date.parse(todo.createdAt) < Date.parse(oldest.createdAt))) {
-      oldest = todo;
-    }
-  }
-  return oldest;
+  return orderedPersonaTodos(todos)[0] ?? null;
 }

package/src/persona/presets.ts

@@ -88,6 +88,7 @@ export function presetToProfileYaml(p: PersonaPreset, common: PresetCommon, opts
     displayName: opts.name?.trim() ? `${opts.name.trim()} · ${p.role}` : p.displayName,
     description: p.oneLine,
     systemPrompt: presetSystemPrompt(p, common, name),
+    todo: `${opts.personaId}.todo.jsonl`,
     preset: { id: p.personaId, role: p.role, ...(title ? { title } : {}), tools: p.tools.map((t) => t.name), firstQuestions: p.firstQuestions },
   };
   return `# 프리셋 «${p.personaId}» 에서 만든 페르소나 — elanous persona add (원본: persona-presets/${p.personaId}.yaml)\n${stringify(profile, { lineWidth: 0 })}`;
@@ -99,7 +100,7 @@ export interface PersonaWriteResult { personaId: string; displayName: string; pa
 // Only fields in the runtime persona schema may be edited; provenance (`preset`) is retained, not editable.
 const PROFILE_KEYS = new Set([
   'personaId', 'displayName', 'description', 'systemPrompt', 'actionHosts', 'offsiteNavigation',
-  'brand', 'models', 'mentionPatterns', 'avatarUrl', 'brandColor', 'browserPort', 'residence', 'capabilities',
+  'brand', 'models', 'mentionPatterns', 'avatarUrl', 'brandColor', 'browserPort', 'residence', 'capabilities', 'todo',
 ]);
 const NESTED_KEYS: Record<string, readonly string[]> = {
   models: ['primary', 'fallback', 'providers'], 'models.providers': ['ollama', 'openai'],