@toddzheng024/dscode-desktop 0.0.0-stage → 0.7.33

package/plugins/triggers/commands.mjs

@@ -0,0 +1,143 @@
+// Human slash commands share the same durable management service as agent tools.
+import { randomUUID } from 'node:crypto';
+import { formatTrigger } from './config.mjs';
+import { formatJob } from './jobs.mjs';
+import { formatRun, readRuns } from './log.mjs';
+import { formatEvent, listEvents } from './spool.mjs';
+
+export const TRIGGER_HELP = `Usage: /trigger (or /triggers)
+  list                              Definitions, registrations and scheduler status
+  show <id>                         Definition and last run
+  new <id>                          Create a disabled, project-local starter
+  create|update <id> <JSON>          Create or edit definition fields
+  enable|disable <id>                Enable or pause a trigger
+  register|unregister <id>           Register or remove its recurring source
+  run <id> [text]                    Queue one event for the scheduler
+  schedule <id> <delay|ISO> [text]   Queue a delayed event, e.g. 30m
+  jobs [id]                         Jobs and waiting reasons in this workspace
+  cancel <jobId>                     Cancel a pending job
+  events <id>                       Queued events and legacy spool entries
+  runs <id>                         Recent run outcomes
+  source <id> [action]               status | start | stop | restart | logs
+  scheduler [action]                 status | install
+
+A queued event needs a running scheduler. Disabling retains pending jobs;
+stopping a source retains accepted events. Scheduler install starts the shared
+service for all registered projects. Changes require a writable, non-plan session.`;
+
+const ok = text => ({ kind: 'success', text });
+const word = input => {
+  const match = input.trim().match(/^(\S+)(?:\s+([\s\S]*))?$/u);
+  return match ? [match[1], match[2] ?? ''] : ['', ''];
+};
+const usage = text => { throw new Error(`Usage: /trigger ${text}`); };
+const exactId = (input, syntax) => { const [id, rest] = word(input); if (!id || rest) usage(syntax); return id; };
+const schedulerText = state => `Scheduler: ${state.running ? 'running' : `stopped — pending work waits; ${state.next_step ?? 'use /trigger scheduler install (macOS), or run dscode trigger scheduler start under a service manager'}`}${state.requires_open_application ? '; requires Desktop to stay open' : ''}${state.error ? `; ${state.error}` : ''}`;
+
+export function triggerCommand({ management, mutationProblem }) {
+  const schedulerActions = management.schedulerActions ?? ['status', 'install'];
+  const help = management.schedulerDescription ? TRIGGER_HELP.replace('status | install', schedulerActions.join(' | '))
+    .replace('Scheduler install starts the shared\nservice for all registered projects.', management.schedulerDescription) : TRIGGER_HELP;
+  return async ({ agent, rawInput = '', commandId, signal }) => {
+    try {
+      signal?.throwIfAborted();
+      const [verb, input] = word(rawInput), action = verb || 'list';
+      if (['help', '--help', '-h'].includes(action)) return ok(help);
+      const project = management.workspace(agent);
+      const mutate = () => {
+        signal?.throwIfAborted();
+        const problem = mutationProblem(agent);
+        if (problem) throw new Error(problem);
+      };
+      if (action === 'list') {
+        if (input) usage('list');
+        const result = await management.manage({ action: 'list' }, agent);
+        const rows = result.definitions.map(definition => {
+          const registration = result.sources.find(s => s.triggerId === definition.id) ?? result.schedules.find(s => s.triggerId === definition.id);
+          const source = registration?.desired ? `source ${registration.desired} (${registration.status})` : registration ? 'registered' : definition.source.kind === 'external' ? 'external event ingress' : 'not registered';
+          return `${formatTrigger(definition, { lastRun: readRuns(management.home, { triggerId: definition.id, limit: 1 })[0] })}\n    scheduler: ${source}`;
+        });
+        return ok([schedulerText(result.scheduler), ...rows, ...(result.problems.length ? ['Unreadable definitions:'] : []), ...result.problems.map(p => `${p.path}: ${p.message}`),
+          ...(!rows.length ? ['No triggers defined. Use /trigger new <id> to create a disabled starter in .dsh/triggers/.'] : []),
+          'Use /trigger help for management commands.'].join('\n'));
+      }
+      if (['show', 'runs', 'events'].includes(action)) {
+        const id = exactId(input, `${action} <id>`);
+        const definition = management.definition(project, id);
+        if (action === 'show') return ok(formatTrigger(definition, { lastRun: readRuns(management.home, { triggerId: id, limit: 1 })[0] }));
+        if (action === 'runs') {
+          const runs = readRuns(management.home, { triggerId: id, limit: 0 }).filter(r => !r.cwd || r.cwd === project).slice(0, 20);
+          return ok(runs.length ? runs.map(formatRun).join('\n') : `No runs recorded for ${id}.`);
+        }
+        const pending = listEvents(management.home, id);
+        management.withStore(store => {
+          for (const job of store.list(id).filter(j => j.project === project && j.workspace === project && j.kind === 'event' && ['pending', 'running'].includes(j.state))) {
+            pending.push({ ...JSON.parse(job.payload), eventId: store.eventIdentity(job.id), receivedAt: job.createdAt });
+          }
+        });
+        pending.sort((a, b) => a.receivedAt - b.receivedAt);
+        return ok(pending.length ? pending.map(formatEvent).join('\n') : `No pending events for ${id}.`);
+      }
+      if (action === 'jobs') {
+        const id = input ? exactId(input, 'jobs [id]') : undefined;
+        const result = await management.jobs({ action: 'list', trigger_id: id, limit: 100 }, agent);
+        return ok([result.jobs.length ? result.jobs.map(formatJob).join('\n') : 'No jobs scheduled in this workspace.', schedulerText(result.scheduler)].join('\n'));
+      }
+      if (action === 'source') {
+        const [id, rest] = word(input), operation = rest || 'status';
+        if (!id || !['status', 'start', 'stop', 'restart', 'logs'].includes(operation)) usage('source <id> [status|start|stop|restart|logs]');
+        if (!['status', 'logs'].includes(operation)) mutate();
+        const result = await management.source({ trigger_id: id, action: operation }, agent);
+        if (operation === 'logs') return ok(result.log || 'No source output recorded.');
+        const s = result.source;
+        return ok([`${id}: desired ${s.desired ?? 'unregistered'}; observed ${s.status}${s.pid ? `; pid ${s.pid}` : ''}`,
+          ...(s.error ? [`Last error: ${s.error}`] : []), ...(s.nextAt ? [`Next attempt: ${new Date(s.nextAt).toISOString()}`] : []),
+          schedulerText(result.scheduler), ...(!['status'].includes(operation) ? ['Saved desired state; the scheduler applies it asynchronously. Accepted jobs remain queued.'] : [])].join('\n'));
+      }
+      if (action === 'scheduler') {
+        const operation = input || 'status';
+        if (!schedulerActions.includes(operation)) usage(`scheduler [${schedulerActions.join('|')}]`);
+        if (operation !== 'status') mutate();
+        const result = await management.scheduler({ action: operation });
+        return ok([...(result.messages ?? []), schedulerText(result.scheduler ?? result)].join('\n'));
+      }
+      if (['new', 'create', 'update', 'enable', 'disable', 'register', 'unregister'].includes(action)) {
+        let id, definition;
+        if (['create', 'update'].includes(action)) {
+          let json; [id, json] = word(input);
+          if (!id || !json) usage(`${action} <id> <JSON definition fields>`);
+          try { definition = JSON.parse(json); } catch { throw new Error('Definition fields must be a JSON object; see /trigger help.'); }
+        } else id = exactId(input, `${action} <id>`);
+        mutate();
+        if (action === 'new') definition = { enabled: false, source: { kind: 'external' }, prompt: 'Describe the task for this trigger.', goal: { objective: 'Describe the outcome to complete.' } };
+        const result = await management.manage({ action: action === 'new' ? 'create' : action, trigger_id: id, definition }, agent);
+        return ok([`${action}: ${id}`, formatTrigger(result.definition), schedulerText(result.scheduler),
+          ...(action === 'new' ? ['Starter is disabled. Edit its prompt, goal and source with /trigger update <id> <JSON>, or ask the agent to configure it, then enable it.'] : []),
+          ...(action === 'disable' ? ['Pending jobs are retained; cancel them separately if needed.'] : []),
+          ...(action === 'unregister' ? ['Pending recurring jobs were cancelled. Delay and emitted jobs are retained.'] : [])].join('\n'));
+      }
+      if (action === 'cancel') {
+        const id = exactId(input, 'cancel <jobId>'); mutate();
+        const result = await management.jobs({ action: 'cancel', job_id: id }, agent);
+        return ok(formatJob(result.job));
+      }
+      if (action === 'schedule' || action === 'run') {
+        const [id, rest] = word(input);
+        if (!id) usage(action === 'run' ? 'run <id> [text]' : 'schedule <id> <delay|ISO> [text]');
+        const identity = `slash-${commandId ?? randomUUID()}`;
+        let result;
+        if (action === 'schedule') {
+          const [when, text] = word(rest);
+          if (!when) usage('schedule <id> <delay|ISO> [text]');
+          mutate();
+          result = await management.jobs({ action: 'schedule', trigger_id: id, ...(/^\d+(?:\.\d+)?[smhd]$/u.test(when) ? { after: when } : { at: when }), event: { source: 'tui', text }, idempotency_key: identity }, agent);
+        } else {
+          mutate();
+          result = await management.emit({ trigger_id: id, eventId: identity, event: { source: 'tui', text: rest } }, agent);
+        }
+        return ok([formatJob(result.job), schedulerText(result.scheduler), 'Queued durably; this command does not wait for the agent run.'].join('\n'));
+      }
+      return { kind: 'error', text: `Unknown action "${action}".\n${help}` };
+    } catch (error) { return { kind: 'error', text: error.message }; }
+  };
+}

