npm - shraga - Versions diffs - 0.1.87 → 0.1.89 - Mend

shraga 0.1.87 → 0.1.89

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 (20) hide show

package/README.md +2 -0
package/dist/client/assets/{index-BSvY0squ.js → index-B-8NBGtJ.js} +38 -38
package/dist/client/index.html +1 -1
package/package.json +1 -1
package/src/cli.ts +28 -51
package/src/client/components/ConversationHeader.tsx +54 -11
package/src/client/components/ConversationPane.tsx +8 -1
package/src/client/lib/ws.ts +1 -1
package/src/server/boot.ts +13 -7
package/src/server/claude.ts +14 -3
package/src/server/data-sync.ts +26 -2
package/src/server/engine/claude-code.ts +27 -4
package/src/server/engine/index.ts +20 -8
package/src/server/notify-owners.ts +7 -6
package/src/server/scheduler/builtins.ts +15 -1
package/src/server/scheduler/runner.ts +5 -4
package/src/server/sessions.ts +11 -3
package/src/server/webhook-lane/feature.ts +227 -0
package/src/server/{para → webhook-lane}/streamer.ts +90 -60
package/src/server/para/feature.ts +0 -229

package/dist/client/index.html CHANGED Viewed

@@ -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-BSvY0squ.js"></script>
+    <script type="module" crossorigin src="/assets/index-B-8NBGtJ.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-J2NH6FvE.css">
   </head>
   <body>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.87",
+  "version": "0.1.89",
   "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/cli.ts CHANGED Viewed

@@ -29,19 +29,23 @@ Subcommands:
   ingress                 Run the host-header TCP router (INGRESS_PORT, default 3100)
                           for previews + blue-green flips. Own process, survives restarts.
   user add <email> <pw>   Seed a local username/password user
-  para post [text]        Push a message into a linked para.li conversation.
-                          Text from [text], --file <path>, or stdin (preferred for
-                          multi-line reports). --conn <id> picks a link when several exist.
+  <add-on>                Any other subcommand is handed to SHRAGA_CLI_EXT, if set.
 Environment:
   CLOUDFLARE_TUNNEL_TOKEN   If set, starts a Cloudflare Tunnel alongside the server.
                             Get the token from Cloudflare Zero Trust > Tunnels > Configure.
   ANTHROPIC_API_KEY         Claude API key (or use \`claude auth login\` for subscription auth)
   VITE_FIREBASE_CONFIG_PROD Firebase config JSON for auth (prod project)
+  SHRAGA_CLI_EXT            Absolute path to an add-on CLI module. Any subcommand this CLI
+                            does not own is handed to it before the server boots. See the
+                            CLI EXTENSION SEAM comment in src/cli.ts.
 `.trim());
   process.exit(0);
 }
+/** Subcommands the core owns. Everything else is offered to SHRAGA_CLI_EXT (see below). */
+const CORE_SUBCOMMANDS = new Set(['user', 'ingress']);
 const port = flag('port', 'p');
 const dataDir = flag('data-dir', 'd');
@@ -62,58 +66,31 @@ if (args[0] === 'user' && args[1] === 'add') {
   process.exit(0);
 }
-// `shraga para post [text]` — the PROACTIVE half of the para.li agent lane.
+// ── CLI EXTENSION SEAM ───────────────────────────────────────────────────────
 //
-// The reactive half (para asks, shraga answers) is driven by para.li calling `/api/para/turn`, and
-// the only other outbound path is the deploy-notice bus subscriber in `para/feature.ts` — which is
-// gated on `kind === 'deploy'`. So a SCHEDULED run (a daily digest) had no way to reach the lane at
-// all: it composes text on its own clock with no inbound turn to answer and no deploy event to ride.
-// This is that door, and it is a CLI rather than a route because the caller is the agent itself,
-// running Bash on this very box: a local process reading the same `para-links.json` the feature
-// writes needs no listener, no API key, and no second copy of the callback secret.
+// The twin of the `registerFeature` / SHRAGA_OVERLAY seam, for the command line. The core owns a
+// short, fixed list of subcommands; ANY other one is handed to the module named by SHRAGA_CLI_EXT,
+// so a downstream distribution can ship its own commands without the core naming them.
 //
