cc-viewer 1.9.12 → 1.9.14

package/server/routes/scheduled-tasks.js

@@ -0,0 +1,310 @@
+// Scheduled-task REST routes (L3).
+//
+//   GET  /api/scheduled-tasks?project=&instance=   → list (+ serverTime/timezone/spawnAvailable)
+//   POST /api/scheduled-tasks                      → create
+//   POST /api/scheduled-tasks/update               → update / pause / resume
+//   POST /api/scheduled-tasks/delete               → delete
+//   POST /api/scheduled-tasks/run                  → Run now
+//   POST /api/scheduled-tasks/preview              → next 3 base fire times for a schedule
+//   GET  /api/scheduled-tasks/runs?id=&project=    → recent runs for one task
+//
+// Auth: reads need only a logged-in viewer; WRITES are admin + same-origin (a scheduled
+// task injects a prompt into a session / spawns a headless agent — same trust level as
+// the resume/upload writers, mirroring routes/resume.js:492).
+//
+// project → cwd resolution (a task stores an ABSOLUTE cwd, not just a project name, so
+// same-basename workspaces never cross-execute — review §6): explicit project → the
+// bound project when it matches, else an instance/registry match; ambiguous → 409;
+// unresolvable → 404 (never silently fall back to the server's process cwd — P1-6).
+//
+// Boundary: L3 may import L1 (lib/*) and L2 (pty-manager/interceptor). The scheduler
+// singleton is imported directly (L3→L1); server.js owns its init/start/stop.
+
+import { _projectName } from '../interceptor.js';
+import { LOG_DIR } from '../../findcc.js';
+import { listLivePtys } from '../pty-manager.js';
+import { sendEventToClients } from '../lib/log-watcher.js';
+import { filterClientsByViewProject } from '../lib/v2/view-router.js';
+import { isAdminReq } from '../lib/is-admin.js';
+import { isSameOriginBrowserRequest } from '../lib/same-origin.js';
+import { reportSwallowed } from '../lib/error-report.js';
+import { normalizeSchedule, nextBaseFor } from '../lib/schedule-model.js';
+import {
+  createTask, updateTask, deleteTask, getTask, readScheduledTasks,
+} from '../lib/scheduled-task-store.js';
+import { readScheduledTaskRuns } from '../lib/scheduled-task-runs-store.js';
+import { runTaskNow, spawnAvailable } from '../lib/scheduled-task-scheduler.js';
+import { loadWorkspaces } from '../workspace-registry.js';
+import { listSdkSessionInstances } from '../lib/sdk-session-index.js';
+
+const MAX_BODY = 1 << 20;
+
+function sendJson(res, code, obj) {
+  res.writeHead(code, { 'Content-Type': 'application/json' });
+  res.end(JSON.stringify(obj));
+}
+
+function _readBody(req, res, deps, cb) {
+  let body = '';
+  req.on('data', (chunk) => { body += chunk; if (body.length > (deps?.MAX_POST_BODY || MAX_BODY)) req.destroy(); });
+  req.on('end', () => {
+    let parsed;
+    try { parsed = body ? JSON.parse(body) : {}; }
+    catch { sendJson(res, 400, { ok: false, error: 'invalid_json' }); return; }
+    cb(parsed);
+  });
+  req.on('error', () => { try { sendJson(res, 400, { ok: false, error: 'invalid_json' }); } catch {} });
+}
+
+function _guardWrite(req, res, parsedUrl, isLocal) {
+  if (!isAdminReq(req, isLocal) || !isSameOriginBrowserRequest(req, parsedUrl)) {
+    sendJson(res, 403, { ok: false, error: 'forbidden' });
+    return false;
+  }
+  return true;
+}
+
+/** Broadcast a task_changed frame to the project's viewers. */
+function _broadcastChanged(deps, project, taskId, action) {
+  try {
+    sendEventToClients(
+      filterClientsByViewProject(deps.clients, project, _projectName || ''),
+      'scheduled_tasks',
+      { type: 'task_changed', project, taskId, action },
+    );
+  } catch (err) { reportSwallowed('scheduled-tasks.broadcast', err); }
+}
+
+/**
+ * Resolve a project name (or explicit instance) to an ABSOLUTE cwd. Returns
+ * { ok:true, cwd } | { ok:false, status, error }.
+ */
+function _resolveProjectToCwd(project, instance) {
+  const bound = _projectName || '';
+  // 1. An explicit instance (SDK session / live PTY) pins the cwd EXACTLY — it wins over
+  //    the project name so two same-basename workspaces never cross-execute (review: the
+  //    bound-project branch must not shadow a deliberate instance pick).
+  if (instance) {
+    try {
+      const sdkHit = listSdkSessionInstances().find(s => s.instanceKey === instance);
+      if (sdkHit && sdkHit.cwd) {
+        // Consistency: the instance's cwd must actually belong to the named project,
+        // else this is a forged/mismatched project+instance pair (security review).
+        if (!project || project === bound || _projectNameOf(sdkHit.cwd) === project) return { ok: true, cwd: sdkHit.cwd };
+        return { ok: false, status: 409, error: 'project_ambiguous' };
+      }
+    } catch { /* fall through */ }
+    const ptyHit = listLivePtys().find(p => p.instanceKey === instance && p.ptyKind === 'claude');
+    if (ptyHit) {
+      if (!project || project === bound || _projectNameOf(ptyHit.cwd) === project) return { ok: true, cwd: ptyHit.cwd };
+      return { ok: false, status: 409, error: 'project_ambiguous' };
+    }
+    // An explicit instance that resolves to nothing is an error, not a silent fallback.
+    return { ok: false, status: 404, error: 'project_unresolved' };
+  }
+  // 2. The bound project (the common case) → the server's own cwd / CCV_PROJECT_DIR.
+  if (!project || project === bound) {
+    const cwd = process.env.CCV_PROJECT_DIR || (bound ? process.cwd() : null);
+    // P1-6: no bound project AND no explicit project → unresolvable (never process.cwd()).
+    if (!cwd) return { ok: false, status: 404, error: 'project_unresolved' };
+    return { ok: true, cwd };
+  }
+  // 3. The workspace registry: a unique projectName match → its path.
+  let matches = [];
+  try {
+    matches = loadWorkspaces().filter(w => w.projectName === project && w.path);
+  } catch (err) { reportSwallowed('scheduled-tasks.registry', err); }
+  if (matches.length === 1) return { ok: true, cwd: matches[0].path };
+  if (matches.length > 1) return { ok: false, status: 409, error: 'project_ambiguous' };
+  return { ok: false, status: 404, error: 'project_unresolved' };
+}
+
+// Project key (sanitized basename) for a cwd, matching the store/UI naming.
+function _projectNameOf(cwd) {
+  const base = String(cwd || '').replace(/\\/g, '/').split('/').filter(Boolean).pop() || '';
+  return base.replace(/[^a-zA-Z0-9_\-.]/g, '_');
+}
+
+/** Public list for a project (bound project when omitted). */
+function listHandler(req, res, parsedUrl) {
+  const project = parsedUrl.searchParams.get('project') || (_projectName || '');
+  const root = LOG_DIR;
+  let reg = { tasks: [], corrupt: false };
+  try {
+    reg = readScheduledTasks(root);
+  } catch (err) {
+    reportSwallowed('scheduled-tasks.list', err);
+    reg = { tasks: [], corrupt: true };
+  }
+  if (reg.corrupt) reportSwallowed('scheduled-tasks.list.corrupt', new Error('preferences.json scheduledTasks is corrupt'));
+  // Prompt secrecy (review): a project query only earns full prompts when it actually
+  // resolves to a known project (bound / registry / live). Otherwise fall back to the
+  // summary shape so an arbitrary ?project= can't pull another project's prompt text.
+  const resolved = project ? _resolveProjectToCwd(project, parsedUrl.searchParams.get('instance') || '') : { ok: false };
+  const fullPrompt = !!project && resolved.ok;
+  const tasks = (reg.tasks || []).filter(t => !project || t.project === project);
+  const running = new Set();
+  for (const t of tasks) if (t.claim) running.add(t.id);
+  const shaped = fullPrompt
+    ? tasks.map(t => ({ ..._publicTask(t), running: running.has(t.id), ...(reg.legacy ? { legacy: true } : {}) }))
+    : tasks.map(t => ({ ..._listTask(t), running: running.has(t.id), ...(reg.legacy ? { legacy: true } : {}) }));
+  sendJson(res, 200, {
+    tasks: shaped,
+    serverTime: Date.now(),
+    timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+    spawnAvailable: _spawnAvailableSafe(),
+    storeCorrupt: !!reg.corrupt,
+  });
+}
+
+function _publicTask(t) {
+  const { runs, claim, ...rest } = t;
+  return rest;
+}
+
+// List payload keeps the full prompt OUT (it may carry secrets and every logged-in
+// viewer can read the list — security P2-3). Full prompts only ship when the project
+// resolves (bound / registry / live instance — see listHandler's fullPrompt gate).
+function _listTask(t) {
+  const p = _publicTask(t);
+  p.promptSummary = String(t.prompt || '').replace(/\s+/g, ' ').trim().slice(0, 200);
+  delete p.prompt;
+  return p;
+}
+
+function _spawnAvailableSafe() {
+  try { return spawnAvailable(); } catch { return false; }
+}
+
+function createHandler(req, res, parsedUrl, isLocal, deps) {
+  if (!_guardWrite(req, res, parsedUrl, isLocal)) return;
+  _readBody(req, res, deps, async (body) => {
+    const project = (typeof body.project === 'string' && body.project) || (_projectName || '');
+    const resolved = _resolveProjectToCwd(project, body.instance);
+    if (!resolved.ok) return sendJson(res, resolved.status, { ok: false, error: resolved.error });
+    if (body.mode === 'spawn' && !_spawnAvailableSafe()) {
+      return sendJson(res, 400, { ok: false, error: 'spawn_unavailable' });
+    }
+    let out;
+    try {
+      out = await createTask(LOG_DIR, {
+        project, cwd: resolved.cwd, prompt: body.prompt, mode: body.mode,
+        schedule: body.schedule, enabled: body.enabled,
+      }, Date.now());
+    } catch (err) {
+      reportSwallowed('scheduled-tasks.create', err);
+      return sendJson(res, 500, { ok: false, error: 'store_corrupt' });
+    }
+    if (!out.ok) return sendJson(res, 400, { ok: false, error: out.reason, detail: out.detail });
+    _broadcastChanged(deps, project, out.task.id, 'created');
+    sendJson(res, 200, { ok: true, task: _publicTask(out.task) });
+  });
+}
+
+function updateHandler(req, res, parsedUrl, isLocal, deps) {
+  if (!_guardWrite(req, res, parsedUrl, isLocal)) return;
+  _readBody(req, res, deps, async (body) => {
+    const id = typeof body.id === 'string' ? body.id : '';
+    if (!id) return sendJson(res, 400, { ok: false, error: 'task_not_found' });
+    let out;
+    try {
+      out = await updateTask(LOG_DIR, id, {
+        prompt: body.prompt, mode: body.mode, schedule: body.schedule, enabled: body.enabled,
+      }, Date.now());
+    } catch (err) {
+      reportSwallowed('scheduled-tasks.update', err);
+      return sendJson(res, 500, { ok: false, error: 'store_corrupt' });
+    }
+    if (!out.ok) return sendJson(res, out.reason === 'task_not_found' ? 404 : 400, { ok: false, error: out.reason, detail: out.detail });
+    _broadcastChanged(deps, out.task.project, id, 'updated');
+    sendJson(res, 200, { ok: true, task: _publicTask(out.task) });
+  });
+}
+
+function deleteHandler(req, res, parsedUrl, isLocal, deps) {
+  if (!_guardWrite(req, res, parsedUrl, isLocal)) return;
+  _readBody(req, res, deps, async (body) => {
+    const id = typeof body.id === 'string' ? body.id : '';
+    let task = null;
+    try { task = getTask(LOG_DIR, id); } catch { /* tolerate */ }
+    let out;
+    try { out = await deleteTask(LOG_DIR, id, Date.now()); }
+    catch (err) {
+      reportSwallowed('scheduled-tasks.delete', err);
+      return sendJson(res, 500, { ok: false, error: 'store_corrupt' });
+    }
+    if (!out.ok) {
+      const status = out.reason === 'task_not_found' ? 404 : (out.reason === 'task_running' ? 409 : 400);
+      return sendJson(res, status, { ok: false, error: out.reason });
+    }
+    _broadcastChanged(deps, (task && task.project) || body.project || (_projectName || ''), id, 'deleted');
+    sendJson(res, 200, { ok: true });
+  });
+}
+
+function runHandler(req, res, parsedUrl, isLocal, deps) {
+  if (!_guardWrite(req, res, parsedUrl, isLocal)) return;
+  _readBody(req, res, deps, async (body) => {
+    const id = typeof body.id === 'string' ? body.id : '';
+    let out;
+    try { out = await runTaskNow(id, { manual: true }); }
+    catch (err) {
+      reportSwallowed('scheduled-tasks.run', err);
+      return sendJson(res, 503, { ok: false, error: 'scheduler_unavailable' });
+    }
+    if (!out.ok) {
+      const status = out.reason === 'scheduler_unavailable' ? 503
+        : out.reason === 'running' ? 409
+        : out.reason === 'not-found' ? 404 : 400;
+      return sendJson(res, status, { ok: false, error: out.reason === 'not-found' ? 'task_not_found' : out.reason });
+    }
+    sendJson(res, 202, { ok: true, runId: out.runId ?? null });
+  });
+}
+
+function previewHandler(req, res, parsedUrl, isLocal, deps) {
+  if (!_guardWrite(req, res, parsedUrl, isLocal)) return;
+  _readBody(req, res, deps, (body) => {
+    const now = Date.now();
+    const norm = normalizeSchedule(body.schedule, now);
+    if (!norm.ok) return sendJson(res, 400, { ok: false, error: norm.error, detail: norm.detail });
+    const next = [];
+    let cursor = now;
+    for (let i = 0; i < 3; i++) {
+      const t = nextBaseFor(norm.schedule, cursor);
+      if (t === null) break;
+      next.push(t);
+      cursor = t;
+    }
+    sendJson(res, 200, {
+      ok: true, next,
+      serverTime: now,
+      timezone: Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC',
+    });
+  });
+}
+
+function runsHandler(req, res, parsedUrl) {
+  const id = parsedUrl.searchParams.get('id') || '';
+  const reqProject = parsedUrl.searchParams.get('project') || (_projectName || '');
+  let task = null;
+  try { task = getTask(LOG_DIR, id); } catch (err) { reportSwallowed('scheduled-tasks.runs', err); }
+  if (!task) return sendJson(res, 404, { ok: false, error: 'task_not_found' });
+  // Runs carry the prompt summary + sessionId — scope them to the task's own project so a
+  // viewer of project A can't read project B's run history by id (security P2-3).
+  if (reqProject && task.project !== reqProject) return sendJson(res, 403, { ok: false, error: 'forbidden' });
+  let runs = [];
+  try { runs = readScheduledTaskRuns(LOG_DIR, id); }
+  catch (err) { reportSwallowed('scheduled-tasks.runs.read', err); }
+  sendJson(res, 200, { ok: true, runs: runs.slice(-20), serverTime: Date.now() });
+}
+
+export const scheduledTasksRoutes = [
+  { method: 'GET', match: 'exact', path: '/api/scheduled-tasks', handler: listHandler },
+  { method: 'GET', match: 'exact', path: '/api/scheduled-tasks/runs', handler: runsHandler },
+  { method: 'POST', match: 'exact', path: '/api/scheduled-tasks', handler: createHandler },
+  { method: 'POST', match: 'exact', path: '/api/scheduled-tasks/update', handler: updateHandler },
+  { method: 'POST', match: 'exact', path: '/api/scheduled-tasks/delete', handler: deleteHandler },
+  { method: 'POST', match: 'exact', path: '/api/scheduled-tasks/run', handler: runHandler },
+  { method: 'POST', match: 'exact', path: '/api/scheduled-tasks/preview', handler: previewHandler },
+];

