tycono-server 0.1.0-beta.0

package/src/api/src/routes/supervision.ts

@@ -0,0 +1,136 @@
+/**
+ * Supervision API — Long-poll watch + peer session discovery (SV-13)
+ *
+ * GET  /api/supervision/watch?sessions=ses-001,ses-002&duration=120&alertOn=msg:done
+ *   → Long-poll: blocks for duration seconds → returns JSON digest
+ *
+ * GET  /api/supervision/peers?waveId=xxx&roleId=cto
+ *   → Returns peer C-Level sessions in the same wave
+ */
+import { Router, type Request, type Response } from 'express';
+import { ActivityStream } from '../services/activity-stream.js';
+import { digest, quietDigest } from '../services/digest-engine.js';
+import { executionManager } from '../services/execution-manager.js';
+import type { ActivityEvent } from '../../../shared/types.js';
+
+export const supervisionRouter = Router();
+
+/* ─── GET /watch — Long-poll supervision digest ─── */
+
+supervisionRouter.get('/watch', async (req: Request, res: Response) => {
+  const sessionsParam = req.query.sessions as string | undefined;
+  if (!sessionsParam) {
+    res.status(400).json({ error: 'sessions query parameter is required (comma-separated session IDs)' });
+    return;
+  }
+
+  const sessionIds = sessionsParam.split(',').filter(Boolean);
+  if (sessionIds.length === 0) {
+    res.status(400).json({ error: 'At least one session ID is required' });
+    return;
+  }
+
+  const durationSec = Math.min(Math.max(Number(req.query.duration) || 120, 5), 300);
+  const alertOnParam = req.query.alertOn as string | undefined;
+  const alertOn = alertOnParam ? alertOnParam.split(',') : ['msg:done', 'msg:error'];
+  const alertSet = new Set(alertOn);
+
+  // Record start checkpoints
+  const startCheckpoints = new Map<string, number>();
+  for (const sid of sessionIds) {
+    const events = ActivityStream.readAll(sid);
+    startCheckpoints.set(sid, events.length > 0 ? events[events.length - 1].seq + 1 : 0);
+  }
+
+  // Set up event collection
+  const collectedEvents = new Map<string, ActivityEvent[]>();
+  for (const sid of sessionIds) {
+    collectedEvents.set(sid, []);
+  }
+
+  let earlyReturn = false;
+  const unsubscribers: Array<() => void> = [];
+
+  for (const sid of sessionIds) {
+    const stream = ActivityStream.getOrCreate(sid, 'unknown');
+    const handler = (event: ActivityEvent) => {
+      const events = collectedEvents.get(sid);
+      if (events) events.push(event);
+      if (alertSet.has(event.type)) {
+        earlyReturn = true;
+      }
+    };
+    stream.subscribe(handler);
+    unsubscribers.push(() => stream.unsubscribe(handler));
+  }
+
+  // Wait for duration or early return
+  await new Promise<void>((resolve) => {
+    const timeout = setTimeout(resolve, durationSec * 1000);
+    const checkInterval = setInterval(() => {
+      if (earlyReturn) {
+        clearTimeout(timeout);
+        clearInterval(checkInterval);
+        resolve();
+      }
+    }, 500);
+    setTimeout(() => { clearInterval(checkInterval); }, durationSec * 1000 + 100);
+  });
+
+  // Unsubscribe all
+  for (const unsub of unsubscribers) unsub();
+
+  // Fallback: read from JSONL for sessions with no live events
+  for (const sid of sessionIds) {
+    const fromSeq = startCheckpoints.get(sid) ?? 0;
+    const liveEvents = collectedEvents.get(sid) ?? [];
+    if (liveEvents.length === 0) {
+      const fileEvents = ActivityStream.readFrom(sid, fromSeq);
+      collectedEvents.set(sid, fileEvents);
+    }
+  }
+
+  const result = digest(collectedEvents);
+
+  res.json({
+    text: result.text,
+    significanceScore: result.significanceScore,
+    anomalies: result.anomalies,
+    checkpoints: Object.fromEntries(result.checkpoints),
+    eventCount: result.eventCount,
+    errorCount: result.errorCount,
+    earlyReturn,
+  });
+});
+
+/* ─── GET /peers — Peer C-Level session discovery ─── */
+
+supervisionRouter.get('/peers', (req: Request, res: Response) => {
+  const waveId = req.query.waveId as string | undefined;
+  const roleId = req.query.roleId as string | undefined;
+
+  if (!waveId || !roleId) {
+    res.status(400).json({ error: 'waveId and roleId are required' });
+    return;
+  }
+
+  // Find all active executions in the same wave that are C-Level
+  const allExecs = executionManager.listExecutions({ active: true });
+  const peers = allExecs.filter(exec => {
+    if (exec.roleId === roleId) return false; // Exclude self
+    // Check if this execution belongs to the same wave
+    // Wave membership is tracked via session store
+    return true; // For now, return all active C-Level sessions
+  });
+
+  res.json({
+    waveId,
+    roleId,
+    peers: peers.map(p => ({
+      sessionId: p.id,
+      roleId: p.roleId,
+      task: p.task.slice(0, 200),
+      status: p.status,
+    })),
+  });
+});