-// Text comes from stdin by default. A digest is multi-line markdown with backticks and emoji, and
-// making a model shell-quote that into argv is a defect generator; `... | shraga para post` is not.
-if (args[0] === 'para' && args[1] === 'post') {
-  const { loadLinks } = await import('./server/para/feature.ts');
-  const { postProactive } = await import('./server/para/streamer.ts');
-  const links = loadLinks();
-  const wanted = flag('conn');
-  const ids = Object.keys(links);
-  // Refuse to guess. Picking "the first" would silently deliver a private report to whichever
-  // connection happened to sort first the day a second one is added.
-  const connId = wanted ?? (ids.length === 1 ? ids[0] : undefined);
-  if (!connId || !links[connId]) {
-    console.error(ids.length
-      ? `usage: shraga para post --conn <connId>   (linked: ${ids.join(', ')})`
-      : 'no para link yet — send one message from para.li to this agent first, then retry.');
-    process.exit(1);
-  }
-  const link = links[connId];
-  const file = flag('file');
-  let text: string;
-  if (file) {
-    text = (await import('node:fs')).readFileSync(file, 'utf-8');
-  } else {
-    // A bare positional (not a flag, and not a flag's VALUE) is accepted for one-liners.
-    const flagVals = new Set<string>();
-    for (let i = 0; i < args.length; i++) if (args[i].startsWith('--')) flagVals.add(args[i + 1]);
-    const positional = args.slice(2).find((a) => !a.startsWith('--') && !flagVals.has(a));
-    text = positional ?? await new Response(Bun.stdin.stream()).text();
-  }
-  if (!text.trim()) {
-    console.error('nothing to post: text was empty (pipe it on stdin, pass --file, or give it as an argument)');
+// CONTRACT. The module is imported for side effects, with `process.argv` untouched — it reads argv
+// itself, and calls `process.exit()` when it has handled the command. If it returns without
+// exiting, we fall through to the normal server boot, which is exactly what an unrecognised
+// subcommand does today. It runs AFTER env resolution (so DATA_DIR/PORT are settled and the
+// extension sees the same data dir the server would) and BEFORE any server boot.
+//
+// WHY AN ENV VAR AND NOT A REGISTRY. There is no server process to register against — this is a
+// one-shot CLI. The path must come from the deployment, and the deployment already sets DATA_DIR
+// and friends the same way.
+const cliExt = process.env.SHRAGA_CLI_EXT?.trim();
+if (cliExt && args[0] && !args[0].startsWith('-') && !CORE_SUBCOMMANDS.has(args[0])) {
+  const { pathToFileURL } = await import('node:url');
+  const { resolve } = await import('node:path');
+  try {
+    await import(pathToFileURL(resolve(cliExt)).href);
+  } catch (err) {
+    console.error(`[cli-ext] failed to load ${cliExt}:`, (err as Error)?.stack || err);
     process.exit(1);
   }
-  const ok = await postProactive({ url: link.url, secret: link.secret, connId }, link.convId, text);
-  // Exit code is the point: `postProactive` swallows transport failures into `false`, so a caller
-  // that only looked at stdout would read a silent drop as a successful delivery.
-  if (!ok) { console.error(`\u2716 para post FAILED \u2192 ${link.convId}`); process.exit(1); }
-  console.log(`\u2705 posted to ${link.convId}`);
-  process.exit(0);
 }
 // `shraga ingress` — host-header TCP router for previews + blue-green flips.

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

@@ -11,11 +11,45 @@ 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.
+ *
+ *  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 —
+ *  i.e. precisely in the case where a run had silently switched provider. The header was structurally
+ *  incapable of reporting a fallback, so a run that billed Anthropic still showed the Cursor chips.
+ *  Runtime ground truth now arrives as a self-consistent (engine, model) PAIR, so nothing is inferred. */
+export function deriveRuntimeBadges(input: {
+  requestedEngine?: string;
+  requestedModel?: string;
+  /** Engine that ran the last turn (session meta `lastEngine`). */
+  actualEngine?: string;
+  /** Model that engine resolved (session meta `lastModel`). */
+  actualModel?: string;
+}) {
+  const requestedEngine = input.requestedEngine || 'claude-code';
+  const engine = input.actualEngine || requestedEngine;
+  // 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;
+  const engineIsNative = engine === 'claude-code' || engine === 'cursor';
+  // Only trust the recorded model when we also know which engine recorded it — the pair, or neither.
+  const rawModel =
+    (input.actualEngine ? input.actualModel : undefined) ||
+    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 };
+}
 function InfoBadges({
   sessionId,
   config,
   sessionDirectives,
   actualModel,
+  actualEngine,
   scheduleId,
   onScheduleClick,
 }: {
@@ -24,19 +58,19 @@ function InfoBadges({
   sessionDirectives?: SessionDirectives;
   /** Model the engine actually resolved at runtime (session meta `lastModel`) — beats configured/requested. */
   actualModel?: string;
+  /** Engine that actually ran the last turn (session meta `lastEngine`). Ground truth, arriving in the
+   *  same `model_resolved` event as `actualModel` — so the pair never has to be inferred from a shape. */
+  actualEngine?: string;
   scheduleId?: string;
   onScheduleClick?: () => void;
 }) {
   const [copied, setCopied] = useState(false);
-  const engine = sessionDirectives?.engine || config.engine || 'claude-code';
-  // The native Claude Code engine records a bare `claude-*` id; a multi-provider add-on engine records
-  // a `provider/model` id. Trust the recorded model only when its shape matches the current engine
-  // family, or a session that has since switched engines would show the previous engine's model.
-  const recordedByNative = actualModel ? !actualModel.includes('/') : undefined;
-  const engineIsNative = engine === 'claude-code' || engine === 'cursor';
-  const trustedActual = recordedByNative !== undefined && recordedByNative === engineIsNative ? actualModel : undefined;
-  const rawModel =
-    trustedActual || sessionDirectives?.model || config.model || (engine === 'cursor' ? 'cursor/composer-2.5' : 'sonnet-4-6');
+  const { engine, engineIsNative, engineMismatch, rawModel, billingProvider } = deriveRuntimeBadges({
+    requestedEngine: sessionDirectives?.engine || config.engine,
+    requestedModel: sessionDirectives?.model || config.model,
+    actualEngine,
+    actualModel,
+  });
   // 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.
@@ -46,8 +80,6 @@ function InfoBadges({
   // engine / provider-prefixed model runs on that provider's key (ai.libx.js adapters throw without
   // one). What that key COSTS is plan-dependent and NOT knowable here (Anthropic API is metered;
   // a Cursor key may draw on a Cursor subscription) — so we label the mechanism, not the billing.
-  // Provider = the model's prefix (bare ⇒ anthropic).
-  const billingProvider = rawModel.includes('/') ? rawModel.split('/')[0] : 'anthropic';
   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.).
@@ -87,6 +119,14 @@ function InfoBadges({
       >
         {onSubscription ? 'sub' : `API·${billingProvider}`}
       </span>
+      {engineMismatch && (
+        <span
+          title={`This session requests the "${engineMismatch}" engine, but the last turn actually ran on "${engine}" — so the chips above report ${engine}, and that provider was billed.`}
+          className="inline-flex items-center rounded-md bg-rose-50 px-1.5 py-0.5 text-[10px] font-medium text-rose-700 ring-1 ring-inset ring-rose-600/20 dark:bg-rose-950/50 dark:text-rose-300 dark:ring-rose-400/30"
+        >
+          ≠ {engineMismatch}
+        </span>
+      )}
       <span className="inline-flex items-center rounded-md bg-amber-50 px-1.5 py-0.5 text-[10px] font-medium text-amber-700 ring-1 ring-inset ring-amber-600/20 dark:bg-amber-950/50 dark:text-amber-300 dark:ring-amber-400/30">
         {permLabel}
       </span>
@@ -127,6 +167,7 @@ export interface ConversationHeaderProps {
   agentConfig: AgentConfig;
   sessionDirectives?: SessionDirectives;
   sessionLastModel?: string;
+  sessionLastEngine?: string;
   sessionScheduleId?: string;
   artifactCount: number;
   getToken: () => Promise<string | null>;
@@ -143,6 +184,7 @@ export function ConversationHeader({
   agentConfig,
   sessionDirectives,
   sessionLastModel,
+  sessionLastEngine,
   sessionScheduleId,
   artifactCount,
   getToken,
@@ -159,6 +201,7 @@ export function ConversationHeader({
         config={agentConfig}
         sessionDirectives={sessionDirectives}
         actualModel={sessionLastModel}
+        actualEngine={sessionLastEngine}
         scheduleId={sessionScheduleId}
         onScheduleClick={onScheduleClick}
       />

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

@@ -43,6 +43,9 @@ export function ConversationPane({ nodeId, sessionId }: { nodeId: string; sessio
   const [sessionDirectives, setSessionDirectives] = useState<SessionDirectives | undefined>();
   const [sessionScheduleId, setSessionScheduleId] = useState<string | undefined>();
   const [sessionLastModel, setSessionLastModel] = useState<string | undefined>();
+  // Engine that ACTUALLY ran the last turn — always set/cleared together with sessionLastModel, since
+  // the pair is the runtime ground truth the header reports (neither half may be inferred).
+  const [sessionLastEngine, setSessionLastEngine] = useState<string | undefined>();
   const [multiParticipant, setMultiParticipant] = useState(false);
   const artifacts = useArtifacts(currentSessionId, ws.getToken, ws.token);
@@ -66,9 +69,10 @@ export function ConversationPane({ nodeId, sessionId }: { nodeId: string; sessio
       } else if (event.type === 'directives') {
         // Optimistic-then-confirm pill: drop stale ground-truth so the pill shows the just-requested
         // model. Untagged event — gate on this pane being mid-turn so idle panes don't flicker.
-        if (busyRef.current) setSessionLastModel(undefined);
+        if (busyRef.current) { setSessionLastModel(undefined); setSessionLastEngine(undefined); }
       } else if (event.type === 'model_resolved' && event.sessionId === currentSessionIdRef.current) {
         setSessionLastModel(event.model);
+        setSessionLastEngine(event.engine);
       }
     },
     [ws, nodeId, artifacts],
@@ -113,6 +117,7 @@ export function ConversationPane({ nodeId, sessionId }: { nodeId: string; sessio
       setSessionDirectives(undefined);
       setSessionScheduleId(undefined);
       setSessionLastModel(undefined);
+      setSessionLastEngine(undefined);
       return;
     }
     apiFetch(`/api/sessions/${currentSessionId}/meta`, ws.getToken)
@@ -121,6 +126,7 @@ export function ConversationPane({ nodeId, sessionId }: { nodeId: string; sessio
         setSessionDirectives(meta.directives);
         setSessionScheduleId(meta.scheduleId);
         setSessionLastModel(meta.lastModel);
+        setSessionLastEngine(meta.lastEngine);
         if (meta.runStatus === 'running') conv.setBusy(true);
       })
       .catch(() => {});
@@ -221,6 +227,7 @@ export function ConversationPane({ nodeId, sessionId }: { nodeId: string; sessio
         agentConfig={ws.agentConfig}
         sessionDirectives={sessionDirectives}
         sessionLastModel={sessionLastModel}
+        sessionLastEngine={sessionLastEngine}
         sessionScheduleId={sessionScheduleId}
         artifactCount={artifacts.artifacts.length}
         getToken={ws.getToken}

package/src/client/lib/ws.ts CHANGED Viewed

@@ -26,7 +26,7 @@ export type ServerEvent =
   | { type: 'session_id'; sessionId: string }
   | { type: 'forked'; sourceSessionId: string; sessionId: string }
   | { type: 'done'; sessionId: string; stopReason?: 'end_turn' | 'max_turns_reached' | (string & {}) }
-  | { type: 'model_resolved'; sessionId: string; model: string }
+  | { type: 'model_resolved'; sessionId: string; model: string; engine: string }
   | { type: 'error'; message: string; sessionId?: string }
   | { type: 'workspace_change'; action: 'created' | 'modified' | 'deleted'; path: string }
   | { type: 'disconnected' }

package/src/server/boot.ts CHANGED Viewed

@@ -25,7 +25,6 @@ import { streamChat, consumeStream, getAgentConfig, saveAgentConfig, getClaudeAu
 import { mountFeatures, registerFeature, resumeFeatureSession, collectFeatureFlags, collectSidecarRoutes } from './features.ts';
 import { registerSpaCatchAll } from './spa-catchall.ts';
 import { slackFeature } from './slack/feature.ts';
-import { paraFeature } from './para/feature.ts';
 import { dataPath } from './paths.ts';
 import { getAllSessions, getSession, getSessionHistory, upsertSession, appendMessage, saveConversation, loadConversation, setSessionDirectives, getAutoApprove, setAutoApprove, getSessionsByScheduleId, getSessionsVisibleTo, isSessionVisibleTo, setRunStatus, incrementRetryCount, getRunningSessions, getActiveLockCount, updateScheduledSessionStatus, setShuttingDown, backfillSessionVisibility, writePartial, readPartial, clearPartial, registerLivePartial, unregisterLivePartial, readLivePartial, acquireSessionLock, releaseSessionLock, replaceSessionLock, isSessionLocked, getSessionAbortController, forkSession, generateSessionTitle, type ConvBlock, type ConvMessage, type SessionMeta } from './sessions.ts';
 import { setBroadcaster } from './session-bus.ts';
@@ -113,7 +112,15 @@ const PASSIVE_FLAG = process.env.SHRAGA_PASSIVE ?? process.env.UNCLAW_PASSIVE;
 const PASSIVE = PASSIVE_FLAG === '1' || PASSIVE_FLAG === 'true';
 if (PASSIVE) console.log('[server] PASSIVE mode — schedulers, consumers and background writers disabled');
+// Local-only prep (git config, gitignore, untracking). The NETWORK half — fetch/merge — is
+// deliberately NOT awaited here; it runs via dataSync.syncOnBoot() AFTER listen(). See syncOnBoot().
 if (!PASSIVE) await dataSync.init();
+// Kick the boot-time data sync detached, AFTER the port is bound. syncOnBoot() never rejects, and the
+// extra .catch() is belt-and-braces: an unhandled rejection here would hit the process-level handler.
+function bootDataSync(): void {
+  dataSync.syncOnBoot().catch(err => console.error('[data-sync] boot sync error:', (err as Error).message));
+}
 await loadShragaConfig();
 // Programmatic engines register through the same seam an overlay uses — BEFORE initEngines() so
 // getAvailableEngines() includes them and a directive can resolve to one immediately.
@@ -993,8 +1000,8 @@ function proxySidecarWebSocket(req: import('node:http').IncomingMessage, socket:
       // proxy-local reply only proves THIS hop is alive: if the proxy→sidecar leg is half-open, or the
       // sidecar has already dropped this client from its subscriber set, the browser still gets pongs,
       // keeps `readyState === OPEN`, shows a green "connected" dot, and every keystroke disappears.
-      // The probe is only worth anything end-to-end, so the sidecar owns the reply (para-pty answers in
-      // its ws message handler); a sidecar that doesn't reply fails the probe, which is the honest
+      // The probe is only worth anything end-to-end, so the sidecar owns the reply (it answers in its
+      // own ws message handler); a sidecar that doesn't reply fails the probe, which is the honest
       // outcome — the client then reconnects rather than trusting a dead pipe.
       if (targetWs.readyState === WebSocket.OPEN) targetWs.send(data, { binary: isBinary });
       else if (!opened && pending.length < 256) pending.push({ data, isBinary }); // bounded: never buffer unboundedly
@@ -1058,7 +1065,7 @@ server.on('upgrade', (req, socket, head) => {
   } else {
     const port = req.url ? resolveSidecarPort(req.url) : null;
     if (port) {
-      // A sidecar socket is a LIVE ATTACHED SHELL (para-pty) — read/write on the user's terminals. It
+      // A sidecar socket is a LIVE ATTACHED SHELL (a terminal daemon) — read/write on the user's terminals. It
       // must be authenticated BEFORE we bridge it, like the HTTP routes (`requireAuth`) and the `/ws`
       // control socket (its `auth` message). NOTE the limit of this gate: it is IDENTITY-ONLY. It proves
       // the token belongs to a valid user; it does NOT check that the user owns (or may access) the
@@ -1215,9 +1222,6 @@ if (process.env.SHRAGA_OVERLAY) {
 // so their routes mount ahead of the SPA fallback, identical to the overlay path.
 for (const f of __reg.features ?? []) registerFeature(f);
 registerFeature(slackFeature);
-// para-li external-agent lane — a second medium alongside Slack; both subscribe the owner-notice
-// bus independently, so neither affects the other.
-registerFeature(paraFeature);
 mountFeatures({ app, requireAuth, broadcast, passive: PASSIVE });
 // Fold in feature-contributed sidecar WS proxy routes (the core names none; each add-on adds its own).
 Object.assign(WS_PROXY_ROUTES, collectSidecarRoutes());
@@ -1233,6 +1237,7 @@ async function activateConsumers() {
   activated = true;
   console.log('[server] ACTIVATING — starting consumers and background writers');
   await dataSync.init();
+  bootDataSync();
   syncVendorRepos().catch(err => console.warn('[vendor-sync] error:', (err as Error).message));
   recordBootGap();
   startHeartbeat();
@@ -2150,6 +2155,7 @@ await new Promise<void>((resolve) => {
     catch (err) { console.warn('[self-upgrade] could not deliver report:', (err as Error).message); }
     startSidecars().catch(err => console.error('[sidecar] startup error:', err));
     recoverInterruptedSessions().catch(err => console.error('[recovery] failed:', err));
+    bootDataSync();
     // The disk MCP catalog is warmed off the turn path by whichever engine consumes it — the CE default
     // (Claude Code) hands MCP servers straight to its SDK and needs no catalog. An add-on engine that
     // uses the shared catalog registers its own boot/interval warm-up through the overlay.

package/src/server/claude.ts CHANGED Viewed

@@ -81,7 +81,7 @@ export type WsEvent =
   | { type: 'question_request'; id: string; questions: AskQuestion[] }
   | { type: 'thinking_delta'; text: string }
   | { type: 'done'; sessionId: string; stopReason?: 'end_turn' | 'max_turns_reached' | (string & {}); builtinHandled?: boolean }
-  | { type: 'model_resolved'; sessionId: string; model: string }
+  | { type: 'model_resolved'; sessionId: string; model: string; engine: string }
   | { type: 'error'; message: string }
   | { type: 'stats'; sample: { t: number; cpu: number; mem: number; load: number; disk: number; diskUsedBytes?: number; diskTotalBytes?: number } };
 // Add-on engines/features emit their OWN events (e.g. a duplex voice brain's `duplex_*`) through the
@@ -356,8 +356,19 @@ export async function* streamChat(opts: {
     console.log(`[stream] turn-context injected (${turnContext.length} chars) for session=${sessionId}`);
   }
-  // Resolve engine and delegate
-  const engine = resolveAndGetEngine(directives as any, config);
+  // Resolve engine and delegate. An unregistered engine is a HARD stop: rerouting to claude-code
+  // would switch provider and billing under the caller while the UI still showed the requested one.
+  // Surfaced as a turn `error` event (not a throw) so every transport — WS, Slack, scheduler, MCP,
+  // webhook — reports it the same way and a scheduled run is marked failed instead of dying.
+  let engine: ReturnType<typeof resolveAndGetEngine>;
+  try {
+    engine = resolveAndGetEngine(directives as any, config);
+  } catch (err) {
+    const message = (err as Error).message;
+    console.error(`[stream] ${message} (user=${opts.uid} session=${sessionId})`);
+    yield { type: 'error', message };
+    return;
+  }
   console.log(`[stream] engine=${engine.name} user=${opts.uid} session=${sessionId}`);
   yield* engine.stream({

package/src/server/data-sync.ts CHANGED Viewed

@@ -179,8 +179,31 @@ export class DataSync {
       await this.untrackIgnored();
       this.ready = true;
     }
+  }
-    await this.pull();
+  /**
+   * Boot-time NETWORK sync: the remote fetch/merge plus the deferred conflict-scan + integrity audit.
+   * Split out of init() so the HTTP port can bind BEFORE any of this runs.
+   *
+   * Why: this used to be the tail of init(), which bootServer awaits before listen(). A stalled pull
+   * (observed on liv-mac-1: `Could not resolve host: github.com`, plus a 60s LLM commit-message
+   * timeout) therefore held the ENTIRE boot — process alive, no listener on any port, 502s for
+   * minutes. The port watchdog then SIGTERM/SIGKILLed the boot (LastExitStatus=9) and the next boot
+   * re-entered the same stall. Serving possibly-stale data and refreshing a moment later is strictly
+   * better than not serving at all.
+   *
+   * Never rejects: the caller runs this detached, and an unhandled rejection here would reach the
+   * process-level handler.
+   */
+  async syncOnBoot(): Promise<void> {
+    if (!this.ready) return; // init() disabled/aborted — nothing to sync against
+    console.log(`${TAG} Boot sync started (background — the server is already serving)`);
+    try {
+      await this.pull();
+      console.log(`${TAG} Boot sync complete`);
+    } catch (err) {
+      console.error(`${TAG} Boot sync FAILED — serving stale data until the next pull:`, (err as Error).message);
+    }
     // Defer heavy sync I/O (reads all tracked files + execSync) to avoid blocking
     // WS connections and page loads during startup.
     setTimeout(() => {
@@ -189,7 +212,8 @@ export class DataSync {
         // execSync inside the audit blocks too — keep it off the scan's tick so the two
         // never add up into one long freeze.
         .then(() => new Promise<void>(r => setImmediate(r)))
-        .then(() => this.runIntegrityAudit());
+        .then(() => this.runIntegrityAudit())
+        .catch(err => console.warn(`${TAG} Post-init integrity audit failed:`, (err as Error).message));
     }, 60_000);
   }

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

@@ -10,7 +10,7 @@ import { registerProactiveMessage } from '../slack/sessions.ts';
 import { registerPoll } from '../polls.ts';
 import { getSession, setSessionModel, getSessionModel, type ConvMessage } from '../sessions.ts';
 import { DEFAULT_MODEL } from '../directives.ts';
-import { resolveModelSwitch } from '../model-aliases.ts';
+import { resolveModelSwitch, MODEL_ALIASES } from '../model-aliases.ts';
 import type { WsEvent, AskQuestion, QuestionAnswers, QuestionHandler } from '../claude.ts';
 import type { AgentEngine, EngineStreamOpts, EngineModel } from './types.ts';
 import { getPromptSuffix } from '../prompt-suffix.ts';
@@ -41,6 +41,16 @@ const DESTRUCTIVE_DATA_PATTERNS = [
   />\s*data\/(conversations?|sessions?|schedules?)\//i,
 ];
+/** Is `id` a model this engine can actually run? Anything else — notably a foreign id like
+ *  `cursor/composer-2.5` or the bare `composer-2.5` a schedule pinned for another engine — used to be
+ *  forwarded straight to the Anthropic SDK, billing Anthropic for a model the caller never asked it
+ *  for. Shape-based rather than an exact list so dated ids (`claude-sonnet-4-5-20250929`) still pass.
+ *  An explicit `anthropic/` prefix is this engine's own provider and is stripped first. */
+function isOwnModel(id: string): boolean {
+  const bare = id.startsWith('anthropic/') ? id.slice('anthropic/'.length) : id;
+  return bare.startsWith('claude-') || bare.toLowerCase() in MODEL_ALIASES;
+}
 type DenyResult = { behavior: 'deny'; message: string };
 function checkSensitiveAccess(toolName: string, input: Record<string, unknown>): DenyResult | null {
@@ -303,7 +313,20 @@ export class ClaudeCodeEngine implements AgentEngine {
     // Always pass an explicit model — left unset, the CLI applies its own default
     // (observed: Opus 4.7), not what the UI's "Default" label promises.
-    options['model'] = directives.model ?? config.model ?? DEFAULT_MODEL;
+    const requestedModel = directives.model || config.model || DEFAULT_MODEL;
+    // Refuse a model that isn't ours instead of posting it to Anthropic. Substituting our default
+    // silently would be the same billing lie in a different costume, so this ends the turn.
+    if (!isOwnModel(requestedModel)) {
+      const message =
+        `Model "${requestedModel}" does not belong to the ${this.name} engine, so this run was stopped ` +
+        `rather than billed to Anthropic under another provider's model name. Pick a Claude model, or ` +
+        `request the engine that owns it (e.g. \`[engine:cursor,model:${requestedModel}]\`) and make sure ` +
+        `that engine is registered on this server.`;
+      console.error(`[claude] ${message}`);
+      yield { type: 'error', message };
+      return;
+    }
+    options['model'] = requestedModel;
     const thinkingMode = directives.thinking ?? config.thinking;
     if (thinkingMode) options['thinking'] = thinkingMode === 'enabled' ? { type: 'enabled' } : { type: thinkingMode };
     const effort = directives.effort ?? config.effort;
@@ -412,11 +435,11 @@ export class ClaudeCodeEngine implements AgentEngine {
               prior: opts.sessionId ? getSessionModel(opts.sessionId) : undefined,
             });
             if (sw.notice) yield { type: 'text_delta', text: sw.notice };
-            if (opts.sessionId) setSessionModel(opts.sessionId, m.model);
+            if (opts.sessionId) setSessionModel(opts.sessionId, m.model, this.name);
             // Live ground-truth so the header pill confirms the actually-resolved model mid-turn
             // (catches inline overrides like [opus] and silent rate-limit fallbacks) instead of
             // only updating on session reload.
-            yield { type: 'model_resolved', sessionId: opts.sessionId ?? '', model: m.model };
+            yield { type: 'model_resolved', sessionId: opts.sessionId ?? '', model: m.model, engine: this.name };
           }
           const servers = m.mcp_servers;
           if (Array.isArray(servers) && servers.length > 0) {

package/src/server/engine/index.ts CHANGED Viewed

@@ -15,7 +15,8 @@ export async function initEngines(): Promise<void> {
   // Core always registers the Claude Code engine (the CE default — @anthropic-ai/claude-agent-sdk).
   // Optional engines are registered by an add-on through the same `registerEngine` seam when the
   // SHRAGA_OVERLAY loads (it's imported before the server serves any turn). Bare CE runs Claude Code
-  // only; a directive requesting an unregistered engine falls back to claude-code (resolveAndGetEngine).
+  // only; a directive requesting an unregistered engine FAILS the turn (resolveAndGetEngine) rather
+  // than rerouting to another vendor's billing.
   registerEngine(new ClaudeCodeEngine());
   // Let `[<model>]` name ANY registered engine's model (e.g. `[composer-2.5]`) and imply its engine.
@@ -49,15 +50,26 @@ export function resolveEngine(directives?: { engine?: string }, agentConfig?: {
   return 'claude-code';
 }
+/** Requested engine isn't registered on this boot. Carries an actionable message; callers surface it
+ *  as a turn error (see streamClaude) — never as a reroute to a different vendor's engine/billing. */
+export class EngineUnavailableError extends Error {
+  constructor(public readonly engine: string, available: string[]) {
+    super(
+      `Engine "${engine}" is not available on this server. Registered engines: ${available.join(', ') || 'none'}. ` +
+        `Optional engines register only when enabled at boot (AGENT_ENGINES must list the engine; the native ` +
+        `cursor engine also needs CURSOR_API_KEY) — check the server env and startup log, then retry. ` +
+        `The run was stopped rather than silently re-routed to another provider's billing.`,
+    );
+    this.name = 'EngineUnavailableError';
+  }
+}
 export function resolveAndGetEngine(directives?: { engine?: string }, agentConfig?: { engine?: string }) {
   const name = resolveEngine(directives, agentConfig);
   // An optional engine may be unregistered on a given boot (add-on not loaded, missing API key or
-  // failed init). Don't let that throw and kill every run — including scheduled jobs like the daily
-  // digest, which resolve the engine from the global agent-config. Fall back to the always-present
-  // claude-code engine with a warning instead.
-  if (!hasEngine(name)) {
-    console.warn(`[engine] "${name}" not registered (available: ${getAvailableEngines().join(', ') || 'none'}) — falling back to claude-code`);
-    return getEngine('claude-code');
-  }
+  // failed init). Rerouting to claude-code here silently switched PROVIDER AND BILLING under the
+  // caller — a cursor/agentx run billed Anthropic while the UI still showed the cursor chips. Fail
+  // loudly instead; the degradation is surfaced to whoever asked (user, schedule) as a turn error.
+  if (!hasEngine(name)) throw new EngineUnavailableError(name, getAvailableEngines());
   return getEngine(name);
 }

package/src/server/notify-owners.ts CHANGED Viewed

@@ -19,10 +19,10 @@ export function ownerEmails(): string[] {
 /** Is this email address an owner of this deployment?
  *
  *  Exported because a medium that is not Slack cannot use `resolveOwners`: that returns Slack ids
- *  (OWNERS ∩ contacts WITH a Slack id), which is a Slack-shaped answer. The para lane holds a
- *  shraga uid + the email of the API key that opened the link, so it joins on the email instead.
- *  An empty/unknown address is NOT an owner — the fail-closed direction, since the alternative is
- *  fanning a deploy report out to whoever happened to link a para. */
+ *  (OWNERS ∩ contacts WITH a Slack id), which is a Slack-shaped answer. A webhook-lane add-on, for
+ *  instance, holds a shraga uid + the email of the API key that opened the link, so it joins on the
+ *  email instead. An empty/unknown address is NOT an owner — the fail-closed direction, since the
+ *  alternative is fanning a deploy report out to whoever happened to open a link. */
 export function isOwnerEmail(email: string | undefined | null): boolean {
   const e = String(email ?? '').trim().toLowerCase();
   return !!e && ownerEmails().includes(e);
@@ -48,8 +48,9 @@ export function senderStamp(): string {
  * side.
  *
  * Returns NOTHING, on purpose. It used to return "was there anyone to tell", which was a truthful
- * answer only while Slack was the sole medium: `resolveOwners` filters on a SLACK id, so once para
- * subscribes the same bus an empty owner list means "no Slack owner", not "nobody was notified".
+ * answer only while Slack was the sole medium: `resolveOwners` filters on a SLACK id, so once another
+ * medium subscribes the same bus an empty owner list means "no Slack owner", not "nobody was
+ * notified".
  * Rather than keep a boolean whose meaning depends on which features happen to be registered — no
  * caller reads it (`data-sync.ts`, `self-upgrade/index.ts`) — the notice is emitted unconditionally
  * and each subscriber decides for itself. The Slack subscriber already no-ops on an empty

package/src/server/scheduler/builtins.ts CHANGED Viewed

@@ -138,7 +138,11 @@ export function ensureBuiltinSchedules(schedules: Schedule[]): Schedule[] {
         match: { status: 'error' },
         throttle: { byFields: ['name', 'error'], windowSec: 21600 },
       },
-      task: { kind: 'prompt', prompt: FAILURE_NOTIFIER_PROMPT },
+      // 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' },
       scope: 'system',
       createdBy: { uid: SYSTEM_UID, email: 'system@shraga.local' },
       createdAt: now,
@@ -163,6 +167,16 @@ 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;
+      }
     } else {
       schedules.push(builtin);
     }