@controlflow-ai/daemon 0.1.2 → 0.1.4

package/src/migrations/043_room_mode_skill_registry.ts

@@ -0,0 +1,92 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 43;
+export const name = 'room_mode_skill_registry';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+export function up(db: Database): void {
+  if (!hasColumn(db, 'chats', 'mode')) {
+    db.exec(`ALTER TABLE chats ADD COLUMN mode TEXT NOT NULL DEFAULT 'standard' CHECK (mode IN ('standard', 'idea_development'))`);
+  }
+
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS skill_definitions (
+      key TEXT PRIMARY KEY,
+      name TEXT NOT NULL,
+      description TEXT NOT NULL,
+      instruction_content TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('active', 'disabled')),
+      version TEXT NOT NULL DEFAULT '1',
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now'))
+    );
+
+    CREATE TABLE IF NOT EXISTS skill_bindings (
+      id TEXT PRIMARY KEY,
+      scope TEXT NOT NULL CHECK (scope IN ('project', 'room', 'agent')),
+      scope_id TEXT NOT NULL,
+      skill_key TEXT NOT NULL REFERENCES skill_definitions(key) ON DELETE CASCADE,
+      enabled INTEGER NOT NULL DEFAULT 1 CHECK (enabled IN (0, 1)),
+      priority INTEGER NOT NULL DEFAULT 100,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      UNIQUE(scope, scope_id, skill_key)
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_skill_bindings_lookup
+      ON skill_bindings(scope, scope_id, enabled, priority, skill_key);
+
+    INSERT INTO skill_definitions (
+      key, name, description, instruction_content, status, version, created_at, updated_at
+    )
+    VALUES (
+      'idea_development',
+      'Idea Development',
+      'Develop early ideas through conversation and project .pal documents before implementation handoff.',
+      'When this skill is enabled, treat the room as an Idea Development room. Do not rush vague ideas into implementation tasks. Help the user develop intent through conversation, clarify maturity and technical participation level, and maintain relevant .pal documents for user review. Keep implementation handoff separate until the idea is clear enough. Preserve ordinary rooms as ordinary rooms; this workflow applies only where the skill is enabled.',
+      'active',
+      '1',
+      datetime('now'),
+      datetime('now')
+    )
+    ON CONFLICT(key) DO UPDATE SET
+      name = excluded.name,
+      description = excluded.description,
+      instruction_content = excluded.instruction_content,
+      status = excluded.status,
+      version = excluded.version,
+      updated_at = datetime('now');
+
+    DROP VIEW IF EXISTS chat_stats;
+    CREATE VIEW chat_stats AS
+    SELECT
+      c.id,
+      c.name,
+      c.display_name,
+      c.kind,
+      c.server_id,
+      c.provider,
+      c.dm_type,
+      c.capabilities_json,
+      c.audit_visibility,
+      c.status,
+      c.mode,
+      c.project_id,
+      p.name AS project_name,
+      p.root_path AS project_root_path,
+      p.computer_id AS project_computer_id,
+      pc.name AS project_computer_name,
+      c.created_at,
+      COUNT(m.id) AS message_count,
+      MAX(m.created_at) AS last_message_at
+    FROM chats c
+    LEFT JOIN projects p ON p.id = c.project_id
+    LEFT JOIN computers pc ON pc.id = p.computer_id
+    LEFT JOIN messages m ON m.chat_id = c.id
+    GROUP BY c.id;
+  `);
+}

package/src/migrations/044_workflow_runtime.ts

@@ -0,0 +1,69 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 44;
+export const name = 'workflow_runtime';
+
+export function up(db: Database): void {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS workflow_runs (
+      id TEXT PRIMARY KEY,
+      file_path TEXT NOT NULL,
+      goal TEXT,
+      status TEXT NOT NULL DEFAULT 'running' CHECK (status IN ('running', 'completed', 'failed')),
+      created_by TEXT,
+      final_output_json TEXT,
+      error TEXT,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at TEXT
+    );
+
+    CREATE TABLE IF NOT EXISTS workflow_nodes (
+      id TEXT PRIMARY KEY,
+      run_id TEXT NOT NULL REFERENCES workflow_runs(id) ON DELETE CASCADE,
+      parent_id TEXT REFERENCES workflow_nodes(id) ON DELETE SET NULL,
+      kind TEXT NOT NULL CHECK (kind IN ('phase', 'agent', 'task', 'message', 'final')),
+      title TEXT NOT NULL,
+      role TEXT,
+      status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'running', 'done', 'failed')),
+      context_json TEXT,
+      instruction TEXT,
+      capabilities_json TEXT NOT NULL DEFAULT '[]',
+      output_contract_json TEXT,
+      output_json TEXT,
+      evidence_json TEXT,
+      task_id TEXT REFERENCES room_tasks(id) ON DELETE SET NULL,
+      message_id INTEGER REFERENCES messages(id) ON DELETE SET NULL,
+      created_at TEXT NOT NULL DEFAULT (datetime('now')),
+      updated_at TEXT NOT NULL DEFAULT (datetime('now')),
+      completed_at TEXT
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_runs_status
+      ON workflow_runs(status, updated_at);
+
+    CREATE INDEX IF NOT EXISTS idx_workflow_nodes_run_parent
+      ON workflow_nodes(run_id, parent_id, created_at);
+
+    INSERT INTO skill_definitions (
+      key, name, description, instruction_content, status, version, created_at, updated_at
+    )
+    VALUES (
+      'workflow_authoring',
+      'Workflow Authoring',
+      'Author PAL Dynamic Orchestration workflow scripts using controlled runtime primitives.',
+      'Use this skill when a complex PAL task should be decomposed into an observable workflow. Write TypeScript or JavaScript workflow files that call PAL workflow primitives for phases, agent nodes, room messages, tasks, result collection, and finalization. Model agent nodes with role, context, instruction, capabilities, output contract, status, and evidence. Keep project filesystem and shell actions inside agent work rather than direct workflow script operations.',
+      'active',
+      '1',
+      datetime('now'),
+      datetime('now')
+    )
+    ON CONFLICT(key) DO UPDATE SET
+      name = excluded.name,
+      description = excluded.description,
+      instruction_content = excluded.instruction_content,
+      status = excluded.status,
+      version = excluded.version,
+      updated_at = datetime('now');
+  `);
+}

