@toddzheng024/dscode-bundle 0.7.24 → 0.7.26

package/plugins/triggers/commands.mjs

@@ -0,0 +1,140 @@
+// 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; use /trigger scheduler install (macOS), or run dscode trigger scheduler start under a service manager'}`;
+
+export function triggerCommand({ management, mutationProblem }) {
+  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(TRIGGER_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 (!['status', 'install'].includes(operation)) usage('scheduler [status|install]');
+        if (operation === 'install') 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${TRIGGER_HELP}` };
+    } catch (error) { return { kind: 'error', text: error.message }; }
+  };
+}

package/plugins/triggers/config.mjs

@@ -1,6 +1,6 @@
 // Trigger definitions: the configuration half of the trigger mechanism
 // (docs/triggers-design.md). A definition says what produces an event, which
-// folder the fresh session binds to, what it is asked to do, and the limits that
+// 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.
@@ -11,11 +11,12 @@
 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']);
+export const SOURCE_KINDS = Object.freeze(['interval', 'calendar', 'watch', 'poll', 'external', 'script']);
 
-/** The only overlap policy: a trigger whose run is still going is skipped. */
+/** 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. */
@@ -70,17 +71,27 @@ function normalizeSource(raw) {
   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']
+    : kind === 'calendar' ? ['kind', 'cron', 'timezone', 'misfire']
       : kind === 'watch' ? ['kind', 'paths']
         : kind === 'poll' ? ['kind', 'everySeconds', 'check']
-          : ['kind'];
+          : 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');
-    // Five fields is the only shape the installer can translate to launchd.
-    if (cron.split(/\s+/u).length !== 5) fail('source.cron must have five fields (minute hour day month weekday)');
-    return { kind, 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');
@@ -101,7 +112,7 @@ function normalizeSource(raw) {
  */
 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', 'goal', 'limits', 'overlap', 'notify'], 'the definition');
+  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');
@@ -115,6 +126,11 @@ export function normalizeTrigger(raw, { origin, path } = {}) {
     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');
@@ -129,7 +145,8 @@ export function normalizeTrigger(raw, { origin, path } = {}) {
   const minIntervalSeconds = limits.minIntervalSeconds === undefined ? DEFAULTS.minIntervalSeconds : positiveInteger(limits.minIntervalSeconds, 'limits.minIntervalSeconds');
   const maxCostUsd = limits.maxCostUsd === undefined ? undefined : positiveNumber(limits.maxCostUsd, 'limits.maxCostUsd');
 
-  if (raw.overlap !== undefined && raw.overlap !== OVERLAP) fail(`overlap must be "${OVERLAP}"`);
+  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);
@@ -141,7 +158,8 @@ export function normalizeTrigger(raw, { origin, path } = {}) {
     ...(raw.effort === undefined ? {} : { effort: nonEmptyString(raw.effort, 'effort') }),
     goal: { objective, maxRounds },
     limits: { timeoutSeconds, maxRunsPerDay, minIntervalSeconds, ...(maxCostUsd === undefined ? {} : { maxCostUsd }) },
-    overlap: OVERLAP,
+    session: { mode: session.mode },
+    overlap,
     notify: NOTIFY,
     origin: origin ?? 'user',
     path: path ?? '',
@@ -227,14 +245,15 @@ const inline = (text, limit = 96) => {
  */
 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.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}`
-          : 'external (emit only)';
+          : 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}`}`,

package/plugins/triggers/host.mjs

@@ -1,4 +1,4 @@
-// Host-side half of one trigger run: the clean session an event starts. Unlike
+// Host-side half of one trigger run: the fresh or resumed session an event uses. Unlike
 // `dscode exec`, which runs exactly one turn, this one keeps going while the
 // goal is active — the round driver supplies the continuation — and stops on the
 // goal's own end, a cap, the timeout, or a needed approval.
@@ -6,7 +6,7 @@
 // It owns the agent, the goal and the transcript; the parent process owns the
 // lock, the limits and the run record. The two swap files: `DSCODE_TRIGGER_OPTIONS`
 // in, `<options>.result.json` out.
-import { randomUUID } from 'node:crypto';
+import { openTriggerSession } from './session.mjs';
 import { createUserMessage } from '@deepseek-ai/dsh-llm';
 import { decideStop } from './run.mjs';
 import { readRunSpec, writeRunResult } from './options.mjs';
@@ -17,10 +17,10 @@ import { triggerOverlay } from './overlay.mjs';
 export { triggerOverlay };
 
 export const name = 'dscode-trigger-host';
-export const inject = ['agents', 'agentPresets', 'agentDefaultModel', 'permissionPresets', 'llm', 'goals', 'appExit'];
+export const inject = ['agents', 'sessions', 'agentPresets', 'agentDefaultModel', 'permissionPresets', 'llm', 'goals', 'appExit'];
 
 export function apply(ctx) {
-  void run(ctx).catch(error => { process.stderr.write(`dscode trigger run: ${error.message}\n`); ctx.get('appExit')(1); });
+  void runTriggerHost(ctx).catch(error => { process.stderr.write(`dscode trigger run: ${error.message}\n`); ctx.get('appExit')(1); });
 }
 
 function splitRoute(value) {
@@ -29,9 +29,8 @@ function splitRoute(value) {
   return [value.slice(0, at), value.slice(at + 1)];
 }
 
-async function run(ctx) {
+export async function runTriggerHost(ctx, { optionsPath = process.env.DSCODE_TRIGGER_OPTIONS, home = process.env.DSH_HOME, spend = sessionSpend } = {}) {
   await ctx.get('loader').await();
-  const optionsPath = process.env.DSCODE_TRIGGER_OPTIONS;
   if (!optionsPath) throw new Error('DSCODE_TRIGGER_OPTIONS is missing');
   const spec = readRunSpec(optionsPath);
   const resultPath = `${optionsPath}.result.json`;
@@ -42,12 +41,7 @@ async function run(ctx) {
   const agentOptions = { provider, model, ...(effort ? { reasoningEffort: effort } : {}) };
   const setup = async agentCtx => { await ctx.agentPresets.mount(agentCtx, spec.preset ?? 'dscode'); };
 
-  const handle = await ctx.agents.create({
-    sessionId: randomUUID(),
-    meta: { cwd: spec.workspace, agentPreset: spec.preset ?? 'dscode' },
-    agentOptions,
-    setup,
-  });
+  const handle = await openTriggerSession(ctx, spec, { home, agentOptions, setup });
   const agent = handle.agent;
   const session = agent.session;
   if (spec.permission) {
@@ -58,6 +52,17 @@ async function run(ctx) {
   // The goal is created through the SERVICE, not the `create_goal` tool: the tool
   // requires a direct human turn, and an unattended run has none. The service is
   // the same path the human-facing /goal command uses.
+  // Every event gets a new goal, including after a blocked/timed-out run. Clear
+  // through the service so the previous goal remains in the durable history.
+  const previousGoal = ctx.goals.get(agent);
+  if (previousGoal) ctx.goals.clear(agent, { id: previousGoal.id, revision: previousGoal.revision });
+  const initialCost = spend(session.id).cost;
+  const runCost = () => {
+    try {
+      const total = spend(session.id).cost;
+      return Number.isFinite(initialCost) && Number.isFinite(total) ? Math.max(0, total - initialCost) : undefined;
+    } catch { return undefined; }
+  };
   ctx.goals.create(agent, { objective: spec.goal.objective, maxGoalRounds: spec.goal.maxRounds });
 
   let finished = false;
@@ -65,16 +70,19 @@ async function run(ctx) {
   let lastText = '';
   const limiter = spec.limits ?? {};
 
-  const finish = (result, tail) => {
+  const finish = async (result, tail) => {
     if (finished) return;
     finished = true;
     if (tail !== undefined && tail.trim() !== '') {
-      try { writeRunTail(process.env.DSH_HOME ?? '.', spec.triggerId, spec.runId, tail); } catch { /* the record still explains the run */ }
+      try { writeRunTail(home ?? '.', spec.triggerId, spec.runId, tail); } catch { /* the record still explains the run */ }
     }
     try {
+      await ctx.sessions.flush(session);
       writeRunResult(resultPath, { ...result, sessionId: session.id });
     } catch (error) {
-      process.stderr.write(`dscode trigger run: could not write the result file: ${error.message}\n`);
+      process.stderr.write(`dscode trigger run: could not persist the run result: ${error.message}\n`);
+      ctx.get('appExit')(1);
+      return;
     }
     ctx.get('appExit')(result.exitCode);
   };
@@ -84,11 +92,10 @@ async function run(ctx) {
     if (finished) return;
     let goal;
     try { goal = ctx.goals.get(agent); } catch { goal = undefined; }
-    let costUsd;
-    try { costUsd = sessionSpend(session.id).cost; } catch { costUsd = undefined; }
+    const costUsd = runCost();
     const decision = decideStop({ goal, costUsd, limits: limiter, approvalsRejected });
     if (!decision.stop) return;
-    finish({
+    void finish({
       outcome: decision.outcome,
       reason: decision.reason ?? null,
       exitCode: decision.exitCode,
@@ -110,7 +117,7 @@ async function run(ctx) {
   });
   ctx.on('session/disposed', source => {
     if (source.id !== session.id) return;
-    finish({ outcome: 'failed', reason: 'model_error', exitCode: 1, cost: null, rounds: null }, lastText);
+    void finish({ outcome: 'failed', reason: 'model_error', exitCode: 1, cost: null, rounds: null }, lastText);
   });
   // No human is present: an approval request is refused, and the run is marked
   // as having needed one so the operator sees it in the record.
@@ -124,11 +131,11 @@ async function run(ctx) {
   if (Number.isFinite(limiter.timeoutSeconds) && limiter.timeoutSeconds > 0) {
     setTimeout(() => {
       const goal = (() => { try { return ctx.goals.get(agent); } catch { return undefined; } })();
-      finish({
+      void finish({
         outcome: 'timedout',
         reason: approvalsRejected ? 'approval_required' : 'timeout',
         exitCode: 124,
-        cost: (() => { try { return sessionSpend(session.id).cost; } catch { return null; } })(),
+        cost: runCost() ?? null,
         rounds: Number.isFinite(goal?.roundsStarted) ? goal.roundsStarted : null,
       }, lastText);
     }, limiter.timeoutSeconds * 1000).unref();

package/plugins/triggers/index.mjs

@@ -1,57 +1,27 @@
-// The read-only half of the trigger mechanism: `/triggers` lists the definitions
-// this machine and this project carry, and `/triggers show <id>` prints one.
-// Nothing here starts a run — the ingress, the runner and the source installers
-// are separate work (docs/triggers-design.md).
-import { loadTriggerDefinitions, formatTrigger } from './config.mjs';
-import { formatRun, readRuns } from './log.mjs';
-import { formatEvent, listEvents } from './spool.mjs';
+// TUI management and agent tools use one definitions/jobs/source service.
+import { registerTriggerTools, mutationProblem } from './tools.mjs';
+import { TriggerManagement } from './management.mjs';
+import { triggerCommand } from './commands.mjs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
 export const name = 'dscode-triggers';
 export const inject = ['commands'];
-
-/** The state directory the launcher hands the child, as the other plugins read it. */
 const stateHome = () => process.env.DSH_HOME ?? process.env.DSCODE_HOME ?? join(homedir(), '.local/share/dscode-hub');
 
 export function apply(ctx) {
-  ctx.commands.register({
-    name: 'triggers',
-    description: 'List trigger definitions, or show one by id',
-    handler({ agent, rawInput }) {
-      const [action, id, extra] = rawInput.trim().split(/\s+/u);
-      const workspace = agent?.session?.header?.cwd;
-      const { definitions, problems } = loadTriggerDefinitions({ home: stateHome(), workspace });
-      const problemsText = problems.length === 0 ? [] : ['', 'Unreadable definitions:', ...problems.map(problem => `  ${problem.path}: ${problem.message}`)];
-      const lastRun = id => readRuns(stateHome(), { triggerId: id, limit: 1 })[0];
-      if (action === 'events') {
-        if (id === undefined || id === '' || extra !== undefined) return { kind: 'error', text: 'Usage: /triggers events <id>' };
-        const pending = listEvents(stateHome(), id);
-        return pending.length === 0
-          ? { kind: 'success', text: `No pending events for ${id}.` }
-          : { kind: 'success', text: pending.map(formatEvent).join('\n') };
-      }
-      if (action === 'runs') {
-        if (id === undefined || id === '' || extra !== undefined) return { kind: 'error', text: 'Usage: /triggers runs <id>' };
-        const runs = readRuns(stateHome(), { triggerId: id, limit: 20 });
-        return runs.length === 0
-          ? { kind: 'success', text: `No runs recorded for ${id}.` }
-          : { kind: 'success', text: runs.map(formatRun).join('\n') };
-      }
-      if (action !== undefined && action !== '' && action !== 'list' && action !== 'show') {
-        return { kind: 'error', text: `Unknown action "${action}". Usage: /triggers [list|show <id>|events <id>|runs <id>]` };
-      }
-      if (action === 'show') {
-        if (id === undefined || id === '') return { kind: 'error', text: `Usage: /triggers show <id>\nKnown ids: ${definitions.map(definition => definition.id).join(', ') || '(none)'}` };
-        const found = definitions.find(definition => definition.id === id);
-        if (found === undefined) return { kind: 'error', text: `No trigger "${id}" in ${stateHome()}/triggers or ${workspace ?? '(no workspace)'}/.dsh/triggers` };
-        if (extra !== undefined) return { kind: 'error', text: `Usage: /triggers show <id>` };
-        return { kind: 'success', text: formatTrigger(found, { lastRun: lastRun(found.id) }) };
-      }
-      if (definitions.length === 0 && problems.length === 0) {
-        return { kind: 'success', text: `No triggers defined.\nAdd one as ${stateHome()}/triggers/<id>.yml, or per project as <workspace>/.dsh/triggers/<id>.yml.\nThe definition format is in docs/triggers-design.md; running them is not implemented yet.` };
-      }
-      return { kind: 'success', text: [...definitions.map(definition => formatTrigger(definition, { lastRun: lastRun(definition.id) })), ...problemsText].join('\n') };
-    },
+  const home = stateHome();
+  let managementContext;
+  ctx.inject(['tools', 'systemPrompt', 'permissionPresets'], toolCtx => {
+    managementContext = toolCtx;
+    registerTriggerTools(toolCtx, { home });
+  });
+  const management = new TriggerManagement({ home, dscodePath: process.env.DSCODE_CLI_PATH });
+  const handler = triggerCommand({ management, mutationProblem: agent => managementContext
+    ? mutationProblem(managementContext, agent) : 'Trigger management services are not available yet.' });
+  for (const name of ['trigger', 'triggers']) ctx.commands.register({
+    name, description: 'Manage triggers, jobs and script sources; /trigger help',
+    input: { hint: '[list|show|new|update|enable|disable|run|schedule|jobs|cancel|source|scheduler|help]' },
+    handler,
   });
 }

package/plugins/triggers/job-cli.mjs

@@ -0,0 +1,110 @@
+import { existsSync } from 'node:fs';
+import { JobStore, formatJob } from './jobs.mjs';
+import { normalizeEvent } from './spool.mjs';
+import { dueTime } from './schedule.mjs';
+import { runScheduler } from './scheduler.mjs';
+import { schedulerService } from './scheduler-service.mjs';
+import { acquireTriggerLease } from './lease.mjs';
+import { appendRun, readRuns } from './log.mjs';
+
+export const JOB_COMMANDS = ['schedule', 'jobs', 'cancel', 'scheduler', 'run-job'];
+
+export async function handleJobCommand(options, context) {
+  const { home, project, now, platform, dscodePath, launchctl, out, err, deps, findDefinition, readEventBody } = context;
+  if (options.command === 'scheduler') {
+    if (!['start', 'tick', 'install', 'uninstall', 'status'].includes(options.id)) throw new Error('scheduler expects start, tick, install, uninstall or status');
+    if (options.id === 'status') {
+      const lease = await acquireTriggerLease(home, '_scheduler');
+      out(lease ? 'scheduler stopped' : 'scheduler running');
+      lease?.release();
+      return 0;
+    }
+    if (!dscodePath || !existsSync(dscodePath)) throw new Error('the scheduler needs a valid dscode program path');
+    if (['install', 'uninstall'].includes(options.id)) {
+      await schedulerService(options.id, { home, dscodePath, platform, launchctl, agentsDirectory: deps.agentsDirectory, out });
+      return 0;
+    }
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.once(signal, stop);
+    try {
+      out(`scheduler ${options.id}: ${home}`);
+      return await runScheduler({ home, dscodePath, once: options.id === 'tick', signal: controller.signal, spawnWorker: deps.spawnWorker, report: err });
+    } finally { for (const signal of ['SIGINT', 'SIGTERM', 'SIGHUP']) process.off(signal, stop); }
+  }
+  const store = new JobStore(home);
+  try {
+    if (options.command === 'jobs') {
+      const jobs = store.list(options.id || undefined);
+      out(jobs.length ? jobs.map(formatJob).join('\n') : 'No jobs scheduled.');
+      return 0;
+    }
+    if (options.command === 'cancel') {
+      store.cancel(options.id, now);
+      out(`cancelled ${options.id}`);
+      return 0;
+    }
+    if (options.command === 'schedule') {
+      const definition = findDefinition(home, project, options.id);
+      const dueAt = dueTime(options, now);
+      const payload = (await readEventBody(options, deps.stdin ?? process.stdin)) ?? {};
+      normalizeEvent(definition.id, payload, { eventId: 'validation', now });
+      if (options.eventId !== undefined) throw new Error('schedule assigns a jobId; --event-id is only for emit/fire/run');
+      const job = store.create({ triggerId: definition.id, project, workspace: definition.workspace, payload, dueAt, now });
+      out(formatJob(job));
+      out('The scheduler delivers this job: dscode trigger scheduler install (or scheduler start).');
+      return 0;
+    }
+    return await executeJob(store, options.id, context);
+  } finally { store.close(); }
+}
+
+export async function executeJob(store, id, context) {
+  const { home, now, deps, out, err, executeEvent, findDefinition } = context;
+  const job = store.get(id);
+  if (!job) throw new Error(`no job "${id}"`);
+  if (job.state !== 'pending' || job.availableAt > now) { out(formatJob(job)); return 0; }
+  const triggerLease = await acquireTriggerLease(home, job.triggerId);
+  if (!triggerLease) { store.defer(id, 'already_running', now + 1000); return 0; }
+  let handle;
+  try {
+    let definition;
+    try { definition = findDefinition(home, job.project, job.triggerId); }
+    catch (error) { store.defer(id, 'definition_missing', now + 30000); err(error.message); return 0; }
+    if (definition.workspace !== job.workspace) {
+      store.defer(id, 'workspace_changed', now + 30000);
+      err(`job ${id} belongs to ${job.workspace}; cancel it and schedule a new job for the changed workspace`);
+      return 0;
+    }
+    const eventId = store.eventIdentity(job.id) ?? `job:${job.id}`;
+    const chosen = normalizeEvent(job.triggerId, { source: job.kind, ...JSON.parse(job.payload) }, { eventId, now: job.createdAt });
+    const result = await executeEvent(definition, {
+      home, now, deps, out, err, triggerLease, chosen, eventId, jobId: id, quietSkips: true,
+      beforeRun: planned => { handle = planned; return store.claim(id, planned.runId, now); },
+    });
+    if (result.skip) {
+      let availableAt = now + 30000;
+      const runs = readRuns(home, { triggerId: job.triggerId, limit: 0 }).filter(r => r.outcome !== 'skipped');
+      if (result.skip === 'too_soon' && runs[0]) availableAt = runs[0].startedAt + definition.limits.minIntervalSeconds * 1000;
+      if (result.skip === 'over_daily_limit') {
+        const withinDay = runs.filter(r => r.startedAt > now - 86400000).sort((a, b) => a.startedAt - b.startedAt);
+        if (withinDay[0]) availableAt = withinDay[0].startedAt + 86400000;
+      }
+      if (result.skip === 'duplicate') {
+        // Reconcile a durable run record after a crash before job-state update.
+        const previous = runs.find(r => r.eventId === eventId);
+        if (store.claim(id, previous.runId, now)) store.finish(id, previous, now);
+      } else store.defer(id, result.skip, availableAt);
+      return 0;
+    }
+    store.finish(id, result.record ?? { exitCode: result.code, reason: 'no_match' });
+    return result.code;
+  } catch (error) {
+    if (handle && store.get(id).state === 'running') {
+      const record = { ...handle, jobId: id, outcome: 'failed', reason: 'model_error', exitCode: 1, endedAt: Date.now(), cwd: job.workspace };
+      appendRun(home, record);
+      store.finish(id, record);
+    }
+    throw error;
+  } finally { triggerLease.release(); }
+}