shraga 0.1.160 → 0.1.161

package/dist/client/index.html

@@ -13,7 +13,7 @@
     <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-yBsLZ3yV.js"></script>
+    <script type="module" crossorigin src="/assets/index-C46Azkf_.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-NtN1I_dh.css">
   </head>
   <body>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.160",
+  "version": "0.1.161",
   "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/server/claude.ts

@@ -313,6 +313,11 @@ async function* runTurn(opts: StreamChatOpts, guard?: TurnGuard): AsyncGenerator
 
   const sessionMeta = opts.sessionId ? getSession(opts.sessionId) : undefined;
   const directives: Directives = { ...sessionMeta?.directives, ...parsed };
+  // A two-model mode (delegate/advisor) is sticky like the model: `[off]` clears it, and a new mode
+  // replaces the other one. `modeOff` is a command, not a setting — never stored.
+  if (parsed.modeOff || parsed.advisor) delete directives.delegate;
+  if (parsed.modeOff || parsed.delegate) delete directives.advisor;
+  delete directives.modeOff;
   // Persist ONLY what was explicitly chosen (inline directives, or the Agent Config panel's
   // per-conversation save). Gaps stay gaps: every engine resolves `directives.x ?? config.x` at
   // send time, so the global agent-config keeps applying live to sessions nobody pinned —

package/src/server/directives.ts

@@ -6,6 +6,12 @@ export interface Directives {
   engine?: string;
   /** claude-code SDK session resume for this conversation (overrides agent-config `sdkResume`). */
   resume?: boolean;
+  /** agentx DELEGATE mode `[planner->worker]` (key `delegate`): the worker model; `model` (left side) plans. */
+  delegate?: string;
+  /** agentx ADVISOR mode `[worker<-advisor]` (key `advisor`): the advisor model; `model` (left side) works. */
+  advisor?: string;
+  /** `[off]` / `[mode:off]`: clears a sticky delegate/advisor mode. Consumed by streamChat, never stored. */
+  modeOff?: boolean;
 }
 
 export interface ParsedPrompt {
@@ -28,7 +34,15 @@ import { MODEL_ALIASES } from './model-aliases.ts';
 
 const DIRECTIVE_RE = /^\s*\[([^\]]*)\]\s*([\s\S]*)/;
 
-const DIRECTIVE_KEYS = ['model', 'turns', 'thinking', 'think', 'effort', 'engine', 'resume'];
+const DIRECTIVE_KEYS = ['model', 'turns', 'thinking', 'think', 'effort', 'engine', 'resume', 'delegate', 'advisor', 'mode'];
+
+/** `a->b` (delegate) / `a<-b` (advisor) — agentx's two-model mode grammar; the left side may be empty. */
+function splitModePair(token: string): { left: string; op: '->' | '<-'; right: string } | null {
+  const i = token.search(/->|<-/);
+  if (i === -1) return null;
+  const right = token.slice(i + 2).trim();
+  return right ? { left: token.slice(0, i).trim(), op: token.slice(i, i + 2) as '->' | '<-', right } : null;
+}
 
 /** 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
@@ -72,6 +86,9 @@ export function isDirectiveGroup(raw: string): boolean {
     const colonIdx = t.indexOf(':');
     if (colonIdx !== -1) return DIRECTIVE_KEYS.includes(t.slice(0, colonIdx).trim().toLowerCase());
     const v = t.toLowerCase();
+    const pair = splitModePair(v);
+    if (pair) return (!pair.left || !!resolveModelAlias(pair.left)) && !!resolveModelAlias(pair.right);
+    if (v === 'off') return true;
     return !!MODEL_ALIASES[v] || !!modelResolver?.(v) || /^\d+$/.test(v) || ['think', 'adaptive', 'nothink', 'nothinking'].includes(v);
   });
 }
@@ -132,6 +149,17 @@ export function parseDirectives(text: string): ParsedPrompt {
       unresolvedModel = applyDirective(directives, key, val) ?? unresolvedModel;
     } else {
       const val = t.toLowerCase();
+      const pair = splitModePair(val);
+      if (pair) {
+        // Both sides must resolve: a half-resolved pair would silently run a mode on the wrong model.
+        const worker = resolveModelAlias(pair.right);
+        if (worker && (!pair.left || resolveModelToken(directives, pair.left))) {
+          if (pair.op === '->') directives.delegate = worker.model; else directives.advisor = worker.model;
+        } else unresolvedModel ??= t;
+        positionalIndex++;
+        continue;
+      }
+      if (val === 'off') { directives.modeOff = true; positionalIndex++; continue; }
       if (positionalIndex === 0 && resolveModelToken(directives, val)) {
         // handled
       } else if (positionalIndex <= 1 && /^\d+$/.test(val)) {
@@ -179,6 +207,18 @@ function applyDirective(d: Directives, key: string, val: string): string | undef
     case 'engine':
       d.engine = val;
       break;
+    case 'delegate':
+    case 'advisor': {
+      const hit = resolveModelAlias(val);
+      if (hit) d[key] = hit.model;
+      else if (isQualifiedModel(val)) d[key] = val;
+      else return val;
+      break;
+    }
+    case 'mode':
+      if (val === 'off') d.modeOff = true;
+      else console.warn(`[directives] Invalid mode value: "${val}"`);
+      break;
     case 'resume':
       if (['on', 'true', '1'].includes(val)) d.resume = true;
       else if (['off', 'false', '0'].includes(val)) d.resume = false;