package/src/migrations/045_skill_repository_ownership.ts

@@ -0,0 +1,64 @@
+import type { Database } from 'bun:sqlite';
+
+export const version = 45;
+export const name = 'skill_repository_ownership';
+
+function hasColumn(db: Database, table: string, column: string): boolean {
+  const rows = db.query(`PRAGMA table_info(${table})`).all() as Array<{ name: string }>;
+  return rows.some((row) => row.name === column);
+}
+
+export function up(db: Database): void {
+  if (!hasColumn(db, 'skill_definitions', 'source')) {
+    db.exec(`ALTER TABLE skill_definitions ADD COLUMN source TEXT NOT NULL DEFAULT 'system'`);
+  }
+  if (!hasColumn(db, 'skill_definitions', 'owner_user_id')) {
+    db.exec(`ALTER TABLE skill_definitions ADD COLUMN owner_user_id TEXT`);
+  }
+  if (!hasColumn(db, 'skill_definitions', 'project_id')) {
+    db.exec(`ALTER TABLE skill_definitions ADD COLUMN project_id TEXT REFERENCES projects(id) ON DELETE SET NULL`);
+  }
+  if (!hasColumn(db, 'skill_definitions', 'repository_path')) {
+    db.exec(`ALTER TABLE skill_definitions ADD COLUMN repository_path TEXT`);
+  }
+
+  db.exec(`
+    UPDATE skill_definitions
+    SET source = 'system',
+        owner_user_id = NULL,
+        project_id = NULL
+    WHERE key IN ('idea_development', 'workflow_authoring');
+
+    CREATE INDEX IF NOT EXISTS idx_skill_definitions_repository
+      ON skill_definitions(source, owner_user_id, project_id, status, key);
+
+    INSERT INTO skill_definitions (
+      key, name, description, instruction_content, status, version, source, owner_user_id, project_id, repository_path, created_at, updated_at
+    )
+    VALUES (
+      'handoff_delivery',
+      'Handoff Delivery',
+      'Implement handoff-room requests with real code changes, verification, review loops, and evidence-based reporting.',
+      'Use this skill in PAL handoff implementation rooms. Convert documented intent into scoped implementation work, preserve unrelated worktree changes, avoid mock or superficial completion, run focused verification, use explicit planning/implementation/testing/review/synthesis loops for complex tasks, and report changed files, commands, evidence, risks, and limitations.',
+      'active',
+      '1',
+      'system',
+      NULL,
+      NULL,
+      NULL,
+      datetime('now'),
+      datetime('now')
+    )
+    ON CONFLICT(key) DO UPDATE SET
+      name = excluded.name,
+      description = excluded.description,
+      instruction_content = excluded.instruction_content,
+      status = excluded.status,
+      version = excluded.version,
+      source = excluded.source,
+      owner_user_id = excluded.owner_user_id,
+      project_id = excluded.project_id,
+      repository_path = excluded.repository_path,
+      updated_at = datetime('now');
+  `);
+}

