tycono 0.1.50 → 0.1.52

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tycono",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "Build an AI company. Watch them work.",
   "type": "module",
   "bin": {
@@ -21,6 +21,7 @@
     "dev:api": "npm run dev --prefix src/api",
     "dev:web": "npm run dev --prefix src/web",
     "build:web": "npm run build --prefix src/web",
+    "build:forge": "tsup --config tsup.forge.ts",
     "typecheck": "npm run typecheck:api && npm run typecheck:web",
     "typecheck:api": "cd src/api && npx tsc --noEmit",
     "typecheck:web": "cd src/web && npx tsc --noEmit",
@@ -41,6 +42,7 @@
     "@types/cors": "^2.8.17",
     "@types/express": "^5.0.0",
     "@types/node": "^22.13.4",
+    "tsup": "^8.5.1",
     "typescript": "^5.7.3"
   },
   "keywords": [

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

@@ -129,6 +129,8 @@ export function assembleContext(
 - If the directive is vague, focus on what YOUR ROLE can contribute. Don't try to cover everything.
 - Break ambiguous directives into concrete actions within your authority scope.
 - If you truly cannot determine what to do, state your interpretation and proceed with it.
+- **If you have subordinates, your FIRST action should be decomposing the task and dispatching.** Do NOT attempt implementation yourself — delegate to the appropriate team member.
+- Review the "Available Team Members" section to understand each subordinate's capabilities before dispatching.
 
 ## Efficiency
 - Read ONLY files directly relevant to your task. Do NOT explore the codebase broadly.
@@ -368,14 +370,51 @@ function buildDispatchSection(orgTree: OrgTree, roleId: string, subordinates: st
 
   const subInfo = subordinates.map((id) => {
     const sub = orgTree.nodes.get(id);
-    const base = sub ? `- **${sub.name}** (\`${id}\`): ${sub.persona.split('\n')[0]}` : `- ${id}`;
+    if (!sub) return `- ${id} — (unknown role)`;
+
+    const lines: string[] = [];
+
+    // Header: name, id, persona summary
     const st = teamStatus?.[id];
-    if (st && st.status === 'working') {
-      const taskHint = st.task ? `: "${st.task.slice(0, 60)}"` : '';
-      return `${base} — **Working**${taskHint}`;
+    const status = st?.status === 'working'
+      ? `🔴 Working${st.task ? ` — "${st.task.slice(0, 60)}"` : ''}`
+      : '🟢 Idle';
+    lines.push(`### ${sub.name} (\`${id}\`) — ${status}`);
+    lines.push(`> ${sub.persona.split('\n')[0]}`);
+
+    // Level & model
+    lines.push(`- **Level**: ${sub.level} | **Model**: ${sub.model ?? 'default'}`);
+
+    // Skills
+    if (sub.skills && sub.skills.length > 0) {
+      lines.push(`- **Skills**: ${sub.skills.join(', ')}`);
+    }
+
+    // Authority — what they can do autonomously
+    if (sub.authority.autonomous.length > 0) {
+      lines.push(`- **Can do**: ${sub.authority.autonomous.join(', ')}`);
+    }
+
+    // Knowledge scope — what they can read/write
+    if (sub.knowledge.reads.length > 0) {
+      lines.push(`- **Reads**: ${sub.knowledge.reads.join(', ')}`);
+    }
+    if (sub.knowledge.writes.length > 0) {
+      lines.push(`- **Writes**: ${sub.knowledge.writes.join(', ')}`);
     }
-    return `${base} — Idle`;
-  }).join('\n');
+
+    // Their own subordinates (for chain delegation visibility)
+    const grandchildren = orgTree.nodes.get(id)?.children ?? [];
+    if (grandchildren.length > 0) {
+      const gcNames = grandchildren.map(gc => {
+        const gcNode = orgTree.nodes.get(gc);
+        return gcNode ? `${gcNode.name} (${gc})` : gc;
+      });
+      lines.push(`- **Their reports**: ${gcNames.join(', ')}`);
+    }
+
+    return lines.join('\n');
+  }).join('\n\n');
 
   const exampleSubId = subordinates[0] ?? 'engineer';
 

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

@@ -272,15 +272,9 @@ export class ClaudeCliRunner implements ExecutionRunner {
               appendOutput: (t) => { output += t; },
               addToolCall: (name, input) => {
                 toolCalls.push({ name, input });
-                // Detect dispatch calls via Bash (dispatch bridge)
-                if (name === 'Bash' && typeof input?.command === 'string') {
-                  const cmd = input.command;
-                  // Match: python3 "$DISPATCH_CMD" <roleId> "task" or dispatch <roleId> "task"
-                  const dispatchMatch = cmd.match(/(?:DISPATCH_CMD|dispatch(?:\.py)?)[^\n]*?\s+(\w+)\s+["'](.+?)["']/);
-                  if (dispatchMatch) {
-                    callbacks.onDispatch?.(dispatchMatch[1], dispatchMatch[2]);
-                  }
-                }
+                // Dispatch detection removed — child jobs created by the Python
+                // dispatch bridge script via POST /api/jobs with parentJobId.
+                // JobManager.startJob() now auto-emits dispatch:start on parent stream.
               },
               incrementTurn: () => { turnCount++; callbacks.onTurnComplete?.(turnCount); },
               recordTokens: (input, out) => {

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

@@ -158,6 +158,17 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
         parentJobId,
       });
       roleStatus.set(cRole, 'working');
+      // Clean up roleStatus when wave job completes — only if no other running jobs for same role
+      const sub = (event: { type: string }) => {
+        if (event.type === 'job:done' || event.type === 'job:error' || event.type === 'job:awaiting_input') {
+          job.stream.unsubscribe(sub);
+          const stillRunning = jobManager.listJobs({ status: 'running', roleId: cRole });
+          if (stillRunning.length === 0) {
+            roleStatus.set(cRole, 'idle');
+          }
+        }
+      };
+      job.stream.subscribe(sub);
       jobIds.push(job.id);
     }
 
@@ -187,6 +198,19 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
   });
 
   roleStatus.set(roleId, 'working');
+
+  // Clean up roleStatus when job completes — only if no other running jobs for same role
+  const sub = (event: { type: string }) => {
+    if (event.type === 'job:done' || event.type === 'job:error' || event.type === 'job:awaiting_input') {
+      job.stream.unsubscribe(sub);
+      const stillRunning = jobManager.listJobs({ status: 'running', roleId });
+      if (stillRunning.length === 0) {
+        roleStatus.set(roleId, 'idle');
+      }
+    }
+  };
+  job.stream.subscribe(sub);
+
   jsonResponse(res, 200, { jobId: job.id });
 }
 
