tycono 0.1.70 → 0.1.71-beta.0

package/package.json

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

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

@@ -155,13 +155,24 @@ Use the code repository path for all source code work (reading, writing, buildin
     sections.push(consultSection);
   }
 
-  // Language preference
+  // Language preference (default: English)
   const prefs = readPreferences(companyRoot);
-  const lang = prefs.language ?? 'auto';
-  if (lang !== 'auto') {
-    const langNames: Record<string, string> = { en: 'English', ko: 'Korean', ja: 'Japanese' };
-    sections.push(`# Language\n\nAlways respond in **${langNames[lang] ?? lang}**. All output — reports, analysis, code comments, status updates — must be in ${langNames[lang] ?? lang}.`);
-  }
+  const lang = prefs.language && prefs.language !== 'auto' ? prefs.language : 'en';
+  const langNames: Record<string, string> = { en: 'English', ko: 'Korean (한국어)', ja: 'Japanese (日本語)' };
+  const langName = langNames[lang] ?? lang;
+  sections.push(`# Language (CRITICAL)
+
+You MUST respond in **${langName}**.
+
+This applies to ALL output without exception:
+- Status updates, reports, and analysis
+- Journal entries and standup notes
+- Decision logs and knowledge documents
+- User-facing messages and explanations
+- Git commit messages and PR descriptions
+
+Code (variable names, comments in code) may remain in English for readability.
+Everything else MUST be in ${langName}.`);
 
   // Execution behavior rules (prevents infinite exploration loops in -p mode)
   sections.push(`# Execution Rules (CRITICAL)

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

@@ -41,6 +41,8 @@ export interface RunnerConfig {
   targetRoles?: string[];
   /** EG-001: Code project root for bash_execute tool */
   codeRoot?: string;
+  /** PSM-004: Environment variables to inject (e.g., port assignments) */
+  env?: Record<string, string>;
 }
 
 /* ─── Callbacks ───────────────────────────────── */

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

@@ -69,58 +69,27 @@ export function handleExecRequest(req: IncomingMessage, res: ServerResponse): vo
    ═══════════════════════════════════════════════ */
 
 function handleJobsRequest(url: string, method: string, req: IncomingMessage, res: ServerResponse): void {
-  // Strip query string for matching
-  const [path, queryString] = url.split('?');
+  const [path] = url.split('?');
 
-  // POST /api/jobs — start a new job
+  // POST /api/jobs — start a new job (creates session + job)
   if (method === 'POST' && path === '/api/jobs') {
     readBody(req).then((body) => handleStartJob(body, res));
     return;
   }
 
-  // GET /api/jobs — list jobs
-  if (method === 'GET' && path === '/api/jobs') {
-    const params = new URLSearchParams(queryString ?? '');
-    handleListJobs(params, res);
-    return;
-  }
-
-  // Match /api/jobs/:id/stream
-  const streamMatch = path.match(/^\/api\/jobs\/([^/]+)\/stream$/);
-  if (streamMatch && method === 'GET') {
-    const params = new URLSearchParams(queryString ?? '');
-    const fromSeq = parseInt(params.get('from') ?? '0', 10);
-    handleJobStream(streamMatch[1], fromSeq, req, res);
-    return;
-  }
-
-  // Match /api/jobs/:id/reply
-  const replyMatch = path.match(/^\/api\/jobs\/([^/]+)\/reply$/);
-  if (replyMatch && method === 'POST') {
-    readBody(req).then((body) => handleReplyToJob(replyMatch[1], body, res));
-    return;
-  }
-
-  // Match /api/jobs/:id/history
+  // GET /api/jobs/:id/history — internal only (used by engine Python sub-processes)
   const historyMatch = path.match(/^\/api\/jobs\/([^/]+)\/history$/);
-  if (historyMatch && method === 'GET') {
-    handleJobHistory(historyMatch[1], res);
-    return;
-  }
-
-  // Match /api/jobs/:id
-  const idMatch = path.match(/^\/api\/jobs\/([^/]+)$/);
-  if (idMatch && method === 'GET') {
-    handleGetJob(idMatch[1], res);
-    return;
-  }
-  if (idMatch && method === 'DELETE') {
-    handleAbortJob(idMatch[1], res);
+  if (method === 'GET' && historyMatch) {
+    const jobId = historyMatch[1];
+    const events = ActivityStream.readAll(jobId);
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({ events }));
     return;
   }
 
-  res.writeHead(404);
-  res.end(JSON.stringify({ error: 'Not found' }));
+  // All other /api/jobs/* endpoints removed — use /api/sessions/* instead
+  res.writeHead(410);  // Gone
+  res.end(JSON.stringify({ error: 'Job monitoring endpoints removed. Use /api/sessions/:id/stream, /api/sessions/:id/abort, /api/sessions/:id/reply instead.' }));
 }
 
 /* ─── POST /api/jobs ─────────────────────── */
@@ -275,121 +244,6 @@ function handleStartJob(body: Record<string, unknown>, res: ServerResponse): voi
   jsonResponse(res, 200, { jobId: job.id, ...(sessionId && { sessionId }) });
 }
 
-/* ─── GET /api/jobs ──────────────────────── */
-
-function handleListJobs(params: URLSearchParams, res: ServerResponse): void {
-  const status = params.get('status') as 'running' | 'done' | 'error' | null;
-  const roleId = params.get('roleId') ?? undefined;
-
-  const jobs = jobManager.listJobs({
-    status: status ?? undefined,
-    roleId,
-  });
-
-  jsonResponse(res, 200, { jobs });
-}
-
-/* ─── GET /api/jobs/:id ──────────────────── */
-
-function handleGetJob(jobId: string, res: ServerResponse): void {
-  const info = jobManager.getJobInfo(jobId);
-  if (!info) {
-    jsonResponse(res, 404, { error: 'Job not found' });
-    return;
-  }
-  jsonResponse(res, 200, info);
-}
-
-/* ─── GET /api/jobs/:id/stream ───────────── */
-
-function handleJobStream(jobId: string, fromSeq: number, req: IncomingMessage, res: ServerResponse): void {
-  const job = jobManager.getJob(jobId);
-
-  // Start SSE
-  startSSE(res);
-
-  // Replay historical events from file
-  const pastEvents = ActivityStream.readFrom(jobId, fromSeq);
-  for (const event of pastEvents) {
-    sendSSE(res, 'activity', event);
-  }
-
-  // If the job is finished (not running/awaiting), send end and close
-  if (!job || (job.status !== 'running' && job.status !== 'awaiting_input')) {
-    sendSSE(res, 'stream:end', { reason: job ? job.status : 'not-found' });
-    res.end();
-    return;
-  }
-
-  // Subscribe for live events
-  const subscriber = (event: ActivityEvent) => {
-    if (event.seq >= fromSeq) {
-      sendSSE(res, 'activity', event);
-    }
-    // Auto-close SSE when job ends or CEO replies (new stream takes over)
-    if (event.type === 'job:done' || event.type === 'job:error') {
-      sendSSE(res, 'stream:end', { reason: event.type === 'job:done' ? 'done' : 'error' });
-      res.end();
-      job.stream.unsubscribe(subscriber);
-    } else if (event.type === 'job:reply') {
-      // CEO replied → close this stream; frontend will connect to continuation job
-      sendSSE(res, 'stream:end', { reason: 'replied' });
-      res.end();
-      job.stream.unsubscribe(subscriber);
-    }
-    // awaiting_input keeps SSE open (sends event but doesn't close)
-  };
-
-  job.stream.subscribe(subscriber);
-
-  // Client disconnect → just unsubscribe (job keeps running)
-  req.on('close', () => {
-    job.stream.unsubscribe(subscriber);
-  });
-}
-
-/* ─── GET /api/jobs/:id/history ──────────── */
-
-function handleJobHistory(jobId: string, res: ServerResponse): void {
-  if (!ActivityStream.exists(jobId)) {
-    jsonResponse(res, 404, { error: 'Job history not found' });
-    return;
-  }
-  const events = ActivityStream.readAll(jobId);
-  jsonResponse(res, 200, { events });
-}
-
-/* ─── DELETE /api/jobs/:id ───────────────── */
-
-function handleAbortJob(jobId: string, res: ServerResponse): void {
-  const success = jobManager.abortJob(jobId);
-  if (!success) {
-    jsonResponse(res, 404, { error: 'Job not found or not running' });
-    return;
-  }
-  jsonResponse(res, 200, { ok: true });
-}
-
-/* ─── POST /api/jobs/:id/reply ──────────── */
-
-function handleReplyToJob(jobId: string, body: Record<string, unknown>, res: ServerResponse): void {
-  const message = body.message as string;
-  if (!message) {
-    jsonResponse(res, 400, { error: 'message is required' });
-    return;
-  }
-
-  const responderRole = body.responderRole as string | undefined;
-
-  const newJob = jobManager.replyToJob(jobId, message, responderRole);
-  if (!newJob) {
-    jsonResponse(res, 400, { error: 'Job not found or not in a replyable state' });
-    return;
-  }
-
-  jsonResponse(res, 200, { jobId: newJob.id, roleId: newJob.roleId });
-}
-
 /* ─── POST /api/waves/save ──────────────── */
 
 function handleSaveWave(body: Record<string, unknown>, res: ServerResponse): void {

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

@@ -7,7 +7,11 @@ import {
   deleteMany,
   deleteEmpty,
   updateSession,
+  addMessage,
+  type Message,
 } from '../services/session-store.js';
+import { jobManager } from '../services/job-manager.js';
+import { ActivityStream, type ActivityEvent } from '../services/activity-stream.js';
 
 export const sessionsRouter = Router();
 
@@ -73,3 +77,156 @@ sessionsRouter.delete('/:id', (req, res) => {
   }
   res.json({ ok: true });
 });
+
+/* ─── SCA-011: Session-based Job proxying ──── */
+
+/** GET /api/sessions/:id/stream — SSE proxy to linked job's activity stream */
+sessionsRouter.get('/:id/stream', (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+
+  const job = jobManager.getJobBySessionId(req.params.id);
+  const fromSeq = parseInt(req.query.from as string ?? '0', 10);
+
+  // Start SSE
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'X-Accel-Buffering': 'no',
+  });
+  res.flushHeaders();
+
+  const sendEvent = (event: string, data: unknown) => {
+    if (res.destroyed || res.writableEnded) return;
+    try { res.write(`event: ${event}\ndata: ${JSON.stringify(data)}\n\n`); } catch { /* ignore */ }
+  };
+
+  // If no job found, try to replay from the session's latest jobId in messages
+  const jobId = job?.id ?? session.messages.filter(m => m.jobId).pop()?.jobId;
+
+  if (jobId) {
+    // Replay historical events
+    const pastEvents = ActivityStream.readFrom(jobId, fromSeq);
+    for (const event of pastEvents) {
+      sendEvent('activity', event);
+    }
+  }
+
+  // If the job is finished or doesn't exist, end
+  if (!job || (job.status !== 'running' && job.status !== 'awaiting_input')) {
+    sendEvent('stream:end', { reason: job ? job.status : 'no-job' });
+    res.end();
+    return;
+  }
+
+  // Subscribe for live events
+  const subscriber = (event: ActivityEvent) => {
+    if (event.seq >= fromSeq) {
+      sendEvent('activity', event);
+    }
+    if (event.type === 'job:done' || event.type === 'job:error') {
+      sendEvent('stream:end', { reason: event.type === 'job:done' ? 'done' : 'error' });
+      res.end();
+      job.stream.unsubscribe(subscriber);
+    } else if (event.type === 'job:reply') {
+      sendEvent('stream:end', { reason: 'replied' });
+      res.end();
+      job.stream.unsubscribe(subscriber);
+    }
+  };
+
+  job.stream.subscribe(subscriber);
+
+  // Heartbeat
+  const heartbeat = setInterval(() => {
+    if (res.destroyed || res.writableEnded) {
+      clearInterval(heartbeat);
+      return;
+    }
+    try { res.write(': heartbeat\n\n'); } catch { /* ignore */ }
+  }, 15_000);
+
+  req.on('close', () => {
+    clearInterval(heartbeat);
+    job.stream.unsubscribe(subscriber);
+  });
+});
+
+/** 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;
+  }
+
+  const job = jobManager.getJobBySessionId(req.params.id);
+  if (!job) {
+    res.status(404).json({ error: 'No active job for this session' });
+    return;
+  }
+
+  const success = jobManager.abortJob(job.id);
+  if (!success) {
+    res.status(400).json({ error: 'Job not running or already finished' });
+    return;
+  }
+
+  res.json({ ok: true, jobId: job.id });
+});
+
+/** POST /api/sessions/:id/reply — reply to awaiting_input job via session */
+sessionsRouter.post('/:id/reply', (req, res) => {
+  const session = getSession(req.params.id);
+  if (!session) {
+    res.status(404).json({ error: 'Session not found' });
+    return;
+  }
+
+  const { message, responderRole } = req.body;
+  if (!message) {
+    res.status(400).json({ error: 'message is required' });
+    return;
+  }
+
+  const job = jobManager.getJobBySessionId(req.params.id);
+  if (!job) {
+    res.status(404).json({ error: 'No active job for this session' });
+    return;
+  }
+
+  // Add CEO reply message to session
+  const ceoMsg: Message = {
+    id: `msg-${Date.now()}-ceo-reply`,
+    from: 'ceo',
+    content: message,
+    type: 'conversation',
+    status: 'done',
+    timestamp: new Date().toISOString(),
+  };
+  addMessage(req.params.id, ceoMsg);
+
+  const newJob = jobManager.replyToJob(job.id, message, responderRole);
+  if (!newJob) {
+    res.status(400).json({ error: 'Job not in a replyable state' });
+    return;
+  }
+
+  // Add role message for the continuation job
+  const roleMsg: Message = {
+    id: `msg-${Date.now() + 1}-role-reply`,
+    from: 'role',
+    content: '',
+    type: 'conversation',
+    status: 'streaming',
+    timestamp: new Date().toISOString(),
+    jobId: newJob.id,
+  };
+  addMessage(req.params.id, roleMsg, true);
+
+  res.json({ ok: true, jobId: newJob.id, sessionId: req.params.id });
+});