package/src/api/src/routes/sync.ts

@@ -0,0 +1,165 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import YAML from 'yaml';
+import { Router, Request, Response, NextFunction } from 'express';
+import { COMPANY_ROOT } from '../services/file-reader.js';
+import { buildOrgTree, type RoleSource } from '../engine/org-tree.js';
+import { RoleLifecycleManager } from '../engine/role-lifecycle.js';
+import { getTokenLedger } from '../services/token-ledger.js';
+import { estimateCost } from '../services/pricing.js';
+import { calcLevel, calcProgress, formatTokens } from '../utils/role-level.js';
+
+export const syncRouter = Router();
+
+/* ─── GET /api/sync/roles — List roles with source tracking ─── */
+
+syncRouter.get('/roles', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const tree = buildOrgTree(COMPANY_ROOT);
+    const trackedRoles: Array<{
+      roleId: string;
+      name: string;
+      level: string;
+      source: RoleSource;
+      persona: string;
+      authority: { autonomous: string[]; needsApproval: string[] };
+      skills?: string[];
+    }> = [];
+
+    for (const [id, node] of tree.nodes) {
+      if (id === 'ceo' || !node.source) continue;
+      trackedRoles.push({
+        roleId: id,
+        name: node.name,
+        level: node.level,
+        source: node.source,
+        persona: node.persona,
+        authority: node.authority,
+        skills: node.skills,
+      });
+    }
+
+    res.json({ roles: trackedRoles });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── POST /api/sync/apply — Apply upstream changes to a role ─── */
+
+syncRouter.post('/apply', async (req: Request, res: Response, next: NextFunction) => {
+  try {
+    const { roleId, changes, upstreamVersion } = req.body as {
+      roleId: string;
+      changes: { persona?: string; authority?: { autonomous: string[]; needsApproval: string[] }; skills?: string[] };
+      upstreamVersion?: string;
+    };
+
+    if (!roleId || !changes) {
+      res.status(400).json({ error: 'roleId and changes are required' });
+      return;
+    }
+
+    const manager = new RoleLifecycleManager(COMPANY_ROOT);
+    await manager.updateRole(roleId, changes);
+
+    // Update source.upstream_version if provided
+    if (upstreamVersion) {
+      const yamlPath = path.join(COMPANY_ROOT, 'knowledge', 'roles', roleId, 'role.yaml');
+      const raw = YAML.parse(fs.readFileSync(yamlPath, 'utf-8')) as Record<string, unknown>;
+      if (raw.source && typeof raw.source === 'object') {
+        (raw.source as Record<string, unknown>).upstream_version = upstreamVersion;
+      }
+      fs.writeFileSync(yamlPath, YAML.stringify(raw));
+    }
+
+    res.json({ ok: true, roleId, applied: Object.keys(changes) });
+  } catch (err) {
+    next(err);
+  }
+});
+
+/* ─── GET /api/sync/stats — Company-wide gamification stats ─── */
+
+syncRouter.get('/stats', (_req: Request, res: Response, next: NextFunction) => {
+  try {
+    const tree = buildOrgTree(COMPANY_ROOT);
+    const ledger = getTokenLedger(COMPANY_ROOT);
+    const summary = ledger.query();
+
+    // Aggregate by role
+    const byRole: Record<string, { inputTokens: number; outputTokens: number; costUsd: number }> = {};
+    const byModel: Record<string, { inputTokens: number; outputTokens: number; costUsd: number }> = {};
+
+    for (const entry of summary.entries) {
+      if (!byRole[entry.roleId]) {
+        byRole[entry.roleId] = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+      }
+      byRole[entry.roleId].inputTokens += entry.inputTokens;
+      byRole[entry.roleId].outputTokens += entry.outputTokens;
+      byRole[entry.roleId].costUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+
+      if (!byModel[entry.model]) {
+        byModel[entry.model] = { inputTokens: 0, outputTokens: 0, costUsd: 0 };
+      }
+      byModel[entry.model].inputTokens += entry.inputTokens;
+      byModel[entry.model].outputTokens += entry.outputTokens;
+      byModel[entry.model].costUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    // Role count (excluding CEO)
+    const roleCount = tree.nodes.size - 1;
+
+    // Compute per-role levels
+    const roleLevels: Array<{
+      roleId: string;
+      name: string;
+      level: number;
+      totalTokens: number;
+      progress: number;
+      formattedTokens: string;
+      costUsd: number;
+    }> = [];
+
+    for (const [id, node] of tree.nodes) {
+      if (id === 'ceo') continue;
+      const roleData = byRole[id];
+      const totalTokens = roleData ? roleData.inputTokens + roleData.outputTokens : 0;
+      roleLevels.push({
+        roleId: id,
+        name: node.name,
+        level: calcLevel(totalTokens),
+        totalTokens,
+        progress: calcProgress(totalTokens),
+        formattedTokens: formatTokens(totalTokens),
+        costUsd: roleData?.costUsd ?? 0,
+      });
+    }
+
+    // Sort by totalTokens desc (leaderboard)
+    roleLevels.sort((a, b) => b.totalTokens - a.totalTokens);
+
+    // Company aggregate
+    const totalTokens = summary.totalInput + summary.totalOutput;
+    let totalCostUsd = 0;
+    for (const entry of summary.entries) {
+      totalCostUsd += estimateCost(entry.inputTokens, entry.outputTokens, entry.model);
+    }
+
+    res.json({
+      company: {
+        roleCount,
+        totalTokens,
+        formattedTokens: formatTokens(totalTokens),
+        totalCostUsd,
+        avgLevel: roleLevels.length > 0
+          ? Math.round(roleLevels.reduce((sum, r) => sum + r.level, 0) / roleLevels.length * 10) / 10
+          : 1,
+      },
+      roles: roleLevels,
+      byModel,
+    });
+  } catch (err) {
+    next(err);
+  }
+});

package/src/api/src/server.ts

@@ -0,0 +1,59 @@
+import { COMPANY_ROOT } from './services/file-reader.js';
+import { applyConfig } from './services/company-config.js';
+import { createHttpServer } from './create-server.js';
+import { listSessions, updateSession } from './services/session-store.js';
+import { ActivityStream } from './services/activity-stream.js';
+
+// Load .tycono/config.json and apply to process.env
+const config = applyConfig(COMPANY_ROOT);
+console.log(`[STARTUP] Engine: ${config.engine}, API key: ${config.apiKey ? 'set' : 'none'}`);
+
+// Startup: mark orphaned 'active' sessions as 'interrupted'
+// These are sessions from a previous server that crashed or was killed
+{
+  const allSessions = listSessions();
+  let orphaned = 0;
+  for (const ses of allSessions) {
+    if (ses.status !== 'active') continue;
+    // Check activity stream — if it has msg:done/msg:error, mark done
+    // If not, mark interrupted (previous server died mid-execution)
+    if (ActivityStream.exists(ses.id)) {
+      const events = ActivityStream.readFrom(ses.id, 0);
+      const tail = events.slice(-5);
+      const isDone = tail.some(e => e.type === 'msg:done' || e.type === 'msg:error');
+      if (isDone) {
+        updateSession(ses.id, { status: 'done' });
+        orphaned++;
+        continue;
+      }
+    }
+    updateSession(ses.id, { status: 'interrupted' as any });
+    orphaned++;
+  }
+  if (orphaned > 0) {
+    console.log(`[STARTUP] Cleaned ${orphaned} orphaned sessions (active → done/interrupted)`);
+  }
+}
+
+const PORT = Number(process.env.PORT) || 3001;
+const server = createHttpServer();
+
+server.listen(PORT, () => {
+  console.log(`[API] Server running on http://localhost:${PORT}`);
+  console.log(`[API] COMPANY_ROOT: ${COMPANY_ROOT}`);
+});
+
+// Graceful shutdown: mark running sessions as interrupted
+function gracefulShutdown(signal: string) {
+  console.log(`[SHUTDOWN] ${signal} received, marking active sessions as interrupted...`);
+  const sessions = listSessions();
+  for (const ses of sessions) {
+    if (ses.status === 'active') {
+      updateSession(ses.id, { status: 'interrupted' as any });
+    }
+  }
+  process.exit(0);
+}
+
+process.on('SIGINT', () => gracefulShutdown('SIGINT'));
+process.on('SIGTERM', () => gracefulShutdown('SIGTERM'));

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

@@ -0,0 +1,184 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { COMPANY_ROOT } from './file-reader.js';
+
+/* ─── Types (re-export from shared contract) ── */
+
+export { type ActivityEventType, type ActivityEvent } from '../../../shared/types.js';
+import type { ActivityEventType, ActivityEvent } from '../../../shared/types.js';
+
+/* ─── Constants ──────────────────────────── */
+
+function streamsDir(): string {
+  return path.join(COMPANY_ROOT, '.tycono', 'activity-streams');
+}
+
+function ensureDir(): void {
+  const dir = streamsDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+function streamPath(streamId: string): string {
+  return path.join(streamsDir(), `${streamId}.jsonl`);
+}
+
+/* ─── Subscriber type ────────────────────── */
+
+export type ActivitySubscriber = (event: ActivityEvent) => void;
+
+/* ─── ActivityStream ─────────────────────── */
+
+export class ActivityStream {
+  readonly sessionId: string;
+  readonly roleId: string;
+  readonly parentSessionId?: string;
+  /** Trace ID for full chain tracking — top-level sessionId propagated to all children */
+  readonly traceId?: string;
+
+  private seq = 0;
+  private subscribers = new Set<ActivitySubscriber>();
+  private filePath: string;
+  private closed = false;
+
+  constructor(sessionId: string, roleId: string, parentSessionId?: string, traceId?: string) {
+    this.sessionId = sessionId;
+    this.roleId = roleId;
+    this.parentSessionId = parentSessionId;
+    this.traceId = traceId;
+
+    ensureDir();
+    this.filePath = streamPath(sessionId);
+
+    // Resume mode: if file already exists, read last seq and continue
+    if (fs.existsSync(this.filePath)) {
+      const content = fs.readFileSync(this.filePath, 'utf-8');
+      const lines = content.split('\n').filter(Boolean);
+      if (lines.length > 0) {
+        try {
+          const lastEvent = JSON.parse(lines[lines.length - 1]) as ActivityEvent;
+          this.seq = lastEvent.seq + 1;
+        } catch { /* start from 0 if parse fails */ }
+      }
+    } else {
+      // Create empty file
+      fs.writeFileSync(this.filePath, '', { flag: 'w' });
+    }
+  }
+
+  /** Append event to JSONL + push to live subscribers */
+  emit(type: ActivityEventType, roleId: string, data: Record<string, unknown>): ActivityEvent {
+    const event: ActivityEvent = {
+      seq: this.seq++,
+      ts: new Date().toISOString(),
+      type,
+      roleId,
+      parentSessionId: this.parentSessionId,
+      ...(this.traceId && { traceId: this.traceId }),
+      data,
+    };
+
+    // Append to file
+    try {
+      fs.appendFileSync(this.filePath, JSON.stringify(event) + '\n');
+    } catch {
+      // File write failure shouldn't crash the stream
+    }
+
+    // Push to subscribers
+    for (const cb of this.subscribers) {
+      try { cb(event); } catch { /* subscriber errors don't affect others */ }
+    }
+
+    return event;
+  }
+
+  subscribe(cb: ActivitySubscriber): void {
+    this.subscribers.add(cb);
+  }
+
+  unsubscribe(cb: ActivitySubscriber): void {
+    this.subscribers.delete(cb);
+  }
+
+  get subscriberCount(): number {
+    return this.subscribers.size;
+  }
+
+  close(): void {
+    this.closed = true;
+    this.subscribers.clear();
+    // Memory: remove from activeStreams cache
+    ActivityStream.activeStreams.delete(this.sessionId);
+  }
+
+  get isClosed(): boolean {
+    return this.closed;
+  }
+
+  get lastSeq(): number {
+    return this.seq;
+  }
+
+  /* ─── Static factory ─────────────────── */
+
+  /** Cache of active streams by sessionId */
+  private static activeStreams = new Map<string, ActivityStream>();
+
+  /** Get or create an ActivityStream for a session. Reuses existing stream for continuations. */
+  static getOrCreate(sessionId: string, roleId: string, parentSessionId?: string, traceId?: string): ActivityStream {
+    const existing = ActivityStream.activeStreams.get(sessionId);
+    if (existing && !existing.isClosed) {
+      return existing;
+    }
+    const stream = new ActivityStream(sessionId, roleId, parentSessionId, traceId);
+    ActivityStream.activeStreams.set(sessionId, stream);
+    return stream;
+  }
+
+  /* ─── Static: read from file ───────────── */
+
+  /** Read events from a JSONL file starting at fromSeq */
+  static readFrom(streamId: string, fromSeq = 0): ActivityEvent[] {
+    const fp = streamPath(streamId);
+    if (!fs.existsSync(fp)) return [];
+
+    const lines = fs.readFileSync(fp, 'utf-8').split('\n').filter(Boolean);
+    const events: ActivityEvent[] = [];
+
+    for (const line of lines) {
+      try {
+        const event = JSON.parse(line) as ActivityEvent;
+        if (event.seq >= fromSeq) {
+          events.push(event);
+        }
+      } catch { /* skip malformed lines */ }
+    }
+
+    return events;
+  }
+
+  /** Read all events from a JSONL file */
+  static readAll(streamId: string): ActivityEvent[] {
+    return ActivityStream.readFrom(streamId, 0);
+  }
+
+  /** Check if a stream file exists */
+  static exists(streamId: string): boolean {
+    return fs.existsSync(streamPath(streamId));
+  }
+
+  /** List all stream files (stream IDs) */
+  static listAll(): string[] {
+    ensureDir();
+    return fs.readdirSync(streamsDir())
+      .filter(f => f.endsWith('.jsonl'))
+      .map(f => f.replace('.jsonl', ''));
+  }
+
+  /** Get the streams directory path */
+  static getStreamDir(): string {
+    return streamsDir();
+  }
+}

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

@@ -0,0 +1,115 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { COMPANY_ROOT } from './file-reader.js';
+import type { RoleStatus } from '../../../shared/types.js';
+
+function activityDir(): string {
+  return path.join(COMPANY_ROOT, '.tycono', 'activity');
+}
+
+export interface RoleActivity {
+  roleId: string;
+  status: RoleStatus;
+  currentTask: string;
+  startedAt: string;
+  updatedAt: string;
+  recentOutput: string;
+}
+
+function activityPath(roleId: string): string {
+  return path.join(activityDir(), `${roleId}.json`);
+}
+
+function ensureDir(): void {
+  const dir = activityDir();
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+}
+
+export function setActivity(roleId: string, task: string): void {
+  ensureDir();
+  const activity: RoleActivity = {
+    roleId,
+    status: 'working',
+    currentTask: task,
+    startedAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    recentOutput: '',
+  };
+  fs.writeFileSync(activityPath(roleId), JSON.stringify(activity, null, 2));
+  invalidateCache();
+}
+
+export function updateActivity(roleId: string, output: string): void {
+  const activity = getActivity(roleId);
+  if (!activity) return;
+  activity.updatedAt = new Date().toISOString();
+  activity.recentOutput = output.slice(-500);
+  fs.writeFileSync(activityPath(roleId), JSON.stringify(activity, null, 2));
+  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;
+  activity.status = 'done';
+  activity.updatedAt = new Date().toISOString();
+  fs.writeFileSync(activityPath(roleId), JSON.stringify(activity, null, 2));
+  invalidateCache();
+}
+
+export function clearActivity(roleId: string): void {
+  const filePath = activityPath(roleId);
+  if (fs.existsSync(filePath)) {
+    fs.unlinkSync(filePath);
+  }
+  invalidateCache();
+}
+
+export function getActivity(roleId: string): RoleActivity | null {
+  const filePath = activityPath(roleId);
+  if (!fs.existsSync(filePath)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+  } catch {
+    return 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'));
+  _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;
+}