elanous 0.2.0 → 0.2.4

package/src/tool-runtime/acp-session-runtime.ts

@@ -38,7 +38,17 @@ import {
   type AcpPlanThenExecuteArgs,
   type AcpSessionStatusArgs,
 } from '../skills/tools/acp-session.js';
-import type { ToolRuntime } from './types.js';
+import type { ToolRuntime, ToolRuntimeContext } from './types.js';
+import { assertClaudeSubscriptionAllowed } from '../policy/claude-subscription-guard.js';
+
+function assertBackendAllowed(backendId: string, ctx: ToolRuntimeContext): void {
+  assertClaudeSubscriptionAllowed({ origin: ctx.requestOrigin ?? 'owner', backendId, surface: ctx.surface });
+}
+
+function assertSessionAllowed(sessionId: string, ctx: ToolRuntimeContext): void {
+  const backendId = /^acp-cli:([^:]+):/.exec(sessionId)?.[1];
+  if (backendId) assertBackendAllowed(backendId, ctx);
+}
 
 // Output types are widened to `any` the way other multi-field runtimes
 // (context-runtime, control-runtime, ...) do — ToolRunResult's union
@@ -49,7 +59,9 @@ import type { ToolRuntime } from './types.js';
 export const acpSessionCreateRuntime: ToolRuntime<AcpSessionCreateArgs, any> = {
   id: 'acp_session_create',
   spec: buildAcpSessionCreateTool(),
-  async run(req) {
+  async run(req, ctx) {
+    assertBackendAllowed(req.brand, ctx);
+    if (req.parentSessionId) assertSessionAllowed(req.parentSessionId, ctx);
     return dispatchAcpSessionCreate(req);
   },
 };
@@ -57,7 +69,8 @@ export const acpSessionCreateRuntime: ToolRuntime<AcpSessionCreateArgs, any> = {
 export const acpSessionSendRuntime: ToolRuntime<AcpSessionSendArgs, any> = {
   id: 'acp_session_send',
   spec: buildAcpSessionSendTool(),
-  async run(req) {
+  async run(req, ctx) {
+    assertSessionAllowed(req.sessionId, ctx);
     return dispatchAcpSessionSend(req);
   },
 };
@@ -82,7 +95,8 @@ export const acpSessionListRuntime: ToolRuntime<AcpSessionListArgs, any> = {
 export const acpSessionResumeRuntime: ToolRuntime<AcpSessionResumeArgs, any> = {
   id: 'acp_session_resume',
   spec: buildAcpSessionResumeTool(),
-  async run(req) {
+  async run(req, ctx) {
+    assertSessionAllowed(req.sessionId, ctx);
     return dispatchAcpSessionResume(req);
   },
 };
@@ -91,7 +105,9 @@ export const acpSessionResumeRuntime: ToolRuntime<AcpSessionResumeArgs, any> = {
 export const acpSessionSpawnSubRuntime: ToolRuntime<AcpSessionSpawnSubArgs, any> = {
   id: 'acp_session_spawn_sub',
   spec: buildAcpSessionSpawnSubTool(),
-  async run(req) {
+  async run(req, ctx) {
+    assertBackendAllowed(req.brand, ctx);
+    assertSessionAllowed(req.parentSessionId, ctx);
     return dispatchAcpSessionSpawnSub(req);
   },
 };
@@ -100,7 +116,10 @@ export const acpSessionSpawnSubRuntime: ToolRuntime<AcpSessionSpawnSubArgs, any>
 export const acpPlanThenExecuteRuntime: ToolRuntime<AcpPlanThenExecuteArgs, any> = {
   id: 'acp_plan_then_execute',
   spec: buildAcpPlanThenExecuteTool(),
-  async run(req) {
+  async run(req, ctx) {
+    assertBackendAllowed(req.brand, ctx);
+    assertBackendAllowed(req.executeBrand ?? req.brand, ctx);
+    assertSessionAllowed(req.parentSessionId, ctx);
     return dispatchAcpPlanThenExecute(req);
   },
 };
@@ -109,7 +128,9 @@ export const acpPlanThenExecuteRuntime: ToolRuntime<AcpPlanThenExecuteArgs, any>
 export const acpSessionStartBackgroundRuntime: ToolRuntime<AcpSessionStartBackgroundArgs, any> = {
   id: 'acp_session_start_background',
   spec: buildAcpSessionStartBackgroundTool(),
-  async run(req) {
+  async run(req, ctx) {
+    assertBackendAllowed(req.brand, ctx);
+    if (req.parentSessionId) assertSessionAllowed(req.parentSessionId, ctx);
     return dispatchAcpSessionStartBackground(req);
   },
 };

package/src/tool-runtime/agent-runtime.ts

@@ -10,6 +10,7 @@ export const agentRuntime: ToolRuntime<Record<string, unknown>, AgentToolResult>
   spec: buildAgentTool(),
   async run(req, ctx) {
     return await dispatchAgent(req, {
+      ...(ctx.agentCwd ? { cwd: ctx.agentCwd } : {}),
       hostTools: ctx.agentHostTools,
       dispatchTool: ctx.agentDispatchTool,
       buildChildToolCatalog: ctx.buildChildToolCatalog,

package/src/tool-runtime/context-runtime.ts

@@ -4,20 +4,13 @@
 // filtering (skill vs dashboard vs mcp) and approval gating stay per-
 // tool. All read-only → no approver slot used.
 //
-// Shared deps (cwd/remoteHost, window-registry getter, session getter,
-// pane-capture) flow through a DI record set at dashboard boot — skills
-// call this with {} and still receive useful answers for workspace/
-// tools/ptys/events which don't need dashboard state.
-//
-// Surface-unification v2.2 V2.2-5 (2026-05-11) — scheduler getter slot
-// retired with the `context.jobs.list` tool (scheduler view 폐기).
+// Shared deps (cwd/remoteHost, session getter) flow through a DI record
+// set at dashboard boot. Skills call this with {} and still receive
+// useful answers from ambient workspace/tools/ptys/events state.
 
 import {
   buildContextTools,
   dispatchContextWorkspace,
-  dispatchContextWindowsList,
-  dispatchContextWindowDetail,
-  dispatchContextPaneDetail,
   dispatchContextPtysList,
   dispatchContextPtyDetail,
   dispatchContextSessionsList,
@@ -32,50 +25,40 @@ import type { ToolRuntime } from './types.js';
 
 let deps: ContextDeps = {};
 
-/** Dashboard boot wires cwd/remote/window-registry/session/scheduler
- *  here so `context.*` tools see the live rig. Skills call this with
- *  {} and still get useful answers for workspace/tools/ptys/events. */
+/** Dashboard boot wires cwd/remote/session here so context tools see
+ *  the live rig. Skills still get ambient workspace/tools/ptys/events. */
 export function setContextRuntimeDeps(next: ContextDeps): void {
   deps = { ...next };
 }
 
 function asRuntime<Req extends Record<string, unknown>>(
   id: string,
-  specIdx: number,
+  name: string,
   fn: (req: Req, deps?: ContextDeps) => Promise<unknown>,
 ): ToolRuntime<Req, any> {
-  const specs = buildContextTools();
+  const spec = buildContextTools().find(tool => tool.name === name);
+  if (!spec) throw new Error(`missing context tool spec: ${name}`);
   return {
     id,
-    spec: specs[specIdx]!,
+    spec,
     async run(req) {
       return fn(req, deps) as Promise<any>;
     },
   };
 }
 
-// Tool index mirrors buildContextTools() order — keep in sync.
-export const contextWorkspaceRuntime     = asRuntime('context_workspace',       0,  dispatchContextWorkspace);
-export const contextWindowsListRuntime   = asRuntime('context_windows_list',    1,  dispatchContextWindowsList);
-export const contextWindowDetailRuntime  = asRuntime('context_window_detail',   2,  dispatchContextWindowDetail);
-export const contextPaneDetailRuntime    = asRuntime('context_pane_detail',     3,  dispatchContextPaneDetail);
-export const contextPtysListRuntime      = asRuntime('context_ptys_list',       4,  dispatchContextPtysList);
-export const contextPtyDetailRuntime     = asRuntime('context_pty_detail',      5,  dispatchContextPtyDetail);
-export const contextSessionsListRuntime  = asRuntime('context_sessions_list',   6,  dispatchContextSessionsList);
-// Surface-unification v2.2 V2.2-5 (2026-05-11) — `contextJobsListRuntime`
-// retired (scheduler view 폐기 · spec idx 7 자리 빈 슬롯이 아니라 후속
-// runtime 들이 한 칸씩 위로 시프트).
-export const contextWidgetsListRuntime   = asRuntime('context_widgets_list',    7,  dispatchContextWidgetsList);
-export const contextPluginsListRuntime   = asRuntime('context_plugins_list',    8,  dispatchContextPluginsList);
-export const contextToolsListRuntime     = asRuntime('context_tools_list',      9,  dispatchContextToolsList);
-export const contextEventsTailRuntime    = asRuntime('context_events_tail',    10,  dispatchContextEventsTail);
-export const contextBootstrapRuntime     = asRuntime('context_bootstrap',      11,  dispatchContextBootstrap);
+export const contextWorkspaceRuntime    = asRuntime('context_workspace',     'ContextWorkspace',     dispatchContextWorkspace);
+export const contextPtysListRuntime     = asRuntime('context_ptys_list',     'ContextPtysList',      dispatchContextPtysList);
+export const contextPtyDetailRuntime    = asRuntime('context_pty_detail',    'ContextPtyDetail',      dispatchContextPtyDetail);
+export const contextSessionsListRuntime = asRuntime('context_sessions_list', 'ContextSessionsList',   dispatchContextSessionsList);
+export const contextWidgetsListRuntime  = asRuntime('context_widgets_list',  'ContextWidgetsList',    dispatchContextWidgetsList);
+export const contextPluginsListRuntime  = asRuntime('context_plugins_list',  'ContextPluginsList',    dispatchContextPluginsList);
+export const contextToolsListRuntime    = asRuntime('context_tools_list',    'ContextToolsList',      dispatchContextToolsList);
+export const contextEventsTailRuntime   = asRuntime('context_events_tail',   'ContextEventsTail',     dispatchContextEventsTail);
+export const contextBootstrapRuntime    = asRuntime('context_bootstrap',     'ContextBootstrap',      dispatchContextBootstrap);
 
 export const ALL_CONTEXT_RUNTIMES: ToolRuntime<any, any>[] = [
   contextWorkspaceRuntime,
-  contextWindowsListRuntime,
-  contextWindowDetailRuntime,
-  contextPaneDetailRuntime,
   contextPtysListRuntime,
   contextPtyDetailRuntime,
   contextSessionsListRuntime,

package/src/tool-runtime/control-runtime.ts

@@ -1,15 +1,7 @@
-// ── Control tool runtimes — Phase D wiring ──
-//
-// Five mutation tools sit next to the existing virtual-window /
-// PTY-shell surfaces rather than replacing them. Each is exposed via
-// `skill` + `dashboard` surfaces; none on `mcp` by default (mutating
-// — add per-tool when an external flow needs it).
+// ── Control tool runtimes ──
 
 import {
   buildControlTools,
-  dispatchControlWindowResize,
-  dispatchControlPaneResize,
-  dispatchControlPaneLayout,
   dispatchControlToolToggle,
   dispatchControlPromptAppend,
   dispatchControlPromptClear,
@@ -18,30 +10,25 @@ import type { ToolRuntime } from './types.js';
 
 function asRuntime<Req extends Record<string, unknown>>(
   id: string,
-  specIdx: number,
+  name: string,
   fn: (req: Req) => Promise<unknown>,
 ): ToolRuntime<Req, any> {
-  const specs = buildControlTools();
+  const spec = buildControlTools().find(tool => tool.name === name);
+  if (!spec) throw new Error(`missing control tool spec: ${name}`);
   return {
     id,
-    spec: specs[specIdx]!,
+    spec,
     async run(req) {
       return fn(req) as Promise<any>;
     },
   };
 }
 
-export const controlWindowResizeRuntime  = asRuntime('control_window_resize',  0, dispatchControlWindowResize);
-export const controlPaneResizeRuntime    = asRuntime('control_pane_resize',    1, dispatchControlPaneResize);
-export const controlPaneLayoutRuntime    = asRuntime('control_pane_layout',    2, dispatchControlPaneLayout);
-export const controlToolToggleRuntime    = asRuntime('control_tool_toggle',    3, dispatchControlToolToggle);
-export const controlPromptAppendRuntime  = asRuntime('control_prompt_append',  4, dispatchControlPromptAppend);
-export const controlPromptClearRuntime   = asRuntime('control_prompt_clear',   5, dispatchControlPromptClear);
+export const controlToolToggleRuntime   = asRuntime('control_tool_toggle',   'ControlToolToggle',   dispatchControlToolToggle);
+export const controlPromptAppendRuntime = asRuntime('control_prompt_append', 'ControlPromptAppend', dispatchControlPromptAppend);
+export const controlPromptClearRuntime  = asRuntime('control_prompt_clear',  'ControlPromptClear',  dispatchControlPromptClear);
 
 export const ALL_CONTROL_RUNTIMES: ToolRuntime<any, any>[] = [
-  controlWindowResizeRuntime,
-  controlPaneResizeRuntime,
-  controlPaneLayoutRuntime,
   controlToolToggleRuntime,
   controlPromptAppendRuntime,
   controlPromptClearRuntime,

package/src/tool-runtime/dashboard-state-runtime.ts

@@ -63,18 +63,14 @@ export const dashboardStateRuntime: ToolRuntime<Record<string, unknown>, Dashboa
     const recentTerminalMouseIntents = (() => {
       try { return terminalMouseIntentsGetter?.() ?? []; } catch { return []; }
     })();
-    const includeVirtualWindows =
-      typeof req.includeVirtualWindows === 'boolean' ? req.includeVirtualWindows : undefined;
     const result = await dispatchGetDashboardState(req, {
       terminalSessions,
       dashboardToolNames,
       recentTerminalMouseIntents,
-      includeVirtualWindows,
     });
     const stableStateHash = createHash('sha1')
       .update(JSON.stringify({
         workspace: result.snapshot.workspace,
-        windows: result.snapshot.windows,
         ptys: result.snapshot.ptys,
         tools: result.snapshot.tools,
         terminalSessions: result.snapshot.terminalSessions,
@@ -91,7 +87,7 @@ export const dashboardStateRuntime: ToolRuntime<Record<string, unknown>, Dashboa
           `[DUPLICATE CALL — state unchanged]\n` +
           `GetDashboardState\n` +
           `Dashboard state is unchanged from ${secondsAgo}s ago. ` +
-          `Use the previous tool_result already in history unless an intervening action changed layout, sessions, cwd, or tool exposure.`,
+          `Use the previous tool_result already in history unless an intervening action changed sessions, cwd, or tool exposure.`,
       };
     }
 

package/src/tool-runtime/elanous-asana-runtimes.ts

@@ -0,0 +1,205 @@
+import type { LLMToolSpec } from '../llm.js';
+import { debug } from '../debug/log.js';
+import { getSecret } from '../nexus/config/secrets/index.js';
+import type { ToolRuntime } from './types.js';
+
+const BASE = 'https://app.asana.com/api/1.0';
+const TOKEN_MISSING = 'Asana 토큰이 없다 — 비밀 connector.asana.token 을 넣어라';
+const PRIORITIES = ['urgent', 'high', 'medium', 'low'] as const;
+const TASK_FIELDS = 'name,notes,permalink_url,modified_at,created_at,completed,custom_fields.name,custom_fields.enum_value.name';
+type Priority = typeof PRIORITIES[number];
+type Args = Record<string, unknown>;
+type Result = { ok: boolean; output: string; [key: string]: unknown };
+type Page<T> = { data: T; next_page?: { uri?: string } | null };
+type Workspace = { gid: string; name: string };
+type Project = { gid: string; name: string };
+type Field = { gid: string; name: string; enum_options?: Array<{ gid: string; name: string }> };
+type Task = {
+  gid: string; name: string; notes?: string; permalink_url?: string;
+  completed: boolean; created_at?: string; modified_at?: string;
+  custom_fields?: Array<{ name: string; enum_value?: { name: string } | null }>;
+};
+
+const productionDeps = { fetch: (input: string, init: RequestInit) => fetch(input, init), getSecret };
+let deps = productionDeps;
+
+/** Inject fake HTTP and secret access without reading or writing the real secret store. */
+export function setElanousAsanaDepsForTest(overrides: Partial<typeof productionDeps>): () => void {
+  if (deps !== productionDeps) throw new Error('Asana dependencies already injected');
+  const injected = { ...productionDeps, ...overrides };
+  deps = injected;
+  return () => { if (deps === injected) deps = productionDeps; };
+}
+
+function spec(name: string, description: string, properties: Record<string, unknown>, required: string[] = []): LLMToolSpec {
+  return { name, description, parameters: { type: 'object', properties, required, additionalProperties: false } };
+}
+const string = { type: 'string' };
+const boolean = { type: 'boolean' };
+const priority = { type: 'string', enum: [...PRIORITIES] };
+
+function requiredString(value: unknown, field: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`${field} 값이 필요하다`);
+  return value.trim();
+}
+function optionalString(value: unknown, field: string): string | undefined {
+  return value === undefined ? undefined : requiredString(value, field);
+}
+function optionalBoolean(value: unknown, field: string, fallback: boolean): boolean {
+  if (value === undefined) return fallback;
+  if (typeof value !== 'boolean') throw new Error(`${field} 는 boolean 이어야 한다`);
+  return value;
+}
+function parsePriority(value: unknown): Priority | undefined {
+  if (value === undefined) return undefined;
+  if (typeof value !== 'string' || !PRIORITIES.includes(value as Priority)) throw new Error('priority 는 urgent, high, medium, low 중 하나여야 한다');
+  return value as Priority;
+}
+function taskPriority(task: Task): Priority | null {
+  const value = task.custom_fields?.find(field => field.name === 'Priority')?.enum_value?.name?.toLowerCase();
+  return PRIORITIES.find(p => p === value) ?? null;
+}
+function taskView(task: Task) {
+  return {
+    gid: task.gid, name: task.name, notes: task.notes ?? '', url: task.permalink_url ?? '',
+    priority: taskPriority(task), completed: task.completed,
+    createdAt: task.created_at ?? null, modifiedAt: task.modified_at ?? null,
+  };
+}
+
+async function request<T>(token: string, path: string, method = 'GET', data?: unknown): Promise<Page<T>> {
+  // Asana's pagination URI is absolute; never forward the bearer credential to another origin.
+  const url = new URL(path.startsWith('/') ? path.slice(1) : path, BASE + '/');
+  if (url.origin !== new URL(BASE).origin || !url.pathname.startsWith('/api/1.0/')) throw new Error('Asana 페이지 주소가 올바르지 않다');
+  const response = await deps.fetch(url.href, {
+    method,
+    headers: { Authorization: `Bearer ${token}`, ...(data === undefined ? {} : { 'Content-Type': 'application/json' }) },
+    ...(data === undefined ? {} : { body: JSON.stringify({ data }) }),
+    redirect: 'error',
+  });
+  if (!response.ok) throw new AsanaHttpError(response.status);
+  return await response.json() as Page<T>;
+}
+class AsanaHttpError extends Error {
+  constructor(readonly status: number) { super(`Asana HTTP ${status}`); }
+}
+class AsanaProjectNotFound extends Error {}
+async function pages<T>(token: string, path: string): Promise<T[]> {
+  const items: T[] = [];
+  const visited = new Set<string>();
+  let next: string | undefined = path;
+  while (next) {
+    if (visited.has(next)) throw new Error('Asana 페이지 순환');
+    visited.add(next);
+    const page: Page<T[]> = await request<T[]>(token, next);
+    items.push(...page.data);
+    next = page.next_page?.uri;
+  }
+  return items;
+}
+
+async function resolveProject(token: string, raw: Args): Promise<string> {
+  const project = optionalString(raw.project, 'project');
+  if (project) return project;
+  const name = requiredString(raw.projectName, 'projectName');
+  const workspace = optionalString(raw.workspace, 'workspace');
+  const workspaces = workspace ? [{ gid: workspace }] : (await request<{ workspaces: Workspace[] }>(token, '/users/me')).data.workspaces;
+  for (const ws of workspaces) {
+    const projects = await pages<Project>(token, `/workspaces/${encodeURIComponent(ws.gid)}/projects?opt_fields=name`);
+    const found = projects.find(p => p.name === name);
+    if (found) return found.gid;
+  }
+  throw new AsanaProjectNotFound(`Asana 프로젝트 '${name}' 을 찾지 못했다`);
+}
+
+async function listTasks(token: string, raw: Args): Promise<Result> {
+  const project = await resolveProject(token, raw);
+  const completed = optionalBoolean(raw.completed, 'completed', false);
+  const prefix = optionalString(raw.prefix, 'prefix');
+  const tasks = (await pages<Task>(token, `/projects/${encodeURIComponent(project)}/tasks?opt_fields=${TASK_FIELDS}${completed ? '&completed_since=1970-01-01T00:00:00.000Z' : ''}`))
+    .filter(task => task.completed === completed && (prefix === undefined || task.name.startsWith(prefix)))
+    .map(taskView);
+  return { ok: true, output: `Asana 태스크 ${tasks.length}개`, tasks };
+}
+
+async function createTask(token: string, raw: Args): Promise<Result> {
+  const project = requiredString(raw.project, 'project');
+  const name = requiredString(raw.name, 'name');
+  const notes = optionalString(raw.notes, 'notes');
+  const wanted = parsePriority(raw.priority);
+  let customFields: Record<string, string> | undefined;
+  if (wanted) {
+    const settings = await pages<{ custom_field: Field }>(token,
+      `/projects/${encodeURIComponent(project)}/custom_field_settings?opt_fields=custom_field.name,custom_field.gid,custom_field.enum_options.name,custom_field.enum_options.gid`);
+    const field = settings.find(s => s.custom_field.name === 'Priority')?.custom_field;
+    const option = field?.enum_options?.find(o => o.name.toLowerCase() === wanted);
+    if (field && option) customFields = { [field.gid]: option.gid };
+  }
+  const data = { projects: [project], name, ...(notes === undefined ? {} : { notes }), ...(customFields ? { custom_fields: customFields } : {}) };
+  const task = (await request<Task>(token, `/tasks?opt_fields=${TASK_FIELDS}`, 'POST', data)).data;
+  return { ok: true, output: `Asana 태스크 생성: ${task.gid}`, task: taskView(task), priorityApplied: !!customFields };
+}
+
+async function comment(token: string, raw: Args): Promise<Result> {
+  const task = requiredString(raw.task, 'task');
+  const text = requiredString(raw.text, 'text');
+  const story = (await request<{ gid: string }>(token, `/tasks/${encodeURIComponent(task)}/stories`, 'POST', { text })).data;
+  return { ok: true, output: `Asana 댓글 생성: ${story.gid}`, story: { gid: story.gid } };
+}
+
+async function complete(token: string, raw: Args): Promise<Result> {
+  const task = requiredString(raw.task, 'task');
+  const completed = optionalBoolean(raw.completed, 'completed', true);
+  const updated = (await request<Task>(token, `/tasks/${encodeURIComponent(task)}?opt_fields=${TASK_FIELDS}`, 'PUT', { completed })).data;
+  return { ok: true, output: `Asana 태스크 ${task}: completed=${completed}`, task: taskView(updated) };
+}
+
+function redactToken<T>(value: T, token: string): T {
+  if (typeof value === 'string') return value.replaceAll(token, '[redacted]') as T;
+  if (Array.isArray(value)) return value.map(item => redactToken(item, token)) as T;
+  if (value && typeof value === 'object') {
+    return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, redactToken(item, token)])) as T;
+  }
+  return value;
+}
+
+function runtime(name: string, toolSpec: LLMToolSpec, action: (token: string, args: Args) => Promise<Result>): ToolRuntime<Args, Result> {
+  return {
+    id: name, spec: toolSpec,
+    async run(args) {
+      let status: number | undefined;
+      let result: Result;
+      let token: string | undefined;
+      try {
+        token = deps.getSecret('connector.asana.token');
+        result = !token ? { ok: false, output: TOKEN_MISSING } : redactToken(await action(token, args), token);
+      } catch (error) {
+        // Never surface a transport exception or response body: either can contain the bearer token.
+        status = error instanceof AsanaHttpError ? error.status : undefined;
+        const missingProject = error instanceof AsanaProjectNotFound ? error.message : undefined;
+        result = { ok: false, output: missingProject ? (token ? redactToken(missingProject, token) : missingProject) : status ? `Asana 요청 실패 (HTTP ${status})` : 'Asana 요청 실패' };
+      }
+      debug.log('tool.asana', 'called', {
+        tool: name, ok: result.ok, ...(status === undefined ? {} : { status }),
+        ...(Array.isArray(result.tasks) ? { count: result.tasks.length } : {}),
+      });
+      return result;
+    },
+  };
+}
+
+export const ELANOUS_ASANA_RUNTIMES: ReadonlyArray<ToolRuntime<Args, Result>> = [
+  runtime('elanous_asana_workspaces', spec('elanous_asana_workspaces', 'List Asana workspaces for the current user.', {}),
+    async token => {
+      const workspaces = (await request<{ workspaces: Workspace[] }>(token, '/users/me')).data.workspaces.map(({ gid, name }) => ({ gid, name }));
+      return { ok: true, output: `Asana 워크스페이스 ${workspaces.length}개`, workspaces };
+    }),
+  runtime('elanous_asana_list_tasks', spec('elanous_asana_list_tasks', 'List project tasks across all Asana pages; defaults to incomplete tasks.',
+    { project: string, projectName: string, workspace: string, completed: boolean, prefix: string }), listTasks),
+  runtime('elanous_asana_create_task', spec('elanous_asana_create_task', 'Create an Asana task in a project with optional Priority enum.',
+    { project: string, name: string, notes: string, priority }, ['project', 'name']), createTask),
+  runtime('elanous_asana_comment', spec('elanous_asana_comment', 'Post a comment on an Asana task.',
+    { task: string, text: string }, ['task', 'text']), comment),
+  runtime('elanous_asana_complete', spec('elanous_asana_complete', 'Set an Asana task completed flag (defaults true).',
+    { task: string, completed: boolean }, ['task']), complete),
+];

package/src/tool-runtime/elanous-control-runtimes.ts

@@ -15,9 +15,10 @@ import {
   type PtyControlResult,
 } from '../pty-shell/pty-control-ipc.js';
 import { resolvePtySpecialKey } from '../pty-shell/pty-special-keys.js';
+import { encodeSgrMouse, type PtyMouseInput } from '../pty-shell/pty-mouse.js';
 import type { ToolRuntime } from './types.js';
 
-const PTY_ACTIONS = ['takeover', 'release', 'input-text', 'input-key', 'resize', 'snapshot', 'rename', 'terminate', 'capabilities'] as const;
+const PTY_ACTIONS = ['takeover', 'release', 'input-text', 'input-key', 'input-mouse', 'resize', 'snapshot', 'rename', 'terminate', 'capabilities'] as const;
 const DEFAULT_TIMEOUT_MS = 2_000;
 const DEFAULT_HOLD_TIMEOUT_MS = 90_000;
 const HOLD_OWNER_REGISTRATION_BUDGET_MS = 8_700;
@@ -76,13 +77,17 @@ export function buildElanousHoldTool(): LLMToolSpec {
 export function buildPtyControlTool(): LLMToolSpec {
   return {
     name: 'PtyControl',
-    description: 'Control a registered PTY through its owning process: inspect, take/release ownership, send input, resize, rename, or terminate.',
+    description: 'Control a registered PTY through its owning process: inspect, take/release ownership, send text/key/mouse input, resize, rename, or terminate. Mouse requires enabled SGR tracking on the owning PTY.',
     parameters: {
       type: 'object',
       properties: {
         ptyId: { type: 'string', description: 'Registered PTY id.' },
         action: { type: 'string', enum: [...PTY_ACTIONS] },
         text: { type: 'string', description: 'Required for input-text as literal text, or input-key as a key name (enter, esc, tab, up, down, left, right, backspace, ctrl+c, etc.).' },
+        x: { type: 'integer', description: 'Required for input-mouse; 1-based column.' },
+        y: { type: 'integer', description: 'Required for input-mouse; 1-based row.' },
+        kind: { type: 'string', enum: ['click', 'scroll-up', 'scroll-down'] },
+        button: { type: 'string', enum: ['left', 'middle', 'right'] },
         cols: { type: 'integer', description: 'Required for resize; positive integer.' },
         rows: { type: 'integer', description: 'Required for resize; positive integer.' },
         ansi: { type: 'boolean', description: 'Optional ANSI reconstruction for snapshot.' },
@@ -278,6 +283,15 @@ function parseActor(value: unknown): 'human' | 'agent' {
 function payloadFor(action: PtyControlAction, raw: Args): PtyControlPayload | undefined {
   if (action === 'input-text') return { chars: requiredInput(raw.text, 'text') };
   if (action === 'input-key') return { chars: resolvePtySpecialKey(requiredInput(raw.text, 'text')) };
+  if (action === 'input-mouse') {
+    const kind = raw.kind;
+    const button = raw.button ?? 'left';
+    if (kind !== 'click' && kind !== 'scroll-up' && kind !== 'scroll-down') throw new Error("'kind' must be click, scroll-up or scroll-down");
+    if (button !== 'left' && button !== 'middle' && button !== 'right') throw new Error("'button' must be left, middle or right");
+    const input: PtyMouseInput = { x: positiveInteger(raw.x, 'x'), y: positiveInteger(raw.y, 'y'), kind, button };
+    encodeSgrMouse(input);
+    return input;
+  }
   if (action === 'resize') return { cols: positiveInteger(raw.cols, 'cols'), rows: positiveInteger(raw.rows, 'rows') };
   if (action === 'snapshot') {
     if (raw.ansi !== undefined && typeof raw.ansi !== 'boolean') throw new Error("'ansi' must be a boolean");

package/src/tool-runtime/elanous-task-submit-runtime.ts

@@ -0,0 +1,124 @@
+// `elanous_task_submit` MCP tool — another agent (Claude Code · Codex · Grok, through the
+// elanous plugin) hands a piece of work to elanous. It goes through the daemon's external
+// entrance POST /v1/tasks as provider `agent-plugin`, so it waits for approval like any
+// other outside input (RFC external tasks §A7 · S2).
+
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { LLMToolSpec } from '../llm.js';
+import { debug } from '../debug/log.js';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import { defaultBaseUrl } from '../telegram-dispatch-forward.js';
+import type { ToolRuntime, ToolRuntimeContext } from './types.js';
+
+export interface ElanousTaskSubmitArgs {
+  title?: unknown;
+  description?: unknown;
+  priority?: unknown;
+  ref?: unknown;
+  url?: unknown;
+}
+
+export interface ElanousTaskSubmitDeps {
+  baseUrl?: () => string | null;
+  token?: () => string | null;
+  fetchImpl?: typeof fetch;
+}
+
+let testDeps: ElanousTaskSubmitDeps | undefined;
+
+/** Test seam — restore with `setElanousTaskSubmitDepsForTest(undefined)`. */
+export function setElanousTaskSubmitDepsForTest(deps: ElanousTaskSubmitDeps | undefined): void {
+  testDeps = deps;
+}
+
+function readToken(): string | null {
+  const p = join(getElanousConfigDir(), 'acp-token');
+  try { return existsSync(p) ? readFileSync(p, 'utf-8').trim() || null : null; } catch { return null; }
+}
+
+export function buildElanousTaskSubmitTool(): LLMToolSpec {
+  return {
+    name: 'elanous_task_submit',
+    description:
+      'Hand a task to elanous (the local agent orchestrator). It is queued in elanous TOX as an external task from this agent and waits for the owner to approve it before anything runs. Use when the user asks to give work to elanous, or to queue follow-up work for later. Returns the task id. Submitting the same ref again updates that task instead of adding a new one.',
+    parameters: {
+      type: 'object',
+      required: ['title'],
+      properties: {
+        title: { type: 'string', description: 'One line: what should be done.' },
+        description: { type: 'string', description: 'Context, acceptance criteria, links. Stored as material, not as instructions to run.' },
+        priority: { type: 'string', enum: ['low', 'medium', 'high'], description: 'Default medium.' },
+        ref: { type: 'string', description: 'Your own stable id for this item (issue key, PR URL, note path). Same ref = same task.' },
+        url: { type: 'string', description: 'Link back to where the task came from.' },
+      },
+    },
+  };
+}
+
+function str(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+export async function submitElanousTask(
+  args: ElanousTaskSubmitArgs,
+  ctx: Pick<ToolRuntimeContext, 'mcpClient'>,
+  deps: ElanousTaskSubmitDeps = testDeps ?? {},
+): Promise<{ output: string; taskId?: string; deduplicated?: boolean; error?: string }> {
+  const title = str(args.title);
+  if (!title) return { output: 'elanous_task_submit: title is required', error: 'invalid-args' };
+  const priority = str(args.priority);
+  if (priority !== undefined && priority !== 'low' && priority !== 'medium' && priority !== 'high') {
+    return { output: 'elanous_task_submit: priority must be low | medium | high', error: 'invalid-args' };
+  }
+  const description = str(args.description);
+  const agent = (ctx.mcpClient ?? 'agent').replace(/\s+/g, '-');
+  const itemRef = str(args.ref) ?? createHash('sha256').update(`${title}\n${description ?? ''}`).digest('hex').slice(0, 12);
+  const ref = `${agent}:${itemRef}`;
+  const base = (deps.baseUrl ?? (() => defaultBaseUrl()))();
+  if (base === null) {
+    debug.log('tool.task-submit', 'refused', { agent, ref, reason: 'no-daemon' });
+    return { output: 'elanous_task_submit: the elanous daemon is not running in this universe — start it with `elanous nexus`, then submit again.', error: 'no-daemon' };
+  }
+  const token = (deps.token ?? readToken)();
+  const url = str(args.url);
+  const body = {
+    title,
+    ...(description ? { description } : {}),
+    ...(priority ? { priority } : {}),
+    external: { provider: 'agent-plugin', ref, ...(url ? { url } : {}) },
+  };
+  try {
+    const res = await (deps.fetchImpl ?? fetch)(`${base}/v1/tasks`, {
+      method: 'POST',
+      headers: { 'content-type': 'application/json', ...(token ? { authorization: `Bearer ${token}` } : {}) },
+      body: JSON.stringify(body),
+    });
+    const payload = await res.json().catch(() => ({})) as { taskId?: string; deduplicated?: boolean; reason?: string; error?: string };
+    if (!res.ok || !payload.taskId) {
+      const reason = payload.reason ?? payload.error ?? `http ${res.status}`;
+      debug.log('tool.task-submit', 'refused', { agent, ref, status: res.status, reason });
+      return { output: `elanous_task_submit: elanous refused the task (${res.status}: ${reason})`, error: 'refused' };
+    }
+    const deduplicated = payload.deduplicated === true;
+    debug.log('tool.task-submit', 'submitted', { agent, ref, taskId: payload.taskId, deduplicated });
+    return {
+      output: `${deduplicated ? 'Updated' : 'Queued'} elanous task ${payload.taskId} (ref ${ref}). It waits for the owner's approval before it runs.`,
+      taskId: payload.taskId,
+      deduplicated,
+    };
+  } catch (err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    debug.log('tool.task-submit', 'refused', { agent, ref, reason });
+    return { output: `elanous_task_submit: could not reach elanous at ${base} (${reason})`, error: 'unreachable' };
+  }
+}
+
+export const elanousTaskSubmitRuntime: ToolRuntime<ElanousTaskSubmitArgs> = {
+  id: 'elanous_task_submit',
+  spec: buildElanousTaskSubmitTool(),
+  async run(req, ctx) {
+    return submitElanousTask(req, ctx);
+  },
+};