package/server/server.js

@@ -21,6 +21,7 @@ import { miscRoutes } from './routes/misc.js';
 import { preferencesRoutes } from './routes/preferences.js';
 import { projectPrefsRoutes } from './routes/project-prefs.js';
 import { sessionPinRoutes } from './routes/session-pin.js';
+import { scheduledTasksRoutes } from './routes/scheduled-tasks.js';
 import { gitRoutes } from './routes/git.js';
 import { pluginsRoutes } from './routes/plugins.js';
 import { pluginServicesRoutes } from './routes/plugin-services.js';
@@ -50,6 +51,8 @@ import * as imCore from './lib/im/im-bridge-core.js';
 import * as imProcMgr from './lib/im/im-process-manager.js';
 import * as chatQueue from './lib/chat-queue.js';
 import { reportSwallowed } from './lib/error-report.js';
+import { initScheduledTaskScheduler, startScheduledTaskScheduler, stopScheduledTaskScheduler } from './lib/scheduled-task-scheduler.js';
+import { executeScheduledTask } from './lib/scheduled-task-executor.js';
 import './lib/adapters/dingtalk-adapter.js'; // side-effect: registers the DingTalk adapter
 import './lib/adapters/feishu-adapter.js';   // side-effect: registers the Feishu adapter
 import './lib/adapters/wecom-adapter.js';    // side-effect: registers the WeCom adapter
