shraga 0.1.94 → 0.1.96

package/src/client/components/schedules/ScheduleEditor.tsx

@@ -5,8 +5,11 @@ import { Button } from '../ui/button';
 import { Input } from '../ui/input';
 import { Textarea } from '../ui/textarea';
 import { AutocompleteTextarea } from '../AutocompleteTextarea';
+import { useEngines } from '@/hooks/useEngines';
+import { readRuntimeDirective, writeRuntimeDirective } from '@/lib/prompt-directives';
 
 interface Props {
+  getToken: () => Promise<string | null>;
   initial?: Schedule;
   onSave: (s: Partial<Schedule>) => Promise<void>;
   onCancel: () => void;
@@ -63,7 +66,65 @@ function MatchEditor({ match, onChange }: { match: Record<string, string>; onCha
   );
 }
 
-export function ScheduleEditor({ initial, onSave, onCancel, skills = [], workspaceFiles = [] }: Props) {
+/** Engine + model picker for a prompt task. There is no stored field behind it: the leading
+ *  `[engine:…,model:…]` directive in the prompt IS the selection, so this reads that directive and
+ *  rewrites it in place. A directive typed by hand therefore shows up here, and a pin can never
+ *  drift out of sync with the prompt the way a shadow `task.model` did. */
+function RuntimePicker({ prompt, onChange, getToken }: { prompt: string; onChange: (p: string) => void; getToken: () => Promise<string | null> }) {
+  const { engines } = useEngines(getToken);
+  // Until the registry has loaded we cannot tell a bare model token from prose, so a rewrite could
+  // leave a stale duplicate pin behind. Read-only until then.
+  const ready = engines.length > 0;
+  const sel = useMemo(() => readRuntimeDirective(prompt), [prompt, ready]);
+  // Narrow the model list only to an engine the directive actually NAMES. An engine merely implied
+  // by the model would otherwise trap a model-only pin — 11 of the 15 live schedules — inside that
+  // engine's list, with no way to reach another engine's models.
+  const engineInfo = sel.engineExplicit ? engines.find((e) => e.name === sel.engine) : undefined;
+  const options = engineInfo
+    ? [{ engine: engineInfo.name, models: engineInfo.models }]
+    : engines.map((e) => ({ engine: e.name, models: e.models }));
+  // A <select> whose value matches no option silently renders the FIRST option while the state says
+  // otherwise — so a hand-typed directive naming something this engine doesn't list would be shown
+  // as a different selection than the one that will actually run. Surface it instead of lying.
+  const listed = (v: string | undefined, all: string[]) => !v || all.includes(v);
+  const modelListed = listed(sel.model, options.flatMap((o) => o.models.map((m) => m.value)));
+  const engineListed = listed(sel.engine, engines.map((e) => e.name));
+  // Only an engine the directive NAMES is carried forward. An inferred one belongs to the model it
+  // was inferred from: re-emitting it while the user picks another engine's model would silently
+  // pin a pairing nobody chose (agentx running a claude-code model).
+  const set = (next: { engine?: string; model?: string }) =>
+    onChange(writeRuntimeDirective(prompt, { engine: sel.engineExplicit ? sel.engine : undefined, model: sel.model, ...next }));
+  const selectClass = 'h-8 rounded-md border border-input bg-background px-2 text-xs';
+
+  return (
+    <div className="flex flex-wrap items-center gap-2">
+      <label className="text-xs text-muted-foreground">Runtime</label>
+      <select
+        className={selectClass}
+        disabled={!ready}
+        value={sel.engine ?? ''}
+        // Switching engine drops the model pin: the old model belongs to the old engine's list.
+        onChange={(e) => set({ engine: e.target.value || undefined, model: undefined })}
+      >
+        <option value="">Default engine (agent config)</option>
+        {!engineListed && <option value={sel.engine}>{sel.engine} — not registered on this server</option>}
+        {engines.map((e) => <option key={e.name} value={e.name}>{e.name}</option>)}
+      </select>
+      <select className={selectClass} disabled={!ready} value={sel.model ?? ''} onChange={(e) => set({ model: e.target.value || undefined })}>
+        <option value="">Default model (agent config)</option>
+        {!modelListed && <option value={sel.model}>{sel.model} — not offered by this engine</option>}
+        {options.map(({ engine, models }) => (
+          <optgroup key={engine} label={engine}>
+            {models.filter((m) => m.value).map((m) => <option key={`${engine}:${m.value}`} value={m.value}>{m.label || m.value}</option>)}
+          </optgroup>
+        ))}
+      </select>
+      {!ready && <span className="text-[10px] text-muted-foreground">loading engines…</span>}
+    </div>
+  );
+}
+
+export function ScheduleEditor({ getToken, initial, onSave, onCancel, skills = [], workspaceFiles = [] }: Props) {
   const tz = useMemo(() => Intl.DateTimeFormat().resolvedOptions().timeZone, []);
   const [name, setName] = useState(initial?.name ?? 'New schedule');
   const [enabled, setEnabled] = useState(initial?.enabled ?? true);
@@ -225,6 +286,8 @@ export function ScheduleEditor({ initial, onSave, onCancel, skills = [], workspa
           ))}
         </div>
         {task.kind === 'prompt' ? (
+          <>
+          <RuntimePicker prompt={task.prompt} getToken={getToken} onChange={(prompt) => setTask({ ...task, prompt })} />
           <AutocompleteTextarea
             rows={5}
             value={task.prompt}
@@ -235,6 +298,7 @@ export function ScheduleEditor({ initial, onSave, onCancel, skills = [], workspa
             autoResize={false}
             className="flex min-h-[80px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-sm shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring"
           />
+          </>
         ) : task.kind === 'bash' ? (
           <Textarea
             rows={3}

package/src/client/hooks/useEngines.ts

@@ -0,0 +1,52 @@
+import { useEffect, useState } from 'react';
+import { setModelResolver } from '../../server/directives.ts';
+import { makeModelResolver } from '../../server/engine/model-resolver.ts';
+
+export interface EngineModel {
+  value: string;
+  label: string;
+  provider?: string;
+}
+
+export interface EngineInfo {
+  name: string;
+  models: EngineModel[];
+}
+
+/**
+ * The live engine registry (`GET /api/engines`) — so a picker can never offer an engine or model
+ * this server doesn't actually have.
+ *
+ * It also installs the model resolver the directive parser uses, seeded from the same response.
+ * Without it the client reads `[composer-2.5]` as prose while the server reads it as a model on
+ * the agentx engine — and an editor that disagrees with the parser corrupts what it rewrites.
+ */
+// One process-wide registry cache behind one resolver installed at import time. Per-hook install/
+// teardown would let one component's unmount clear the resolver another is still parsing with.
+let registry: EngineInfo[] = [];
+setModelResolver(makeModelResolver(() => registry));
+
+export function useEngines(getToken: () => Promise<string | null>, enabled = true) {
+  const [engines, setEngines] = useState<EngineInfo[]>(registry);
+  const [multiEngine, setMultiEngine] = useState(false);
+
+  useEffect(() => {
+    if (!enabled) return;
+    let alive = true;
+    getToken().then((token) => {
+      if (!token || !alive) return;
+      fetch('/api/engines', { headers: { Authorization: `Bearer ${token}` } })
+        .then((r) => r.json())
+        .then((data) => {
+          if (!alive) return;
+          registry = data.engines ?? [];
+          setEngines(registry);
+          setMultiEngine(data.multiEngine ?? false);
+        })
+        .catch((e) => console.warn('[engines] load failed', e));
+    });
+    return () => { alive = false; };
+  }, [enabled, getToken]);
+
+  return { engines, multiEngine };
+}

package/src/client/lib/prompt-directives.ts

@@ -0,0 +1,65 @@
+/**
+ * Reading and rewriting the leading `[engine:…,model:…]` runtime directive of a prompt.
+ *
+ * The directive IS the selection — there is no separate stored field to shadow it — so the
+ * schedule editor's runtime picker is just a view onto this text. Both halves reuse the server's
+ * own parser (`src/server/directives.ts`), never a second one: a divergent client opinion would
+ * either strip a token the server still reads or keep one it doesn't.
+ */
+import { parseDirectives, splitDirectiveGroups, resolveModelAlias } from '../../server/directives.ts';
+
+export interface RuntimeSelection {
+  engine?: string;
+  model?: string;
+}
+
+export interface ReadSelection extends RuntimeSelection {
+  /** Was the engine WRITTEN as `engine:…`, or merely implied by an engine-owned model token?
+   *  An implied engine must not be treated as a choice — narrowing a model picker to it would trap
+   *  a model-only directive inside one engine's list, with no way to pick another engine's model. */
+  engineExplicit: boolean;
+}
+
+/** What the server will actually run this prompt on, as written. Includes a directive the user
+ *  typed by hand, and an engine implied by a bare engine-owned model token (`[composer-2.5]`). */
+export function readRuntimeDirective(text: string): ReadSelection {
+  const { directives } = parseDirectives(text);
+  const engineExplicit = splitDirectiveGroups(text, { strict: true }).groups.some((g) =>
+    g.split(',').some((t) => /^\s*engine\s*:/i.test(t)));
+  return { engine: directives.engine, model: directives.model, engineExplicit };
+}
+
+const RUNTIME_KEY_RE = /^(engine|model)\s*:/i;
+
+/**
+ * Replaces the runtime selection in place, preserving every other directive (turns, thinking,
+ * effort) and the prompt body verbatim.
+ *
+ * Strict group scanning: unlike the server parser — which by contract consumes its first bracket
+ * group even when it is nonsense — this only touches groups that actually READ as directives, so a
+ * prompt whose body legitimately opens with `[WARN] …` is left alone and gets the pin prepended.
+ */
+export function writeRuntimeDirective(text: string, sel: RuntimeSelection): string {
+  const { groups, body } = splitDirectiveGroups(text, { strict: true });
+  const kept: string[] = [];
+  // Mirrors the parser's positional rule: only the FIRST positional token can be a model.
+  let seenPositional = false;
+  for (const group of groups) {
+    for (const raw of group.split(',').map((t) => t.trim()).filter(Boolean)) {
+      if (RUNTIME_KEY_RE.test(raw)) continue; // the pin being replaced
+      if (raw.includes(':')) { kept.push(raw); continue; }
+      const isBareModel = !seenPositional && !!resolveModelAlias(raw);
+      seenPositional = true;
+      if (!isBareModel) kept.push(raw); // `120` (turns), `think` — not ours to touch
+    }
+  }
+  // An engine the chosen model already implies is not written: `[model:cursor/composer-2.5]` and
+  // `[engine:agentx,model:cursor/composer-2.5]` mean the same thing to the parser, and emitting the
+  // longer one would stamp a pin the user never chose onto every schedule that carries a model-only
+  // directive (11 of the 15 live ones) the moment the picker is touched.
+  const impliedEngine = sel.model ? resolveModelAlias(sel.model)?.engine : undefined;
+  const engine = sel.engine && sel.engine !== impliedEngine ? sel.engine : undefined;
+  const pins = [engine && `engine:${engine}`, sel.model && `model:${sel.model}`].filter(Boolean) as string[];
+  const tokens = [...pins, ...kept];
+  return tokens.length ? `[${tokens.join(',')}] ${body}` : body;
+}

package/src/client/lib/schedule-types.ts

@@ -5,8 +5,8 @@ export type Trigger =
   | { kind: 'event'; source: string; match?: Record<string, string> };
 
 export type Task =
-  | { kind: 'prompt'; prompt: string; model?: string; engine?: string }
-  | { kind: 'bash'; command: string; model?: string; engine?: string }
+  | { kind: 'prompt'; prompt: string }
+  | { kind: 'bash'; command: string }
   | { kind: 'job'; command: string };
 
 export type Scope = 'system' | 'user';

package/src/server/directives.ts

@@ -45,22 +45,27 @@ export type ModelResolver = (token: string) => { model: string; engine?: string
 let modelResolver: ModelResolver | null = null;
 export function setModelResolver(fn: ModelResolver | null): void { modelResolver = fn; }
 
-/** Alias table first (canonical shorthands win), then the engine registry. */
+/** Alias table first (canonical shorthands win), then the engine registry. Exported because the
+ *  client's directive editor needs the SAME verdict on "is this bare token a model?" as the parser —
+ *  a second opinion there would strip a token the server still reads, or keep one it doesn't. */
+export function resolveModelAlias(token: string): { model: string; engine?: string } | null {
+  const v = token.trim().toLowerCase();
+  if (MODEL_ALIASES[v]) return { model: MODEL_ALIASES[v] };
+  return modelResolver?.(v) ?? null;
+}
+
 function resolveModelToken(d: Directives, val: string): boolean {
-  if (MODEL_ALIASES[val]) { d.model = MODEL_ALIASES[val]; return true; }
-  const hit = modelResolver?.(val);
-  if (hit) {
-    d.model = hit.model;
-    // An engine-owned model implies its engine — but never override an explicit `[engine:x]`.
-    if (hit.engine && !d.engine) d.engine = hit.engine;
-    return true;
-  }
-  return false;
+  const hit = resolveModelAlias(val);
+  if (!hit) return false;
+  d.model = hit.model;
+  // An engine-owned model implies its engine — but never override an explicit `[engine:x]`.
+  if (hit.engine && !d.engine) d.engine = hit.engine;
+  return true;
 }
 
 /** Does a bracket group look like directives (vs. prompt text that happens to start with `[`)?
  * Every token must be a known key:value or a known positional, else we leave the group alone. */
-function isDirectiveGroup(raw: string): boolean {
+export function isDirectiveGroup(raw: string): boolean {
   const tokens = raw.split(',').map((t) => t.trim()).filter(Boolean);
   if (!tokens.length) return false;
   return tokens.every((t) => {
@@ -71,23 +76,31 @@ function isDirectiveGroup(raw: string): boolean {
   });
 }
 
-export function parseDirectives(text: string): ParsedPrompt {
-  // Consume EVERY consecutive leading [..] group, not just the first. runner.ts prepends
-  // `[model] ` onto prompts that may already open with `[turns:120]`, so a single-group parse
-  // silently dropped the second — a schedule pinned to opus quietly ran on the config default
-  // for three days. Groups that don't parse as directives are left as prompt text.
+/** Splits the leading `[..]` directive groups off a prompt — the single answer to "where do the
+ *  directives end". Consumes EVERY consecutive leading group, not just the first: a prompt may
+ *  legitimately open with `[engine:x,model:y] [turns:120] …`, and a single-group scan silently
+ *  dropped the second (a schedule pinned to opus quietly ran on the config default for three days).
+ *
+ *  `strict` requires every group — the first included — to actually look like directives. The parser
+ *  stays lenient there (long-standing contract: `[unknown] hi` strips the group and warns), but an
+ *  EDITOR rewriting the directive in place must never swallow a prompt whose body legitimately opens
+ *  with bracketed prose. */
+export function splitDirectiveGroups(text: string, opts?: { strict?: boolean }): { groups: string[]; body: string } {
   let rest = text;
   const groups: string[] = [];
   for (;;) {
     const m = rest.match(DIRECTIVE_RE);
     if (!m) break;
     const g = m[1].trim();
-    // The first group is always consumed (long-standing contract: `[unknown] hi` strips and warns).
-    // Later groups must actually look like directives, so prompt text such as `[WARN] …` survives.
-    if (groups.length && g && !isDirectiveGroup(g)) break;
+    if ((groups.length || opts?.strict) && g && !isDirectiveGroup(g)) break;
     groups.push(g);
     rest = m[2];
   }
+  return { groups, body: rest };
+}
+
+export function parseDirectives(text: string): ParsedPrompt {
+  const { groups, body: rest } = splitDirectiveGroups(text);
   if (!groups.length) return { prompt: text, directives: {} };
 
   const raw = groups.filter(Boolean).join(',');

package/src/server/engine/claude-code.ts

@@ -207,7 +207,8 @@ export class ClaudeCodeEngine implements AgentEngine {
   getModels(): EngineModel[] {
     return [
       { value: '', label: `Default (${DEFAULT_MODEL})` },
-      { value: 'claude-fable-5', label: 'Fable 5 — frontier, most capable' },
+      { value: 'claude-fable-5-1', label: 'Fable 5.1 — frontier, most capable' },
+      { value: 'claude-fable-5', label: 'Fable 5' },
       { value: 'claude-opus-5', label: 'Opus 5 — most capable' },
       { value: 'claude-opus-4-8', label: 'Opus 4.8' },
       { value: 'claude-opus-4-7', label: 'Opus 4.7' },

package/src/server/engine/index.ts

@@ -5,6 +5,7 @@ export { ClaudeCodeEngine } from './claude-code.ts';
 import { registerEngine, getEngine, getAvailableEngines, hasEngine } from './registry.ts';
 import { ClaudeCodeEngine } from './claude-code.ts';
 import { setModelResolver } from '../directives.ts';
+import { makeModelResolver } from './model-resolver.ts';
 
 let _initialized = false;
 
@@ -20,25 +21,9 @@ export async function initEngines(): Promise<void> {
   registerEngine(new ClaudeCodeEngine());
 
   // Let `[<model>]` name ANY registered engine's model (e.g. `[composer-2.5]`) and imply its engine.
-  // Resolved lazily on each parse so engines an add-on registers later are covered too.
-  // `[composer-2.5]` must reach the engine's real id (`cursor/composer-2.5`), so an exact match is
-  // tried first, then the bare suffix after the provider prefix — and ONLY when it is unambiguous
-  // across engines, so a name two engines share is never silently routed to whichever came first.
-  setModelResolver((token) => {
-    const t = token.toLowerCase();
-    const hits: { model: string; engine: string }[] = [];
-    for (const name of getAvailableEngines()) {
-      for (const m of getEngine(name).getModels()) {
-        if (!m.value) continue;
-        const v = m.value.toLowerCase();
-        if (v === t) return { model: m.value, engine: name };
-        if (v.slice(v.lastIndexOf('/') + 1) === t) hits.push({ model: m.value, engine: name });
-      }
-    }
-    if (hits.length === 1) return hits[0];
-    if (hits.length > 1) console.warn(`[directives] Ambiguous model "${token}" (${hits.map((h) => `${h.engine}:${h.model}`).join(', ')}) — use the full id`);
-    return null;
-  });
+  // Resolved lazily on each parse so engines an add-on registers later are covered too. The rule
+  // itself is shared with the client's directive editor — see makeModelResolver.
+  setModelResolver(makeModelResolver(() => getAvailableEngines().map((name) => ({ name, models: getEngine(name).getModels() }))));
 
   console.log(`[engine] Available engines: ${getAvailableEngines().join(', ')}`);
 }

package/src/server/engine/model-resolver.ts

@@ -0,0 +1,36 @@
+import type { ModelResolver } from '../directives.ts';
+
+/** Engine → the model ids it advertises. Exactly what `GET /api/engines` serves, so the client
+ *  can build the SAME resolver the server parses with. */
+export interface EngineModels {
+  name: string;
+  models: { value: string }[];
+}
+
+/**
+ * Lets `[<model>]` name ANY registered engine's model (e.g. `[composer-2.5]`) and imply its engine.
+ *
+ * `[composer-2.5]` must reach the engine's real id (`cursor/composer-2.5`), so an exact match is
+ * tried first, then the bare suffix after the provider prefix — and ONLY when it is unambiguous
+ * across engines, so a name two engines share is never silently routed to whichever came first.
+ *
+ * Pure and dependency-free: the server passes a live view of its registry (so engines an add-on
+ * registers later are covered), the client passes what `/api/engines` returned.
+ */
+export function makeModelResolver(engines: () => EngineModels[]): ModelResolver {
+  return (token) => {
+    const t = token.toLowerCase();
+    const hits: { model: string; engine: string }[] = [];
+    for (const { name, models } of engines()) {
+      for (const m of models) {
+        if (!m.value) continue;
+        const v = m.value.toLowerCase();
+        if (v === t) return { model: m.value, engine: name };
+        if (v.slice(v.lastIndexOf('/') + 1) === t) hits.push({ model: m.value, engine: name });
+      }
+    }
+    if (hits.length === 1) return hits[0];
+    if (hits.length > 1) console.warn(`[directives] Ambiguous model "${token}" (${hits.map((h) => `${h.engine}:${h.model}`).join(', ')}) — use the full id`);
+    return null;
+  };
+}

package/src/server/model-aliases.ts

@@ -8,7 +8,8 @@
 
 /** Canonical short aliases → concrete Anthropic model ids. */
 export const MODEL_ALIASES: Record<string, string> = {
-  fable: 'claude-fable-5',
+  fable: 'claude-fable-5-1',
+  'fable-5-1': 'claude-fable-5-1',
   'fable-5': 'claude-fable-5',
   opus: 'claude-opus-5',
   'opus-5': 'claude-opus-5',

package/src/server/modules/service.ts

@@ -11,6 +11,7 @@
  *    Only state.json answers "is the module on".
  *  - Reconcile is idempotent: write-if-changed skills, upserts preserve enabled/runCount/lastRun.
  */
+import { foldLegacyRuntimePin } from '../scheduler/builtins.ts';
 import { mkdirSync, readdirSync, readFileSync, writeFileSync, existsSync, unlinkSync, renameSync, rmSync, copyFileSync, statSync, appendFileSync } from 'node:fs';
 import path from 'node:path';
 import { dataPath, DATA_DIR, PACKAGE_ROOT } from '../paths.ts';
@@ -305,6 +306,9 @@ function applyModule(rec: InstalledModule): void {
       const t = rendered.task as Record<string, unknown>;
       if (k in t && !t[k]) delete t[k];
     }
+    // A runtime knob is now expressed as the prompt's own `[engine:…,model:…]` directive, not as a
+    // shadow field — fold whatever the manifest templated into it.
+    foldLegacyRuntimePin(rendered.task as Record<string, any>);
     const existing = scheduler.getSchedule(id);
     const now = Date.now();
     const schedule: Schedule = {

package/src/server/scheduler/builtins.ts

@@ -56,6 +56,30 @@ const FAILURE_NOTIFIER_PROMPT = [
 const LEGACY_SESSION_LINE = /^.*<deployment URL>\/\?session=<sessionId>(.*)$/gm;
 const SESSION_LINE_FIX = "  *Session:* <the payload's sessionUrl, verbatim — omit this line if absent>";
 
+/**
+ * One source of truth for a prompt run's runtime: the leading `[engine:…,model:…]` directive of the
+ * prompt. `task.model`/`task.engine` were an INVISIBLE second copy — no UI ever showed them, which
+ * is how nine live schedules drifted to a half-pin (`model` set, `engine` not) that nobody could
+ * see or fix. Fold such a pin into the prompt exactly as runner.ts used to synthesize it, so the
+ * run is byte-identical for a `prompt` task and the selection is now editable where the prompt is.
+ * NOT byte-identical for a `promptFile` task: runner.ts treated `task.prompt` as dead text once
+ * `promptFile` was set, and it now survives as the directive-carrying prefix. No live schedule uses
+ * `promptFile`, and dropping the prefix instead would silently lose the pin these lines exist to
+ * preserve — so the prefix is the deliberate choice, not an oversight.
+ *
+ * Applied to schedules loaded from disk AND to a module's freshly rendered task, so a manifest that
+ * still templates a `model` knob keeps working instead of silently losing its pin.
+ * `bash`/`job` tasks have no prompt to hold a directive, so their (unreadable) pin is just dropped.
+ */
+export function foldLegacyRuntimePin(task: Record<string, any>): void {
+  if (task.kind === 'prompt' && (task.model || task.engine)) {
+    const pins = [task.engine && `engine:${task.engine}`, task.model && `model:${task.model}`].filter(Boolean);
+    task.prompt = `[${pins.join(',')}] ${task.prompt ?? ''}`;
+  }
+  delete task.model;
+  delete task.engine;
+}
+
 export function isSystemSchedule(schedule: Schedule): boolean {
   return schedule.scope === 'system';
 }
@@ -86,6 +110,16 @@ export function backfillScope(schedules: Schedule[]): void {
     if (task.kind === 'job' && task.command === 'bun run summarize:conversations') {
       task.command = SUMMARIZER_CMD;
     }
+    // Undo the `engine: 'claude-code'` pin reconcile stamped onto the failure notifier. It shipped on
+    // a premise the box's own logs disprove — nothing was ever misrouted; the deployment was simply
+    // globally on claude-code then and on agentx now — and it made the alarm the second casualty of
+    // the real failure mode (an org cap on the pinned provider). Narrow on purpose: exactly the
+    // state that clause produced (this id, that engine, no model), so it cannot eat a real choice.
+    if (s.id === FAILURE_NOTIFIER_SCHEDULE_ID && task.engine === 'claude-code' && !task.model) {
+      delete task.engine;
+    }
+    foldLegacyRuntimePin(task);
+
     // Heal a persisted failure-notifier prompt still carrying the un-supplied "<deployment URL>"
     // placeholder — reconcile won't touch task.prompt, so this is the only path that reaches it.
     if (s.id === FAILURE_NOTIFIER_SCHEDULE_ID && typeof task.prompt === 'string') {
@@ -138,11 +172,7 @@ export function ensureBuiltinSchedules(schedules: Schedule[]): Schedule[] {
         match: { status: 'error' },
         throttle: { byFields: ['name', 'error'], windowSec: 21600 },
       },
-      // Pinned to the always-registered engine ON PURPOSE. Left unpinned, this run inherits whatever
-      // agent-config.json's global `engine` happens to be — and an optional engine can simply not
-      // register on a given boot (add-on absent, missing API key), which is exactly the failure this
-      // job exists to report. Its own alert must not be the second casualty.
-      task: { kind: 'prompt', prompt: FAILURE_NOTIFIER_PROMPT, engine: 'claude-code' },
+      task: { kind: 'prompt', prompt: FAILURE_NOTIFIER_PROMPT },
       scope: 'system',
       createdBy: { uid: SYSTEM_UID, email: 'system@shraga.local' },
       createdAt: now,
@@ -167,16 +197,8 @@ export function ensureBuiltinSchedules(schedules: Schedule[]): Schedule[] {
       existing.scope = builtin.scope;
       existing.trigger = existing.trigger ?? builtin.trigger;
       existing.createdBy = builtin.createdBy;
-      // A builtin's stored task is preserved (deployments edit the prompt) — with one exception: an
-      // engine/model pin is only meaningful as a PAIR. A stored task with a `model` but no `engine`
-      // was resolved against whatever the ambient global config was at the time, which is how the
-      // failure notifier ended up pinned to `composer-2.5` while running on claude-code. So when the
-      // builtin pins an engine and the stored task pins NONE, adopt the builtin's pair wholesale.
-      // An explicit stored `engine` is a real operator choice and is left untouched.
-      if (builtin.task.kind !== 'job' && existing.task.kind !== 'job' && builtin.task.engine && !existing.task.engine) {
-        existing.task.engine = builtin.task.engine;
-        existing.task.model = builtin.task.model;
-      }
+      // A builtin's stored task is otherwise preserved — deployments edit the prompt (and with it
+      // the runtime directive), and those edits must survive an upgrade.
     } else {
       schedules.push(builtin);
     }

package/src/server/scheduler/runner.ts

@@ -9,6 +9,17 @@ import type { Schedule, ScheduleRunSummary } from './types.ts';
 import { updateRunLockPid, clearRunningMarker, loadSchedules } from './storage.ts';
 import { readOutcome, clearOutcome, pendingDeadline, outcomePrompt, MAX_PENDING_MS } from './outcome.ts';
 import { addUnread } from '../unread.ts';
+import { splitDirectiveGroups } from '../directives.ts';
+
+/** The prompt a `prompt` task runs, from wherever it is stored. Its leading `[…]` directive is the
+ *  task's runtime selection — there is no separate stored pin.
+ *  With a `promptFile`, `prompt` is a PREFIX rather than dead text: the directive has to live
+ *  somewhere the editor can rewrite, and that must not be someone's workspace file. */
+function taskPromptText(task: { prompt?: string; promptFile?: string }): string {
+  if (!task.promptFile) return task.prompt ?? '';
+  const body = readFileSync(resolvePromptFile(task.promptFile), 'utf-8').trim();
+  return task.prompt ? `${task.prompt.trim()} ${body}` : body;
+}
 
 export interface RunContext {
   sessionId: string;
@@ -194,13 +205,19 @@ export async function runSchedule(
 
   let prompt: string;
   if (resume) {
-    // The original task prompt is already in the conversation from the interrupted run.
+    // The original task prompt is already in the conversation from the interrupted run — but a
+    // resume prompt is a fresh "continue where you left off" string, not the saved original, so the
+    // task's own leading `[engine:…,model:…]` directive has to be carried onto it. Without that the
+    // resumed turn runs on the global default: a different engine, and a different vendor's bill.
     prompt = resume.prompt;
+    const groups = task.kind === 'prompt' ? splitDirectiveGroups(taskPromptText(task), { strict: true }).groups : [];
+    const raw = groups.filter(Boolean).join(',');
+    if (raw) prompt = `[${raw}] ${prompt}`;
   } else if (task.kind === 'bash') {
     const cmd = override || task.command;
     prompt = `Run exactly this bash command and report the result concisely:\n\n\`\`\`bash\n${cmd}\n\`\`\``;
   } else {
-    let base = task.promptFile ? readFileSync(resolvePromptFile(task.promptFile), 'utf-8').trim() : (task.prompt ?? '');
+    let base = taskPromptText(task);
     if (override) base = `${base}\n\n---\nAdditional instructions for this run:\n${override}`;
     if (eventCtx) base = `${base}\n\n---\n${formatEventBlock(eventCtx)}`;
     prompt = base;
@@ -216,15 +233,6 @@ export async function runSchedule(
     prompt = `${prompt}\n\n---\n${outcomePrompt(sessionId)}`;
   }
 
-  // task.engine/task.model ride the same prompt-directive channel users type by hand —
-  // parseDirectives strips them and resolves aliases. Prepending (vs new plumbing) also persists the
-  // choice into the saved prompt, so the session UI shows what the schedule actually requested.
-  // Applied on RESUME too: a resume's prompt is a fresh "continue where you left off" string, not the
-  // saved original, so skipping this here silently dropped the schedule's engine/model pin and let the
-  // resumed turn run on the global default — a different engine, and a different vendor's bill.
-  const pins = [task.engine && `engine:${task.engine}`, task.model && `model:${task.model}`].filter(Boolean);
-  if (pins.length) prompt = `[${pins.join(',')}] ${prompt}`;
-
   // Save the synthesized user prompt to the conversation (skip on resume — task prompt already persisted).
   if (!resume) {
     appendMessage(sessionId, {

package/src/server/scheduler/types.ts

@@ -19,11 +19,16 @@ export interface EventThrottle {
   windowSec: number;
 }
 
-/** `engine`/`model` pin the runtime a run uses (e.g. engine 'agentx' + model
- *  'cursor/composer-2.5'); both ride the prompt-directive channel — see runner.ts. */
+/** The runtime a prompt run uses is NOT a field here: it is the leading `[engine:…,model:…]`
+ *  directive of the prompt itself (or of the promptFile's contents) — one source of truth, editable
+ *  and visible in the same place the prompt is. A separate stored pin shadowed it invisibly, which
+ *  is how nine live schedules ended up half-pinned (`model` set, `engine` not) with no UI to see it.
+ *  `bash` and `job` carry no selector: `bash` has no prompt to hold a directive (its prompt is a
+ *  fixed synthesized wrapper) and `job` never reaches an agent at all — both follow agent config.
+ *  Pin a shell command's runtime by writing a prompt task that runs it. */
 export type Task =
-  | { kind: 'prompt'; prompt?: string; promptFile?: string; model?: string; engine?: string }
-  | { kind: 'bash'; command: string; model?: string; engine?: string }
+  | { kind: 'prompt'; prompt?: string; promptFile?: string }
+  | { kind: 'bash'; command: string }
   | { kind: 'job'; command: string };
 
 /** Visibility: 'system' schedules + their sessions are shared with all whitelisted users; 'user' is private to createdBy. */