@relayflows/sdk 2.0.15 → 2.0.17

package/src/cli/cloud-schedule.ts

@@ -0,0 +1,135 @@
+import { CloudFlowError } from '../cloud-http.js';
+import { listCloudSchedules, scheduleInCloud, unscheduleInCloud, type CloudSchedule } from '../cloud-schedule.js';
+import { DirectInputError, isAuthoredFlowPath, parseDirectInput } from '../direct-input.js';
+import { snapshotJsonValue, type JsonValue } from '../json-value.js';
+import type { CliIo } from '../cli.js';
+
+export interface CloudScheduleArgs {
+  command: 'schedule';
+  value: string;
+  cron: string | undefined;
+  every: string | undefined;
+  tz: string | undefined;
+  input: string | undefined;
+  name: string | undefined;
+  json: boolean;
+}
+
+/**
+ * `flows schedule <flow.yaml|flow.ts> [--cron "<expr>" | --every <n><s|m|h|d>]
+ *   [--tz <IANA>] [--input <json|file>] [--name <n>] [--json]`
+ *
+ * With neither `--cron` nor `--every`, the flow's own `schedule.*` handler
+ * supplies the cron, so a declared schedule and its hosted registration
+ * cannot drift.
+ */
+export function parseCloudScheduleArgs(args: readonly string[]): CloudScheduleArgs | undefined {
+  let value: string | undefined;
+  const flags: Record<'cron' | 'every' | 'tz' | 'input' | 'name', string | undefined> = {
+    cron: undefined, every: undefined, tz: undefined, input: undefined, name: undefined,
+  };
+  let json = false;
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]!;
+    if (arg === '--json') {
+      if (json) return undefined;
+      json = true;
+      continue;
+    }
+    if (arg === '--cron' || arg === '--every' || arg === '--tz' || arg === '--input' || arg === '--name') {
+      const key = arg.slice(2) as keyof typeof flags;
+      const next = args[i + 1];
+      // A cron expression legitimately starts with `*`; only a flag-shaped value is refused.
+      if (flags[key] !== undefined || next === undefined || next.startsWith('--')) return undefined;
+      flags[key] = next;
+      i += 1;
+      continue;
+    }
+    if (arg.startsWith('-') || value !== undefined) return undefined;
+    value = arg;
+  }
+  if (value === undefined) return undefined;
+  if (flags.cron !== undefined && flags.every !== undefined) return undefined;
+  if (flags.input !== undefined && !isAuthoredFlowPath(value)) return undefined;
+  return { command: 'schedule', value, ...flags, json };
+}
+
+function describe(schedule: CloudSchedule): string {
+  const last = schedule.lastTriggeredAt === undefined ? ''
+    : ` last ${schedule.lastTriggeredAt}${schedule.lastTriggerStatus === undefined ? '' : ` (${schedule.lastTriggerStatus})`}`;
+  return `${schedule.id} ${schedule.status} ${JSON.stringify(schedule.name)} cron "${schedule.cronExpression}" tz ${schedule.timezone}${last}`;
+}
+
+export async function runCloudScheduleCli(args: CloudScheduleArgs, io: CliIo): Promise<0 | 1 | 2> {
+  try {
+    let input: JsonValue | undefined;
+    let inputPresent = false;
+    if (isAuthoredFlowPath(args.value)) {
+      try {
+        input = snapshotJsonValue(parseDirectInput(args.input), 'Cloud authored input');
+        inputPresent = true;
+      } catch (error) {
+        if (error instanceof DirectInputError) throw new CloudFlowError('invalid_input', error.message);
+        throw error;
+      }
+    }
+    const schedule = await scheduleInCloud({
+      flow: { path: args.value },
+      ...(args.cron === undefined ? {} : { cron: args.cron }),
+      ...(args.every === undefined ? {} : { every: args.every }),
+      ...(args.tz === undefined ? {} : { tz: args.tz }),
+      ...(args.name === undefined ? {} : { name: args.name }),
+      ...(inputPresent ? { input } : {}),
+    });
+    if (args.json) {
+      io.stdout(JSON.stringify({ ok: true, ...schedule }));
+      return 0;
+    }
+    io.stdout(`SCHEDULED ${describe(schedule)}`);
+    io.stdout('Each fire submits this exact source through the same admission as flows run --cloud; list with: flows schedules');
+    return 0;
+  } catch (error) {
+    return reportFailure(error, args.json, io);
+  }
+}
+
+export async function runCloudSchedulesCli({ json }: { json: boolean }, io: CliIo): Promise<0 | 1 | 2> {
+  try {
+    const schedules = await listCloudSchedules();
+    if (json) {
+      io.stdout(JSON.stringify({ ok: true, schedules }));
+      return 0;
+    }
+    if (schedules.length === 0) io.stdout('No workflow schedules in this workspace.');
+    for (const schedule of schedules) io.stdout(describe(schedule));
+    return 0;
+  } catch (error) {
+    return reportFailure(error, json, io);
+  }
+}
+
+export async function runCloudUnscheduleCli(
+  { scheduleId, json }: { scheduleId: string; json: boolean }, io: CliIo,
+): Promise<0 | 1 | 2> {
+  try {
+    await unscheduleInCloud(scheduleId);
+    io.stdout(json ? JSON.stringify({ ok: true, scheduleId, deleted: true }) : `UNSCHEDULED ${scheduleId}`);
+    return 0;
+  } catch (error) {
+    return reportFailure(error, json, io);
+  }
+}
+
+function reportFailure(error: unknown, json: boolean, io: CliIo): 1 | 2 {
+  const code = error instanceof CloudFlowError ? error.code : 'cloud_schedule_failed';
+  let message = error instanceof Error ? error.message : 'Cloud schedule failed.';
+  // The schedule routes take a browser session or a `cli:auth` token.
+  if (error instanceof CloudFlowError && error.status === 403) {
+    message += ' Scheduling needs an interactive `cli:auth` credential: run `agent-relay cloud login`.';
+  }
+  if (json) io.stdout(JSON.stringify({ ok: false, code, message }));
+  else io.stderr(`${code}: ${message}`);
+  return error instanceof CloudFlowError
+    && (['configuration', 'unsupported_source', 'invalid_input'].includes(error.code) || error.status === 403 || error.status === 401)
+    ? 2 : 1;
+}