@@ -843,6 +846,7 @@ const _routes = [
   ...preferencesRoutes,
   ...projectPrefsRoutes,
   ...sessionPinRoutes,
+  ...scheduledTasksRoutes,
   ...gitRoutes,
   ...pluginsRoutes,
   ...pluginServicesRoutes,
@@ -1167,6 +1171,130 @@ export async function startViewer() {
   }
 }
 
+// ─── Scheduled tasks (scheduler wiring) ─────────────────────────────────────
+// The scheduler is L1 pure logic; every SDK/PTY capability is injected here (server.js
+// is the only place that knows isSdkMode / LOG_DIR / the SSE client set). Paths are
+// compared case-insensitively on win32 (workspace-registry's pathEq semantics).
+function _schedSamePath(a, b) {
+  if (typeof a !== 'string' || typeof b !== 'string' || !a || !b) return false;
+  return process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+
+// Process-level capability filter (P0-1): a process only claims a task it can run.
+// inject needs a LIVE session for the task's cwd in THIS process; spawn needs SDK mode.
+function _schedCanExecute(task) {
+  try {
+    // A workspace-management process (bound no project / no launched workspace) must never
+    // claim tasks — they belong to a tab's bound workspace (integration P0-1).
+    if (isWorkspaceMode && !_workspaceLaunched) return false;
+    // spawn capability is settled at execute time (the SDK accessors lazy-load on first
+    // execute); the tick-level filter only needs the mode gate so a PTY-mode process
+    // never claims a spawn task it can't run.
+    if (task.mode === 'spawn') return isSdkMode;
+    if (isSdkMode) {
+      // SDK sessions register eagerly at init; if the accessor isn't loaded yet, be
+      // permissive (execute will re-check and report no_live_session honestly).
+      return _sdkListSessions ? _sdkListSessions().some(s => _schedSamePath(s.cwd, task.cwd)) : true;
+    }
+    return _ptyListLive ? _ptyListLive().some(p => p.ptyKind === 'claude' && _schedSamePath(p.cwd, task.cwd)) : true;
+  } catch { return false; }
+}
+
+function _schedIsReady() {
+  try {
+    if (isSdkMode) return _sdkListSessions ? _sdkListSessions().length > 0 : true;
+    return _ptyListLive ? _ptyListLive().some(p => p.ptyKind === 'claude') : true;
+  } catch { return false; }
+}
+
+async function _schedExecute(task, claim) {
+  // Assemble the io accessors lazily (dynamic import keeps the L2 managers out of the
+  // L1 executor's module graph; server.js is L4 and may import them).
+  if (!_sdkListSessions && isSdkMode) {
+    try {
+      const sdk = await import('./lib/sdk-manager.js');
+      _sdkListSessions = sdk.listSdkSessions;
+      _sdkGetQueueSnapshotFn = sdk.getQueueSnapshot;
+      _sdkSendUserMessageFn = sdk.sendUserMessage;
+      _sdkIsAvailable = sdk.isSdkAvailable;
+      _sdkSpawnEphemeral = sdk.spawnEphemeralSession;
+    } catch (err) { reportSwallowed('server.sched-sdk-import', err); }
+  }
+  if (!_ptyListLive && !isSdkMode) {
+    try {
+      const pm = await import('./pty-manager.js');
+      _ptyListLive = pm.listLivePtys;
+      _ptyGetKindFor = pm.getPtyKindFor;
+    } catch (err) { reportSwallowed('server.sched-pty-import', err); }
+  }
+  const io = {
+    isSdkMode,
+    sdk: {
+      isSdkAvailable: () => (_sdkIsAvailable ? _sdkIsAvailable() : false),
+      listSdkSessions: () => (_sdkListSessions ? _sdkListSessions() : []),
+      getQueueSnapshot: (anchor) => (_sdkGetQueueSnapshotFn ? _sdkGetQueueSnapshotFn(anchor) : []),
+      sendUserMessage: (text, anchor) => (_sdkSendUserMessageFn ? _sdkSendUserMessageFn(text, anchor) : Promise.resolve()),
+      spawnEphemeralSession: (prompt, opts) => (_sdkSpawnEphemeral ? _sdkSpawnEphemeral(prompt, opts) : Promise.resolve({ ok: false, reason: 'sdk_unavailable' })),
+    },
+    pty: {
+      listLivePtys: () => (_ptyListLive ? _ptyListLive() : []),
+      getPtyKindFor: (anchor) => (_ptyGetKindFor ? _ptyGetKindFor(anchor) : null),
+    },
+    chatQueue,
+    samePath: _schedSamePath,
+  };
+  return executeScheduledTask(task, claim, io);
+}
+
+// Lazily-resolved capability accessors (populated on first use / after SDK init).
+let _sdkListSessions = null;
+let _sdkGetQueueSnapshotFn = null;
+let _sdkSendUserMessageFn = null;
+let _sdkIsAvailable = null;
+let _sdkSpawnEphemeral = null;
+let _ptyListLive = null;
+let _ptyGetKindFor = null;
+
+async function _initScheduledTasks() {
+  try {
+    // Preload the capability accessors BEFORE the first tick, so canExecute's very first
+    // evaluation is real (not the permissive fail-open default). Without this an Electron
+    // management process / tab worker would claim every due task on its first tick only
+    // to fail them (review: integration P0-1).
+    if (isSdkMode) {
+      try {
+        const sdk = await import('./lib/sdk-manager.js');
+        _sdkListSessions = sdk.listSdkSessions;
+        _sdkGetQueueSnapshotFn = sdk.getQueueSnapshot;
+        _sdkSendUserMessageFn = sdk.sendUserMessage;
+        _sdkIsAvailable = sdk.isSdkAvailable;
+        _sdkSpawnEphemeral = sdk.spawnEphemeralSession;
+      } catch (err) { reportSwallowed('server.sched-sdk-preload', err); }
+    } else {
+      try {
+        const pm = await import('./pty-manager.js');
+        _ptyListLive = pm.listLivePtys;
+        _ptyGetKindFor = pm.getPtyKindFor;
+      } catch (err) { reportSwallowed('server.sched-pty-preload', err); }
+    }
+    initScheduledTaskScheduler({
+      getRoot: () => LOG_DIR,
+      getMode: () => ({ sdk: isSdkMode }),
+      getSpawnConfig: () => ({ available: isSdkMode && !!(_sdkIsAvailable && _sdkIsAvailable()) }),
+      canExecute: _schedCanExecute,
+      isReady: _schedIsReady,
+      execute: _schedExecute,
+      broadcast: (project, payload) => {
+        try {
+          sendEventToClients(_filterClientsByViewProject(clients, project), 'scheduled_tasks', payload);
+        } catch (err) { reportSwallowed('server.sched-broadcast', err); }
+      },
+      report: reportSwallowed,
+    });
+    startScheduledTaskScheduler();
+  } catch (err) { reportSwallowed('server.sched-init', err); }
+}
+
 let _startingPromise = null;
 
 async function _doStart() {
@@ -1363,6 +1491,12 @@ async function _doStart() {
           if (isCliMode) {
             await setupTerminalWebSocket(currentServer);
           }
+          // Scheduled tasks: only a CLI-mode process that is NOT an IM worker runs the
+          // scheduler (an IM worker shares LOG_DIR but has no resident session to inject
+          // into — review P0-1). A workspace-management/static viewer process never does.
+          if (isCliMode && !process.env.CCV_IM_PLATFORM) {
+            await _initScheduledTasks();
+          }
           // Install the unified upgrade router (all modes): plugin service WS prefixes + registered terminal/mux.
           // Install after createServer and before the first request to close the upgrade gap.
           installUpgradeRouter(currentServer);
@@ -3324,6 +3458,7 @@ async function _doStop() {
   // Drop chat-queue timers (rescue / idle poll) so a stop/start cycle never injects a stale
   // queued message into a fresh PTY session.
   try { chatQueue.stop(); } catch { /* best-effort */ }
+  try { stopScheduledTaskScheduler(); } catch { /* best-effort */ }
   _clearTurnActiveHeartbeat();
   // Per-workspace: tear down every scope bucket plus the per-scope session tags
   // and streaming-edge records, so a restarted server never replays a stale

package/server/system-prompt-templates/presets/kimi-k3.md

@@ -10,6 +10,10 @@ You are ${model.name}, an interactive coding agent that helps users with softwar
 
 IMPORTANT: Never generate or guess URLs unless you are confident they help the user with programming. Prefer URLs the user provides or ones found in local files.
 
+# Choosing skills
+ - At the skill-selection entry point, skip `claude-api` and the skill whose display title is "Building LLM-Powered Applications with Claude": they are the same Anthropic-only API skill, so treat the identifier and title as aliases. Do not invoke it or read its documentation unless the task explicitly requires Claude/Anthropic SDK or API integration. This applies even when Claude Code automatically recommends or triggers it.
+ - Working on model-name recognition, model logos, aliases, or context-window classification in an existing project is local application code, NOT LLM API integration. Do not load `claude-api` for these tasks merely because the code mentions models, Claude, or model IDs. Locate the local matcher and its tests first; for a genuinely unrelated skill, do not load it just to determine that it is unrelated.
+
 # Doing tasks
  - Read the relevant files before acting or answering; ground every claim and change in code you have actually looked at.
  - Before your first tool call, output a one-sentence action plan; then act.

package/dist/assets/classDiagram-6PBFFD2Q-C0dwAyuU.js

@@ -1 +0,0 @@
-import{s as styles_default,c as classRenderer_v3_unified_default,a as classDiagram_default,C as ClassDB}from"./chunk-4TB4RGXK-GWLkQKRO.js";import{_ as __name}from"./mermaid.core-CNYcCP19.js";import"./chunk-FMBD7UC4-DK-vXpZP.js";import"./chunk-YZCP3GAM-DtYet6WV.js";import"./chunk-55IACEB6-B6LOFqRZ.js";import"./chunk-EDXVE4YY-Ct3e09Ku.js";import"./vendor-markdown-DOJHsAxX.js";import"./vendor-mdxeditor-BreKt5Hd.js";import"./vendor-antd-CfuxfYfy.js";import"./vendor-codemirror-C4Jn4TTc.js";var diagram={parser:classDiagram_default,get db(){return new ClassDB},renderer:classRenderer_v3_unified_default,styles:styles_default,init:__name(cnf=>{cnf.class||(cnf.class={}),cnf.class.arrowMarkerAbsolute=cnf.arrowMarkerAbsolute},"init")};export{diagram};

package/dist/assets/classDiagram-v2-HSJHXN6E-C0dwAyuU.js

@@ -1 +0,0 @@
-import{s as styles_default,c as classRenderer_v3_unified_default,a as classDiagram_default,C as ClassDB}from"./chunk-4TB4RGXK-GWLkQKRO.js";import{_ as __name}from"./mermaid.core-CNYcCP19.js";import"./chunk-FMBD7UC4-DK-vXpZP.js";import"./chunk-YZCP3GAM-DtYet6WV.js";import"./chunk-55IACEB6-B6LOFqRZ.js";import"./chunk-EDXVE4YY-Ct3e09Ku.js";import"./vendor-markdown-DOJHsAxX.js";import"./vendor-mdxeditor-BreKt5Hd.js";import"./vendor-antd-CfuxfYfy.js";import"./vendor-codemirror-C4Jn4TTc.js";var diagram={parser:classDiagram_default,get db(){return new ClassDB},renderer:classRenderer_v3_unified_default,styles:styles_default,init:__name(cnf=>{cnf.class||(cnf.class={}),cnf.class.arrowMarkerAbsolute=cnf.arrowMarkerAbsolute},"init")};export{diagram};

package/dist/assets/clone-fiofFlrV.js

@@ -1 +0,0 @@
-import{b as baseClone}from"./graph-Dh22wYWs.js";function clone(value){return baseClone(value,4)}export{clone as c};