tycono 0.1.64 → 0.1.66

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

@@ -8,6 +8,8 @@ import { setActivity, updateActivity, completeActivity } from './activity-tracke
 import type { RunnerResult } from '../engine/runners/types.js';
 import { estimateCost } from './pricing.js';
 import { readConfig, getConversationLimits } from './company-config.js';
+import { postKnowledgingCheck, type KnowledgeDebtItem } from '../engine/knowledge-gate.js';
+import { getSession, updateMessage as updateSessionMessage, appendMessageEvent } from './session-store.js';
 
 /* ─── Types ──────────────────────────────── */
 
@@ -29,6 +31,12 @@ export interface Job {
   error?: string;
   /** Which role should respond when status is awaiting_input */
   targetRole?: string;
+  /** Selective dispatch scope — only these roles can be dispatched to */
+  targetRoles?: string[];
+  /** Knowledge debt items detected by Post-Knowledging check */
+  knowledgeDebt?: KnowledgeDebtItem[];
+  /** D-014: Session this job belongs to */
+  sessionId?: string;
 }
 
 export interface JobInfo {
@@ -42,6 +50,8 @@ export interface JobInfo {
   createdAt: string;
   /** Which role should respond when status is awaiting_input */
   targetRole?: string;
+  /** Final output text (available when status is done) */
+  output?: string;
 }
 
 export interface StartJobParams {
@@ -54,6 +64,10 @@ export interface StartJobParams {
   model?: string;
   /** If true, this is a continuation from CEO reply — skip question detection */
   isContinuation?: boolean;
+  /** Selective dispatch: only these roles are allowed as dispatch targets */
+  targetRoles?: string[];
+  /** D-014: Link this job to a session (internal tracking) */
+  sessionId?: string;
 }
 
 /* ─── Helpers ────────────────────────────── */
@@ -155,6 +169,8 @@ class JobManager {
       parentJobId: params.parentJobId,
       childJobIds: [],
       createdAt: new Date().toISOString(),
+      targetRoles: params.targetRoles,
+      sessionId: params.sessionId,
     };
 
     this.jobs.set(jobId, job);
@@ -209,35 +225,71 @@ class JobManager {
         sourceRole: params.sourceRole ?? 'ceo',
         orgTree,
         readOnly: params.readOnly,
-        maxTurns: limits.hardLimit,  // Runner backup safety net = Harness hardLimit
+        maxTurns: limits.hardLimit,
         model,
         jobId,
         teamStatus,
+        targetRoles: params.targetRoles,
       },
       {
         onText: (text) => {
           updateActivity(params.roleId, text);
           stream.emit('text', params.roleId, { text });
+          // D-014: Update linked session message content
+          if (job.sessionId) {
+            this.updateSessionRoleMessage(job, text);
+          }
         },
         onThinking: (text) => {
           stream.emit('thinking', params.roleId, { text });
+          // D-014 SCA-010: Embed thinking event in session message
+          if (job.sessionId) {
+            this.embedSessionEvent(job, 'thinking', { text: text.slice(0, 200) });
+          }
         },
         onToolUse: (name, input) => {
           stream.emit('tool:start', params.roleId, {
             name,
             input: input ? summarizeInput(input) : undefined,
           });
+          // D-014 SCA-010: Embed tool event in session message
+          if (job.sessionId) {
+            this.embedSessionEvent(job, 'tool:start', {
+              name,
+              input: input ? summarizeInput(input) : undefined,
+            });
+          }
         },
         onDispatch: (subRoleId, subTask) => {
+          // 2-layer defense: block dispatch to roles outside targetRoles scope
+          if (params.targetRoles && params.targetRoles.length > 0) {
+            if (!params.targetRoles.includes(subRoleId)) {
+              console.warn(`[JobManager] Dispatch blocked: ${params.roleId} → ${subRoleId} (not in targetRoles)`);
+              stream.emit('stderr', params.roleId, {
+                message: `Dispatch to ${subRoleId} blocked — not in active target scope for this wave.`,
+              });
+              return;
+            }
+          }
           // Create child job — startJob() auto-emits dispatch:start
           // on parent stream when parentJobId is set.
-          this.startJob({
+          // Propagate targetRoles to child jobs for cascading enforcement
+          const childJob = this.startJob({
             type: 'assign',
             roleId: subRoleId,
             task: subTask,
             sourceRole: params.roleId,
             parentJobId: jobId,
+            targetRoles: params.targetRoles,
           });
+          // D-014 SCA-010: Embed dispatch event in session message
+          if (job.sessionId) {
+            this.embedSessionEvent(job, 'dispatch:start', {
+              roleId: subRoleId,
+              task: subTask,
+              childJobId: childJob.id,
+            });
+          }
         },
         onConsult: (subRoleId, question) => {
           // Create child job in read-only mode for consultation
@@ -348,9 +400,45 @@ class JobManager {
             targetRole,
           });
         } else {
+          // ─── Post-Knowledging check ───
+          // Extract changed .md files from tool calls and check for knowledge debt
+          const changedMdFiles = result.toolCalls
+            .filter(tc => (tc.name === 'write_file' || tc.name === 'edit_file') && tc.input && typeof tc.input.path === 'string')
+            .map(tc => String(tc.input!.path))
+            .filter(p => p.endsWith('.md'));
+
+          if (changedMdFiles.length > 0) {
+            try {
+              const pkResult = postKnowledgingCheck(COMPANY_ROOT, changedMdFiles);
+              if (!pkResult.pass) {
+                job.knowledgeDebt = pkResult.debt;
+                console.log(
+                  `[Post-K] Job ${jobId} (${params.roleId}): ${pkResult.debt.length} knowledge debt item(s)`,
+                );
+                for (const d of pkResult.debt) {
+                  console.log(`  [Post-K] ${d.type}: ${d.message}`);
+                }
+                // Include debt info in done event
+                (doneData as Record<string, unknown>).knowledgeDebt = pkResult.debt.map(d => ({
+                  type: d.type,
+                  file: d.file,
+                  message: d.message,
+                }));
+              }
+            } catch (err) {
+              console.warn('[Post-K] Check failed:', err);
+            }
+          }
+
           job.status = 'done';
           completeActivity(params.roleId);
           stream.emit('job:done', params.roleId, doneData);
+          // D-014: Update linked session message with final results
+          if (job.sessionId) {
+            this.finalizeSessionMessage(job, 'done', result);
+          }
+          // Cleanup orphaned child jobs (awaiting_input with no parent to respond)
+          this.cleanupOrphanedChildren(job.id);
         }
       })
       .catch((err: Error) => {
@@ -374,11 +462,93 @@ class JobManager {
         completeActivity(params.roleId);
 
         stream.emit('job:error', params.roleId, { message: err.message });
+        // D-014: Mark linked session message as error
+        if (job.sessionId) {
+          this.finalizeSessionMessage(job, 'error');
+        }
       });
 
     return job;
   }
 
+  /* ─── D-014: Session ↔ Job bridge ───────── */
+
+  /** Accumulated text content for session messages linked to jobs */
+  private sessionMsgContent = new Map<string, string>();
+
+  /** Update session role message content as text streams in */
+  private updateSessionRoleMessage(job: Job, text: string): void {
+    if (!job.sessionId) return;
+    const session = getSession(job.sessionId);
+    if (!session) return;
+
+    // Find the role message linked to this job
+    const roleMsg = session.messages.find(m => m.jobId === job.id && m.from === 'role');
+    if (!roleMsg) return;
+
+    const key = `${job.sessionId}:${roleMsg.id}`;
+    const current = (this.sessionMsgContent.get(key) ?? '') + text;
+    this.sessionMsgContent.set(key, current);
+
+    updateSessionMessage(job.sessionId, roleMsg.id, { content: current });
+  }
+
+  /** Embed an activity event into the session message linked to this job (SCA-010) */
+  private embedSessionEvent(job: Job, type: string, data: Record<string, unknown>): void {
+    if (!job.sessionId) return;
+    const session = getSession(job.sessionId);
+    if (!session) return;
+
+    const roleMsg = session.messages.find(m => m.jobId === job.id && m.from === 'role');
+    if (!roleMsg) return;
+
+    const event: ActivityEvent = {
+      seq: (roleMsg.events?.length ?? 0) + 1,
+      ts: new Date().toISOString(),
+      type: type as ActivityEvent['type'],
+      roleId: job.roleId,
+      data,
+    };
+    appendMessageEvent(job.sessionId, roleMsg.id, event);
+  }
+
+  /** Finalize session message when job completes or errors */
+  private finalizeSessionMessage(job: Job, status: 'done' | 'error', result?: RunnerResult): void {
+    if (!job.sessionId) return;
+    const session = getSession(job.sessionId);
+    if (!session) return;
+
+    const roleMsg = session.messages.find(m => m.jobId === job.id && m.from === 'role');
+    if (!roleMsg) return;
+
+    const key = `${job.sessionId}:${roleMsg.id}`;
+    const finalContent = this.sessionMsgContent.get(key) ?? roleMsg.content;
+    this.sessionMsgContent.delete(key);
+
+    updateSessionMessage(job.sessionId, roleMsg.id, {
+      content: finalContent,
+      status,
+      ...(result && {
+        turns: result.turns,
+        tokens: result.totalTokens,
+      }),
+    });
+  }
+
+  /** Cleanup orphaned child jobs when parent completes */
+  private cleanupOrphanedChildren(parentJobId: string): void {
+    for (const job of this.jobs.values()) {
+      if (job.parentJobId === parentJobId && job.status === 'awaiting_input') {
+        job.status = 'done';
+        completeActivity(job.roleId);
+        job.stream.emit('job:done', job.roleId, {
+          output: '[Auto-closed] Parent job completed',
+          turns: 0,
+        });
+      }
+    }
+  }
+
   /** Get a job by ID (in-memory or reconstruct from file) */
   getJob(id: string): Job | undefined {
     return this.jobs.get(id);
@@ -426,6 +596,7 @@ class JobManager {
       childJobIds: job.childJobIds,
       createdAt: job.createdAt,
       targetRole: job.targetRole,
+      output: job.result?.output,
     };
   }
 
@@ -465,18 +636,19 @@ class JobManager {
     return true;
   }
 
-  /** Reply to an awaiting_input job → creates a continuation job */
+  /** Reply to an awaiting_input or done job → creates a continuation job */
   replyToJob(id: string, response: string, responderRole?: string): Job | null {
     const job = this.jobs.get(id);
-    if (!job || job.status !== 'awaiting_input') return null;
+    if (!job || (job.status !== 'awaiting_input' && job.status !== 'done')) return null;
 
+    const isFollowUp = job.status === 'done';
     const effectiveResponder = responderRole ?? job.targetRole ?? 'ceo';
 
     // Mark previous job as done (don't emit job:done — the stream stays open
     // for the continuation job which will emit its own job:done when finished)
     job.status = 'done';
-    completeActivity(job.roleId);
-    job.stream.emit('job:reply', job.roleId, { response, responderRole: effectiveResponder });
+    if (!isFollowUp) completeActivity(job.roleId);
+    job.stream.emit('job:reply', job.roleId, { response, responderRole: effectiveResponder, isFollowUp });
 
     // Build continuation prompt with previous context
     const prevOutput = job.result?.output ?? '';
@@ -486,16 +658,20 @@ class JobManager {
 
     // Use the actual responder role name in the prompt
     const responderLabel = effectiveResponder === 'ceo' ? 'CEO' : effectiveResponder.toUpperCase();
-    const continuationTask = `[Continuation — previous output follows]\n${contextSummary}\n\n[${responderLabel} Response]\n${response}`;
+    const continuationTask = isFollowUp
+      ? `[CEO Follow-up Directive]\n${response}\n\n[Previous context — your earlier report follows]\n${contextSummary}`
+      : `[Continuation — previous output follows]\n${contextSummary}\n\n[${responderLabel} Response]\n${response}`;
 
-    // Create new job for same role (mark as continuation to skip question detection)
+    // Create new job for same role
+    // Follow-ups (from done state) should allow question detection since they're fresh directives
+    // Continuations (from awaiting_input) skip question detection to avoid infinite loops
     const newJob = this.startJob({
       type: job.type,
       roleId: job.roleId,
       task: continuationTask,
       sourceRole: effectiveResponder,
       parentJobId: job.id,
-      isContinuation: true,
+      isContinuation: !isFollowUp,
     });
 
     job.childJobIds.push(newJob.id);

package/src/api/src/services/port-registry.ts

@@ -0,0 +1,222 @@
+/**
+ * port-registry.ts — Session port allocation and tracking
+ *
+ * Manages port assignments for parallel dev server sessions.
+ * Each job/session gets unique API + Vite ports to avoid conflicts.
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import net from 'node:net';
+import { COMPANY_ROOT } from './file-reader.js';
+
+/* ─── Types ──────────────────────────────── */
+
+export interface PortAllocation {
+  api: number;
+  vite: number;
+  hmr?: number;
+}
+
+export interface SessionPort {
+  sessionId: string;
+  roleId: string;
+  task: string;
+  ports: PortAllocation;
+  worktreePath?: string;
+  pid?: number;
+  startedAt: string;
+  status: 'active' | 'idle' | 'dead';
+}
+
+interface RegistryFile {
+  sessions: SessionPort[];
+}
+
+/* ─── Port Pools ─────────────────────────── */
+
+const API_PORT_START = 3001;
+const VITE_PORT_START = 5173;
+const HMR_PORT_START = 24678;
+const POOL_SIZE = 10;
+
+/* ─── Helpers ────────────────────────────── */
+
+function getRegistryPath(): string {
+  return path.join(COMPANY_ROOT, '.tycono', 'port-registry.json');
+}
+
+function readRegistry(): RegistryFile {
+  const filePath = getRegistryPath();
+  try {
+    if (fs.existsSync(filePath)) {
+      return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+  } catch { /* ignore corrupt file */ }
+  return { sessions: [] };
+}
+
+function writeRegistry(data: RegistryFile): void {
+  const filePath = getRegistryPath();
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, JSON.stringify(data, null, 2));
+}
+
+function isProcessAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isPortAvailable(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const server = net.createServer();
+    server.once('error', () => resolve(false));
+    server.once('listening', () => {
+      server.close();
+      resolve(true);
+    });
+    server.listen(port, '127.0.0.1');
+  });
+}
+
+/* ─── PortRegistry ───────────────────────── */
+
+class PortRegistry {
+  /** Allocate ports for a new session */
+  async allocate(sessionId: string, roleId: string, task: string): Promise<PortAllocation> {
+    const registry = readRegistry();
+    const usedApi = new Set(registry.sessions.map(s => s.ports.api));
+    const usedVite = new Set(registry.sessions.map(s => s.ports.vite));
+    const usedHmr = new Set(registry.sessions.filter(s => s.ports.hmr).map(s => s.ports.hmr!));
+
+    // Find first available port in pool
+    let api = 0;
+    let vite = 0;
+    let hmr = 0;
+
+    for (let i = 0; i < POOL_SIZE; i++) {
+      const candidate = API_PORT_START + i;
+      if (!usedApi.has(candidate) && await isPortAvailable(candidate)) {
+        api = candidate;
+        break;
+      }
+    }
+
+    for (let i = 0; i < POOL_SIZE; i++) {
+      const candidate = VITE_PORT_START + i;
+      if (!usedVite.has(candidate) && await isPortAvailable(candidate)) {
+        vite = candidate;
+        break;
+      }
+    }
+
+    for (let i = 0; i < POOL_SIZE; i++) {
+      const candidate = HMR_PORT_START + i;
+      if (!usedHmr.has(candidate) && await isPortAvailable(candidate)) {
+        hmr = candidate;
+        break;
+      }
+    }
+
+    // Fallback: let OS pick
+    if (!api) api = 0;
+    if (!vite) vite = 0;
+
+    const ports: PortAllocation = { api, vite };
+    if (hmr) ports.hmr = hmr;
+
+    const session: SessionPort = {
+      sessionId,
+      roleId,
+      task: task.slice(0, 80),
+      ports,
+      startedAt: new Date().toISOString(),
+      status: 'active',
+    };
+
+    registry.sessions.push(session);
+    writeRegistry(registry);
+
+    return ports;
+  }
+
+  /** Release ports when a session ends */
+  release(sessionId: string): boolean {
+    const registry = readRegistry();
+    const before = registry.sessions.length;
+    registry.sessions = registry.sessions.filter(s => s.sessionId !== sessionId);
+    if (registry.sessions.length < before) {
+      writeRegistry(registry);
+      return true;
+    }
+    return false;
+  }
+
+  /** Update session info (e.g., set PID, worktree path) */
+  update(sessionId: string, patch: Partial<Pick<SessionPort, 'pid' | 'worktreePath' | 'status' | 'task'>>): boolean {
+    const registry = readRegistry();
+    const session = registry.sessions.find(s => s.sessionId === sessionId);
+    if (!session) return false;
+
+    if (patch.pid !== undefined) session.pid = patch.pid;
+    if (patch.worktreePath !== undefined) session.worktreePath = patch.worktreePath;
+    if (patch.status !== undefined) session.status = patch.status;
+    if (patch.task !== undefined) session.task = patch.task.slice(0, 80);
+
+    writeRegistry(registry);
+    return true;
+  }
+
+  /** Get all sessions */
+  getAll(): SessionPort[] {
+    return readRegistry().sessions;
+  }
+
+  /** Get a specific session */
+  get(sessionId: string): SessionPort | null {
+    return readRegistry().sessions.find(s => s.sessionId === sessionId) ?? null;
+  }
+
+  /** Detect and clean up dead sessions (PID gone) */
+  cleanup(): { cleaned: SessionPort[]; remaining: SessionPort[] } {
+    const registry = readRegistry();
+    const cleaned: SessionPort[] = [];
+    const remaining: SessionPort[] = [];
+
+    for (const session of registry.sessions) {
+      if (session.pid && !isProcessAlive(session.pid)) {
+        session.status = 'dead';
+        cleaned.push(session);
+      } else {
+        remaining.push(session);
+      }
+    }
+
+    if (cleaned.length > 0) {
+      registry.sessions = remaining;
+      writeRegistry(registry);
+    }
+
+    return { cleaned, remaining };
+  }
+
+  /** Get summary stats */
+  getSummary(): { active: number; totalPorts: number } {
+    const sessions = this.getAll();
+    const active = sessions.filter(s => s.status === 'active').length;
+    return {
+      active,
+      totalPorts: active * 2, // api + vite per session
+    };
+  }
+}
+
+/* ─── Export singleton ───────────────────── */
+
+export const portRegistry = new PortRegistry();

package/src/api/src/services/scaffold.ts

@@ -6,6 +6,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { execSync } from 'node:child_process';
 import { writeConfig } from './company-config.js';
 import type { CompanyConfig } from './company-config.js';
 
@@ -61,6 +62,12 @@ export function getAvailableTeams(): string[] {
     .map(f => f.replace('.json', ''));
 }
 
+export interface SkillToolDef {
+  package: string;
+  binary: string;
+  installCmd: string;
+}
+
 export interface SkillMeta {
   id: string;
   name: string;
@@ -72,6 +79,7 @@ export interface SkillMeta {
   compatibleRoles: string[];
   dependencies: string[];
   files: string[];
+  tools?: SkillToolDef[];
 }
 
 /**
@@ -94,6 +102,88 @@ export function getAvailableSkills(): SkillMeta[] {
   return skills;
 }
 
+/**
+ * Check if a CLI binary is available on the system
+ */
+function isBinaryInstalled(binary: string): boolean {
+  try {
+    execSync(`which ${binary}`, { stdio: 'ignore', timeout: 5000 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Collect all tools required by a set of skills
+ */
+export function getRequiredTools(skillIds: string[]): Array<SkillToolDef & { skillId: string; installed: boolean }> {
+  const tools: Array<SkillToolDef & { skillId: string; installed: boolean }> = [];
+  const seen = new Set<string>();
+
+  for (const skillId of skillIds) {
+    const metaPath = path.join(TEMPLATES_DIR, 'skills', skillId, 'meta.json');
+    if (!fs.existsSync(metaPath)) continue;
+
+    const meta: SkillMeta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+    if (!meta.tools?.length) continue;
+
+    for (const tool of meta.tools) {
+      if (seen.has(tool.package)) continue;
+      seen.add(tool.package);
+      tools.push({
+        ...tool,
+        skillId,
+        installed: isBinaryInstalled(tool.binary),
+      });
+    }
+  }
+
+  return tools;
+}
+
+export interface ToolInstallCallbacks {
+  onChecking?: (tool: string) => void;
+  onInstalling?: (tool: string) => void;
+  onInstalled?: (tool: string) => void;
+  onSkipped?: (tool: string, reason: string) => void;
+  onError?: (tool: string, error: string) => void;
+  onDone?: (stats: { installed: number; skipped: number; failed: number }) => void;
+}
+
+/**
+ * Install CLI tools required by skills
+ */
+export function installSkillTools(skillIds: string[], callbacks?: ToolInstallCallbacks): void {
+  const tools = getRequiredTools(skillIds);
+  let installed = 0;
+  let skipped = 0;
+  let failed = 0;
+
+  for (const tool of tools) {
+    callbacks?.onChecking?.(tool.package);
+
+    if (tool.installed) {
+      callbacks?.onSkipped?.(tool.package, 'already installed');
+      skipped++;
+      continue;
+    }
+
+    callbacks?.onInstalling?.(tool.package);
+    try {
+      execSync(tool.installCmd, { stdio: 'ignore', timeout: 120000 });
+      callbacks?.onInstalled?.(tool.package);
+      installed++;
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : 'install failed';
+      callbacks?.onError?.(tool.package, msg);
+      failed++;
+    }
+  }
+
+  callbacks?.onDone?.({ installed, skipped, failed });
+}
+
 function renderTemplate(template: string, vars: Record<string, string>): string {
   let result = template;
   for (const [key, value] of Object.entries(vars)) {