@toddzheng024/dscode-bundle 0.7.25 → 0.7.27

package/package.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.7.25",
+  "version": "0.7.27",
   "type": "module",
   "license": "MIT",
   "author": "Todd Zheng",
@@ -308,6 +308,7 @@
     "@deepseek-ai/schemastery": "3.18.2",
     "@anionex/dsh-computer-use": "0.3.2",
     "chrome-devtools-mcp": "1.9.0",
+    "cron-parser": "5.7.0",
     "imapflow": "2.0.5",
     "mailparser": "3.9.28",
     "nodemailer": "10.0.10",

package/plugins/openrouter/wire.mjs

@@ -219,6 +219,9 @@ export function errorCode(status, error) {
   const code = Number.isInteger(status) ? status : Number(error?.code);
   // A 402 names token counts ("fewer max_tokens"); its status decides before any wording does.
   if (code === 402) return QUOTA_EXCEEDED_CODE;
+  // OpenRouter can reject a replay before generation without typed metadata.
+  // Keep this narrow: an ordinary permission-denied 403 still means AUTH.
+  if (code === 403 && typeof error?.message === 'string' && /^Request blocked by content filter\b/i.test(error.message)) return 'CONTENT_POLICY';
   const detail = [error?.message, error?.metadata?.raw].filter(value => typeof value === 'string').join(' ');
   if (isContextWindowExceededError(detail)) return CONTEXT_WINDOW_EXCEEDED_CODE;
   if (isQuotaExceededError(detail)) return QUOTA_EXCEEDED_CODE;

package/plugins/session-metrics/index.mjs

@@ -6,7 +6,7 @@ import { BALANCE_PROVIDERS, refreshBalance } from './balance.mjs';
 import { refreshOpenRouterModels } from '../openrouter/models.mjs';
 import { REPLAY_KIND } from '../openrouter/wire.mjs';
 import { providerSpec } from '../providers/catalog.mjs';
-import { createWindowRate } from './rate.mjs';
+import { createSmoothedRate } from './rate.mjs';
 import { currentCharge } from './attribution.mjs';
 
 // Chunks that carry generated output; the first one marks time to first token.
@@ -15,18 +15,20 @@ export const name = 'dscode-session-metrics';
 export const inject = ['llm', 'agents', 'tokenMeter', 'sessionProjections'];
 export function apply(ctx) {
   const snapshots = new WeakMap();
-  const liveRate = createWindowRate();
+  const smoothedRate = createSmoothedRate();
+  const activeRequests = new WeakMap();
   ctx.effect(() => setMetricSource(id => {
     const agent = ctx.agents.get(id);
     if (!agent) return undefined;
     const session = agent.session;
     const cached = snapshots.get(session);
-    if (cached?.seq === session.seq) return { ...cached.value, currentTps: liveRate.get(session) };
+    const requestActive = (activeRequests.get(session) ?? 0) > 0;
+    if (cached?.seq === session.seq) return { ...cached.value, currentTps: smoothedRate.get(session), requestActive };
     const state = ctx.sessionProjections.stateOf(session, 'contextPressure');
     const measurement = ctx.tokenMeter.measure(session);
     const value = { events: session.snapshotEvents(), used: measurement.totalTokens, capacity: state?.contextWindow };
     snapshots.set(session, { seq: session.seq, value });
-    return { ...value, currentTps: liveRate.get(session) };
+    return { ...value, currentTps: smoothedRate.get(session), requestActive };
   }));
   const home = process.env.DSH_HOME;
   // Remaining balance is best-effort decoration: resolve the key lazily (never
@@ -72,19 +74,26 @@ export function apply(ctx) {
     save({ kind: 'start', id, time, provider: options.provider, model: options.model, purpose });
     let usage, firstTokenTime, billed;
     const liveSession = purpose === 'agent' ? ctx.agents.get(sessionId)?.session : undefined;
+    const settleRate = liveSession
+      ? smoothedRate.begin(liveSession, JSON.stringify([options.provider, options.model, options.reasoningEffort ?? null]))
+      : undefined;
+    if (liveSession) activeRequests.set(liveSession, (activeRequests.get(liveSession) ?? 0) + 1);
+    let completed = false;
     try {
       for await (const chunk of next()) {
         if (chunk.type === 'usage') usage = chunk.usage;
         else if (firstTokenTime === undefined && OUTPUT_CHUNKS.has(chunk.type)) firstTokenTime = Date.now();
         // OpenRouter reports what it charged; the finish of its response carries it.
         if (chunk.type === 'finish' && chunk.replayState?.response?.kind === REPLAY_KIND && Number.isFinite(chunk.replayState.response.cost)) billed = chunk.replayState.response.cost;
-        if (liveSession) liveRate.add(liveSession, chunk);
         yield chunk;
       }
+      completed = true;
     } finally {
-      if (liveSession) liveRate.calibrate(liveSession, usage?.outputTokens);
+      const endTime = Date.now();
+      if (liveSession) activeRequests.set(liveSession, (activeRequests.get(liveSession) ?? 1) - 1);
+      if (completed) settleRate?.({ start: time, end: endTime, outputTokens: usage?.outputTokens });
       // `time` stays the start (it prices the call); `endTime` and `firstTokenTime` time it.
-      save({ kind: 'end', id, time, endTime: Date.now(), ...(firstTokenTime === undefined ? {} : { firstTokenTime }), usage: usage ?? null, ...(billed === undefined
+      save({ kind: 'end', id, time, endTime, ...(firstTokenTime === undefined ? {} : { firstTokenTime }), usage: usage ?? null, ...(billed === undefined
         ? { cost: estimateCost(options.provider, options.model, usage, time), priceVersion: priceVersionFor(options.provider, options.model) }
         : { cost: billed, priceVersion: 'openrouter-billed' }) });
     }

package/plugins/session-metrics/rate.mjs

@@ -1,69 +1,34 @@
-const WINDOW_MS = 5000;
-// A pause longer than this (tool execution, the wait for the first token) ends
-// the current output burst: the next chunk starts a fresh window instead of
-// averaging over the silence.
-const GAP_MS = 1500;
-const MIN_SPAN_MS = 500;
-
-// Providers report exact output tokens only when a request settles. During
-// streaming, estimate from UTF-8 bytes without rounding each small chunk.
-export function estimatedDeltaTokens(chunk) {
-  const text = chunk.type === 'text-delta' || chunk.type === 'reasoning-delta'
-    ? chunk.text
-    : chunk.type === 'tool-call-delta' ? chunk.argumentsDelta : undefined;
-  return typeof text === 'string' ? Buffer.byteLength(text, 'utf8') / 4 : 0;
-}
+// Each valid completed request halves every older sample's weight.
+const DECAY = 0.5;
 
 /**
- * Live output rate: tokens seen in the last five seconds divided by the time
- * that window actually spans, so the rate is right from the first second of a
- * burst. Settled usage calibrates the byte-based estimate per session.
+ * Normalized exponential average of per-request TPS, from final API usage.
+ * New samples have weight 1; existing weights multiply by DECAY. Normalizing
+ * the startup weights keeps newer requests more influential from sample two.
+ * Idle time and unusable samples do not age the history.
  */
-export function createWindowRate() {
-  const samples = new WeakMap();
-  const stateOf = session => {
-    let state = samples.get(session);
-    if (!state) { state = { values: [], head: 0, sum: 0, factor: 1, pending: 0 }; samples.set(session, state); }
-    return state;
-  };
-  const prune = (state, now) => {
-    while (state.head < state.values.length && state.values[state.head].time <= now - WINDOW_MS) {
-      state.sum -= state.values[state.head++].tokens;
-    }
-    if (state.head > 128 && state.head * 2 > state.values.length) {
-      state.values.splice(0, state.head);
-      state.head = 0;
-    }
-  };
+export function createSmoothedRate() {
+  const sessions = new WeakMap();
   return {
-    add(session, chunk, now = Date.now()) {
-      const tokens = estimatedDeltaTokens(chunk);
-      if (!(tokens > 0)) return;
-      const state = stateOf(session);
-      const last = state.values.at(-1);
-      if (last && now - last.time > GAP_MS) { state.values = []; state.head = 0; state.sum = 0; }
-      state.values.push({ time: now, tokens });
-      state.sum += tokens;
-      state.pending += tokens;
-      prune(state, now);
-    },
-    /** Feed the provider's settled output count for the request whose chunks were just added. */
-    calibrate(session, outputTokens) {
-      const state = samples.get(session);
-      if (!state) return;
-      const pending = state.pending;
-      state.pending = 0;
-      if (!(pending > 0) || !Number.isFinite(outputTokens) || outputTokens <= 0) return;
-      const ratio = Math.min(2, Math.max(0.5, outputTokens / pending));
-      state.factor = state.factor * 0.5 + ratio * 0.5;
+    begin(session, route) {
+      let state = sessions.get(session);
+      if (!state || state.route !== route) {
+        state = { route, weightedRate: 0, weight: 0 };
+        sessions.set(session, state);
+      }
+      // A late completion from an older model must not contaminate the new one.
+      return ({ start, end, outputTokens }) => {
+        if (sessions.get(session) !== state || !Number.isFinite(start) || !Number.isFinite(end)
+          || end <= start || !Number.isFinite(outputTokens) || outputTokens < 0) return;
+        const rate = outputTokens / ((end - start) / 1000);
+        if (!Number.isFinite(rate)) return;
+        state.weightedRate = state.weightedRate * DECAY + rate;
+        state.weight = state.weight * DECAY + 1;
+      };
     },
-    get(session, now = Date.now()) {
-      const state = samples.get(session);
-      if (!state) return null;
-      prune(state, now);
-      if (state.head >= state.values.length) return 0;
-      const span = Math.min(WINDOW_MS, Math.max(MIN_SPAN_MS, now - state.values[state.head].time));
-      return Math.max(0, state.sum) * state.factor / (span / 1000);
+    get(session) {
+      const state = sessions.get(session);
+      return state?.weight > 0 ? state.weightedRate / state.weight : null;
     },
   };
 }

package/plugins/session-metrics/view.mjs

@@ -111,7 +111,7 @@ function resetStamp(iso, now) {
  * terminal width decides which segments the drop ladder keeps.
  */
 const FIGURE = {
-  /** `~999.9` decode rates; the average reads the same scale without the tilde. */
+  /** Request and session-average rates share the same fixed figure width. */
   rate: 6,
   /** `100%` context occupancy. */
   percent: 4,
@@ -135,7 +135,7 @@ function figure(text, width) {
   return padding > 0 ? ' '.repeat(padding) + text : text;
 }
 
-export function formatFooter(metrics, context, columns = 80, rates, locale = 'en', provider = 'deepseek-official') {
+function footerFigures(metrics, context, rates, locale = 'en', provider = 'deepseek-official') {
   const label = key => t(locale, key);
   const ctx = figure(Number.isFinite(context) ? `${Math.round(context)}%` : '--', FIGURE.percent);
   const cache = figure(metrics.cache === null ? '--' : `${metrics.cache.toFixed(1)}%`, FIGURE.share);
@@ -161,13 +161,21 @@ export function formatFooter(metrics, context, columns = 80, rates, locale = 'en
   // priceable, the same mark the total uses.
   const turn = metrics.lastTurn === undefined || !Number.isFinite(metrics.lastTurn.cost) ? ''
     : `#${metrics.lastTurn.turn} $${metrics.lastTurn.cost.toFixed(2)}${metrics.lastTurn.unknown ? '+' : ''}`;
-  // Every figure reads value first and carries its own short qualifier, so the
-  // cluster stays scannable without a `label:` prefix in front of each number.
-  const base = rates ? [
-    `${figure(Number.isFinite(rates.current) ? '~' + rates.current.toFixed(1) : '--', FIGURE.rate)} tps`,
-    `${figure(Number.isFinite(rates.average) ? rates.average.toFixed(1) : '--', FIGURE.rate)} tps ${label('footer.average')}`,
-    `${ctx} ${label('footer.context')}`, money, `${cache} ${label('footer.cache')}`,
-  ] : [`${ctx} ${label('footer.context')}`, money, `${cache} ${label('footer.cache')}`];
+  return {
+    current: rates ? `${rates.active ? '◌' : ' '} ${figure(Number.isFinite(rates.current) ? rates.current.toFixed(1) : '--', FIGURE.rate)} tps` : '',
+    average: rates ? `${figure(Number.isFinite(rates.average) ? rates.average.toFixed(1) : '--', FIGURE.rate)} tps ${label('footer.average')}` : '',
+    context: `${ctx} ${label('footer.context')}`,
+    money,
+    cache: `${cache} ${label('footer.cache')}`,
+    turn,
+  };
+}
+
+/** Flat footer for text consumers; the TUI uses the same figures as separate groups. */
+export function formatFooter(metrics, context, columns = 80, rates, locale = 'en', provider = 'deepseek-official') {
+  const figures = footerFigures(metrics, context, rates, locale, provider);
+  const { current, average, context: ctx, money, cache, turn } = figures;
+  const base = rates ? [current, average, ctx, money, cache] : [ctx, money, cache];
   // The slot is reserved even when no turn has cost anything yet: the drop
   // ladder's indices are fixed against this array, and an unfilled slot renders
   // as '' (skipped by `render`) exactly like the absent figure would.
@@ -204,7 +212,7 @@ export function sessionSpend(id) {
 
 /** Per-events memo: the status line renders up to once a second, and summarize/average are O(events). */
 const footerCache = new WeakMap();
-export function footerFor(id, stats, columns, provider = 'deepseek-official', locale = 'en') {
+export function footerFor(id, stats, columns, provider = 'deepseek-official', locale = 'en', format = formatFooter) {
   const limit = parseBudget(process.env.DSCODE_SESSION_BUDGET_USD);
   try {
     const data = id ? source?.(id) : undefined;
@@ -222,6 +230,12 @@ export function footerFor(id, stats, columns, provider = 'deepseek-official', lo
     // The budget comes from the environment for this process only: it is a
     // per-machine spending guard, not a session property worth persisting.
     const budget = limit === null ? undefined : evaluateBudget(summary.cost, limit);
-    return formatFooter({ ...summary, ...(budget === undefined ? {} : { budget }) }, Number.isFinite(used) && capacity > 0 ? used / capacity * 100 : undefined, columns, { current: data?.currentTps, average }, locale, provider);
-  } catch { return formatFooter({ cost: 0, unknown: true, cache: null }, undefined, columns, { current: null, average: null }, locale, provider); }
+    return format({ ...summary, ...(budget === undefined ? {} : { budget }) }, Number.isFinite(used) && capacity > 0 ? used / capacity * 100 : undefined, columns, { current: data?.currentTps, average, active: data?.requestActive }, locale, provider);
+  } catch { return format({ cost: 0, unknown: true, cache: null }, undefined, columns, { current: null, average: null }, locale, provider); }
+}
+
+/** Structured figures preserve money/cache as one right-aligned group in the TUI. */
+export function footerFiguresFor(id, stats, provider = 'deepseek-official', locale = 'en') {
+  return footerFor(id, stats, 0, provider, locale,
+    (metrics, context, _columns, rates, language, route) => footerFigures(metrics, context, rates, language, route));
 }

package/plugins/triggers/cli.mjs

@@ -8,6 +8,13 @@
 // injected, which is also what makes the whole command testable.
 
 import { existsSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { setTimeout as sleep } from 'node:timers/promises';
+import { acquireTriggerLease } from './lease.mjs';
+import { handleJobCommand, JOB_COMMANDS, executeJob } from './job-cli.mjs';
+import { emitToSource } from './source-ingress.mjs';
+import { JobStore } from './jobs.mjs';
+import { schedulerService } from './scheduler-service.mjs';
 import { dirname, join, resolve } from 'node:path';
 import { parse as parseYaml } from 'yaml';
 import { loadTriggerDefinitions, formatTrigger } from './config.mjs';
@@ -23,17 +30,25 @@ export const USAGE = `Usage: dscode trigger <command> [options]
 Commands:
   run <id>              Start one run now (respecting the trigger's limits)
   fire <id>             Post an event and run it: --text "..." or --event FILE
-  emit <id>             Only post an event for the next drain
+  emit <id>             Commit an event to the scheduler queue
   events [id]           Print the events waiting in a trigger's spool
   list                  List the trigger definitions and their last outcome
   show <id>             Print one definition
   log [id]              Print recorded runs, newest first (--failed for failures only)
   new <id>              Write a starter definition into the project
   enable|disable <id>   Set the definition's enabled flag in its own file
-  install <id>          Schedule the trigger with launchd (or print the crontab)
+  schedule <id>         Schedule one event: --after 30m or --at ISO_TIMESTAMP
+  jobs [id]             List scheduled jobs and their state
+  cancel <jobId>        Cancel a pending job (never stops a running one)
+  source <id> <action>  status | start | stop | restart | logs
+  scheduler <action>    start | tick | install | uninstall | status
+  run-job <jobId>       Execute one due job (used by the scheduler)
+  install <id>          Register a recurring source and install the scheduler
   uninstall <id>        Remove the schedule
 
 Options:
+  --after DURATION     Delay such as 30s, 10m, 2h or 1d (schedule only)
+  --at TIMESTAMP       ISO timestamp with an explicit offset (schedule only)
   --event FILE          Event body as JSON; "-" reads stdin
   --text TEXT           Event body text (with "fire"/"emit")
   --event-id ID         Identity of the posted event; retry with the same one
@@ -45,7 +60,7 @@ Exit codes are the run's: 0 completed, skipped or nothing to do; 1 failed;
 2 round or cost cap; 3 the goal is blocked or paused; 124 timeout; 130 interrupted.
 An orderly stop writes a result file; only a Host that died leaves none behind.`;
 
-const COMMANDS = ['run', 'fire', 'emit', 'events', 'list', 'show', 'log', 'new', 'enable', 'disable', 'install', 'uninstall'];
+const COMMANDS = ['source', 'run', 'fire', 'emit', 'events', 'list', 'show', 'log', 'new', 'enable', 'disable', 'install', 'uninstall', ...JOB_COMMANDS];
 
 /** Parse the arguments after `trigger`. */
 export function parseTriggerArgs(argv) {
@@ -54,16 +69,18 @@ export function parseTriggerArgs(argv) {
   options.command = words.shift() ?? '';
   if (options.command === '' || options.command === '--help' || options.command === '-h') { options.help = true; return options; }
   if (!COMMANDS.includes(options.command)) { options.error = `unknown command "${options.command}"`; return options; }
-  if (['list', 'log'].includes(options.command)) {
+  if (['list', 'log', 'events', 'jobs'].includes(options.command)) {
     if (words.length > 0 && !words[0].startsWith('-')) options.id = words.shift();
   } else {
     const id = words.shift() ?? '';
     if (id === '' || id.startsWith('-')) { options.error = `${options.command} needs a trigger id`; return options; }
     options.id = id;
   }
+  if (options.command === 'source') options.action = words.shift() ?? 'status';
   while (words.length > 0) {
     const flag = words.shift();
     const value = () => { const next = words.shift(); if (next === undefined) { options.error = `${flag} needs a value`; return undefined; } return next; };
+    if (flag === '--after' || flag === '--at') { const next = value(); if (next === undefined) return options; options[flag.slice(2)] = next; continue; }
     if (flag === '--event') { const next = value(); if (next === undefined) return options; options.event = next; continue; }
     if (flag === '--text') { const next = value(); if (next === undefined) return options; options.text = next; continue; }
     if (flag === '--event-id') { const next = value(); if (next === undefined) return options; options.eventId = next; continue; }
@@ -74,6 +91,7 @@ export function parseTriggerArgs(argv) {
     options.error = `unknown option "${flag}"`;
     return options;
   }
+  if (options.command !== 'schedule' && (options.after !== undefined || options.at !== undefined)) options.error = '--after and --at are only accepted by schedule';
   return options;
 }
 
@@ -112,6 +130,7 @@ export function scaffoldTrigger(id, { workspace }) {
     `workspace: ${workspace}`,
     'prompt: describe what this run should do',
     'source: { kind: interval, seconds: 300 }',
+    'session: { mode: new }',
     'goal: { objective: describe the finished state, maxRounds: 20 }',
     'limits: { timeoutSeconds: 1800, maxRunsPerDay: 24, minIntervalSeconds: 60 }',
     '',
@@ -257,6 +276,28 @@ export async function runTriggerCli(argv, deps = {}) {
   // A CLI function returns an exit code: an unknown id, an unreadable definition
   // or a missing workspace is a user-facing message, not a thrown stack.
   try {
+    if (process.env.DSCODE_SOURCE_SOCKET) {
+      if (options.command !== 'emit') throw new Error('script source ingress only supports emit');
+      const payload = (await readEventBody(options, deps.stdin ?? process.stdin)) ?? {};
+      out(JSON.stringify(await emitToSource({ triggerId: options.id, eventId: options.eventId, payload })));
+      return 0;
+    }
+    if (options.command === 'source') {
+      const definition = findDefinition(home, project, options.id);
+      if (definition.source.kind !== 'script') throw new Error('source management requires a script source');
+      const store = new JobStore(home);
+      try {
+        if (['status', 'logs'].includes(options.action)) {
+          const source = store.source(definition.id, project);
+          out(options.action === 'logs' ? source?.log || '(no source output)' : JSON.stringify(source ?? { status: 'unregistered' }));
+        } else { out(JSON.stringify(store.controlSource(definition, project, options.action))); out('The shared scheduler must be running to supervise sources.'); }
+      } finally { store.close(); }
+      return 0;
+    }
+    if (JOB_COMMANDS.includes(options.command)) return await handleJobCommand(options, {
+      home, project, now, platform, dscodePath, launchctl, out, err, deps,
+      findDefinition, readEventBody, executeEvent,
+    });
     if (options.command === 'list') {
       const { definitions, problems } = loadTriggerDefinitions({ home, workspace: project });
       if (definitions.length === 0 && problems.length === 0) { out('No triggers defined.'); return 0; }
@@ -277,15 +318,23 @@ export async function runTriggerCli(argv, deps = {}) {
       return 0;
     }
     if (options.command === 'events') {
+      let durableCount = 0;
+      const store = new JobStore(home);
+      try {
+        for (const job of store.list(options.id || undefined).filter(j => j.project === project && j.kind === 'event' && ['pending', 'running'].includes(j.state))) {
+          durableCount += 1;
+          out(`${job.triggerId} ${job.state} ${store.eventIdentity(job.id)} ${JSON.parse(job.payload).text}`);
+        }
+      } finally { store.close(); }
       if (options.id === '') {
         const { definitions } = loadTriggerDefinitions({ home, workspace: project });
         let total = 0;
         for (const definition of definitions) for (const event of listEvents(home, definition.id)) { out(`${definition.id} ${formatEvent(event)}`); total += 1; }
-        if (total === 0) out('No pending events.');
+        if (total === 0 && durableCount === 0) out('No pending events.');
         return 0;
       }
       const pending = listEvents(home, options.id);
-      if (pending.length === 0) out(`No pending events for ${options.id}.`);
+      if (pending.length === 0 && durableCount === 0) out(`No pending events for ${options.id}.`);
       else for (const event of pending) out(formatEvent(event));
       return 0;
     }
@@ -314,6 +363,8 @@ export async function runTriggerCli(argv, deps = {}) {
       const definition = findDefinition(home, project, options.id);
       const path = agentPath(home, definition.id);
       if (options.command === 'uninstall') {
+        const store = new JobStore(home);
+        try { store.unregister(definition.id, project, now); } finally { store.close(); }
         if (launchctl !== undefined && platform === 'darwin') await launchctl(['bootout', `gui/${process.getuid?.() ?? ''}/${'ai.dscode.trigger.' + definition.id}`], { ignoreFailure: true });
         rmSync(path, { force: true });
         out(`removed the schedule for ${options.id} (${path})`);
@@ -332,6 +383,15 @@ export async function runTriggerCli(argv, deps = {}) {
         err(`cannot install ${options.id}: ${dscodePath} is not an executable file, and launchd runs no shell profile`);
         return 1;
       }
+      if (['calendar', 'interval', 'poll', 'script'].includes(definition.source.kind)) {
+        const store = new JobStore(home);
+        try { store.register(definition, project, now); } finally { store.close(); }
+        if (platform === 'darwin' && launchctl) await launchctl(['bootout', `gui/${process.getuid()}/ai.dscode.trigger.${definition.id}`], { ignoreFailure: true });
+        rmSync(path, { force: true });
+        out(`registered ${definition.id} with the scheduler`);
+        await schedulerService('install', { home, dscodePath, platform, launchctl, agentsDirectory: deps.agentsDirectory, out });
+        return 0;
+      }
       const plist = launchAgent(definition, { home, dscodePath, project });
       mkdirSync(dirname(path), { recursive: true, mode: 0o700 });
       writeFileSync(path, plist, { mode: 0o600 });
@@ -350,14 +410,26 @@ export async function runTriggerCli(argv, deps = {}) {
     const definition = findDefinition(home, project, options.id);
     if (options.command === 'emit') {
       const body = (await readEventBody(options, deps.stdin ?? process.stdin)) ?? {};
-      const event = emitEvent(home, definition.id, { source: 'cli', ...body }, { eventId: options.eventId ?? deps.eventId ?? `manual-${new Date(now).toISOString()}`, now });
-      out(`posted ${event.eventId} to ${definition.id} (${listEvents(home, definition.id).length} pending)`);
+      const store = new JobStore(home);
+      try {
+        const job = store.acceptEvent({ definition, project, payload: { source: 'cli', ...body }, eventId: options.eventId ?? deps.eventId ?? `manual-${randomUUID()}`, now });
+        out(`queued ${store.eventIdentity(job.id)} to ${definition.id}: ${job.id} (${job.state})`);
+        out('Delivery requires the shared scheduler, or dscode trigger run ' + definition.id);
+      } finally { store.close(); }
       return 0;
     }
+    if (options.command === 'run') {
+      const store = new JobStore(home);
+      try {
+        const wanted = options.eventId ?? deps.eventId;
+        const job = store.list(definition.id).reverse().find(j => j.project === project && j.kind === 'event' && (wanted === undefined ? j.state === 'pending' : store.eventIdentity(j.id) === wanted));
+        if (job) return await executeJob(store, job.id, { home, project, now, deps, out, err, executeEvent, findDefinition });
+      } finally { store.close(); }
+    }
     let fired;
     if (options.command === 'fire') {
       const body = (await readEventBody(options, deps.stdin ?? process.stdin)) ?? {};
-      fired = emitEvent(home, definition.id, { source: 'cli', ...body }, { eventId: options.eventId ?? deps.eventId ?? `fire-${new Date(now).toISOString()}`, now });
+      fired = emitEvent(home, definition.id, { source: 'cli', ...body }, { eventId: options.eventId ?? deps.eventId ?? `fire-${randomUUID()}`, now });
     }
 
     const pending = listEvents(home, definition.id);
@@ -369,21 +441,80 @@ export async function runTriggerCli(argv, deps = {}) {
       err(`no pending event "${wanted}" for ${definition.id}; post it with "emit", or omit --event-id`);
       return 1;
     }
-    const chosen = fired ?? matching ?? (wanted === undefined ? pending[0] : undefined);
+    const scheduled = definition.session.mode === 'persistent' && definition.source.kind !== 'external' && options.command === 'run' && wanted === undefined;
+    const chosen = fired ?? matching ?? (!scheduled && wanted === undefined ? pending[0] : undefined);
     const eventId = chosen?.eventId ?? wanted ?? firingIdentity(definition, now);
-    const plan = planTriggerRun(definition, { home, now, eventId });
-    if (plan.action === 'skip') {
-      err(`skipped ${definition.id}: ${plan.reason}`);
-      return recordSkip(home, definition, { reason: plan.reason, eventId, now });
+    const persistent = definition.session.mode === 'persistent';
+    // Scheduled invocations also become durable events when a session is reused.
+    // An explicit external drain processes the backlog without inventing a tick.
+    if (persistent && chosen === undefined) {
+      emitEvent(home, definition.id, { source: definition.source.kind }, { eventId, now });
     }
+    const triggerLease = await acquireTriggerLease(home, definition.id, { wait: persistent });
+    if (!triggerLease) {
+      err(`skipped ${definition.id}: already_running`);
+      return recordSkip(home, definition, { reason: 'already_running', eventId, now });
+    }
+    try {
+      if (!persistent) return (await executeEvent(definition, { home, now, eventId, chosen, deps, out, err, triggerLease })).code;
+      let exitCode = 0;
+      const clock = deps.clock ?? (() => deps.now ?? Date.now());
+      for (;;) {
+        const next = listEvents(home, definition.id, { limit: 1 })[0];
+        if (!next) {
+          const own = readRuns(home, { triggerId: definition.id, limit: 0 }).find(run => run.eventId === eventId && run.outcome !== 'skipped');
+          return exitCode || own?.exitCode || 0;
+        }
+        const current = findDefinition(home, project, definition.id);
+        if (current.session.mode !== 'persistent') return exitCode;
+        const result = await executeEvent(current, { home, now: clock(), eventId: next.eventId, chosen: next, deps, out, err, triggerLease });
+        if (result.skip === 'duplicate') {
+          consumeEvent(home, definition.id, next.eventId);
+          continue;
+        }
+        if (result.skip === 'too_soon') {
+          const previous = readRuns(home, { triggerId: definition.id, limit: 0 }).find(run => run.outcome !== 'skipped');
+          const remaining = previous.startedAt + current.limits.minIntervalSeconds * 1000 - clock();
+          await (deps.delay ?? sleep)(Math.max(1, Math.min(remaining, 1000)));
+          continue;
+        }
+        if (result.skip) return exitCode; // disabled, daily cap, or a legacy run: leave events pending
+        if (result.code !== 0) exitCode = result.code;
+        if (result.code === 130) return exitCode;
+      }
+    } finally { triggerLease.release(); }
+  } catch (error) {
+    err(error?.message ?? String(error));
+    return 1;
+  }
+}
 
+/** The launcher and the source driver both must inject a spawn. */
+function missingSpawn() {
+  throw new Error('this build has no way to start a run: inject spawnRun');
+}
+
+/** Execute one event while the caller holds the cross-process trigger lease. */
+async function executeEvent(definition, { home, now, eventId, chosen, deps, out, err, triggerLease, beforeRun, jobId, quietSkips = false }) {
+  const plan = planTriggerRun(definition, { home, now, eventId });
+  if (plan.action === 'skip') {
+    if (quietSkips || definition.session.mode === 'persistent' && plan.reason === 'too_soon') return { code: 0, skip: plan.reason };
+    err(`skipped ${definition.id}: ${plan.reason}`);
+    recordSkip(home, definition, { reason: plan.reason, eventId, now });
+    return { code: 0, skip: plan.reason };
+  }
+
+  try {
+    if (beforeRun && !beforeRun(plan.handle)) return { code: 0, skip: 'cancelled' };
     // A poll source only runs when its predicate says there is work; without a
     // resident listener this scheduled invocation IS the poll.
     if (definition.source.kind === 'poll') {
-      const check = await evaluateCheck(definition.source.check, { cwd: definition.workspace, timeoutMs: 60000, ...(deps.spawnCheck === undefined ? {} : { spawn: deps.spawnCheck }) });
+      const check = await evaluateCheck(definition.source.check, { home, permission: definition.permission, cwd: definition.workspace, timeoutMs: 60000, ...(deps.spawnCheck === undefined ? {} : { spawn: deps.spawnCheck }) });
       if (!check.matched) {
         err(`nothing to do for ${definition.id} (${check.code === null ? 'the check did not finish' : `check exited ${check.code}`})`);
-        return recordLockedSkip(home, definition, plan.handle, { reason: 'no_match', eventId, details: check.output, now });
+        recordLockedSkip(home, definition, plan.handle, { reason: 'no_match', eventId, details: check.output, now });
+        if (chosen !== undefined) consumeEvent(home, definition.id, chosen.eventId);
+        return { code: 0 };
       }
     }
 
@@ -391,6 +522,7 @@ export async function runTriggerCli(argv, deps = {}) {
       triggerId: definition.id,
       runId: plan.handle.runId,
       workspace: definition.workspace,
+      session: definition.session,
       prompt: renderPrompt(definition.prompt, chosen),
       preset: definition.preset,
       permission: definition.permission,
@@ -399,17 +531,9 @@ export async function runTriggerCli(argv, deps = {}) {
       goal: { objective: definition.goal.objective, maxRounds: definition.goal.maxRounds },
       limits: definition.limits,
       eventId,
+      ...(jobId ? { jobId } : {}),
     };
-    let code;
-    let result;
-    try {
-      ({ code, result } = await (deps.spawnRun ?? missingSpawn)({ spec, home, cwd: definition.workspace }));
-    } catch (error) {
-      // The Host never ran, so the event is still pending and the lock must not
-      // outlive the attempt: a later drain should be free to try it again.
-      releaseTriggerRun(home, plan.handle);
-      throw error;
-    }
+    const { code, result } = await (deps.spawnRun ?? missingSpawn)({ spec, home, cwd: definition.workspace, triggerLease });
     // Consumed only once the Host has actually run: a failure before that leaves
     // the event pending rather than dropping it.
     if (chosen !== undefined) consumeEvent(home, definition.id, chosen.eventId);
@@ -424,16 +548,11 @@ export async function runTriggerCli(argv, deps = {}) {
       rounds: result?.rounds ?? null,
       eventId,
       endedAt: Date.now(),
+      cwd: definition.workspace,
+      source: chosen?.source ?? definition.source.kind,
+      ...(jobId ? { jobId } : {}),
     });
     out(`${definition.id} ${formatRun(record)}${record.sessionId === null ? '' : ` · ${record.sessionId}`}`);
-    return record.exitCode;
-  } catch (error) {
-    err(error?.message ?? String(error));
-    return 1;
-  }
-}
-
-/** The launcher and the source driver both must inject a spawn. */
-function missingSpawn() {
-  throw new Error('this build has no way to start a run: inject spawnRun');
+    return { code: record.exitCode, record };
+  } finally { releaseTriggerRun(home, plan.handle); }
 }