elanous 0.2.11 → 0.2.13

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';
@@ -335,7 +338,7 @@ import {
   handleTasksList,
   handleTaskDetail,
 } from './tasks-scheduler.js';
-import { handleTaskCardsGet } from './task-cards-api.js';
+import { handleTaskCardsGet, handleTaskCardsWishPost } from './task-cards-api.js';
 import { handleTaskCreatePost, handleTaskApprovePost } from './tasks-create.js';
 import { matchIngestAuthorization } from './ingest-token.js';
 import {
@@ -344,6 +347,8 @@ import {
   handleWorkflowApprovalsPending,
   handleWorkflowDelete,
   handleWorkflowGet,
+  handleWorkflowHistoryList,
+  handleWorkflowHistoryVersionGet,
   handleWorkflowPut,
   handleWorkflowRunGet,
   handleWorkflowRunsList,
@@ -470,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;
@@ -850,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,
@@ -1336,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);
@@ -1360,10 +1395,29 @@ export async function routeRequest(
     return handleSkillProblems(req, opts.metaApi);
   }
 
+  if (method === 'GET' && pathname === '/v1/persona-presets') {
+    if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+    return dispatchPersonaRoute(req, pathname) as Promise<Response>;
+  }
+
   // Mutation routes (PR ι) — POST/PATCH/DELETE on /v1/nexus/tabs[/:id[/action]].
   // 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);
@@ -1389,6 +1443,10 @@ export async function routeRequest(
       const mutated = await handleGraphsMutation(pathname, req);
       if (mutated) return mutated;
     }
+    if (method === 'POST' && pathname === '/v1/task-cards/wish') {
+      if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
+      return handleTaskCardsWishPost(req);
+    }
     if (method === 'POST' && pathname === '/v1/tasks') {
       if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
       return handleTaskCreatePost(req, opts.metaApi);
@@ -1645,10 +1703,10 @@ export async function routeRequest(
       if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
       return pathname === '/v1/setup/child-llm' ? handleChildLlmSet(req) : handleAnswerPrioritySet(req);
     }
-    // PWA `/settings` Phase 3 (2026-05-19) — persona description PATCH.
-    // dispatchPersonaRoute 가 PATCH 분기를 자체 처리. GET sibling 은
-    // 아래 GET-only 블록의 기존 /v1/personas 핸들러.
-    if (pathname.startsWith('/v1/personas/') && method === 'PATCH') {
+    // Persona creation and editing require owner auth before parsing a write body.
+    if ((method === 'POST' && pathname === '/v1/personas')
+      || (method === 'PATCH' && pathname.startsWith('/v1/personas/'))) {
+      if (!opts.metaApi || !checkAuth(req, opts.metaApi)) return jsonResponse({ error: 'unauthorized' }, 401);
       const result = await dispatchPersonaRoute(req, pathname);
       if (result) return result;
     }
@@ -2645,7 +2703,7 @@ export async function routeRequest(
     catch { return jsonResponse({ error: 'bad_request' }, 400); }
     return handleScheduleDetail(req, id, opts.metaApi);
   }
-  if (pathname === '/v1/task-cards' || /^\/v1\/task-cards\/[^/]+$/.test(pathname)) {
+  if (method === 'GET' && (pathname === '/v1/task-cards' || /^\/v1\/task-cards\/[^/]+$/.test(pathname))) {
     return handleTaskCardsGet(pathname);
   }
   if (pathname === '/v1/tasks') {
@@ -2738,11 +2796,23 @@ export async function routeRequest(
   }
   if (pathname.startsWith('/v1/workflows/')) {
     if (!opts.metaApi) return jsonResponse({ error: 'meta-api-not-wired' }, 503);
-    const wfName = decodeURIComponent(pathname.slice('/v1/workflows/'.length));
+    const segments = pathname.slice('/v1/workflows/'.length).split('/');
+    let wfName: string;
+    try { wfName = decodeURIComponent(segments[0] ?? ''); }
+    catch { return jsonResponse({ error: 'bad_request', reason: 'invalid workflow name' }, 400); }
     if (!wfName || wfName.includes('/') || wfName.includes('\\') || wfName.includes('..')) {
       return jsonResponse({ error: 'bad_request', reason: 'invalid workflow name' }, 400);
     }
-    return handleWorkflowGet(req, wfName, opts.metaApi);
+    if (segments.length === 2 && segments[1] === 'history') {
+      return handleWorkflowHistoryList(req, wfName, opts.metaApi);
+    }
+    if (segments.length === 3 && segments[1] === 'history') {
+      let id: string;
+      try { id = decodeURIComponent(segments[2] ?? ''); }
+      catch { return jsonResponse({ error: 'bad_request', reason: 'invalid workflow history version id' }, 400); }
+      return handleWorkflowHistoryVersionGet(req, wfName, id, opts.metaApi);
+    }
+    if (segments.length === 1) return handleWorkflowGet(req, wfName, opts.metaApi);
   }
   if (pathname.startsWith('/v1/nexus/templates/')) {
     const name = pathname.slice('/v1/nexus/templates/'.length);

package/src/nexus/api/outbound-report.ts

@@ -19,6 +19,9 @@ import { checkAuth, type MetaApiOpts } from './meta-api.js';
 import { routeOutbound } from '../outbound/router.js';
 import { getUserConfig } from '../../user-config.js';
 import { openSurfaceEventsDb, recordEvent } from '../../domains/surface-events.js';
+import { debug } from '../../debug/log.js';
+import { resolveReportTarget } from '../../telegram-report.js';
+import type { RouteResult, RouterDeps } from '../outbound/router.js';
 
 /** 크로스서피스 기억(P0.5) — /v1/outbound = ALL outbound 단일 수렴점이므로 여기서
  *  원장 기록하면 sendOutbound 클라 + 직접 POST(morning-report·external) 전부 포착.
@@ -31,6 +34,21 @@ function recordOutboundEvent(text: string, kind: string): void {
   } catch { /* 발송 원장 기록 실패는 무시 */ }
 }
 
+function observeDaemonSend(cfg: ReturnType<typeof getUserConfig>, text: string, kind: string, result: RouteResult, source: string): void {
+  if (result.suppressed) return; // 라우터가 suppressedBy 만 싣는 억제 관측을 남긴다.
+  try {
+    const target = result.channels.some(c => c.type === 'telegram') ? resolveReportTarget(cfg, kind) : null;
+    const id = target?.botToken.split(':', 1)[0];
+    const bot = id && /^\d+$/.test(id) ? `telegram:${id}` : target ? 'telegram:configured' : 'none';
+    debug.log('outbound.send', result.delivered ? 'sent' : 'failed', {
+      kind: /^[a-zA-Z0-9_-]{1,80}$/.test(kind) ? kind : 'unknown',
+      source: /^[a-zA-Z0-9_./-]{1,160}$/.test(source) ? source : 'unknown',
+      chars: text.length, bot, path: 'daemon',
+      channels: result.channels.map(c => ({ type: c.type, ok: c.ok })),
+    });
+  } catch { /* observation must not change the send result */ }
+}
+
 interface OutboundBody {
   text?: string;
   markdown?: boolean;
@@ -45,14 +63,16 @@ function json(body: unknown, status: number): Response {
 }
 
 /** The daemon's own sendOutbound path (OB8) — what POST /v1/outbound does, without the HTTP self-call. */
-export async function routeOutboundInProcess(text: string, kind: string): Promise<boolean> {
-  const result = await routeOutbound(getUserConfig(), { text, markdown: false, kind });
-  if (result.delivered) recordOutboundEvent(text, kind);
+export async function routeOutboundInProcess(text: string, kind: string, source = 'daemon-in-process', deferFailureObservation = false): Promise<boolean> {
+  const cfg = getUserConfig();
+  const result = await routeOutbound(cfg, { text, markdown: false, kind });
+  if (result.delivered || !deferFailureObservation) observeDaemonSend(cfg, text, kind, result, source);
+  if (result.delivered && !result.suppressed) recordOutboundEvent(text, kind);
   return result.delivered;
 }
 
 /** POST /v1/outbound — fan one message out to the routed channels. */
-export async function handleOutboundReport(req: Request, metaApi: MetaApiOpts): Promise<Response> {
+export async function handleOutboundReport(req: Request, metaApi: MetaApiOpts, routerDeps: RouterDeps = {}): Promise<Response> {
   if (!checkAuth(req, metaApi)) return json({ error: 'unauthorized' }, 401);
 
   let body: OutboundBody;
@@ -68,16 +88,29 @@ export async function handleOutboundReport(req: Request, metaApi: MetaApiOpts):
     // Router is per-channel fail-soft; `delivered` = any channel ok.
     // Producers (outbound-alert.ts deliver()) gate their direct-telegram
     // fallback on this top-level boolean — keep it stable.
-    const result = await routeOutbound(cfg, { text, markdown: body.markdown ?? true, kind });
-    if (result.delivered) recordOutboundEvent(text, kind); // 크로스서피스 기억 원장(P0.5)
+    const result = await routeOutbound(cfg, { text, markdown: body.markdown ?? true, kind }, routerDeps);
+    const clientFallback = req.headers.get('X-Elanous-Client-Fallback') === 'direct';
+    const source = req.headers.get('X-Elanous-Outbound-Source') ?? 'daemon-http';
+    if (result.delivered || !clientFallback) observeDaemonSend(cfg, text, kind, result, source);
+    if (result.delivered && !result.suppressed) recordOutboundEvent(text, kind); // 크로스서피스 기억 원장(P0.5)
     return json({
       delivered: result.delivered,
       // Legacy single-channel field (pre-R6 consumers) + full breakdown.
-      channel: result.delivered ? (result.channels.find(c => c.ok)?.type ?? 'none') : 'none',
+      channel: result.suppressed ? 'suppressed' : (result.channels.find(c => c.ok)?.type ?? 'none'),
       channels: result.channels,
+      ...(result.suppressed ? { suppressed: true, suppressedBy: result.suppressedBy } : {}),
+      ...(!result.suppressed && result.channels.length === 0 ? { reason: 'no-channel' } : {}),
       kind,
     }, result.delivered ? 200 : 503);
   } catch (e) {
+    if (req.headers.get('X-Elanous-Client-Fallback') !== 'direct') {
+      try {
+        debug.log('outbound.send', 'failed', {
+          kind: /^[a-zA-Z0-9_-]{1,80}$/.test(kind) ? kind : 'unknown',
+          source: 'daemon-http', chars: text.length, bot: 'unknown', path: 'daemon',
+        });
+      } catch { /* observation must not change the response */ }
+    }
     return json({ error: e instanceof Error ? e.message : String(e) }, 502);
   }
 }

package/src/nexus/api/personas.ts

@@ -1,27 +1,14 @@
-// NEXUS · personas REST handlers (§6.4 · 2026-05-09).
-//
-// Endpoints
-//   GET  /v1/personas              — list all loaded personas
-//   GET  /v1/personas/:personaId   — single persona profile
-//
-// Architecture: read-only thin wrapper over the global PersonaRegistry
-// (`src/persona/global-registry.ts`). Disk yaml is the source of truth;
-// editing requires text editor + `elanous persona reload` (or fs.watch
-// auto-reload). PWA Showroom consumes this for the per-panel persona
-// picker (§6.4 Q2 = REST read-only).
-//
-// PLAN: 내부 문서 `PLAN-cv-3-showroom-mvp-2026-05-07` §6.4
-// Cross-ref: src/persona/global-registry.ts (singleton accessor)
-//            src/persona/types.ts (PersonaProfile shape)
-
-import { homedir } from 'node:os';
-import { join } from 'node:path';
+// NEXUS · personas REST handlers. Presets clone into the state persona store;
+// writes reload the global registry so subsequent reads see the saved profile.
 
 import {
   awaitGlobalPersonaLoad,
   getGlobalPersonaRegistry,
   reloadGlobalPersonaRegistry,
+  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 {
@@ -113,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);
 }
@@ -193,22 +180,41 @@ export function handlePersonasEvents(
   });
 }
 
-/** Resolve personas dir same way `global-registry.ts` does, so the PATCH
- *  endpoint targets the file the registry will reload. */
-function resolvePersonasDir(): string {
-  const env = process.env.ELANOUS_PERSONAS_DIR;
-  if (env && env.length > 0) return env;
-  return join(homedir(), '.elanous', 'personas');
+/** GET /v1/persona-presets — shipped preset catalog in index order. */
+export function handlePersonaPresets(req: Request, opts: PersonaRouteOpts = {}): Response {
+  if (opts.checkAuth && !opts.checkAuth(req)) return jsonResponse({ error: 'unauthorized' }, 401);
+  return jsonResponse({ presets: loadPresets() }, 200);
 }
 
-/** PATCH /v1/personas/:personaId — update description.
- *
- *  Body: `{ description: "<string, ≤ 280 chars>" }` — empty string clears.
- *  Other fields ignored (yaml surgical edit pattern).
- *
- *  Returns 200 with the updated `PersonaWire` after reload, 400 / 404 /
- *  500 with structured `{ error, reason? }`.
- */
+/** POST /v1/personas — clone a shipped preset into the user's persona store. */
+export async function handlePersonaCreate(req: Request, opts: PersonaRouteOpts = {}): Promise<Response> {
+  if (opts.checkAuth && !opts.checkAuth(req)) return jsonResponse({ error: 'unauthorized' }, 401);
+  let body: unknown;
+  try { body = await req.json(); }
+  catch { return jsonResponse({ error: 'invalid-json' }, 400); }
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return jsonResponse({ error: 'invalid-body' }, 400);
+  const { preset, name } = body as Record<string, unknown>;
+  if (typeof preset !== 'string' || !preset.trim() || typeof name !== 'string' || !name.trim()) {
+    return jsonResponse({ error: 'preset-and-name-required' }, 400);
+  }
+  await awaitGlobalPersonaLoad();
+  if (!loadPresets().some((p) => p.personaId === preset)) return notFound(`preset ${preset} not found`);
+  try {
+    const created = clonePreset(preset, name.trim(), { dir: resolveStatePersonaDir() });
+    await reloadGlobalPersonaRegistry();
+    const persona = getGlobalPersonaRegistry().get(created.personaId);
+    if (!persona) return notFound(`persona ${created.personaId} not found after reload`);
+    return jsonResponse({ persona: toWire(persona) }, 201);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith('persona name already exists:')) {
+      return jsonResponse({ error: 'persona-name-conflict' }, 409);
+    }
+    return jsonResponse({ error: 'create-failed' }, 500);
+  }
+}
+
+/** PATCH /v1/personas/:personaId — description-only edits retain the
+ *  existing surgical YAML behavior; multi-field edits use the persona store. */
 export async function handlePersonaPatch(
   req: Request,
   personaId: string,
@@ -217,17 +223,23 @@ export async function handlePersonaPatch(
   if (opts.checkAuth && !opts.checkAuth(req)) {
     return jsonResponse({ error: 'unauthorized' }, 401);
   }
-  let body: { description?: unknown };
-  try {
-    body = (await req.json()) as { description?: unknown };
-  } catch {
-    return jsonResponse({ error: 'invalid-json' }, 400);
+  let parsed: unknown;
+  try { parsed = await req.json(); }
+  catch { return jsonResponse({ error: 'invalid-json' }, 400); }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+    return jsonResponse({ error: 'invalid-body' }, 400);
   }
-  if (typeof body.description !== 'string') {
-    return jsonResponse({ error: 'description-required' }, 400);
+  const body = parsed as Record<string, unknown>;
+  const fields = Object.keys(body);
+  if (!fields.length) return jsonResponse({ error: 'description-required' }, 400);
+  if (fields.some((field) => !['displayName', 'description', 'systemPrompt'].includes(field))) {
+    return jsonResponse({ error: 'invalid-persona-field' }, 400);
   }
-  if (body.description.length > MAX_PERSONA_DESCRIPTION_LENGTH * 4) {
-    // Guard against pathological inputs before the helper trims.
+  if (fields.some((field) => typeof body[field] !== 'string')
+    || (body.displayName !== undefined && !(body.displayName as string).trim())) {
+    return jsonResponse({ error: 'invalid-persona-field' }, 400);
+  }
+  if (typeof body.description === 'string' && body.description.length > MAX_PERSONA_DESCRIPTION_LENGTH * 4) {
     return jsonResponse({ error: 'description-too-long' }, 400);
   }
 
@@ -237,14 +249,37 @@ export async function handlePersonaPatch(
     return notFound(`persona ${personaId} not found`);
   }
 
-  const dir = resolvePersonasDir();
-  const result = updatePersonaDescription(dir, personaId, body.description);
-  if (!result.ok) {
-    const status = result.reason === 'file-not-found' ? 404 : 400;
-    return jsonResponse({ error: 'patch-failed', reason: result.reason }, status);
+  const dir = resolveStatePersonaDir();
+  if (fields.length === 1 && typeof body.description === 'string') {
+    const result = updatePersonaDescription(dir, personaId, body.description);
+    if (!result.ok) {
+      const status = result.reason === 'file-not-found' ? 404 : 400;
+      return jsonResponse({ error: 'patch-failed', reason: result.reason }, status);
+    }
+  } else {
+    const edits: Record<string, unknown> = {};
+    for (const field of fields) edits[field] = body[field];
+    if (typeof edits.description === 'string') {
+      const description = edits.description.trim();
+      edits.description = description;
+      if (description.length > MAX_PERSONA_DESCRIPTION_LENGTH) {
+        return jsonResponse({ error: 'description-too-long' }, 400);
+      }
+    }
+    try {
+      editPersona(personaId, edits, { dir });
+    } catch (error) {
+      if (error instanceof Error && error.message.startsWith('persona not found:')) {
+        return notFound(`persona ${personaId} not found in state store`);
+      }
+      if (error instanceof Error && error.message.startsWith('persona name already exists:')) {
+        return jsonResponse({ error: 'persona-name-conflict' }, 409);
+      }
+      return jsonResponse({ error: 'patch-failed', reason: error instanceof Error ? error.message : 'invalid-persona' }, 400);
+    }
   }
 
-  // Reload so the in-memory registry reflects the new description on the
+  // Reload so the in-memory registry reflects the saved fields on the
   // next GET. fs.watch would auto-reload but is async + race-y vs the
   // immediate echo below.
   await reloadGlobalPersonaRegistry();
@@ -255,7 +290,7 @@ export async function handlePersonaPatch(
   return jsonResponse({ persona: toWire(reloaded) }, 200);
 }
 
-/** Combined dispatcher — `/v1/personas[/:id]` + `/v1/personas/events`.
+/** Combined dispatcher — `/v1/persona-presets` + `/v1/personas[/:id]` + `/v1/personas/events`.
  *  Returns null when the pathname doesn't match so the caller chains. */
 export async function dispatchPersonaRoute(
   req: Request,
@@ -263,11 +298,14 @@ export async function dispatchPersonaRoute(
   opts: PersonaRouteOpts = {},
 ): Promise<Response | null> {
   const method = req.method.toUpperCase();
+  if (pathname === '/v1/persona-presets') {
+    if (method !== 'GET') return jsonResponse({ error: 'method not allowed' }, 405);
+    return handlePersonaPresets(req, opts);
+  }
   if (pathname === '/v1/personas') {
-    if (method !== 'GET') {
-      return jsonResponse({ error: 'method not allowed' }, 405);
-    }
-    return handlePersonasList(req, opts);
+    if (method === 'GET') return handlePersonasList(req, opts);
+    if (method === 'POST') return handlePersonaCreate(req, opts);
+    return jsonResponse({ error: 'method not allowed' }, 405);
   }
   // SSE — must come BEFORE the single-persona regex so that the
   // literal "events" segment isn't misread as a personaId.
@@ -279,8 +317,13 @@ export async function dispatchPersonaRoute(
   }
   const match = pathname.match(/^\/v1\/personas\/([^/]+)$/);
   if (!match) return null;
-  const personaId = decodeURIComponent(match[1]!);
+  let personaId: string;
+  try { personaId = decodeURIComponent(match[1]!); }
+  catch { return jsonResponse({ error: 'invalid-persona-id' }, 400); }
   if (method === 'PATCH') {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(personaId)) {
+      return jsonResponse({ error: 'invalid-persona-id' }, 400);
+    }
     return handlePersonaPatch(req, personaId, opts);
   }
   if (method !== 'GET') {

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/nexus/api/task-cards-api.ts

@@ -1,6 +1,25 @@
 import { CardStore } from '../../task-cards/card-store.js';
+import { createWishCard } from '../../intake-plane/wish-card.js';
 import { jsonResponse } from './json-response.js';
 
+export async function handleTaskCardsWishPost(req: Request, root?: string): Promise<Response> {
+  let body: unknown;
+  try { body = await req.json(); }
+  catch { return jsonResponse({ error: 'bad_request' }, 400); }
+  if (!body || typeof body !== 'object' || Array.isArray(body)) return jsonResponse({ error: 'bad_request' }, 400);
+  const { text, ref } = body as Record<string, unknown>;
+  if (typeof text !== 'string' || !text.trim() || typeof ref !== 'string' || !ref.trim()) {
+    return jsonResponse({ error: 'bad_request' }, 400);
+  }
+  const store = new CardStore(root);
+  try {
+    const card = createWishCard({ text, source: 'pwa', ref }, store);
+    return jsonResponse(card, card.created ? 201 : 200);
+  } finally {
+    store.close();
+  }
+}
+
 /** Read-only card API; route registration and authorization belong to the HTTP server. */
 export function handleTaskCardsGet(pathname: string, root?: string): Response {
   if (pathname !== '/v1/task-cards' && !/^\/v1\/task-cards\/[^/]+$/.test(pathname)) {