shraga 0.1.53 → 0.1.55

package/defaults/skills/scheduler.md

@@ -130,14 +130,21 @@ Trigger:
   { kind: "cron", expr: "<cron>", tz: "<IANA_tz>" }
   { kind: "event", source: "<name>", match?: { "<dot.path>": "<value>" } }
 
-Task:
-  { kind: "prompt", prompt: "<text>" }
-  { kind: "bash", command: "<cmd>" }
+Task:                                      // model/engine pin the runtime (see below)
+  { kind: "prompt", prompt: "<text>", model?: "<model>", engine?: "<engine>" }
+  { kind: "bash", command: "<cmd>", model?: "<model>", engine?: "<engine>" }
 
 Schedule: { id, name, enabled, trigger, task, scope, createdBy, nextRun?, lastRun?, runCount,
             onMissed?, missedRun? }
 ```
 
+`task.model` / `task.engine` pin what the run executes on, instead of the instance default:
+`model` takes an alias (`opus`, `haiku`) or a provider-qualified id (`cursor/composer-2.5`);
+`engine` names a registered runtime (`claude-code`, `agentx`, `cursor` — availability is
+deployment-specific). Both are prepended to the prompt as a `[engine:…,model:…]` directive, so a
+prompt that opens with its OWN model group (`[opus] …`) would out-rank the pin — drop it from the
+prompt text when pinning. `job` tasks run a command, not an agent, so neither applies.
+
 ## Missed windows (`onMissed` / `missedRun`)
 
 If a window elapses with nothing running (deploy, crash, power cut — or the host **suspending**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.53",
+  "version": "0.1.55",
   "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/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 }
-  | { kind: 'bash'; command: string; model?: string }
+  | { kind: 'prompt'; prompt: string; model?: string; engine?: string }
+  | { kind: 'bash'; command: string; model?: string; engine?: string }
   | { kind: 'job'; command: string };
 
 export type Scope = 'system' | 'user';

package/src/server/directives.ts

@@ -25,6 +25,13 @@ const DIRECTIVE_RE = /^\s*\[([^\]]*)\]\s*([\s\S]*)/;
 
 const DIRECTIVE_KEYS = ['model', 'turns', 'thinking', 'think', 'effort', 'engine'];
 
+/** MODEL_ALIASES only covers the bare Anthropic shorthands. A `provider/model` id
+ *  (`cursor/composer-2.5`, `openai/gpt-5.6`) is already concrete — gating it on the alias table
+ *  silently dropped it and ran the instance default instead. Honoured ONLY in `model:` key form:
+ *  as a bare positional it is indistinguishable from prompt text like `[src/foo.ts]`, which a
+ *  second bracket group would then swallow. */
+const isQualifiedModel = (v: string) => /^[a-z0-9._-]+\/[a-z0-9./_-]+$/.test(v);
+
 /** 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 {
@@ -84,7 +91,9 @@ export function parseDirectives(text: string): ParsedPrompt {
       } else if (['nothink', 'nothinking'].includes(val)) {
         directives.thinking = 'disabled';
       } else if (positionalIndex === 0) {
-        console.warn(`[directives] Unknown model alias: "${t}"`);
+        console.warn(isQualifiedModel(val)
+          ? `[directives] Provider-qualified model needs key form: "[model:${t}]"`
+          : `[directives] Unknown model alias: "${t}"`);
       }
       positionalIndex++;
     }
@@ -97,6 +106,7 @@ function applyDirective(d: Directives, key: string, val: string) {
   switch (key) {
     case 'model':
       if (MODEL_ALIASES[val]) d.model = MODEL_ALIASES[val];
+      else if (isQualifiedModel(val)) d.model = val;
       else console.warn(`[directives] Unknown model alias: "${val}"`);
       break;
     case 'turns':

package/src/server/modules/service.ts

@@ -300,8 +300,11 @@ function applyModule(rec: InstalledModule): void {
     const id = scheduleIdFor(rec, def);
     expectedIds.add(id);
     const rendered = renderDeep({ name: def.name, trigger: def.trigger, task: def.task }, config, `${rec.name}/schedules/${def.def}`);
-    // A templated model knob rendered to "" must not ship a bogus empty model — omit the field.
-    if ('model' in rendered.task && !(rendered.task as { model?: string }).model) delete (rendered.task as { model?: string }).model;
+    // A templated runtime knob rendered to "" must not ship a bogus empty pin — omit the field.
+    for (const k of ['model', 'engine'] as const) {
+      const t = rendered.task as Record<string, unknown>;
+      if (k in t && !t[k]) delete t[k];
+    }
     const existing = scheduler.getSchedule(id);
     const now = Date.now();
     const schedule: Schedule = {

package/src/server/scheduler/runner.ts

@@ -140,10 +140,13 @@ export async function runSchedule(
     if (eventCtx) base = `${base}\n\n---\n${formatEventBlock(eventCtx)}`;
     prompt = base;
   }
-  // task.model rides the same [model] prompt-directive channel users type by hand — parseDirectives
-  // strips it and resolves aliases. Prepending (vs new plumbing) also persists the choice into the
-  // saved prompt, so the session UI shows which model the schedule actually requested.
-  if (!resume && task.model) prompt = `[${task.model}] ${prompt}`;
+  // 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.
+  if (!resume) {
+    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) {

package/src/server/scheduler/types.ts

@@ -19,9 +19,11 @@ 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. */
 export type Task =
-  | { kind: 'prompt'; prompt?: string; promptFile?: string; model?: string }
-  | { kind: 'bash'; command: string; model?: string }
+  | { kind: 'prompt'; prompt?: string; promptFile?: string; model?: string; engine?: string }
+  | { kind: 'bash'; command: string; model?: string; engine?: string }
   | { kind: 'job'; command: string };
 
 /** Visibility: 'system' schedules + their sessions are shared with all whitelisted users; 'user' is private to createdBy. */