package/src/cli/cloud-sync.ts

@@ -0,0 +1,37 @@
+import { CloudFlowError } from '../cloud-http.js';
+import { applyCloudPatch, downloadCloudPatch, patchedPaths } from '../cloud-sync.js';
+import type { CliIo } from '../cli.js';
+
+/**
+ * `flows sync <run-id>`: fetch the diff a hosted run left in its synced tree
+ * and apply it here. The patch is the sandbox's own `git diff` against the
+ * uploaded baseline, so applying it reproduces exactly what the run's steps
+ * wrote — no re-execution, no re-upload.
+ */
+export async function runCloudSyncCli(
+  { runId, json, root }: { runId: string; json: boolean; root: string },
+  io: CliIo,
+): Promise<0 | 1 | 2> {
+  try {
+    const { patch, hasChanges } = await downloadCloudPatch(runId, {});
+    if (!hasChanges || !patch.trim()) {
+      if (json) io.stdout(JSON.stringify({ ok: true, runId, hasChanges: false, applied: false }));
+      else io.stdout(`NO CHANGES ${runId}`);
+      return 0;
+    }
+    applyCloudPatch(root, patch);
+    const files = patchedPaths(patch);
+    if (json) io.stdout(JSON.stringify({ ok: true, runId, hasChanges: true, applied: true, files }));
+    else {
+      io.stdout(`APPLIED ${runId}: ${files.length} file${files.length === 1 ? '' : 's'}${files.length ? `\n  ${files.join('\n  ')}` : ''}`);
+      io.stdout('Applied to the working tree, uncommitted: review with git diff before keeping it.');
+    }
+    return 0;
+  } catch (error) {
+    const code = error instanceof CloudFlowError ? error.code : 'cloud_sync_failed';
+    const message = error instanceof Error ? error.message : 'Cloud sync failed.';
+    if (json) io.stdout(JSON.stringify({ ok: false, code, message, runId }));
+    else io.stderr(`${code}: ${message} (run ${runId})`);
+    return error instanceof CloudFlowError && ['configuration', 'sync_unsupported', 'patch_conflict'].includes(error.code) ? 2 : 1;
+  }
+}

package/src/cli/direct-run.ts

