tycono 0.1.89-beta.0 → 0.1.89-beta.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.89-beta.0",
+  "version": "0.1.89-beta.1",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {

package/src/api/src/create-server.ts

@@ -21,6 +21,7 @@ import { engineRouter } from './routes/engine.js';
 import { sessionsRouter } from './routes/sessions.js';
 import { setupRouter } from './routes/setup.js';
 import { getAllActivities, completeActivity } from './services/activity-tracker.js';
+import { type RoleStatus, isRoleActive } from '../../shared/types';
 import { knowledgeRouter } from './routes/knowledge.js';
 import { preferencesRouter } from './routes/preferences.js';
 import { saveRouter } from './routes/save.js';
@@ -50,7 +51,7 @@ const corsOrigin = isProd ? true : /^http:\/\/localhost:\d+$/;
 function cleanupStaleActivities(): void {
   const activities = getAllActivities();
   for (const activity of activities) {
-    if (activity.status === 'working') {
+    if (isRoleActive(activity.status as RoleStatus)) {
       completeActivity(activity.roleId);
       console.log(`[STARTUP] Cleaned stale activity: ${activity.roleId} (was working on "${activity.currentTask}")`);
     }

package/src/api/src/engine/agent-loop.ts

@@ -35,6 +35,8 @@ export interface AgentConfig {
   onDispatch?: (roleId: string, task: string) => void;
   onConsult?: (roleId: string, question: string) => void;
   onTurnComplete?: (turn: number) => void;
+  /** Trace: emitted when system prompt is assembled */
+  onPromptAssembled?: (systemPrompt: string, userTask: string) => void;
 }
 
 export interface AgentResult {
@@ -124,6 +126,9 @@ export async function runAgentLoop(config: AgentConfig): Promise<AgentResult> {
   // 1. Assemble context
   const context = assembleContext(companyRoot, roleId, task, sourceRole, orgTree, { teamStatus: config.teamStatus, targetRoles: config.targetRoles });
 
+  // Trace: capture assembled prompt for debugging
+  config.onPromptAssembled?.(context.systemPrompt, task);
+
   // 2. Determine tools
   const subordinates = getSubordinates(orgTree, roleId);
   const hasBash = !readOnly && !!config.codeRoot;

package/src/api/src/engine/context-assembler.ts

@@ -42,7 +42,8 @@ export interface AssembledContext {
  * 8. CEO Decisions (전사 공지 — Approved 결정만)
  * 9. Task
  */
-export type TeamStatus = Record<string, { status: string; task?: string }>;
+export type { TeamStatus } from '../../../shared/types';
+import { type RoleStatus, type TeamStatus, isRoleActive } from '../../../shared/types';
 
 export function assembleContext(
   companyRoot: string,
@@ -461,7 +462,7 @@ function buildDispatchSection(orgTree: OrgTree, roleId: string, subordinates: st
 
     // Header: name, id, persona summary
     const st = teamStatus?.[id];
-    const status = st?.status === 'working'
+    const status = st?.status && isRoleActive(st.status)
       ? `🔴 Working${st.task ? ` — "${st.task.slice(0, 60)}"` : ''}`
       : '🟢 Idle';
     lines.push(`### ${sub.name} (\`${id}\`) — ${status}`);

package/src/api/src/engine/runners/claude-cli.ts

@@ -267,6 +267,9 @@ export class ClaudeCliRunner implements ExecutionRunner {
     // 1. Context Assembly
     const context = assembleContext(companyRoot, roleId, task, sourceRole, orgTree, { teamStatus, targetRoles });
 
+    // Trace: capture assembled prompt for debugging
+    callbacks.onPromptAssembled?.(context.systemPrompt, task);
+
     // 2. System prompt를 임시 파일로 저장 (CLI arg 길이 제한 대비)
     const tmpDir = path.join(os.tmpdir(), 'tycono-engine');
     fs.mkdirSync(tmpDir, { recursive: true });

package/src/api/src/engine/runners/direct-api.ts

@@ -47,6 +47,7 @@ export class DirectApiRunner implements ExecutionRunner {
       onDispatch: (roleId, task) => callbacks.onDispatch?.(roleId, task),
       onConsult: (roleId, question) => callbacks.onConsult?.(roleId, question),
       onTurnComplete: (turn) => callbacks.onTurnComplete?.(turn),
+      onPromptAssembled: (systemPrompt, userTask) => callbacks.onPromptAssembled?.(systemPrompt, userTask),
     }).then((agentResult): RunnerResult => ({
       output: agentResult.output,
       turns: agentResult.turns,

package/src/api/src/engine/runners/types.ts

@@ -23,7 +23,8 @@ export interface ImageAttachment {
 
 /* ─── Config ──────────────────────────────────── */
 
-export type TeamStatus = Record<string, { status: string; task?: string }>;
+export type { TeamStatus } from '../../../../shared/types';
+import type { TeamStatus } from '../../../../shared/types';
 
 export interface RunnerConfig {
   companyRoot: string;
@@ -55,6 +56,8 @@ export interface RunnerCallbacks {
   onConsult?: (roleId: string, question: string) => void;
   onTurnComplete?: (turn: number) => void;
   onError?: (error: string) => void;
+  /** Trace: emitted when system prompt is assembled, for full prompt capture */
+  onPromptAssembled?: (systemPrompt: string, userTask: string) => void;
 }
 
 /* ─── Result ──────────────────────────────────── */

package/src/api/src/routes/execute.ts

@@ -14,6 +14,7 @@ import {
   type ImageAttachment,
 } from '../services/session-store.js';
 import { jobManager, type Job } from '../services/job-manager.js';
+import { type JobStatus, type RoleStatus, type WaveRoleStatus, type TeamStatus, isJobActive, isRoleActive, jobStatusToRoleStatus, eventTypeToJobStatus } from '../../../shared/types';
 import { ActivityStream, type ActivityEvent, type ActivitySubscriber } from '../services/activity-stream.js';
 import { earnCoinsInternal } from './coins.js';
 import { appendFollowUpToWave } from '../services/wave-tracker.js';
@@ -32,7 +33,7 @@ function getRunner() {
 
 /* ─── Active execution tracking (legacy, kept for /api/exec/status compat) ──── */
 
-const roleStatus = new Map<string, 'idle' | 'working' | 'done'>();
+const roleStatus = new Map<string, RoleStatus>();
 
 /* ─── Raw HTTP handler (Express 5 SSE 호환 문제 우회) ─── */
 
@@ -116,6 +117,21 @@ function handleJobsRequest(url: string, method: string, req: IncomingMessage, re
     return;
   }
 
+  // POST /api/jobs/:id/abort — abort a running job directly by jobId
+  const abortMatch = path.match(/^\/api\/jobs\/([^/]+)\/abort$/);
+  if (method === 'POST' && abortMatch) {
+    const jobId = abortMatch[1];
+    const success = jobManager.abortJob(jobId);
+    if (!success) {
+      res.writeHead(404);
+      res.end(JSON.stringify({ error: 'Job not found or not running' }));
+    } else {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({ ok: true, jobId }));
+    }
+    return;
+  }
+
   // All other /api/jobs/* endpoints → 410
   res.writeHead(410);
   res.end(JSON.stringify({ error: 'Use /api/sessions/* for client-facing operations. /api/jobs/:id and /api/jobs/:id/history are internal only.' }));
@@ -311,9 +327,9 @@ function handleSaveWave(body: Record<string, unknown>, res: ServerResponse): voi
     roleId: string;
     roleName: string;
     jobId: string;
-    status: string;
+    status: WaveRoleStatus;
     events: ReturnType<typeof ActivityStream.readAll>;
-    childJobs: Array<{ roleId: string; roleName: string; jobId: string; status: string; events: ReturnType<typeof ActivityStream.readAll> }>;
+    childJobs: Array<{ roleId: string; roleName: string; jobId: string; status: WaveRoleStatus; events: ReturnType<typeof ActivityStream.readAll> }>;
   }
   const rolesData: WaveRoleData[] = [];
 
@@ -323,7 +339,7 @@ function handleSaveWave(body: Record<string, unknown>, res: ServerResponse): voi
     const roleId = startEvent?.roleId ?? 'unknown';
     const roleName = (startEvent?.data?.roleName as string) ?? roleId;
     const doneEvent = events.find(e => e.type === 'job:done' || e.type === 'job:awaiting_input' || e.type === 'job:error');
-    const status = doneEvent?.type === 'job:done' ? 'done' : doneEvent?.type === 'job:error' ? 'error' : doneEvent?.type === 'job:awaiting_input' ? 'awaiting_input' : 'unknown';
+    const status: WaveRoleStatus = doneEvent ? eventTypeToJobStatus(doneEvent.type) as WaveRoleStatus : 'unknown';
 
     // Collect child jobs (dispatched sub-roles)
     const childJobs: WaveRoleData['childJobs'] = [];
@@ -333,7 +349,7 @@ function handleSaveWave(body: Record<string, unknown>, res: ServerResponse): voi
         const targetRoleId = (e.data.targetRoleId as string) ?? 'unknown';
         const childEvents = ActivityStream.readAll(childJobId);
         const childDone = childEvents.find(ce => ce.type === 'job:done' || ce.type === 'job:error' || ce.type === 'job:awaiting_input');
-        const childStatus = childDone?.type === 'job:done' ? 'done' : childDone?.type === 'job:error' ? 'error' : 'unknown';
+        const childStatus: WaveRoleStatus = childDone ? eventTypeToJobStatus(childDone.type) as WaveRoleStatus : 'unknown';
         childJobs.push({
           roleId: targetRoleId,
           roleName: (childEvents.find(ce => ce.type === 'job:start')?.data?.roleName as string) ?? targetRoleId,
@@ -547,6 +563,9 @@ function handleAssign(body: Record<string, unknown>, req: IncomingMessage, res:
       case 'stderr':
         sendSSE(res, 'stderr', { message: event.data.message });
         break;
+      case 'job:awaiting_input':
+        sendSSE(res, 'awaiting_input', { question: event.data.question, targetRole: event.data.targetRole, reason: event.data.reason });
+        break;
       case 'job:done':
         cleanupLifecycle();
         sendSSE(res, 'done', event.data);
@@ -568,6 +587,7 @@ function handleAssign(body: Record<string, unknown>, req: IncomingMessage, res:
   req.on('close', () => {
     cleanupLifecycle();
     job.stream.unsubscribe(subscriber);
+    roleStatus.set(roleId, 'idle');
   });
 }
 
@@ -645,6 +665,9 @@ function handleWave(body: Record<string, unknown>, req: IncomingMessage, res: Se
         case 'stderr':
           sendSSE(res, 'stderr', { roleId: rolePrefix, message: event.data.message });
           break;
+        case 'job:awaiting_input':
+          sendSSE(res, 'role:awaiting_input', { roleId: rolePrefix, question: event.data.question, targetRole: event.data.targetRole, reason: event.data.reason });
+          break;
         case 'job:done':
           sendSSE(res, 'role:done', { roleId: rolePrefix, ...event.data });
           doneCount++;
@@ -687,27 +710,31 @@ function handleStatus(res: ServerResponse): void {
     statuses[activity.roleId] = activity.status;
   }
 
-  // 2. JobManager running jobs are the source of truth for "working"
-  const runningJobs = jobManager.listJobs({ status: 'running' });
-  const runningRoles = new Set(runningJobs.map(j => j.roleId));
+  // 2. JobManager active jobs (isJobActive: running | awaiting_input)
+  const activeJobs = jobManager.listJobs({ active: true });
+  const activeRoles = new Set(activeJobs.map(j => j.roleId));
 
   // 2b. In-memory roleStatus (includes chat streaming sessions, not just jobs)
   const memoryWorking = new Set<string>();
   for (const [rid, st] of roleStatus.entries()) {
-    if (st === 'working') memoryWorking.add(rid);
+    if (isRoleActive(st as RoleStatus)) memoryWorking.add(rid);
   }
 
-  // 3. Any role marked "working" in file but NOT in JobManager AND NOT in memory → done
+  // 3. Stale cleanup: active in file but NOT in JobManager AND NOT in memory → done
   for (const roleId of Object.keys(statuses)) {
-    if (statuses[roleId] === 'working' && !runningRoles.has(roleId) && !memoryWorking.has(roleId)) {
+    const s = statuses[roleId];
+    if (isRoleActive(s as RoleStatus) && !activeRoles.has(roleId) && !memoryWorking.has(roleId)) {
       statuses[roleId] = 'done';
       completeActivity(roleId);
     }
   }
 
-  // 4. Running jobs override everything
-  for (const job of runningJobs) {
-    statuses[job.roleId] = 'working';
+  // 4. Active jobs override — use jobStatusToRoleStatus() for canonical mapping
+  for (const job of activeJobs) {
+    const mappedStatus = jobStatusToRoleStatus(job.status as JobStatus);
+    // running job → 'working' always wins over awaiting_input
+    if (statuses[job.roleId] === 'working' && mappedStatus === 'awaiting_input') continue;
+    statuses[job.roleId] = mappedStatus;
   }
 
   // 5. In-memory working (chat streaming) also overrides
@@ -715,7 +742,7 @@ function handleStatus(res: ServerResponse): void {
     statuses[rid] = 'working';
   }
 
-  const activeExecs = runningJobs.map((j) => ({
+  const activeExecs = activeJobs.map((j) => ({
     id: j.id,
     roleId: j.roleId,
     task: j.task,
@@ -885,6 +912,14 @@ function handleSessionMessage(
             input: event.data.input,
           });
           break;
+        case 'job:awaiting_input':
+          sendSSE(res, 'dispatch:progress', {
+            roleId: event.roleId,
+            type: 'awaiting_input',
+            question: event.data.question,
+            targetRole: event.data.targetRole,
+          });
+          break;
         case 'job:done':
           sendSSE(res, 'dispatch:progress', {
             roleId: event.roleId,
@@ -906,15 +941,18 @@ function handleSessionMessage(
     childSubscriptions.push({ job: childJob, subscriber });
   });
 
-  // Build team status from running jobs (same as JobManager pattern)
-  const teamStatus: Record<string, { status: string; task?: string }> = {};
-  for (const j of jobManager.listJobs({ status: 'running' })) {
-    teamStatus[j.roleId] = { status: 'working', task: j.task };
+  // Build team status from active jobs using schema helpers
+  const teamStatus: TeamStatus = {};
+  for (const j of jobManager.listJobs({ active: true })) {
+    const mapped = jobStatusToRoleStatus(j.status as JobStatus);
+    // 'working' takes priority over 'awaiting_input' for same role
+    if (teamStatus[j.roleId]?.status === 'working' && mapped === 'awaiting_input') continue;
+    teamStatus[j.roleId] = { status: mapped, task: j.task };
   }
   // Also include roleStatus for roles working via session (not tracked as jobs)
   for (const [rid, status] of roleStatus) {
-    if (status === 'working' && rid !== roleId && !teamStatus[rid]) {
-      teamStatus[rid] = { status: 'working' };
+    if (isRoleActive(status as RoleStatus) && rid !== roleId && !teamStatus[rid]) {
+      teamStatus[rid] = { status: status as RoleStatus };
     }
   }
 

package/src/api/src/routes/operations.ts

@@ -1,8 +1,10 @@
 import { Router, Request, Response, NextFunction } from 'express';
 import { readFile, listFiles, fileExists, COMPANY_ROOT } from '../services/file-reader.js';
 import { extractBoldKeyValues } from '../services/markdown-parser.js';
+import { ActivityStream } from '../services/activity-stream.js';
 import path from 'node:path';
 import fs from 'node:fs';
+import { type JobStatus, isJobActive } from '../../../shared/types';
 
 export const operationsRouter = Router();
 
@@ -50,7 +52,7 @@ operationsRouter.get('/waves', (_req: Request, res: Response, next: NextFunction
         try {
           const data = JSON.parse(readFile(`operations/waves/${f}`));
           const roles = data.roles ?? [];
-          const hasRunning = roles.some((r: { status?: string }) => r.status === 'running' || r.status === 'awaiting_input');
+          const hasRunning = roles.some((r: { status?: string }) => r.status && isJobActive(r.status as JobStatus));
           return {
             id,
             timestamp: id,
@@ -174,3 +176,133 @@ operationsRouter.delete('/decisions/:id', (req: Request, res: Response, next: Ne
     next(err);
   }
 });
+
+// --- Traces (AI-readable agent conversation debugging) ---
+
+/**
+ * GET /api/ops/traces/:jobId — Dump full trace for a job
+ * Returns all events including full prompt/response for the job
+ * and all child jobs in the trace chain.
+ *
+ * Query params:
+ *   ?chain=true  — include all jobs in the same trace (default: true)
+ *   ?type=trace  — filter to trace:prompt and trace:response events only
+ */
+operationsRouter.get('/traces/:jobId', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const jobId = String(req.params.jobId);
+    const includeChain = String(req.query.chain ?? 'true') !== 'false';
+    const typeFilter = String(req.query.type ?? '') || undefined;
+
+    // Read the target job's events
+    const events = ActivityStream.readAll(jobId);
+    if (events.length === 0) {
+      res.status(404).json({ error: `No activity stream found for job: ${jobId}` });
+      return;
+    }
+
+    // Extract traceId from the first event
+    const traceId = events[0]?.traceId ?? events.find(e => e.data?.traceId)?.data?.traceId as string ?? jobId;
+
+    if (!includeChain) {
+      const filtered = typeFilter
+        ? events.filter(e => e.type.startsWith(typeFilter))
+        : events;
+      res.json({ traceId, jobs: [{ jobId, events: filtered }] });
+      return;
+    }
+
+    // Find all jobs in the same trace
+    const allJobIds = ActivityStream.listAll();
+    const traceJobs: Array<{ jobId: string; roleId: string; events: typeof events }> = [];
+
+    for (const jid of allJobIds) {
+      const jobEvents = ActivityStream.readAll(jid);
+      const startEvent = jobEvents.find(e => e.type === 'job:start');
+      const jobTraceId = jobEvents[0]?.traceId ?? startEvent?.data?.traceId;
+
+      if (jobTraceId === traceId || jid === jobId) {
+        const filtered = typeFilter
+          ? jobEvents.filter(e => e.type.startsWith(typeFilter))
+          : jobEvents;
+        traceJobs.push({
+          jobId: jid,
+          roleId: startEvent?.roleId ?? 'unknown',
+          events: filtered,
+        });
+      }
+    }
+
+    // Sort by timestamp of first event
+    traceJobs.sort((a, b) => {
+      const aTs = a.events[0]?.ts ?? '';
+      const bTs = b.events[0]?.ts ?? '';
+      return aTs.localeCompare(bTs);
+    });
+
+    res.json({ traceId, jobCount: traceJobs.length, jobs: traceJobs });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/**
+ * GET /api/ops/traces — List recent traces (grouped by traceId)
+ * Query params:
+ *   ?limit=20    — max traces to return
+ *   ?roleId=cto  — filter by role
+ */
+operationsRouter.get('/traces', (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const limit = parseInt(String(req.query.limit ?? '20')) || 20;
+    const roleFilter = req.query.roleId ? String(req.query.roleId) : undefined;
+
+    const allJobIds = ActivityStream.listAll();
+    const traces = new Map<string, {
+      traceId: string;
+      startedAt: string;
+      rootRole: string;
+      rootTask: string;
+      jobCount: number;
+      status: string;
+    }>();
+
+    for (const jid of allJobIds) {
+      const events = ActivityStream.readAll(jid);
+      const startEvent = events.find(e => e.type === 'job:start');
+      if (!startEvent) continue;
+
+      const traceId = events[0]?.traceId ?? startEvent?.data?.traceId as string ?? jid;
+      if (roleFilter && startEvent.roleId !== roleFilter) continue;
+
+      if (!traces.has(traceId)) {
+        const doneEvent = events.find(e => e.type === 'job:done');
+        const errorEvent = events.find(e => e.type === 'job:error');
+        const awaitingEvent = events.find(e => e.type === 'job:awaiting_input');
+        const status = awaitingEvent ? 'awaiting_input'
+          : doneEvent ? 'done'
+          : errorEvent ? 'error'
+          : 'running';
+
+        traces.set(traceId, {
+          traceId,
+          startedAt: startEvent.ts,
+          rootRole: startEvent.roleId,
+          rootTask: (startEvent.data.task as string ?? '').slice(0, 200),
+          jobCount: 1,
+          status,
+        });
+      } else {
+        traces.get(traceId)!.jobCount++;
+      }
+    }
+
+    const sorted = [...traces.values()]
+      .sort((a, b) => b.startedAt.localeCompare(a.startedAt))
+      .slice(0, limit);
+
+    res.json(sorted);
+  } catch (err) {
+    next(err);
+  }
+});

package/src/api/src/routes/sessions.ts

@@ -11,6 +11,7 @@ import {
   type Message,
 } from '../services/session-store.js';
 import { jobManager } from '../services/job-manager.js';
+import { isJobActive } from '../../../shared/types';
 import { ActivityStream, type ActivityEvent } from '../services/activity-stream.js';
 import { updateFollowUpForReply } from '../services/wave-tracker.js';
 
@@ -118,7 +119,7 @@ sessionsRouter.get('/:id/stream', (req, res) => {
   }
 
   // If the job is finished or doesn't exist, end
-  if (!job || (job.status !== 'running' && job.status !== 'awaiting_input')) {
+  if (!job || !isJobActive(job.status)) {
     sendEvent('stream:end', { reason: job ? job.status : 'no-job' });
     res.end();
     return;
@@ -159,12 +160,8 @@ sessionsRouter.get('/:id/stream', (req, res) => {
 
 /** POST /api/sessions/:id/abort — abort linked job */
 sessionsRouter.post('/:id/abort', (req, res) => {
-  const session = getSession(req.params.id);
-  if (!session) {
-    res.status(404).json({ error: 'Session not found' });
-    return;
-  }
-
+  // Try session-based lookup first, then fallback to direct job search
+  // (session file may not exist after server restart, but job can still be in-memory)
   const job = jobManager.getJobBySessionId(req.params.id);
   if (!job) {
     res.status(404).json({ error: 'No active job for this session' });

package/src/api/src/services/activity-stream.ts

@@ -2,26 +2,10 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { COMPANY_ROOT } from './file-reader.js';
 
-/* ─── Types ──────────────────────────────── */
-
-export type ActivityEventType =
-  | 'job:start' | 'job:done' | 'job:error'
-  | 'job:awaiting_input' | 'job:reply'
-  | 'text' | 'thinking'
-  | 'tool:start' | 'tool:result'
-  | 'dispatch:start' | 'dispatch:done'
-  | 'turn:complete' | 'turn:warning' | 'turn:limit'
-  | 'import:scan' | 'import:process' | 'import:created'
-  | 'stderr';
-
-export interface ActivityEvent {
-  seq: number;
-  ts: string;
-  type: ActivityEventType;
-  roleId: string;
-  parentJobId?: string;
-  data: Record<string, unknown>;
-}
+/* ─── Types (re-export from shared contract) ── */
+
+export { type ActivityEventType, type ActivityEvent } from '../../../shared/types';
+import type { ActivityEventType, ActivityEvent } from '../../../shared/types';
 
 /* ─── Constants ──────────────────────────── */
 
@@ -50,16 +34,19 @@ export class ActivityStream {
   readonly jobId: string;
   readonly roleId: string;
   readonly parentJobId?: string;
+  /** Trace ID for full chain tracking — top-level jobId propagated to all children */
+  readonly traceId?: string;
 
   private seq = 0;
   private subscribers = new Set<ActivitySubscriber>();
   private filePath: string;
   private closed = false;
 
-  constructor(jobId: string, roleId: string, parentJobId?: string) {
+  constructor(jobId: string, roleId: string, parentJobId?: string, traceId?: string) {
     this.jobId = jobId;
     this.roleId = roleId;
     this.parentJobId = parentJobId;
+    this.traceId = traceId;
 
     ensureDir();
     this.filePath = streamPath(jobId);
@@ -75,6 +62,7 @@ export class ActivityStream {
       type,
       roleId,
       parentJobId: this.parentJobId,
+      ...(this.traceId && { traceId: this.traceId }),
       data,
     };
 

package/src/api/src/services/activity-tracker.ts

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { COMPANY_ROOT } from './file-reader.js';
+import type { RoleStatus } from '../../../shared/types';
 
 function activityDir(): string {
   return path.join(COMPANY_ROOT, 'operations', 'activity');
@@ -8,7 +9,7 @@ function activityDir(): string {
 
 export interface RoleActivity {
   roleId: string;
-  status: 'idle' | 'working' | 'done';
+  status: RoleStatus;
   currentTask: string;
   startedAt: string;
   updatedAt: string;
@@ -49,6 +50,15 @@ export function updateActivity(roleId: string, output: string): void {
   invalidateCache();
 }
 
+export function markAwaitingInput(roleId: string): void {
+  const activity = getActivity(roleId);
+  if (!activity) return;
+  activity.status = 'awaiting_input';
+  activity.updatedAt = new Date().toISOString();
+  fs.writeFileSync(activityPath(roleId), JSON.stringify(activity, null, 2));
+  invalidateCache();
+}
+
 export function completeActivity(roleId: string): void {
   const activity = getActivity(roleId);
   if (!activity) return;