package/plugins/triggers/config.mjs

@@ -0,0 +1,264 @@
+// Trigger definitions: the configuration half of the trigger mechanism
+// (docs/triggers-design.md). A definition says what produces an event, which
+// folder the session binds to, what it is asked to do, and the limits that
+// keep an unattended run bounded. Nothing here starts a run: the ingress, the
+// runner and the source installers are separate work, and `/triggers` reads this
+// layer only.
+//
+// One bad file never hides the rest: discovery returns the definitions it could
+// read plus a per-file problem list, so a listing always shows what is usable.
+
+import { readdirSync, readFileSync } from 'node:fs';
+import { isAbsolute, join, resolve } from 'node:path';
+import { parse as parseYaml } from 'yaml';
+import { validateCalendar } from './schedule.mjs';
+
+/** Source kinds this version accepts; each has its own required fields. */
+export const SOURCE_KINDS = Object.freeze(['interval', 'calendar', 'watch', 'poll', 'external', 'script']);
+
+/** The default fresh-session overlap policy; persistent sessions queue instead. */
+export const OVERLAP = 'skip';
+
+/** The only notification policy for now: append to the run log. */
+export const NOTIFY = 'log';
+
+/** Defaults a definition may omit. */
+export const DEFAULTS = Object.freeze({
+  enabled: true,
+  preset: 'dscode',
+  permission: 'workspace-write',
+  maxGoalRounds: 20,
+  timeoutSeconds: 1800,
+  maxRunsPerDay: 24,
+  minIntervalSeconds: 60,
+});
+
+/** Permission presets an unattended run may use; `ask` can never complete. */
+const UNATTENDED_PERMISSIONS = Object.freeze(['auto-review', 'auto', 'workspace-write', 'read-only', 'danger-full-access']);
+
+const ID_PATTERN = /^[a-z0-9][a-z0-9._-]*$/u;
+
+class TriggerConfigError extends Error {}
+
+const fail = message => { throw new TriggerConfigError(message); };
+
+const isPlainObject = value => typeof value === 'object' && value !== null && !Array.isArray(value);
+
+function positiveNumber(value, label) {
+  if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) fail(`${label} must be a positive number`);
+  return value;
+}
+
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) fail(`${label} must be a positive whole number`);
+  return value;
+}
+
+function nonEmptyString(value, label) {
+  if (typeof value !== 'string' || value.trim() === '') fail(`${label} must be a non-empty string`);
+  return value.trim();
+}
+
+/** Reject a key this version does not read, so a typo cannot fall back silently. */
+function knownKeys(raw, allowed, label) {
+  const unknown = Object.keys(raw).filter(key => !allowed.includes(key));
+  if (unknown.length > 0) fail(`${label} has no such field: ${unknown.join(', ')} (accepted: ${allowed.join(', ')})`);
+}
+
+/** Validate and normalize one source block. */
+function normalizeSource(raw) {
+  if (!isPlainObject(raw)) fail('source must be an object');
+  const kind = nonEmptyString(raw.kind, 'source.kind');
+  if (!SOURCE_KINDS.includes(kind)) fail(`source.kind must be one of: ${SOURCE_KINDS.join(', ')}`);
+  const fields = kind === 'interval' ? ['kind', 'seconds']
+    : kind === 'calendar' ? ['kind', 'cron', 'timezone', 'misfire']
+      : kind === 'watch' ? ['kind', 'paths']
+        : kind === 'poll' ? ['kind', 'everySeconds', 'check']
+          : kind === 'script' ? ['kind', 'mode', 'command', 'everySeconds', 'timeoutSeconds', 'permission'] : ['kind'];
+  knownKeys(raw, fields, `source (${kind})`);
+  if (kind === 'script') {
+    if (!['poll', 'daemon'].includes(raw.mode)) fail('source.mode must be poll or daemon');
+    if (!Array.isArray(raw.command) || !raw.command.length || raw.command.some(arg => typeof arg !== 'string' || arg.includes('\0')) || !raw.command[0].trim()) fail('source.command must be a non-empty argv array');
+    const permission = raw.permission ?? 'read-only';
+    if (!['read-only', 'workspace-write'].includes(permission)) fail('source.permission must be read-only or workspace-write');
+    if (raw.mode === 'daemon' && (raw.everySeconds !== undefined || raw.timeoutSeconds !== undefined)) fail('daemon sources do not accept everySeconds or timeoutSeconds');
+    return { kind, mode: raw.mode, command: raw.command, permission, ...(raw.mode === 'poll' ? { everySeconds: positiveInteger(raw.everySeconds, 'source.everySeconds'), timeoutSeconds: positiveInteger(raw.timeoutSeconds ?? 60, 'source.timeoutSeconds') } : {}) };
+  }
+  if (kind === 'interval') return { kind, seconds: positiveInteger(raw.seconds, 'source.seconds') };
+  if (kind === 'calendar') {
+    const cron = nonEmptyString(raw.cron, 'source.cron');
+    const timezone = raw.timezone === undefined ? Intl.DateTimeFormat().resolvedOptions().timeZone : nonEmptyString(raw.timezone, 'source.timezone');
+    const misfire = raw.misfire ?? 'run-once';
+    if (!['run-once', 'skip'].includes(misfire)) fail('source.misfire must be run-once or skip');
+    validateCalendar(cron, timezone);
+    return { kind, cron, timezone, misfire };
+  }
+  if (kind === 'watch') {
+    if (!Array.isArray(raw.paths) || raw.paths.length === 0) fail('source.paths must be a non-empty list of paths');
+    return { kind, paths: raw.paths.map((path, index) => nonEmptyString(path, `source.paths[${index}]`)) };
+  }
+  if (kind === 'poll') {
+    return { kind, everySeconds: positiveInteger(raw.everySeconds, 'source.everySeconds'), check: nonEmptyString(raw.check, 'source.check') };
+  }
+  return { kind };
+}
+
+/**
+ * Validate one raw definition into the normalized shape.
+ * @param raw - the parsed YAML/JSON body.
+ * @param meta - where it came from: `{ origin, path }`.
+ * @returns the normalized definition.
+ * @throws {TriggerConfigError} with a user-facing message.
+ */
+export function normalizeTrigger(raw, { origin, path } = {}) {
+  if (!isPlainObject(raw)) fail('a trigger definition must be a mapping');
+  knownKeys(raw, ['id', 'enabled', 'source', 'workspace', 'prompt', 'preset', 'permission', 'model', 'effort', 'session', 'goal', 'limits', 'overlap', 'notify'], 'the definition');
+  const id = nonEmptyString(raw.id, 'id');
+  if (!ID_PATTERN.test(id)) fail('id must start with a letter or digit and use only a-z, 0-9, dot, underscore or dash');
+  const workspace = nonEmptyString(raw.workspace, 'workspace');
+  if (!isAbsolute(workspace)) fail('workspace must be an absolute path: a triggered session binds to it and cannot change folders');
+  const prompt = nonEmptyString(raw.prompt, 'prompt');
+  const enabled = raw.enabled === undefined ? DEFAULTS.enabled : raw.enabled;
+  if (typeof enabled !== 'boolean') fail('enabled must be true or false');
+
+  const permission = raw.permission === undefined ? DEFAULTS.permission : nonEmptyString(raw.permission, 'permission');
+  if (!UNATTENDED_PERMISSIONS.includes(permission)) {
+    fail(`permission must be one of: ${UNATTENDED_PERMISSIONS.join(', ')} — an unattended run cannot ask for approval`);
+  }
+
+  const session = raw.session === undefined ? { mode: 'new' } : raw.session;
+  if (!isPlainObject(session)) fail('session must be an object with mode: new or persistent');
+  knownKeys(session, ['mode'], 'session');
+  if (!['new', 'persistent'].includes(session.mode)) fail('session.mode must be new or persistent');
+
+  const goal = raw.goal;
+  if (!isPlainObject(goal)) fail('goal must be an object with the objective to finish');
+  knownKeys(goal, ['objective', 'maxRounds'], 'goal');
+  const objective = nonEmptyString(goal.objective, 'goal.objective');
+  const maxRounds = goal.maxRounds === undefined ? DEFAULTS.maxGoalRounds : positiveInteger(goal.maxRounds, 'goal.maxRounds');
+
+  const limits = raw.limits === undefined ? {} : raw.limits;
+  if (!isPlainObject(limits)) fail('limits must be an object');
+  knownKeys(limits, ['timeoutSeconds', 'maxRunsPerDay', 'minIntervalSeconds', 'maxCostUsd'], 'limits');
+  const timeoutSeconds = limits.timeoutSeconds === undefined ? DEFAULTS.timeoutSeconds : positiveInteger(limits.timeoutSeconds, 'limits.timeoutSeconds');
+  const maxRunsPerDay = limits.maxRunsPerDay === undefined ? DEFAULTS.maxRunsPerDay : positiveInteger(limits.maxRunsPerDay, 'limits.maxRunsPerDay');
+  const minIntervalSeconds = limits.minIntervalSeconds === undefined ? DEFAULTS.minIntervalSeconds : positiveInteger(limits.minIntervalSeconds, 'limits.minIntervalSeconds');
+  const maxCostUsd = limits.maxCostUsd === undefined ? undefined : positiveNumber(limits.maxCostUsd, 'limits.maxCostUsd');
+
+  const overlap = session.mode === 'persistent' ? 'queue' : OVERLAP;
+  if (raw.overlap !== undefined && raw.overlap !== overlap) fail(`overlap must be "${overlap}" for session.mode ${session.mode}`);
+  if (raw.notify !== undefined && raw.notify !== NOTIFY) fail(`notify must be "${NOTIFY}"`);
+
+  const source = normalizeSource(raw.source);
+  return {
+    id, enabled, source, workspace, prompt,
+    preset: raw.preset === undefined ? DEFAULTS.preset : nonEmptyString(raw.preset, 'preset'),
+    permission,
+    ...(raw.model === undefined ? {} : { model: nonEmptyString(raw.model, 'model') }),
+    ...(raw.effort === undefined ? {} : { effort: nonEmptyString(raw.effort, 'effort') }),
+    goal: { objective, maxRounds },
+    limits: { timeoutSeconds, maxRunsPerDay, minIntervalSeconds, ...(maxCostUsd === undefined ? {} : { maxCostUsd }) },
+    session: { mode: session.mode },
+    overlap,
+    notify: NOTIFY,
+    origin: origin ?? 'user',
+    path: path ?? '',
+  };
+}
+
+/** Parse one file body: JSON or YAML by extension, YAML as the general form. */
+function parseBody(text, path) {
+  if (/\.json$/iu.test(path)) {
+    try { return JSON.parse(text); } catch (error) { fail(`not valid JSON: ${error.message}`); }
+  }
+  try { return parseYaml(text); } catch (error) { fail(`not valid YAML: ${error.message}`); }
+}
+
+/** Read one directory of definitions, returning definitions and problems. */
+function readDirectory(directory, origin) {
+  const definitions = [];
+  const problems = [];
+  let entries;
+  try {
+    entries = readdirSync(directory);
+  } catch (error) {
+    // Absent is normal (most machines and projects have no triggers); anything
+    // else must be reported, or a permission problem reads as "none defined".
+    if (error?.code !== 'ENOENT' && error?.code !== 'ENOTDIR') {
+      problems.push({ path: directory, message: `cannot read the trigger directory: ${error?.code ?? error?.message ?? error}` });
+    }
+    return { definitions, problems };
+  }
+  for (const entry of entries.sort()) {
+    if (!/\.(ya?ml|json)$/iu.test(entry)) continue;
+    const path = join(directory, entry);
+    try {
+      const normalized = normalizeTrigger(parseBody(readFileSync(path, 'utf8'), path), { origin, path });
+      if (normalized.id !== entry.replace(/\.(ya?ml|json)$/iu, '')) {
+        fail(`id "${normalized.id}" must match the file name ("${entry}")`);
+      }
+      definitions.push(normalized);
+    } catch (error) {
+      problems.push({ path, message: error instanceof TriggerConfigError ? error.message : String(error?.message ?? error) });
+    }
+  }
+  return { definitions, problems };
+}
+
+/**
+ * Discover trigger definitions. User-level files live under `<state>/triggers/`;
+ * project files under `<workspace>/.dsh/triggers/` and win on an id collision, so
+ * a repository can pin its own definition and have it reviewed in a pull request.
+ * @param options - `{ home, workspace }`; either may be absent.
+ * @returns `{ definitions, problems }`, definitions sorted by id.
+ */
+export function loadTriggerDefinitions({ home, workspace } = {}) {
+  const user = home === undefined ? { definitions: [], problems: [] } : readDirectory(join(home, 'triggers'), 'user');
+  const project = workspace === undefined ? { definitions: [], problems: [] } : readDirectory(join(resolve(workspace), '.dsh', 'triggers'), 'project');
+  const byId = new Map();
+  for (const definition of user.definitions) byId.set(definition.id, definition);
+  for (const definition of project.definitions) byId.set(definition.id, { ...definition, overrides: byId.has(definition.id) });
+  return {
+    definitions: [...byId.values()].sort((left, right) => left.id.localeCompare(right.id)),
+    problems: [...user.problems, ...project.problems],
+  };
+}
+
+/** The newest run in one line; `formatRun` in log.mjs owns the vocabulary. */
+function formatLastRun(record) {
+  const when = new Date(record.startedAt).toISOString().replace('T', ' ').slice(0, 19);
+  const reason = record.reason === null || record.reason === undefined ? '' : ` (${record.reason})`;
+  return `${when} ${record.outcome}${reason} · exit ${record.exitCode}`;
+}
+
+/** One line, bounded: a listing row must never be forged out of a value. */
+const inline = (text, limit = 96) => {
+  const folded = String(text).replace(/\s+/gu, ' ').trim();
+  return folded.length > limit ? `${folded.slice(0, limit - 1)}…` : folded;
+};
+
+/**
+ * One definition as the text `/triggers` prints.
+ * @param definition - a normalized definition.
+ * @param options - `{ lastRun }`: the newest run record, when the log has one.
+ * @returns the aligned block.
+ */
+export function formatTrigger(definition, { lastRun } = {}) {
+  const source = definition.source.kind === 'interval' ? `every ${definition.source.seconds}s`
+    : definition.source.kind === 'calendar' ? `cron ${definition.source.cron} (${definition.source.timezone}, ${definition.source.misfire})`
+      : definition.source.kind === 'watch' ? `watch ${definition.source.paths.join(', ')}`
+        : definition.source.kind === 'poll' ? `poll ${definition.source.everySeconds}s: ${definition.source.check}`
+          : definition.source.kind === 'script' ? `script ${definition.source.mode}: ${definition.source.command.join(' ')}` : 'external (emit only)';
+  return [
+    `${definition.enabled ? 'on ' : 'off'} ${definition.id}${definition.overrides ? ' (project overrides user)' : ''}`,
+    `    source:    ${source}`,
+    `    workspace: ${definition.workspace}`,
+    `    session:   ${definition.session?.mode ?? 'new'}`,
+    `    goal:      ${inline(definition.goal.objective)} (max ${definition.goal.maxRounds} rounds)`,
+    `    prompt:    ${inline(definition.prompt)}`,
+    `    limits:    ${definition.limits.timeoutSeconds}s, ${definition.limits.maxRunsPerDay}/day${definition.limits.maxCostUsd === undefined ? '' : `, $${definition.limits.maxCostUsd}`}`,
+    `    run as:    ${definition.preset}/${definition.permission}${definition.model === undefined ? '' : ` · ${definition.model}`}`,
+    `    file:      ${definition.path === '' ? '(unknown)' : definition.path}`,
+    ...(lastRun === undefined ? [] : [`    last:      ${formatLastRun(lastRun)}`]),
+  ].join('\n');
+}