package/src/migrations.ts

@@ -22,6 +22,28 @@ import * as computerAgentAssignments from './migrations/020_computer_agent_assig
 import * as providerIdentityBindings from './migrations/021_provider_identity_bindings.js';
 import * as larkAuthorizedUsers from './migrations/022_lark_authorized_users.js';
 import * as projects from './migrations/023_projects.js';
+import * as agentsModel from './migrations/024_agents_model.js';
+import * as roomArchive from './migrations/025_room_archive.js';
+import * as projectArchive from './migrations/026_project_archive.js';
+import * as agentPermissionProfiles from './migrations/027_agent_permission_profiles.js';
+import * as larkWebsocketRestartState from './migrations/028_lark_websocket_restart_state.js';
+import * as heldMessageDrafts from './migrations/029_held_message_drafts.js';
+import * as agentRoomReadState from './migrations/030_agent_room_read_state.js';
+import * as roomTasks from './migrations/031_room_tasks.js';
+import * as roomReminders from './migrations/032_room_reminders.js';
+import * as roomSavedMessages from './migrations/033_room_saved_messages.js';
+import * as agentActivityEvents from './migrations/034_agent_activity_events.js';
+import * as agentAvatars from './migrations/035_agent_avatars.js';
+import * as projectAgentDefaults from './migrations/036_project_agent_defaults.js';
+import * as messageAttachments from './migrations/037_message_attachments.js';
+import * as agentActivityRoomScope from './migrations/038_agent_activity_room_scope.js';
+import * as messageAttachmentsPath from './migrations/039_message_attachments_path.js';
+import * as messageAttachmentsFileSchema from './migrations/040_message_attachments_file_schema.js';
+import * as roomSystemEvents from './migrations/041_room_system_events.js';
+import * as messageAttachmentFileKind from './migrations/042_message_attachment_file_kind.js';
+import * as roomModeSkillRegistry from './migrations/043_room_mode_skill_registry.js';
+import * as workflowRuntime from './migrations/044_workflow_runtime.js';
+import * as skillRepositoryOwnership from './migrations/045_skill_repository_ownership.js';
 
 interface Migration {
   version: number;
@@ -29,7 +51,53 @@ interface Migration {
   up(db: Database): void;
 }
 
-const migrations: Migration[] = [initial, daemonDeliveries, sessionsRuns, messageIdempotency, artifacts, larkChannelFoundation, agentsA0, b0ChatHistory, b0TranscriptIngestSeq, b0TranscriptShadowExternalIds, b0ChannelConversationAuditOnly, b0CrossConversationInvariant, b10EngInboundRawEvents, agentsRuntime, agentRuntimeSessions, roomParticipants, unifiedRoomDelivery, roomDisplayNames, computerConnections, computerAgentAssignments, providerIdentityBindings, larkAuthorizedUsers, projects].sort((a, b) => a.version - b.version);
+const migrations: Migration[] = [
+  initial,
+  daemonDeliveries,
+  sessionsRuns,
+  messageIdempotency,
+  artifacts,
+  larkChannelFoundation,
+  agentsA0,
+  b0ChatHistory,
+  b0TranscriptIngestSeq,
+  b0TranscriptShadowExternalIds,
+  b0ChannelConversationAuditOnly,
+  b0CrossConversationInvariant,
+  b10EngInboundRawEvents,
+  agentsRuntime,
+  agentRuntimeSessions,
+  roomParticipants,
+  unifiedRoomDelivery,
+  roomDisplayNames,
+  computerConnections,
+  computerAgentAssignments,
+  providerIdentityBindings,
+  larkAuthorizedUsers,
+  projects,
+  agentsModel,
+  roomArchive,
+  projectArchive,
+  agentPermissionProfiles,
+  larkWebsocketRestartState,
+  heldMessageDrafts,
+  agentRoomReadState,
+  roomTasks,
+  roomReminders,
+  roomSavedMessages,
+  agentActivityEvents,
+  agentAvatars,
+  projectAgentDefaults,
+  messageAttachments,
+  agentActivityRoomScope,
+  messageAttachmentsPath,
+  messageAttachmentsFileSchema,
+  roomSystemEvents,
+  messageAttachmentFileKind,
+  roomModeSkillRegistry,
+  workflowRuntime,
+  skillRepositoryOwnership,
+].sort((a, b) => a.version - b.version);
 
 function assertContiguousMigrations(): void {
   for (let index = 0; index < migrations.length; index += 1) {

package/src/neeko.ts

@@ -1,17 +1,53 @@
-import { buildPalPrompt, runtimeCwd, type AgentRuntime, type AgentRuntimeRunInput } from './agent-runtime.js';
+import { buildPalPrompt, runtimeLaunchRoot, runtimeCwd, type AgentRuntime, type AgentRuntimeRunInput } from './agent-runtime.js';
+import { writeGeneratedOpenCodeConfig } from './agent-permissions.js';
 export type { AgentRuntimeRunInput, AgentRuntimeRunResult } from './agent-runtime.js';
 export { runAgentRuntime } from './agent-runtime.js';
 
-export function makeNeekoRuntime(agentUuid: string): AgentRuntime {
+export function makeNeekoRuntime(agentUuid: string, model?: string | null): AgentRuntime {
   void agentUuid;
+  const selectedModel = model?.trim() || 'opencode/nemotron-3-super-free';
   return {
     name: 'neeko',
-    capabilities: { protocol: 'acp', resume: 'runtime-session-id', busyDeliveryMode: 'queue', supportsMcp: true },
+    capabilities: { protocol: 'json-stream', resume: 'runtime-session-id', busyDeliveryMode: 'queue', supportsMcp: false, supportsSteer: false },
     command: 'neeko',
     buildPrompt: buildPalPrompt,
     buildCwd: runtimeCwd,
+    buildEnv(input: AgentRuntimeRunInput): Record<string, string> {
+      return { OPENCODE_CONFIG: writeGeneratedOpenCodeConfig(input) };
+    },
     buildArgs(input: AgentRuntimeRunInput): string[] {
-      return ['acp', '--cwd', runtimeCwd(input), ...input.extraArgs];
+      const prompt = buildPalPrompt(input);
+      const resumeArgs = input.runtimeSessionId ? ['--session', input.runtimeSessionId] : [];
+      return [
+        'run',
+        '--format', 'json',
+        '--model', selectedModel,
+        '--dir', runtimeLaunchRoot(input),
+        ...resumeArgs,
+        ...input.extraArgs,
+        prompt,
+      ];
+    },
+    parseOutput({ stdout, stderr, input }) {
+      let runtimeSessionId = input.runtimeSessionId ?? null;
+      const output: string[] = [];
+      for (const line of stdout.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed.startsWith('{')) continue;
+        try {
+          const event = JSON.parse(trimmed) as { sessionID?: unknown; type?: unknown; part?: { type?: unknown; text?: unknown } };
+          if (typeof event.sessionID === 'string' && event.sessionID.trim()) runtimeSessionId = event.sessionID;
+          if (event.type === 'text' && event.part?.type === 'text' && typeof event.part.text === 'string') {
+            output.push(event.part.text);
+          }
+        } catch {
+          output.push(trimmed);
+        }
+      }
+      return {
+        output: [output.join(''), stderr.trim()].filter(Boolean).join('\n'),
+        runtimeSessionId,
+      };
     },
   };
 }

package/src/runtime-env.ts

@@ -0,0 +1,179 @@
+import { existsSync } from 'node:fs';
+import { delimiter, join } from 'node:path';
+import { homedir, userInfo } from 'node:os';
+import { spawnSync } from 'node:child_process';
+
+export interface RuntimeEnvReport {
+  effectiveEnv: NodeJS.ProcessEnv;
+  hydrated: string[];
+  missing: string[];
+  warnings: string[];
+  krb5: RuntimeKrb5Report;
+}
+
+export interface RuntimeKrb5Report {
+  ccname?: string;
+  valid: boolean;
+  expiresAt?: Date;
+  principal?: string;
+  error?: string;
+  skipped?: boolean;
+}
+
+interface ProbeKrb5Options {
+  runCommand?: (command: string, args: string[], env: NodeJS.ProcessEnv) => { status: number | null; stdout: string; stderr: string; error?: Error };
+}
+
+interface HydrateRuntimeEnvOptions extends ProbeKrb5Options {
+  userInfo?: () => { username: string; homedir: string };
+  getuid?: () => number | undefined;
+  exists?: (path: string) => boolean;
+  findCommandDir?: (command: string, env: NodeJS.ProcessEnv) => string | undefined;
+}
+
+function defaultRunCommand(command: string, args: string[], env: NodeJS.ProcessEnv): { status: number | null; stdout: string; stderr: string; error?: Error } {
+  const result = spawnSync(command, args, { env, encoding: 'utf8' });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+    error: result.error,
+  };
+}
+
+function krb5FilePath(ccname: string): string {
+  return ccname.replace(/^FILE:/, '');
+}
+
+export function ensurePathContains(pathValue: string, entries: Array<string | undefined>): string {
+  const seen = new Set<string>();
+  const parts: string[] = [];
+  for (const part of [...entries, ...pathValue.split(delimiter)]) {
+    if (!part || seen.has(part)) continue;
+    seen.add(part);
+    parts.push(part);
+  }
+  return parts.join(delimiter);
+}
+
+export function findCommandDir(command: string, env: NodeJS.ProcessEnv = process.env): string | undefined {
+  for (const dir of (env.PATH ?? '').split(delimiter)) {
+    if (!dir) continue;
+    if (existsSync(join(dir, command))) return dir;
+  }
+  return undefined;
+}
+
+function parseKlist(output: string): Pick<RuntimeKrb5Report, 'principal' | 'expiresAt' | 'valid'> {
+  const principal = output.match(/^Default principal:\s*(.+)$/m)?.[1]?.trim();
+  let expiresAt: Date | undefined;
+  for (const line of output.split('\n')) {
+    const match = line.match(/^\s*\d{2}\/\d{2}\/\d{4}\s+\d{2}:\d{2}:\d{2}\s+(\d{2}\/\d{2}\/\d{4}\s+\d{2}:\d{2}:\d{2})\s+/);
+    if (!match) continue;
+    const parsed = new Date(match[1]!);
+    if (!Number.isNaN(parsed.getTime()) && (!expiresAt || parsed > expiresAt)) expiresAt = parsed;
+  }
+  return { principal, expiresAt, valid: Boolean(expiresAt && expiresAt.getTime() > Date.now()) };
+}
+
+function krb5CheckDisabled(): boolean {
+  return /^(1|true|yes|on)$/i.test(process.env.PAL_DAEMON_DISABLE_KRB5_CHECK ?? '');
+}
+
+export function probeKrb5(ccname: string | undefined, options: ProbeKrb5Options = {}): RuntimeKrb5Report {
+  if (!ccname) return { valid: false };
+  if (krb5CheckDisabled()) {
+    return { ccname, valid: false, skipped: true, error: 'disabled' };
+  }
+  const runCommand = options.runCommand ?? defaultRunCommand;
+  const result = runCommand('klist', ['-c', ccname], process.env);
+  if (result.error) return { ccname, valid: false, error: result.error.message };
+  if (result.status !== 0) return { ccname, valid: false, error: (result.stderr || result.stdout).trim() || `klist exited ${result.status}` };
+  return { ccname, ...parseKlist(result.stdout) };
+}
+
+export function hydrateRuntimeEnv(base: NodeJS.ProcessEnv = process.env, options: HydrateRuntimeEnvOptions = {}): RuntimeEnvReport {
+  const env: NodeJS.ProcessEnv = { ...base };
+  const hydrated: string[] = [];
+  const missing: string[] = [];
+  const warnings: string[] = [];
+  const currentUser = options.userInfo?.() ?? userInfo();
+  const exists = options.exists ?? existsSync;
+
+  if (!env.HOME) {
+    env.HOME = currentUser.homedir || homedir();
+    hydrated.push('HOME');
+  }
+  if (!env.USER) {
+    env.USER = currentUser.username;
+    hydrated.push('USER');
+  }
+  if (!env.KRB5CCNAME) {
+    const uid = options.getuid?.() ?? process.getuid?.();
+    const candidates = [
+      env.HOME ? `FILE:${env.HOME}/.krb5cc` : undefined,
+      uid === undefined ? undefined : `FILE:/tmp/krb5cc_${uid}`,
+    ].filter((candidate): candidate is string => Boolean(candidate));
+    const found = candidates.find((candidate) => exists(krb5FilePath(candidate)));
+    if (found) {
+      env.KRB5CCNAME = found;
+      hydrated.push('KRB5CCNAME');
+    } else {
+      missing.push('KRB5CCNAME');
+    }
+  }
+  if (!env.LANG && !env.LC_ALL) {
+    env.LANG = 'C.UTF-8';
+    hydrated.push('LANG');
+  }
+  if (!env.TERM) {
+    env.TERM = 'dumb';
+    hydrated.push('TERM');
+  }
+  if (!env.HTTPS_PROXY && !env.https_proxy) warnings.push('HTTPS_PROXY is not set; internal runtime auth may require a proxy');
+  if (!env.HTTP_PROXY && !env.http_proxy) warnings.push('HTTP_PROXY is not set; internal runtime auth may require a proxy');
+  if (!env.NO_PROXY && !env.no_proxy) warnings.push('NO_PROXY is not set; proxy bypasses may be missing');
+
+  const passthrough = (env.PAL_RUNTIME_ENV_PASSTHROUGH ?? '').split(',').map((value) => value.trim()).filter(Boolean);
+  for (const name of passthrough) {
+    if (!env[name] && base[name]) env[name] = base[name];
+  }
+
+  const cocoDir = (options.findCommandDir ?? findCommandDir)('coco', env);
+  env.PATH = ensurePathContains(env.PATH ?? '', [
+    env.HOME ? `${env.HOME}/.local/bin` : undefined,
+    env.HOME ? `${env.HOME}/.bun/bin` : undefined,
+    cocoDir,
+  ]);
+
+  const krb5 = probeKrb5(env.KRB5CCNAME, options);
+  if (env.KRB5CCNAME && !krb5.valid && !krb5.skipped) warnings.push(`KRB5CCNAME is set but klist did not find a valid ticket${krb5.error ? `: ${krb5.error}` : ''}`);
+  return { effectiveEnv: env, hydrated, missing, warnings, krb5 };
+}
+
+function formatDuration(ms: number): string {
+  const minutes = Math.max(0, Math.round(ms / 60000));
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  return hours > 0 ? `${hours}h${remainingMinutes}m` : `${remainingMinutes}m`;
+}
+
+export function logEnvReport(report: RuntimeEnvReport): void {
+  const env = report.effectiveEnv;
+  console.log('[daemon] runtime env preflight');
+  console.log(`  HOME=${env.HOME ?? '<missing>'}${report.hydrated.includes('HOME') ? ' (hydrated)' : ''}`);
+  console.log(`  USER=${env.USER ?? '<missing>'}${report.hydrated.includes('USER') ? ' (hydrated)' : ''}`);
+  console.log(`  KRB5CCNAME=${env.KRB5CCNAME ?? '<missing>'}${report.hydrated.includes('KRB5CCNAME') ? ' (hydrated)' : ''}`);
+  if (report.krb5.valid && report.krb5.expiresAt) {
+    console.log(`  klist principal=${report.krb5.principal ?? '-'} expires=${report.krb5.expiresAt.toISOString()} (in ${formatDuration(report.krb5.expiresAt.getTime() - Date.now())})`);
+  } else if (report.krb5.skipped) {
+    console.log(`  klist skipped: ${report.krb5.error ?? 'disabled'}`);
+  } else if (report.krb5.ccname) {
+    console.log(`  klist invalid${report.krb5.error ? ` error=${report.krb5.error}` : ''}`);
+  } else {
+    console.log('  klist skipped: KRB5CCNAME missing');
+  }
+  const cocoDir = findCommandDir('coco', env);
+  console.log(`  PATH includes coco=${cocoDir ? `${join(cocoDir, 'coco')} ok` : 'not found'}`);
+  console.log(`  hydrated=[${report.hydrated.join(', ')}] missing=[${report.missing.join(', ')}] warnings=[${report.warnings.join('; ')}]`);
+}

package/src/runtime-registry.ts

@@ -3,23 +3,19 @@ import type { AgentRuntime, AgentRuntimeProtocol } from './agent-runtime.js';
 const supportedProtocols = new Set<AgentRuntimeProtocol>(['json-stream', 'acp']);
 
 const runtimeFactories = {
-  codex: async (agentUuid: string): Promise<AgentRuntime> => {
+  codex: async (agentUuid: string, model: string | null): Promise<AgentRuntime> => {
     const { makeCodexRuntime } = await import('./codex.js');
-    return makeCodexRuntime(agentUuid);
+    return makeCodexRuntime(agentUuid, model);
   },
-  coco: async (agentUuid: string): Promise<AgentRuntime> => {
+  coco: async (agentUuid: string, model: string | null): Promise<AgentRuntime> => {
     const { makeCocoRuntime } = await import('./coco.js');
-    return makeCocoRuntime(agentUuid);
+    return makeCocoRuntime(agentUuid, model);
   },
-  'coco-stream-json': async (agentUuid: string): Promise<AgentRuntime> => {
-    const { makeCocoStreamJsonRuntime } = await import('./coco.js');
-    return makeCocoStreamJsonRuntime(agentUuid);
-  },
-  neeko: async (agentUuid: string): Promise<AgentRuntime> => {
+  neeko: async (agentUuid: string, model: string | null): Promise<AgentRuntime> => {
     const { makeNeekoRuntime } = await import('./neeko.js');
-    return makeNeekoRuntime(agentUuid);
+    return makeNeekoRuntime(agentUuid, model);
   },
-} satisfies Record<string, (agentUuid: string) => Promise<AgentRuntime>>;
+} satisfies Record<string, (agentUuid: string, model: string | null) => Promise<AgentRuntime>>;
 
 export type RuntimeName = keyof typeof runtimeFactories;
 
@@ -27,13 +23,87 @@ export function knownRuntimeNames(): RuntimeName[] {
   return Object.keys(runtimeFactories) as RuntimeName[];
 }
 
-export async function resolveRuntimeDriver(runtimeName: string, agentUuid: string): Promise<AgentRuntime> {
+export interface RuntimeModelLookup {
+  models: string[];
+  error: string | null;
+}
+
+function modelCommand(runtimeName: string): { command: string; args: string[] } {
+  if (runtimeName === 'codex') return { command: 'codex', args: ['debug', 'models'] };
+  if (runtimeName === 'coco') return { command: 'coco', args: ['models'] };
+  if (runtimeName === 'neeko') return { command: 'neeko', args: ['models'] };
+  throw new Error(`Unsupported runtime '${runtimeName}'. Supported runtimes: ${knownRuntimeNames().join(', ')}.`);
+}
+
+function stripAnsi(value: string): string {
+  return value.replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, '');
+}
+
+function uniqueNonEmpty(values: string[]): string[] {
+  return Array.from(new Set(values.map((value) => value.trim()).filter(Boolean)));
+}
+
+function parseModelOutput(runtimeName: string, stdout: string): string[] {
+  const clean = stripAnsi(stdout).trim();
+  if (!clean) return [];
+  if (runtimeName === 'codex') {
+    const parsed = JSON.parse(clean) as { models?: Array<{ slug?: unknown; id?: unknown; name?: unknown }> };
+    return uniqueNonEmpty((parsed.models ?? []).map((model) => String(model.slug ?? model.id ?? model.name ?? '')));
+  }
+  return uniqueNonEmpty(clean.split(/\r?\n/).filter((line) => !/^\s*(available\s+)?models\s*:?\s*$/i.test(line)));
+}
+
+export async function runtimeModelOptions(runtimeName: string): Promise<string[]> {
+  const runtime = runtimeName.trim();
+  modelCommand(runtime);
+  const { command, args } = modelCommand(runtime);
+  const proc = Bun.spawn([command, ...args], {
+    stdout: 'pipe',
+    stderr: 'pipe',
+    env: process.env,
+  });
+  const [stdout, stderr, exitCode] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+    proc.exited,
+  ]);
+  if (exitCode !== 0) {
+    const detail = stderr.trim() || stdout.trim() || `exit ${exitCode}`;
+    throw new Error(`Could not load models for runtime '${runtime}': ${detail}`);
+  }
+  return parseModelOutput(runtime, stdout);
+}
+
+export async function lookupRuntimeModels(runtimeName: string): Promise<RuntimeModelLookup> {
+  try {
+    return { models: await runtimeModelOptions(runtimeName), error: null };
+  } catch (error) {
+    return { models: [], error: error instanceof Error ? error.message : String(error) };
+  }
+}
+
+export async function allRuntimeModelOptions(): Promise<Record<RuntimeName, RuntimeModelLookup>> {
+  const entries = await Promise.all(knownRuntimeNames().map(async (name) => [name, await lookupRuntimeModels(name)] as const));
+  return Object.fromEntries(entries) as Record<RuntimeName, RuntimeModelLookup>;
+}
+
+export async function validateRuntimeModel(runtimeName: string, model: string | null | undefined): Promise<string | null> {
+  const trimmed = model?.trim() || null;
+  if (!trimmed) return null;
+  const options = await runtimeModelOptions(runtimeName);
+  if (!options.includes(trimmed)) {
+    throw new Error(`Unsupported model '${trimmed}' for runtime '${runtimeName}'. Supported models: ${options.join(', ')}.`);
+  }
+  return trimmed;
+}
+
+export async function resolveRuntimeDriver(runtimeName: string, agentUuid: string, model?: string | null): Promise<AgentRuntime> {
   const factory = runtimeFactories[runtimeName as RuntimeName];
   if (!factory) {
     throw new Error(`Unsupported runtime '${runtimeName}'. Supported runtimes: ${knownRuntimeNames().join(', ')}.`);
   }
 
-  const driver = await factory(agentUuid);
+  const driver = await factory(agentUuid, model?.trim() || null);
   if (!supportedProtocols.has(driver.capabilities.protocol)) {
     throw new Error(`Runtime '${runtimeName}' uses unsupported protocol '${driver.capabilities.protocol}'. Supported protocols: ${Array.from(supportedProtocols).join(', ')}.`);
   }