@@ -423,6 +447,7 @@ function startSSE(res: ServerResponse): void {
     'Connection': 'keep-alive',
     'X-Accel-Buffering': 'no',
   });
+  res.flushHeaders();
 }
 
 /** Start SSE heartbeat + timeout. Returns cleanup function. */
@@ -861,8 +886,20 @@ 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 };
+  }
+  // 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' };
+    }
+  }
+
   const handle = getRunner().execute(
-    { companyRoot: COMPANY_ROOT, roleId, task: fullTask, sourceRole: 'ceo', orgTree, readOnly, model: orgTree.nodes.get(roleId)?.model, attachments },
+    { companyRoot: COMPANY_ROOT, roleId, task: fullTask, sourceRole: 'ceo', orgTree, readOnly, model: orgTree.nodes.get(roleId)?.model, attachments, teamStatus },
     {
       onText: (text) => {
         roleMsg.content += text;

package/src/api/src/routes/preferences.ts

@@ -1,3 +1,4 @@
+import crypto from 'node:crypto';
 import { Router, Request, Response, NextFunction } from 'express';
 import { COMPANY_ROOT } from '../services/file-reader.js';
 import { readPreferences, writePreferences, mergePreferences } from '../services/preferences.js';
@@ -21,7 +22,9 @@ preferencesRouter.put('/', (req: Request, res: Response, next: NextFunction) =>
       res.status(400).json({ error: 'Invalid preferences body' });
       return;
     }
+    const existing = readPreferences(COMPANY_ROOT);
     writePreferences(COMPANY_ROOT, {
+      instanceId: existing.instanceId, // preserve — never overwrite from client
       appearances: prefs.appearances ?? {},
       theme: prefs.theme ?? 'default',
     });
@@ -31,6 +34,19 @@ preferencesRouter.put('/', (req: Request, res: Response, next: NextFunction) =>
   }
 });
 
+// POST /api/preferences/regenerate-token — regenerate instanceId
+preferencesRouter.post('/regenerate-token', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const current = readPreferences(COMPANY_ROOT);
+    const oldId = current.instanceId;
+    current.instanceId = crypto.randomUUID();
+    writePreferences(COMPANY_ROOT, current);
+    res.json({ ok: true, oldInstanceId: oldId, newInstanceId: current.instanceId });
+  } catch (err) {
+    next(err);
+  }
+});
+
 // PATCH /api/preferences — partial merge
 preferencesRouter.patch('/', (req: Request, res: Response, next: NextFunction) => {
   try {

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

@@ -37,6 +37,7 @@ export function setActivity(roleId: string, task: string): void {
     recentOutput: '',
   };
   fs.writeFileSync(activityPath(roleId), JSON.stringify(activity, null, 2));
+  invalidateCache();
 }
 
 export function updateActivity(roleId: string, output: string): void {
@@ -45,6 +46,7 @@ export function updateActivity(roleId: string, output: string): void {
   activity.updatedAt = new Date().toISOString();
   activity.recentOutput = output.slice(-500);
   fs.writeFileSync(activityPath(roleId), JSON.stringify(activity, null, 2));
+  invalidateCache();
 }
 
 export function completeActivity(roleId: string): void {
@@ -53,6 +55,7 @@ export function completeActivity(roleId: string): void {
   activity.status = 'done';
   activity.updatedAt = new Date().toISOString();
   fs.writeFileSync(activityPath(roleId), JSON.stringify(activity, null, 2));
+  invalidateCache();
 }
 
 export function clearActivity(roleId: string): void {
@@ -60,6 +63,7 @@ export function clearActivity(roleId: string): void {
   if (fs.existsSync(filePath)) {
     fs.unlinkSync(filePath);
   }
+  invalidateCache();
 }
 
 export function getActivity(roleId: string): RoleActivity | null {
@@ -72,14 +76,30 @@ export function getActivity(roleId: string): RoleActivity | null {
   }
 }
 
+/** Cached getAllActivities — avoids re-reading files within TTL window */
+let _activitiesCache: RoleActivity[] | null = null;
+let _activitiesCacheTs = 0;
+const ACTIVITIES_CACHE_TTL = 500; // ms
+
 export function getAllActivities(): RoleActivity[] {
+  const now = Date.now();
+  if (_activitiesCache && now - _activitiesCacheTs < ACTIVITIES_CACHE_TTL) {
+    return _activitiesCache;
+  }
   ensureDir();
   const files = fs.readdirSync(activityDir()).filter(f => f.endsWith('.json'));
-  return files.map(f => {
+  _activitiesCache = files.map(f => {
     try {
       return JSON.parse(fs.readFileSync(path.join(activityDir(), f), 'utf-8'));
     } catch {
       return null;
     }
   }).filter((a): a is RoleActivity => a !== null);
+  _activitiesCacheTs = now;
+  return _activitiesCache;
+}
+
+/** Invalidate cache after writes (setActivity, updateActivity, completeActivity) */
+function invalidateCache(): void {
+  _activitiesCache = null;
 }

package/src/api/src/services/job-manager.ts

@@ -124,6 +124,20 @@ class JobManager {
       sourceRole: params.sourceRole ?? 'ceo',
     });
 
+    // If this job has a parent, emit dispatch:start on the parent's stream
+    // so the Wave Command Center can track this child job.
+    if (params.parentJobId) {
+      const parentJob = this.jobs.get(params.parentJobId);
+      if (parentJob) {
+        parentJob.childJobIds.push(jobId);
+        parentJob.stream.emit('dispatch:start', parentJob.roleId, {
+          targetRoleId: params.roleId,
+          task: params.task,
+          childJobId: jobId,
+        });
+      }
+    }
+
     // Set activity tracker
     setActivity(params.roleId, params.task);
 
@@ -164,21 +178,15 @@ class JobManager {
           });
         },
         onDispatch: (subRoleId, subTask) => {
-          // Create child job for the dispatch
-          const childJob = this.startJob({
+          // Create child job — startJob() auto-emits dispatch:start
+          // on parent stream when parentJobId is set.
+          this.startJob({
             type: 'assign',
             roleId: subRoleId,
             task: subTask,
             sourceRole: params.roleId,
             parentJobId: jobId,
           });
-          job.childJobIds.push(childJob.id);
-
-          stream.emit('dispatch:start', params.roleId, {
-            targetRoleId: subRoleId,
-            task: subTask,
-            childJobId: childJob.id,
-          });
         },
         onTurnComplete: (turn) => {
           stream.emit('turn:complete', params.roleId, { turn });

package/src/api/src/services/preferences.ts

@@ -4,6 +4,7 @@
  * 캐릭터 외모, 오피스 테마 등 사용자 설정을 서버 파일로 영속화한다.
  * company-config.ts의 readConfig/writeConfig 패턴을 따른다.
  */
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import path from 'node:path';
 
@@ -46,6 +47,7 @@ export interface AddedFurniture {
 }
 
 export interface Preferences {
+  instanceId?: string; // anonymous persistent token — auto-generated on first read
   appearances: Record<string, CharacterAppearance>;
   theme: string;
   speech?: SpeechSettings;
@@ -64,25 +66,34 @@ function prefsPath(companyRoot: string): string {
   return path.join(companyRoot, CONFIG_DIR, PREFS_FILE);
 }
 
-/** Read preferences from .tycono/preferences.json. Returns defaults if missing. */
+/** Read preferences from .tycono/preferences.json. Returns defaults if missing.
+ *  Auto-generates instanceId on first access and persists it. */
 export function readPreferences(companyRoot: string): Preferences {
   const p = prefsPath(companyRoot);
-  if (!fs.existsSync(p)) return { ...DEFAULT, appearances: {} };
-  try {
-    const data = JSON.parse(fs.readFileSync(p, 'utf-8'));
-    return {
-      appearances: data.appearances ?? {},
-      theme: data.theme ?? 'default',
-      speech: data.speech ?? undefined,
-      language: data.language ?? undefined,
-      furnitureOverrides: data.furnitureOverrides ?? undefined,
-      deskOverrides: data.deskOverrides ?? undefined,
-      removedFurniture: data.removedFurniture ?? undefined,
-      addedFurniture: data.addedFurniture ?? undefined,
-    };
-  } catch {
-    return { ...DEFAULT, appearances: {} };
+  let data: Record<string, unknown> = {};
+  if (fs.existsSync(p)) {
+    try { data = JSON.parse(fs.readFileSync(p, 'utf-8')); } catch { /* use defaults */ }
   }
+
+  const prefs: Preferences = {
+    instanceId: (data.instanceId as string) ?? undefined,
+    appearances: (data.appearances as Record<string, CharacterAppearance>) ?? {},
+    theme: (data.theme as string) ?? 'default',
+    speech: (data.speech as SpeechSettings) ?? undefined,
+    language: (data.language as string) ?? undefined,
+    furnitureOverrides: (data.furnitureOverrides as Record<string, FurnitureOverride>) ?? undefined,
+    deskOverrides: (data.deskOverrides as Record<string, DeskOverride>) ?? undefined,
+    removedFurniture: (data.removedFurniture as string[]) ?? undefined,
+    addedFurniture: (data.addedFurniture as AddedFurniture[]) ?? undefined,
+  };
+
+  // Auto-generate instanceId on first access
+  if (!prefs.instanceId) {
+    prefs.instanceId = crypto.randomUUID();
+    writePreferences(companyRoot, prefs);
+  }
+
+  return prefs;
 }
 
 /** Write preferences to .tycono/preferences.json. Creates dir if needed. */
@@ -92,10 +103,11 @@ export function writePreferences(companyRoot: string, prefs: Preferences): void
   fs.writeFileSync(prefsPath(companyRoot), JSON.stringify(prefs, null, 2) + '\n');
 }
 
-/** Merge partial preferences into existing. */
+/** Merge partial preferences into existing. instanceId is never overwritten by client. */
 export function mergePreferences(companyRoot: string, partial: Partial<Preferences>): Preferences {
   const current = readPreferences(companyRoot);
   const merged: Preferences = {
+    instanceId: current.instanceId, // preserve — never overwrite from client
     appearances: partial.appearances !== undefined
       ? { ...current.appearances, ...partial.appearances }
       : current.appearances,