package/plugins/triggers/desktop-client.mjs

@@ -0,0 +1,155 @@
+globalThis.__ModuleLoader__.load({
+  id: '@toddzheng024/dscode-desktop',
+  factory: require => {
+    const { createElement: h, useState, useEffect, useRef } = require('react');
+    const control = { padding: '8px 10px', border: '1px solid #8886', borderRadius: 6, background: 'transparent', color: 'inherit', font: 'inherit', boxSizing: 'border-box', minWidth: 0, maxWidth: '100%' };
+    const row = { display: 'flex', flexWrap: 'wrap', gap: 8, alignItems: 'center' };
+    const initial = () => ({ id: '', prompt: '', objective: '', kind: 'interval', seconds: '3600', cron: '0 9 * * 1-5', timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+      command: '[]', scriptMode: 'poll', persistent: true, permission: 'read-only', enabled: true });
+    function Schedules({ execute }) {
+      const [snapshot, setSnapshot] = useState(null), [session, setSession] = useState(''), [workspace, setWorkspace] = useState(null);
+      const [draft, setDraft] = useState(initial), [editing, setEditing] = useState(null), [busy, setBusy] = useState(false), [error, setError] = useState(''), [log, setLog] = useState('');
+      const [refreshError, setRefreshError] = useState('');
+      const pending = useRef(null), foreground = useRef(false), alive = useRef(true), selected = useRef(''), eventKeys = useRef(new Map()), actionError = useRef(null);
+      // Foreground failures must be visible even after submitting a long form.
+      // Polling errors use separate state and must not steal the user's focus.
+      useEffect(() => { if (error) actionError.current?.focus(); }, [error]);
+      const refresh = async () => {
+        const value = await execute('status');
+        if (!alive.current) return;
+        setSnapshot(value);
+        const id = value.sessions.some(item => item.id === selected.current) ? selected.current : value.sessions[0]?.id ?? '';
+        if (id !== selected.current) { setWorkspace(null); setEditing(null); setDraft(initial()); setLog(''); }
+        selected.current = id; setSession(id);
+        if (id) {
+          const result = await execute('workspace', { sessionId: id });
+          if (alive.current && selected.current === id) setWorkspace(result);
+        } else setWorkspace(null);
+        if (alive.current) setRefreshError('');
+      };
+      const run = async (task, background = false) => {
+        if (background ? pending.current : foreground.current) return;
+        if (!background) { foreground.current = true; setBusy(true); setError(''); }
+        const previous = pending.current;
+        const operation = (async () => {
+          if (previous) await previous;
+          if (!alive.current) return;
+          try { await task(); } catch (error) {
+            if (alive.current) {
+              if (background) setRefreshError(`Unable to refresh schedules: ${error.message}`);
+              else setError(error.message);
+            }
+          }
+        })();
+        pending.current = operation;
+        try { await operation; } finally {
+          if (pending.current === operation) pending.current = null;
+          if (!background) { foreground.current = false; if (alive.current) setBusy(false); }
+        }
+      };
+      useEffect(() => {
+        alive.current = true; void run(refresh);
+        const timer = setInterval(() => { void run(refresh, true); }, 5000);
+        return () => { alive.current = false; clearInterval(timer); };
+      }, []);
+      const mutate = (action, args) => run(async () => {
+        await execute(action, { sessionId: selected.current, args }); await refresh();
+      });
+      const button = (label, action, disabled = false) => h('button', { type: 'button', style: control, disabled: busy || disabled, onClick: action }, label);
+      const field = (label, key, type = 'text') => h('label', { style: { display: 'grid', gap: 4 } }, label,
+        h('input', { 'aria-label': label, style: control, type, value: draft[key], disabled: key === 'id' && !!editing,
+          onChange: event => setDraft(previous => ({ ...previous, [key]: event.target.value })) }));
+      const select = (label, key, values) => h('label', null, label, h('select', { 'aria-label': label, style: control, value: draft[key],
+        onChange: event => setDraft(previous => ({ ...previous, [key]: event.target.value })) }, ...values.map(([value, label]) => h('option', { key: value, value }, label))));
+      const edit = definition => {
+        setEditing(definition);
+        setDraft({ ...initial(), id: definition.id, prompt: definition.prompt, objective: definition.goal.objective, kind: definition.source.kind,
+          seconds: String(definition.source.seconds ?? definition.source.everySeconds ?? 3600), cron: definition.source.cron ?? '0 9 * * 1-5',
+          timezone: definition.source.timezone ?? initial().timezone, command: JSON.stringify(definition.source.command ?? []),
+          scriptMode: definition.source.mode ?? 'poll', persistent: definition.session.mode === 'persistent', permission: definition.permission, enabled: definition.enabled });
+      };
+      const save = () => run(async () => {
+        const source = draft.kind === 'calendar' ? { kind: 'calendar', cron: draft.cron, timezone: draft.timezone }
+          : draft.kind === 'interval' ? { kind: 'interval', seconds: Number(draft.seconds) }
+            : draft.kind === 'script' ? { kind: 'script', mode: draft.scriptMode, command: JSON.parse(draft.command),
+              ...(draft.scriptMode === 'poll' ? { everySeconds: Number(draft.seconds) } : {}) } : { kind: 'external' };
+        const previousSource = editing?.source.kind === draft.kind ? { ...editing.source } : {};
+        if (draft.kind === 'script' && draft.scriptMode === 'daemon') { delete previousSource.everySeconds; delete previousSource.timeoutSeconds; }
+        await execute('manage', { sessionId: selected.current, args: { action: editing ? 'update' : 'create', trigger_id: draft.id,
+          definition: { prompt: draft.prompt, source: { ...previousSource, ...source },
+            goal: { ...(editing?.goal ?? {}), objective: draft.objective.trim() || draft.prompt }, session: { mode: draft.persistent ? 'persistent' : 'new' },
+            permission: draft.permission, enabled: draft.enabled } } });
+        if (alive.current) { setEditing(null); setDraft(initial()); }
+        await refresh();
+      });
+      const runIdentity = definition => JSON.stringify([definition.workspace, definition.id]);
+      const runOnce = definition => run(async () => {
+        const identity = runIdentity(definition);
+        if (!eventKeys.current.has(identity)) eventKeys.current.set(identity, crypto.randomUUID());
+        await execute('jobs', { sessionId: selected.current, args: { action: 'schedule', trigger_id: definition.id, after: '1s', idempotency_key: eventKeys.current.get(identity) } });
+        // Keep this task's key through a lost reply or failed refresh, even if
+        // the user runs another task or changes workspace before retrying.
+        await refresh(); eventKeys.current.delete(identity);
+      });
+      return h('section', { 'aria-label': 'DSCODE scheduling settings', style: { display: 'grid', gridTemplateColumns: 'minmax(0, 1fr)', gap: 16, padding: 20, maxWidth: 960, minWidth: 0, boxSizing: 'border-box', overflowWrap: 'anywhere' } },
+        h('h2', { style: { margin: 0 } }, 'DSCODE schedules'),
+        h('p', null, 'Enabling delivery runs due tasks for every registered project and remembers this choice when Desktop opens again. Keep the application open. Stopping delivery interrupts active tasks and script sources; pending jobs stay queued.'),
+        error && h('div', { role: 'alert', tabIndex: -1, ref: actionError }, error),
+        refreshError && h('div', { role: 'alert' }, refreshError),
+        snapshot && h('div', { role: 'status' }, `Delivery: ${snapshot.scheduler.running ? 'running' : snapshot.scheduler.stopping ? 'stopping' : 'stopped'} · Resume on launch: ${snapshot.scheduler.enabled ? 'on' : 'off'}${snapshot.scheduler.owner === 'external' ? ' · controlled by another process' : ''}`),
+        snapshot?.scheduler.error && h('div', { role: 'alert' }, snapshot.scheduler.error),
+        h('div', { style: row },
+          button('Enable delivery and resume on launch', () => run(async () => { await execute('start'); await refresh(); }), !snapshot || snapshot.scheduler.owner === 'external' || snapshot.scheduler.running || snapshot.scheduler.stopping),
+          button('Stop delivery and disable resume', () => run(async () => { await execute('stop'); await refresh(); }), !snapshot || (!snapshot.scheduler.enabled && !snapshot.scheduler.running)),
+          button('Refresh schedules', () => run(refresh))),
+        snapshot?.scheduler.owner === 'external' && h('p', null, snapshot.scheduler.next_step),
+        h('label', null, 'Workspace session', h('select', { 'aria-label': 'Workspace session', style: { ...control, display: 'block', width: '100%' }, value: session, disabled: busy,
+          onChange: event => { selected.current = event.target.value; setSession(event.target.value); setWorkspace(null); setEditing(null); setDraft(initial()); setLog(''); void run(refresh); } },
+        h('option', { value: '' }, 'Choose an open DSCODE session'), ...(snapshot?.sessions ?? []).map(item => h('option', { key: item.id, value: item.id }, `${item.workspace} · ${item.id.slice(0, 8)}`)))),
+        !session && h('p', null, 'Open a DSCODE session in the project you want to schedule.'),
+        workspace && h('div', null,
+          !workspace.writable && h('p', null, 'This session can inspect schedules. Use a writable, non-plan session to change them.'),
+          ...workspace.problems.map(problem => h('div', { role: 'alert', key: problem.path }, `${problem.path}: ${problem.message}`)),
+          h('h3', null, 'Tasks'),
+          ...workspace.definitions.map(item => h('article', { key: item.id, style: { padding: '12px 0', borderBottom: '1px solid #8884' } },
+            h('strong', null, item.id), h('p', null, `${item.enabled ? 'Enabled' : 'Paused'} · ${item.source.kind} · ${item.permission}`), h('p', { style: { whiteSpace: 'pre-wrap' } }, item.prompt),
+            h('div', { style: row }, button(`Edit ${item.id}`, () => edit(item), !workspace.writable || item.origin !== 'project'),
+              button(`${item.enabled ? 'Pause' : 'Enable'} ${item.id}`, () => mutate('manage', { action: item.enabled ? 'disable' : 'enable', trigger_id: item.id }), !workspace.writable || item.origin !== 'project'),
+              button(`${eventKeys.current.has(runIdentity(item)) ? 'Retry' : 'Run'} ${item.id} once`, () => runOnce(item), !workspace.writable || !item.enabled)),
+            item.source.kind === 'script' && h('div', { style: row },
+              h('span', null, `Source: ${workspace.sources.find(source => source.triggerId === item.id)?.status ?? 'unregistered'}`),
+              ...['start', 'stop', 'restart'].map(action => button(`${action} ${item.id} source`, () => mutate('source', { action, trigger_id: item.id }), !workspace.writable)),
+              button(`Read ${item.id} source log`, () => run(async () => { const result = await execute('source', { sessionId: selected.current, args: { action: 'logs', trigger_id: item.id } }); if (alive.current) setLog(result.log || 'No source output recorded.'); }))))),
+          log && h('pre', { 'aria-label': 'Source log', style: { whiteSpace: 'pre-wrap', overflowWrap: 'anywhere' } }, log),
+          !workspace.definitions.length && h('p', null, 'No tasks in this workspace.'),
+          h('fieldset', { disabled: busy || !workspace.writable, style: { display: 'grid', gridTemplateColumns: 'minmax(0, 1fr)', minWidth: 0, gap: 12, border: '1px solid #8886', borderRadius: 8, padding: 16 } },
+            h('legend', null, editing ? `Edit ${editing.id}` : 'Create task'), field('Task ID', 'id'),
+            h('label', null, 'Task instructions', h('textarea', { 'aria-label': 'Task instructions', style: { ...control, display: 'block', width: '100%', minHeight: 90 }, value: draft.prompt,
+              onChange: event => setDraft(previous => ({ ...previous, prompt: event.target.value })) })),
+            field('Goal (defaults to task instructions)', 'objective'),
+            select('Schedule', 'kind', [['interval', 'Interval'], ['calendar', 'Calendar'], ['external', 'Manual or external event'], ['script', 'Script events']]),
+            draft.kind === 'calendar' && h('div', { style: { display: 'grid', gap: 8 } }, field('Cron expression', 'cron'), field('Timezone', 'timezone')),
+            draft.kind === 'script' && h('div', { style: { display: 'grid', gap: 8 } }, field('Script command (JSON argument array)', 'command'), select('Script mode', 'scriptMode', [['poll', 'Poll'], ['daemon', 'Daemon']])),
+            (draft.kind === 'interval' || (draft.kind === 'script' && draft.scriptMode === 'poll')) && field('Interval seconds', 'seconds', 'number'),
+            select('Run permission', 'permission', [['read-only', 'Read only'], ['workspace-write', 'Write in this workspace']]),
+            ...[['persistent', 'Continue the task’s own session'], ['enabled', 'Enable this task']].map(([key, label]) => h('label', { key }, h('input', { type: 'checkbox', checked: draft[key],
+              onChange: event => setDraft(previous => ({ ...previous, [key]: event.target.checked })) }), label)),
+            h('div', { style: row }, button(editing ? 'Save task changes' : 'Create task', save, !draft.id.trim() || !draft.prompt.trim()),
+              editing && button('Cancel editing', () => { setEditing(null); setDraft(initial()); }))),
+          h('h3', null, 'Recent jobs'),
+          ...workspace.jobs.map(job => h('div', { key: job.id, style: { ...row, padding: '8px 0' } },
+            h('span', { style: { flex: 1 } }, `${job.triggerId}: ${job.state}${job.reason ? ` (${job.reason})` : ''} · ${new Date(job.dueAt).toLocaleString()}`),
+            job.state === 'pending' && button(`Cancel ${job.triggerId} job`, () => mutate('jobs', { action: 'cancel', job_id: job.id }), !workspace.writable))),
+          !workspace.jobs.length && h('p', null, 'No jobs in this workspace.')));
+    }
+    return { inject: ['slots', 'connection'], apply(ctx) {
+      ctx.slots.inject('settings.section', () => ctx.slots.register({ name: 'settings.section', id: 'dscode-schedules', order: 13, label: () => 'DSCODE schedules',
+        inject: () => ({ execute: async (action, args = {}) => {
+          const response = await ctx.connection.rpc.call('/api', 'dscode-triggers', { action, ...args });
+          if (!response.ok) throw Error(response.error.message);
+          return response.value;
+        } }),
+      }, Schedules));
+    } };
+  },
+});