npm - shraga - Versions diffs - 0.1.93 → 0.1.95 - Mend

shraga 0.1.93 → 0.1.95

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (19) hide show

package/dist/client/assets/{index-B--gTLyT.css → index-CJDfTuzn.css} +1 -1
package/dist/client/assets/{index-C3l1Wz_q.js → index-D2xviJL0.js} +238 -238
package/dist/client/index.html +2 -2
package/package.json +1 -1
package/src/client/components/ConfigPanel.tsx +2 -20
package/src/client/components/ConversationHeader.tsx +62 -27
package/src/client/components/SchedulesManager.tsx +2 -0
package/src/client/components/schedules/ScheduleEditor.tsx +65 -1
package/src/client/hooks/useEngines.ts +52 -0
package/src/client/lib/prompt-directives.ts +65 -0
package/src/client/lib/schedule-types.ts +2 -2
package/src/server/data-sync.ts +7 -1
package/src/server/directives.ts +32 -19
package/src/server/engine/index.ts +4 -19
package/src/server/engine/model-resolver.ts +36 -0
package/src/server/modules/service.ts +4 -0
package/src/server/scheduler/builtins.ts +37 -15
package/src/server/scheduler/runner.ts +19 -11
package/src/server/scheduler/types.ts +9 -4

package/dist/client/index.html CHANGED Viewed

@@ -13,8 +13,8 @@
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600&display=swap" rel="stylesheet" />
-    <script type="module" crossorigin src="/assets/index-C3l1Wz_q.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-B--gTLyT.css">
+    <script type="module" crossorigin src="/assets/index-D2xviJL0.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-CJDfTuzn.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.93",
+  "version": "0.1.95",
   "description": "The teammate you delegate coding to — a self-hostable, multi-user AI coding agent web UI (Claude Code, with a pluggable engine seam).",
   "type": "module",
   "main": "./src/index.ts",

package/src/client/components/ConfigPanel.tsx CHANGED Viewed

@@ -5,6 +5,7 @@ import { Input } from './ui/input';
 import { Textarea } from './ui/textarea';
 import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogTrigger, DialogBody, DialogFooter } from './ui/dialog';
 import { useSlots } from '@/lib/slots';
+import { useEngines, type EngineModel } from '@/hooks/useEngines';
 interface AgentConfig {
   model?: string;
@@ -18,17 +19,6 @@ interface AgentConfig {
   effort?: 'low' | 'medium' | 'high' | 'max';
 }
-interface EngineModel {
-  value: string;
-  label: string;
-  provider?: string;
-}
-interface EngineInfo {
-  name: string;
-  models: EngineModel[];
-}
 const FALLBACK_MODELS: EngineModel[] = [
   { value: '', label: 'Default (claude-sonnet-5)' },
   { value: 'claude-fable-5', label: 'Fable 5 — frontier, most capable' },
@@ -64,8 +54,7 @@ export function ConfigPanel({ getToken, onSaved, trigger, sessionId, sessionDire
   const [config, setConfig] = useState<AgentConfig>({});
   const [open, setOpen] = useState(false);
   const [saving, setSaving] = useState(false);
-  const [engines, setEngines] = useState<EngineInfo[]>([]);
-  const [multiEngine, setMultiEngine] = useState(false);
+  const { engines, multiEngine } = useEngines(getToken, open);
   // Global config as loaded — so a per-session runtime change doesn't clobber the global defaults.
   const globalRef = useRef<AgentConfig>({});
   // Save scope for the runtime knobs (engine/model/turns/thinking): this conversation, or the
@@ -93,13 +82,6 @@ export function ConfigPanel({ getToken, onSaved, trigger, sessionId, sessionDire
           });
         })
         .catch(() => {});
-      fetch('/api/engines', { headers: { Authorization: `Bearer ${token}` } })
-        .then((r) => r.json())
-        .then((data) => {
-          setEngines(data.engines ?? []);
-          setMultiEngine(data.multiEngine ?? false);
-        })
-        .catch(() => {});
     });
   }, [open, getToken, sessionId, sessionDirectives]);