@@ -172,7 +172,7 @@ export async function runDirectFlow(
     // diagnostic carried up from `classifyOutcome` already names the step, its
     // exit code and its output tail; this branch is what lets it reach the
     // terminal. `resumeFlow` takes the same branch, through the same helper.
-    if (error instanceof AuthoredFlowExecutionError && error.code === 'step_failed') {
+    if (error instanceof AuthoredFlowExecutionError && (error.code === 'step_failed' || error.code === 'gate_failed')) {
       return authoredStepFailure('run', base, socketPath, error);
     }
     const runId = error instanceof AuthoredFlowExecutionError ? error.runId : undefined;

package/src/cli/run.ts

@@ -37,7 +37,7 @@ export interface ParkedStep {
 }
 
 export interface RunDiagnostic extends StepFailedDetails {
-  severity: 'refusal' | 'failure' | 'parked' | 'warning';
+  severity: 'refusal' | 'failure' | 'parked' | 'warning' | 'declined';
   kind: RunFailureKind | RunWarningKind | RunCompletionReason;
   message: string;
 }
@@ -223,7 +223,7 @@ export async function resumeFlow(
     // leaving it on `protocolFailure` meant `flows run` printed the evidence
     // while `flows resume` still printed `protocol_error` and
     // `RUN <id> unknown` for the identical failure.
-    if (error instanceof AuthoredFlowExecutionError && error.code === 'step_failed') {
+    if (error instanceof AuthoredFlowExecutionError && (error.code === 'step_failed' || error.code === 'gate_failed')) {
       return authoredStepFailure('resume', base, socketPath, error, runId);
     }
     if (!(error instanceof JournalProtocolError) || error.code !== 'run_not_found') {
@@ -287,10 +287,12 @@ export function authoredStepFailure(
       completionReason: 'step_failed',
       diagnostics: [...base.diagnostics, {
         severity: 'failure',
-        kind: 'step_failed',
+        // A predicate gate that judged false is a run failure with its own
+        // name, so the report says which kind of check the body did not pass.
+        kind: error.code === 'gate_failed' ? 'gate_failed' : 'step_failed',
         // The `step_failed: ` prefix `AuthoredFlowExecutionError` adds is
         // redundant once the diagnostic is labelled `[step_failed]`.
-        message: error.message.replace(/^step_failed: /, ''),
+        message: error.message.replace(/^(?:step_failed|gate_failed): /, ''),
       }],
     },
   };
@@ -328,6 +330,17 @@ export function authoredCompletion(
         exitCode: 0,
         report: { ...common, ok: true, status: 'completed', completionReason: 'success' },
       };
+    case 'declined':
+      return {
+        exitCode: 0,
+        report: {
+          ...common, ok: true, status: 'completed', completionReason: 'success',
+          diagnostics: [...base.diagnostics, {
+            severity: 'declined', kind: 'run_declined',
+            message: 'Flow deliberately chose not to act on this input.',
+          }],
+        },
+      };
     case 'needs_human':
       return {
         exitCode: 3,
@@ -358,7 +371,7 @@ export function authoredCompletion(
         },
       };
   }
-  // Exhaustive by construction. A fourth lowered completion has to choose its
+  // Exhaustive by construction. A new lowered completion has to choose its
   // own exit code and wording here; it must not inherit "its own checks did not
   // pass", which would state something the body never declared. Letting an
   // unlisted reason fall through to the failure branch is how a reporting-side

package/src/cli.ts

@@ -24,6 +24,9 @@ import { runDirectFlow } from './cli/direct-run.js';
 import { parseReplayArgs, replayJournal, type ReplayArgs } from './cli/replay.js';
 import { checkTypeScriptFlow } from './cli/check-typescript.js';
 import { runCloudCli } from './cli/cloud-run.js';
+import { runCloudSyncCli } from './cli/cloud-sync.js';
+import { parseCloudDeployArgs, runCloudDeployCli, runCloudDeploymentsCli, runCloudUndeployCli, type CloudDeployArgs } from './cli/cloud-deploy.js';
+import { parseCloudScheduleArgs, runCloudScheduleCli, runCloudSchedulesCli, runCloudUnscheduleCli, type CloudScheduleArgs } from './cli/cloud-schedule.js';
 import { isAuthoredFlowPath } from './direct-input.js';
 import { parseDeployArgs, runDeploy, type DeployArgs } from './cli/deploy.js';
 import { parseDigestReference } from './bundle-transport.js';
@@ -51,7 +54,14 @@ type ParsedArgs =
   | BuildArgs
   | DeployArgs
   | { command: 'serve-webhook'; dataDir: string; port: number; admitted?: readonly string[] }
-  | { command: 'cloud-run'; value: string; json: boolean; wait: boolean }
+  | { command: 'cloud-run'; value: string; json: boolean; wait: boolean; input: string | undefined; syncCode: boolean }
+  | { command: 'sync'; runId: string; json: boolean; root: string }
+  | CloudDeployArgs
+  | { command: 'deployments'; json: boolean }
+  | { command: 'undeploy'; agentId: string; json: boolean }
+  | CloudScheduleArgs
+  | { command: 'schedules'; json: boolean }
+  | { command: 'unschedule'; scheduleId: string; json: boolean }
   | { command: 'check'; json: boolean; watch: boolean; value: string }
   | { command: 'run'; bucket: string | undefined; reuseFromRunId: string | undefined; localAgent: boolean; dataDir: string; input: string | undefined; json: boolean; spawn: boolean; noObserverLink: boolean; allowHumanInfluenced: boolean; value: string }
   | { command: 'resume'; localAgent: boolean; dataDir: string; json: boolean; spawn: boolean; noObserverLink: boolean; allowHumanInfluenced: boolean; value: string }
@@ -66,12 +76,20 @@ const USAGE = [
   'flows add <helper-name|@flows/helper-name>',
   'flows build [--out <dir>] <flow.yaml|flow.ts>',
   'flows build --verify <bundle-dir>',
+  'flows deploy <flow.ts> --repo <owner/name> --on <provider>[:key=value,...] [--on ...] --approver <handle> [--agents claude[,codex]] [--name <name>] [--draft] [--json]',
+  'flows deployments [--json]',
+  'flows undeploy [--json] <deployment-id>',
+  'flows schedule <flow.yaml|flow.ts> [--cron "<expr>" | --every <n><s|m|h|d>] [--tz <IANA>] [--input <inline-json-or-file>] [--name <name>] [--json]',
+  'flows schedules [--json]',
+  'flows unschedule [--json] <schedule-id>',
   'flows deploy <flow>@sha256:<digest> --to <file-bucket-uri>',
   'flows run <flow>@sha256:<digest> [--bucket <file-bucket-uri>] [--data-dir <dir>] [--json]',
   'flows check [--watch] [--json] <flow.ts|flow.yaml|spec.json>',
   'flows serve-webhook --data-dir <dir> --port <p> [--allow <name>[,<name>]]',
   'flows run [--json] [--no-spawn] [--no-observer-link] [--data-dir <dir>] [--local-agent] [--reuse-from <run-id>] <flow.yaml|spec.json>',
-  'flows run --cloud [--json] [--wait] <flow.yaml|spec.json>',
+  'flows run --cloud [--json] [--wait] [--sync-code] <flow.yaml|spec.json>',
+  'flows run --cloud [--json] [--wait] [--sync-code] <flow.ts> --input <inline-json-or-file>',
+  'flows sync [--json] [--dir <path>] <run-id>',
   'flows run [--json] [--no-spawn] [--no-observer-link] [--data-dir <dir>] [--local-agent] <flow.ts> --input <inline-json-or-file>',
   'flows tick start --schedule-id <id> --interval-ms <ms> [--epoch-ms <ms>] [--max-catch-up <n>] [--poll-interval-ms <ms>] [--data-dir <dir>] <spec.json>',
   'flows resume [--allow-human-influenced] [--json] [--no-spawn] [--no-observer-link] [--data-dir <dir>] [--local-agent] <run-id>',
@@ -116,6 +134,13 @@ export async function runCli(
   if (parsed.command === 'serve-webhook') return runServeWebhook(parsed, io);
 
   if (parsed.command === 'cloud-run') return runCloudCli(parsed, io);
+  if (parsed.command === 'sync') return runCloudSyncCli(parsed, io);
+  if (parsed.command === 'cloud-deploy') return runCloudDeployCli(parsed, io);
+  if (parsed.command === 'deployments') return runCloudDeploymentsCli(parsed, io);
+  if (parsed.command === 'undeploy') return runCloudUndeployCli(parsed, io);
+  if (parsed.command === 'schedule') return runCloudScheduleCli(parsed, io);
+  if (parsed.command === 'schedules') return runCloudSchedulesCli(parsed, io);
+  if (parsed.command === 'unschedule') return runCloudUnscheduleCli(parsed, io);
   if (parsed.command === 'replay') return replayJournal(parsed, io);
   if (parsed.command === 'build') return runBuild(parsed, io);
   if (parsed.command === 'deploy') return runDeploy(parsed, io);
@@ -251,6 +276,7 @@ async function checkAuthoredFlowComposed(path: string): Promise<{ report: CheckR
   return {
     report: {
       ...mcp.report,
+      ...(triggers?.report.schedules === undefined ? {} : { schedules: triggers.report.schedules }),
       diagnostics: [...helper.report.diagnostics, ...mcp.report.diagnostics, ...triggerDiagnostics],
       ok: helper.report.ok && mcp.report.ok && triggerOk,
     },
@@ -419,17 +445,47 @@ function parseArgs(args: readonly string[]): ParsedArgs | undefined {
   if (command === 'add') return args.length === 2 ? { command: 'add', value: args[1]! } : undefined;
   if (command === 'replay') return parseReplayArgs(args.slice(1));
   if (command === 'build') return parseBuildArgs(args.slice(1));
-  if (command === 'deploy') return parseDeployArgs(args.slice(1));
+  if (command === 'deploy') {
+    // The positional decides the form: an authored source deploys a hosted
+    // listener; a digest reference copies a sealed bundle into a file bucket.
+    const source = args.slice(1).find(a => !a.startsWith('-') && isAuthoredFlowPath(a));
+    return source !== undefined ? parseCloudDeployArgs(args.slice(1)) : parseDeployArgs(args.slice(1));
+  }
+  if (command === 'schedule') return parseCloudScheduleArgs(args.slice(1));
+  if (command === 'schedules') {
+    const rest = args.slice(1);
+    if (rest.length > 1 || (rest.length === 1 && rest[0] !== '--json')) return undefined;
+    return { command: 'schedules', json: rest.length === 1 };
+  }
+  if (command === 'unschedule') {
+    const rest = args.slice(1).filter(a => a !== '--json');
+    const json = args.length - 1 - rest.length;
+    if (json > 1 || rest.length !== 1 || rest[0]!.startsWith('-')) return undefined;
+    return { command: 'unschedule', scheduleId: rest[0]!, json: json === 1 };
+  }
+  if (command === 'undeploy') {
+    const rest = args.slice(1).filter(a => a !== '--json');
+    const json = args.length - 1 - rest.length;
+    if (json > 1 || rest.length !== 1 || rest[0]!.startsWith('-')) return undefined;
+    return { command: 'undeploy', agentId: rest[0]!, json: json === 1 };
+  }
+  if (command === 'deployments') {
+    const rest = args.slice(1);
+    if (rest.length > 1 || (rest.length === 1 && rest[0] !== '--json')) return undefined;
+    return { command: 'deployments', json: rest.length === 1 };
+  }
   if (command === 'serve-webhook') return parseWebhookArgs(args.slice(1));
   if (command === 'hn-monitor') return parseHnMonitorArgs(args.slice(1));
   if (command === 'tick') return parseTickArgs(args.slice(1));
   if (command === 'observer') return parseObserverArgs(args.slice(1));
+  if (command === 'sync') return parseSyncArgs(args.slice(1));
   if (command !== 'check' && command !== 'run' && command !== 'resume') return undefined;
 
   let json = false;
   let watch = false;
   let cloud = false;
   let wait = false;
+  let syncCode = false;
   let localAgent = false;
   let allowHumanInfluenced = false;
   let dataDir = DEFAULT_DATA_DIR;
@@ -443,10 +499,11 @@ function parseArgs(args: readonly string[]): ParsedArgs | undefined {
   const positionals: string[] = [];
   for (let index = 1; index < args.length; index += 1) {
     const argument = args[index]!;
-    if (argument === '--cloud' || argument === '--wait') {
-      if (command !== 'run' || (argument === '--cloud' ? cloud : wait)) return undefined;
+    if (argument === '--cloud' || argument === '--wait' || argument === '--sync-code') {
+      if (command !== 'run' || (argument === '--cloud' ? cloud : argument === '--wait' ? wait : syncCode)) return undefined;
       if (argument === '--cloud') cloud = true;
-      else wait = true;
+      else if (argument === '--wait') wait = true;
+      else syncCode = true;
       continue;
     }
     if (argument === '--allow-human-influenced') {
@@ -520,13 +577,15 @@ function parseArgs(args: readonly string[]): ParsedArgs | undefined {
   if (bucket !== undefined && (cloud || !parseDigestReference(positionals[0]!))) return undefined;
   if (cloud) {
     // `--cloud` submits the spec to Cloud, so every flag that only describes a
-    // local run -- an inline input, a data dir, a suppressed daemon, a local
-    // agent, a local observer-link opt-out -- describes nothing there and is
-    // refused rather than ignored.
-    if (allowHumanInfluenced || sawInput || sawDataDir || !spawn || localAgent || noObserverLink || reuseFromRunId !== undefined) return undefined;
-    return { command: 'cloud-run', value: positionals[0]!, json, wait };
+    // local run -- a data dir, a suppressed daemon, a local agent, a local
+    // observer-link opt-out -- describes nothing there and is refused rather
+    // than ignored. `--input` is the authored body's argument and travels with
+    // the source, so it is accepted exactly where a local run accepts it.
+    if (allowHumanInfluenced || sawDataDir || !spawn || localAgent || noObserverLink || reuseFromRunId !== undefined) return undefined;
+    if (sawInput && !isAuthoredFlowPath(positionals[0]!)) return undefined;
+    return { command: 'cloud-run', value: positionals[0]!, json, wait, input, syncCode };
   }
-  if (wait) return undefined;
+  if (wait || syncCode) return undefined;
   if (reuseFromRunId !== undefined && isAuthoredFlowPath(positionals[0]!)) return undefined;
 
   if (command === 'run' && input !== undefined && !isAuthoredFlowPath(positionals[0]!)) return undefined;
@@ -579,6 +638,32 @@ function parseHnMonitorArgs(rest: readonly string[]): ParsedArgs | undefined {
  * directory at all -- the mint is a pure Relaycast API round-trip. No
  * positional argument, no other flags.
  */
+/** `flows sync [--json] [--dir <path>] <run-id>`: apply a hosted run's patch to a local tree. */
+function parseSyncArgs(args: readonly string[]): ParsedArgs | undefined {
+  let json = false;
+  let root: string | undefined;
+  const positionals: string[] = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const argument = args[index]!;
+    if (argument === '--json') {
+      if (json) return undefined;
+      json = true;
+      continue;
+    }
+    if (argument === '--dir') {
+      const value = args[index + 1];
+      if (root !== undefined || value === undefined || value.startsWith('-')) return undefined;
+      root = value;
+      index += 1;
+      continue;
+    }
+    if (argument.startsWith('-')) return undefined;
+    positionals.push(argument);
+  }
+  if (positionals.length !== 1) return undefined;
+  return { command: 'sync', runId: positionals[0]!, json, root: root ?? '.' };
+}
+
 function parseObserverArgs(rest: readonly string[]): ParsedArgs | undefined {
   let dataDir = DEFAULT_DATA_DIR;
   let sawDataDir = false;
@@ -689,6 +774,15 @@ function emitCheckReport(report: CheckReport, json: boolean, io: CliIo): void {
     const vacuous = gate.acceptsAnyOutput === true ? ' [json_schema accepts any output]' : '';
     io.stdout(`GATE step "${gate.stepId}" ${gate.checks.join('+')} from data (kernel, journal-replayable)${vacuous}`);
   }
+  for (const schedule of report.schedules ?? []) {
+    const declared = schedule.cron !== undefined
+      ? `cron "${schedule.cron}"${schedule.tz === undefined ? '' : ` tz ${schedule.tz}`}`
+      : `every ${schedule.intervalMs}ms`;
+    const local = schedule.localUnsupported !== undefined
+      ? `Cloud only: ${schedule.localUnsupported}`
+      : `local: flows tick start --schedule-id ${schedule.scheduleId} --interval-ms ${schedule.intervalMs} --epoch-ms ${schedule.epochMs}`;
+    io.stdout(`SCHEDULE handler ${schedule.handler} ${declared} -> flows.tick schedule_id ${schedule.scheduleId} [${local}]`);
+  }
   for (const resolution of report.resolutions) {
     const config = resolution.source === 'project' && report.projectConfigPath !== undefined
       ? ` (${report.projectConfigPath})`
@@ -750,6 +844,7 @@ function diagnosticLabel(severity: string): string {
     case 'warning': return 'WARNING';
     case 'failure': return 'FAILED';
     case 'parked': return 'PARKED';
+    case 'declined': return 'DECLINED';
     default: return 'REFUSED';
   }
 }