package/src/client/components/ConversationHeader.tsx CHANGED Viewed

@@ -11,8 +11,16 @@ interface SessionDirectives {
   engine?: string;
 }
-/** What the chips must report: the engine/model that ACTUALLY ran, and whether that disagrees with
- *  what this session asks for. Pure, so the rule is testable without a DOM.
+/** Provenance of what the chips report.
+ *  - `ran`        a turn executed and recorded a self-consistent (engine, model) PAIR.
+ *  - `ran-model`  a turn executed and recorded its MODEL, but not the engine that ran it — every
+ *                 session written before `lastEngine` existed (45 of 817 on the live box).
+ *  - `pending`    nothing has run in this conversation yet. */
+export type RuntimeProvenance = 'ran' | 'ran-model' | 'pending';
+/** What the chips must report: the engine/model that ACTUALLY ran, and — separately — what this
+ *  session is currently SET to run. Those are different claims and the pill must never blur them.
+ *  Pure, so the rule is testable without a DOM.
  *
  *  The bug this replaces: the old code inferred the engine from the model id's SHAPE (bare ⇒ native)
  *  and threw away the runtime-recorded model whenever the shape disagreed with the requested engine —
@@ -28,23 +36,32 @@ export function deriveRuntimeBadges(input: {
   actualModel?: string;
 }) {
   const requestedEngine = input.requestedEngine || 'claude-code';
-  const engine = input.actualEngine || requestedEngine;
+  const provenance: RuntimeProvenance = input.actualEngine ? 'ran' : input.actualModel ? 'ran-model' : 'pending';
+  // A recorded model is ground truth about the MODEL whether or not an engine was recorded beside
+  // it, so it is never dropped — dropping it made the UI report the REQUESTED runtime for a turn
+  // that had already run, the one claim this must never make. What a lone model cannot do is name
+  // the engine: an id is bare or prefixed by PROVIDER, and a provider is not an engine (agentx runs
+  // anthropic models). So with no `lastEngine`, the engine stays unknown rather than guessed.
+  const engine = provenance === 'ran' ? input.actualEngine! : provenance === 'pending' ? requestedEngine : undefined;
+  const rawModel =
+    input.actualModel || input.requestedModel || (requestedEngine === 'cursor' ? 'cursor/composer-2.5' : 'sonnet-4-6');
   // A mismatch is a fact worth showing, not something to launder away: the last turn ran somewhere
-  // other than where this session currently asks to run.
-  const engineMismatch = input.actualEngine && input.actualEngine !== requestedEngine ? requestedEngine : undefined;
+  // other than where this session currently asks to run — which the ground-truth pill alone cannot
+  // say, because it reports only where the turn DID run, not where the next one will be sent.
+  const engineMismatch = provenance === 'ran' && engine !== requestedEngine ? requestedEngine : undefined;
   const engineIsNative = engine === 'claude-code' || engine === 'cursor';
-  // "The pair, or neither" is right for the ENGINE, not for the provider: a `provider/` prefix on the
-  // recorded model is direct evidence of what actually ran and was billed, and needs no engine to read.
-  // Only a BARE recorded id is unreadable alone (it belongs to whichever engine recorded it), so only
-  // that one is dropped. Sessions written before lastEngine existed carry a prefixed model and nothing
-  // else — dropping it made the UI report the requested provider, the very claim this must never make.
-  const recordedModel = input.actualEngine || input.actualModel?.includes('/') ? input.actualModel : undefined;
-  const rawModel =
-    recordedModel || input.requestedModel || (engine === 'cursor' ? 'cursor/composer-2.5' : 'sonnet-4-6');
-  // Provider = the model's prefix; a bare id belongs to the engine that ran it (claude-code ⇒ anthropic,
-  // an add-on engine ⇒ that engine's own provider) — never assume anthropic just because a prefix is absent.
-  const billingProvider = rawModel.includes('/') ? rawModel.split('/')[0] : engine === 'claude-code' ? 'anthropic' : engine;
-  return { engine, engineIsNative, engineMismatch, rawModel, billingProvider };
+  // Provider = the model's prefix; a bare id belongs to the engine that ran it (claude-code ⇒
+  // anthropic, an add-on engine ⇒ that engine's own provider). With neither a prefix nor a known
+  // engine there is nothing to name it from, so it is reported as unknown, never assumed.
+  const billingProvider = rawModel.includes('/')
+    ? rawModel.split('/')[0]
+    : engine === 'claude-code'
+      ? 'anthropic'
+      : engine;
+  return { provenance, engine, engineIsNative, engineMismatch, rawModel, billingProvider };
 }
 function InfoBadges({
@@ -68,7 +85,7 @@ function InfoBadges({
   onScheduleClick?: () => void;
 }) {
   const [copied, setCopied] = useState(false);
-  const { engine, engineIsNative, engineMismatch, rawModel, billingProvider } = deriveRuntimeBadges({
+  const { provenance, engine, engineIsNative, engineMismatch, rawModel, billingProvider } = deriveRuntimeBadges({
     requestedEngine: sessionDirectives?.engine || config.engine,
     requestedModel: sessionDirectives?.model || config.model,
     actualEngine,
@@ -77,7 +94,18 @@ function InfoBadges({
   // A multi-provider add-on engine runs any provider's model through its own loop, so it must be
   // distinguishable from a native runtime running the same model. Prefix such a model with the engine
   // name; native engines (claude-code, cursor) show the model plainly. Engine name comes from data.
-  const model = !engineIsNative ? `${engine} · ${rawModel.replace('claude-', '')}` : rawModel.replace('claude-', '');
+  // With no engine recorded there is nothing truthful to prefix with, so the model stands alone.
+  const shortModel = rawModel.replace('claude-', '');
+  const model = engine && !engineIsNative ? `${engine} · ${shortModel}` : shortModel;
+  // A selection is not a runtime. Until a turn has run, the chips describe what the NEXT one will
+  // use — marked so, and never presented as something that executed.
+  const pending = provenance === 'pending';
+  const pendingRing = pending ? ' border border-dashed border-current/40 opacity-80' : '';
+  const runtimeTitle = pending
+    ? 'Nothing has run in this conversation yet — this is what the next turn is set to use.'
+    : provenance === 'ran-model'
+      ? `Model recorded from the last turn. The engine that ran it was not recorded (this conversation predates engine tracking), so it is not named here.`
+      : `Engine and model that actually ran the last turn.`;
   // Auth-mechanism indicator. The only verifiable distinction is claude.ai OAuth login vs a provider
   // API key: the native claude-code engine can run on a login (no ANTHROPIC_API_KEY); every add-on
   // engine / provider-prefixed model runs on that provider's key (ai.libx.js adapters throw without
@@ -86,15 +114,19 @@ function InfoBadges({
   const onSubscription = engine === 'claude-code' && config.claudeAuthSource === 'subscription';
   // Tone: green = claude.ai login (no key); amber = provider key whose usage may be subscription-
   // covered (Cursor); rose = provider key that is genuinely metered (Anthropic/OpenAI/etc.).
-  const billingTone = onSubscription ? 'sub' : billingProvider === 'cursor' ? 'plan' : 'metered';
+  const billingTone = !billingProvider ? 'unknown' : onSubscription ? 'sub' : billingProvider === 'cursor' ? 'plan' : 'metered';
   const billingClass =
-    billingTone === 'sub'
+    billingTone === 'unknown'
+      ? 'bg-muted text-muted-foreground ring-border'
+      : billingTone === 'sub'
       ? 'bg-emerald-50 text-emerald-700 ring-emerald-600/20 dark:bg-emerald-950/50 dark:text-emerald-300 dark:ring-emerald-400/30'
       : billingTone === 'plan'
         ? 'bg-amber-50 text-amber-700 ring-amber-600/20 dark:bg-amber-950/50 dark:text-amber-300 dark:ring-amber-400/30'
         : 'bg-rose-50 text-rose-700 ring-rose-600/20 dark:bg-rose-950/50 dark:text-rose-300 dark:ring-rose-400/30';
   const billingTitle =
-    billingTone === 'sub'
+    billingTone === 'unknown'
+      ? 'The engine that ran this turn was not recorded and the model id carries no provider prefix — the billed provider cannot be named from what was stored.'
+      : billingTone === 'sub'
       ? 'Claude.ai subscription (OAuth login) — no API key in use'
       : billingTone === 'plan'
         ? `Runs on your ${billingProvider} API key — usage may draw on your ${billingProvider} plan/subscription`
@@ -113,14 +145,17 @@ function InfoBadges({
   return (
     <div className="flex items-center gap-1.5 flex-wrap">
-      <span className="inline-flex items-center rounded-md bg-blue-50 px-1.5 py-0.5 text-[10px] font-medium text-blue-700 ring-1 ring-inset ring-blue-600/20 dark:bg-blue-950/50 dark:text-blue-300 dark:ring-blue-400/30">
-        {model}
+      <span
+        title={runtimeTitle}
+        className={`inline-flex items-center rounded-md bg-blue-50 px-1.5 py-0.5 text-[10px] font-medium text-blue-700 ring-1 ring-inset ring-blue-600/20 dark:bg-blue-950/50 dark:text-blue-300 dark:ring-blue-400/30${pendingRing}`}
+      >
+        {pending ? `→ ${model}` : model}
       </span>
       <span
-        title={billingTitle}
-        className={`inline-flex items-center rounded-md px-1.5 py-0.5 text-[10px] font-medium ring-1 ring-inset ${billingClass}`}
+        title={pending ? `${runtimeTitle} ${billingTitle}` : billingTitle}
+        className={`inline-flex items-center rounded-md px-1.5 py-0.5 text-[10px] font-medium ring-1 ring-inset ${billingClass}${pendingRing}`}
       >
-        {onSubscription ? 'sub' : `API·${billingProvider}`}
+        {billingTone === 'unknown' ? 'API·?' : onSubscription ? 'sub' : `API·${billingProvider}`}
       </span>
       {engineMismatch && (
         <span

package/src/client/components/SchedulesManager.tsx CHANGED Viewed

@@ -65,6 +65,7 @@ export const SchedulesManager = forwardRef<SchedulesManagerHandle, Props>(functi
         {creating ? (
           <ScheduleEditor
             key="__new__"
+            getToken={getToken}
             onSave={async (s) => { await create(s); closeEditor(); }}
             onCancel={closeEditor}
             skills={skills}
@@ -73,6 +74,7 @@ export const SchedulesManager = forwardRef<SchedulesManagerHandle, Props>(functi
         ) : editing ? (
           <ScheduleEditor
             key={editing.id}
+            getToken={getToken}
             initial={editing}
             onSave={async (s) => { await update(editing.id, s); closeEditor(); }}
             onCancel={closeEditor}

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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/data-sync.ts CHANGED Viewed

@@ -72,7 +72,13 @@ export function extractCommitSubject(raw: string): string {
  *  guard aborts the WHOLE commit, so one churn file stalls every other file's sync indefinitely —
  *  measured 2026-09-07: repeated BLOCKED alerts and a 27-commit push backlog behind two task files. */
 export function isChurnPath(file: string): boolean {
-  return /(^|\/)workspace\/[^/]+\/workers\/(logs|tasks)\//.test(file) || /\.bak(-|\.|$)/.test(file);
+  return /(^|\/)workspace\/[^/]+\/workers\/(logs|tasks)\//.test(file)
+    // Per-job runtime records (one .json/.log/.status triple per background job), written on
+    // dispatch and garbage-collected once the job is done. 54 live files churning constantly, so
+    // their deletion is the design, not a regression — the integrity audit reported dozens of
+    // "missing … in reference but not HEAD" lines for a routine GC pass.
+    || /(^|\/)jobs\/job-[^/]+\.(json|log|status)$/.test(file)
+    || /\.bak(-|\.|$)/.test(file);
 }
 export class DataSyncOptions {

package/src/server/directives.ts CHANGED Viewed

@@ -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/index.ts CHANGED Viewed

@@ -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 ADDED Viewed

@@ -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;
+  };
+}