shraga 0.1.158 → 0.1.160

package/dist/client/index.html

@@ -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-z_8q_3F7.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-BLAQpfJ9.css">
+    <script type="module" crossorigin src="/assets/index-yBsLZ3yV.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-NtN1I_dh.css">
   </head>
   <body>
     <div id="root"></div>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "shraga",
-  "version": "0.1.158",
+  "version": "0.1.160",
   "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

@@ -11,6 +11,8 @@ import { ClaudeAccountSection } from './ClaudeAccountSection';
 
 interface AgentConfig {
   model?: string;
+  /** Default model for scheduled runs; unset = same as `model`. */
+  scheduleModel?: string;
   engine?: string;
   systemPrompt?: string;
   allowedTools?: string[];
@@ -176,6 +178,18 @@ export function ConfigPanel({ getToken, onSaved, trigger, sessionId, sessionDire
       )
     : null;
 
+  /** The model <option>s (grouped by provider when the engine has several). `skipDefault` drops the "" entry. */
+  const modelOptions = (skipDefault = false) => {
+    const opts = (list: EngineModel[]) => list.filter((m) => !skipDefault || m.value).map((m) => (
+      <option key={m.value} value={m.value}>{m.label}</option>
+    ));
+    return groupedModels
+      ? groupedModels.map(([provider, providerModels]) => (
+          <optgroup key={provider} label={provider.charAt(0).toUpperCase() + provider.slice(1)}>{opts(providerModels)}</optgroup>
+        ))
+      : opts(models);
+  };
+
   const selectClass = 'flex h-10 w-full rounded-md border border-input bg-background px-3 py-2 text-sm ring-offset-background focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2';
 
   return (
@@ -237,20 +251,22 @@ export function ConfigPanel({ getToken, onSaved, trigger, sessionId, sessionDire
               onChange={(e) => setConfig((c) => ({ ...c, model: e.target.value || undefined }))}
               className={selectClass}
             >
-              {groupedModels ? (
-                groupedModels.map(([provider, providerModels]) => (
-                  <optgroup key={provider} label={provider.charAt(0).toUpperCase() + provider.slice(1)}>
-                    {providerModels.map((m) => (
-                      <option key={m.value} value={m.value}>{m.label}</option>
-                    ))}
-                  </optgroup>
-                ))
-              ) : (
-                models.map((m) => (
-                  <option key={m.value} value={m.value}>{m.label}</option>
-                ))
-              )}
+              {modelOptions()}
+            </select>
+          </div>
+
+          <div>
+            <label className="text-sm font-medium mb-1.5 block">Scheduled tasks model</label>
+            <select
+              disabled={!canGlobal}
+              value={config.scheduleModel ?? ''}
+              onChange={(e) => setConfig((c) => ({ ...c, scheduleModel: e.target.value || undefined }))}
+              className={selectClass}
+            >
+              <option value="">Same as default model ({(sessionId && !applyGlobally ? globalRef.current.model : config.model) || DEFAULT_MODEL})</option>
+              {modelOptions(true)}
             </select>
+            <p className="text-xs text-muted-foreground mt-1">Used by scheduled runs whose prompt has no <code>[model:…]</code> directive.</p>
           </div>
 
           {slots.settingsSections?.({ getToken, sessionId })}

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

@@ -1,4 +1,4 @@
-import { useMemo, useState } from 'react';
+import { useEffect, useMemo, useState } from 'react';
 import cronstrue from 'cronstrue';
 import type { Schedule, Trigger, Task } from '@/lib/schedule-types';
 import { Button } from '../ui/button';
@@ -7,6 +7,7 @@ import { Textarea } from '../ui/textarea';
 import { AutocompleteTextarea } from '../AutocompleteTextarea';
 import { useEngines } from '@/hooks/useEngines';
 import { readRuntimeDirective, writeRuntimeDirective } from '@/lib/prompt-directives';
+import { DEFAULT_MODEL } from '../../../shared/models';
 
 interface Props {
   getToken: () => Promise<string | null>;
@@ -72,6 +73,15 @@ function MatchEditor({ match, onChange }: { match: Record<string, string>; onCha
  *  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);
+  // The model an unpinned scheduled run actually uses: scheduleModel > model > built-in default.
+  const [defaultModel, setDefaultModel] = useState<string>();
+  useEffect(() => {
+    let alive = true;
+    getToken().then((token) => (token ? fetch('/api/config', { headers: { Authorization: `Bearer ${token}` } }).then((r) => r.json()) : null))
+      .then((c) => { if (alive && c) setDefaultModel(c.scheduleModel || c.model || DEFAULT_MODEL); })
+      .catch((e) => console.warn('[schedules] agent config load failed', e));
+    return () => { alive = false; };
+  }, [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;
@@ -111,7 +121,7 @@ function RuntimePicker({ prompt, onChange, getToken }: { prompt: string; onChang
         {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>
+        <option value="">Default model ({(!sel.engineExplicit && defaultModel) || '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}>

package/src/server/boot.ts

@@ -31,6 +31,7 @@ import { setBroadcaster, emitToSession } from './session-bus.ts';
 import { TURN_CONTROL_EVENTS } from './turn-stream.ts';
 import * as scheduler from './scheduler/index.ts';
 import { initPolls } from './polls.ts';
+import { isScheduledSession } from './scheduler/runner.ts';
 import { initBackgroundJobs } from './background-jobs.ts';
 import { pushEnabled } from './push/push.ts';
 import { upsertToken, removeToken } from './push/store.ts';
@@ -1365,7 +1366,7 @@ initPolls({
       // NOTHING until it ended — and an add-on engine's subagent events were dropped outright — so a
       // turn that dispatched a worker was indistinguishable from one that only claimed to.
       return await consumeStream(
-        streamChat({ principal: fromInternal({ uid, email: userEmail, lane: 'wake' }), prompt, sessionId, uid, userEmail, mcpServers: getMcpConfig(uid), abortController, onPermissionRequest: async () => ({ allow: true }) }),
+        streamChat({ principal: fromInternal({ uid, email: userEmail, lane: 'wake' }), prompt, sessionId, uid, userEmail, mcpServers: getMcpConfig(uid), abortController, onPermissionRequest: async () => ({ allow: true }), scheduled: isScheduledSession(sessionId) }),
         undefined,
         {
           maxResultChars: STREAMED_RESULT_MAX,

package/src/server/claude.ts

@@ -207,6 +207,8 @@ export interface StreamChatOpts {
    * where an add-on's contributor reads its own keys. */
   turnHints?: Record<string, unknown>;
   context?: Record<string, string>;
+  /** Unattended scheduled run: `config.scheduleModel` (when set) replaces `config.model` as the default. */
+  scheduled?: boolean;
 }
 
 /** Run one agent turn. Security wrapper: resolves the principal's role/profile and audits turn.start / turn.end.
@@ -285,8 +287,16 @@ export async function taintSession(sessionId: string, principal: Principal | (()
   return lowerSessionFloor(sessionId, resolvePrincipal(sec.policy, p).rank);
 }
 
-async function* runTurn(opts: StreamChatOpts, guard?: TurnGuard): AsyncGenerator<WsEvent> {
+/** The agent config a turn runs under. A scheduled run swaps in `scheduleModel` as its default model —
+ *  at the config layer, so every engine's `directives.model || config.model` picks it up and an
+ *  explicit `[model:…]` directive still wins. */
+export function effectiveAgentConfig(opts: Pick<StreamChatOpts, 'scheduled'>): AgentConfig {
   const config = getAgentConfig();
+  return opts.scheduled && config.scheduleModel ? { ...config, model: config.scheduleModel } : config;
+}
+
+async function* runTurn(opts: StreamChatOpts, guard?: TurnGuard): AsyncGenerator<WsEvent> {
+  const config = effectiveAgentConfig(opts);
   const { prompt: cleanPrompt, directives: parsed, unresolvedModel } = parseDirectives(opts.prompt);
 
   // An explicit model selection that resolves to nothing is a HARD stop, for the same reason an

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

@@ -538,11 +538,13 @@ export class ClaudeCodeEngine implements AgentEngine {
     // where the profile grants Bash — job_start is arbitrary shell — and only for a real session id
     // (wake reports need a session to land in).
     if (durableJobs) {
-      // The job store scrubs `*_API_KEY` from children, so a nested agent (the social legs' agentx worker)
-      // died "No provider key found" (2026-09-24). Hand back the provider keys THIS turn's own env already
-      // carries (profile-filtered by buildAgentEnv) — the same set the agentx engine gives its jobs.
-      const providerEnv = Object.fromEntries(Object.entries(sdkEnv).filter(([k, v]) => /_API_KEY$/.test(k) && v));
-      const server = jobsMcpServer({ sessionId: opts.sessionId!, uid: opts.uid, userEmail: opts.userEmail, cwd, env: providerEnv });
+      // The job store scrubs credentials from children, but here the turn's own Bash already sees this
+      // env (profile-filtered by buildAgentEnv). Scrubbing it made job_start strictly weaker than Bash, and
+      // the hook steers long scripts INTO job_start: a nested agent died "No provider key found" (2026-09-24),
+      // AGF Post-Daily lost MIXPANEL_API_SECRET_AGF/GOOGLE_SERVICE_ACCOUNT (2026-10-20). Hand the job the
+      // turn's env, minus PORT (the server's own; a job honouring it would shadow us).
+      const jobEnv = Object.fromEntries(Object.entries(sdkEnv).filter(([k, v]) => v && k !== 'PORT'));
+      const server = jobsMcpServer({ sessionId: opts.sessionId!, uid: opts.uid, userEmail: opts.userEmail, cwd, env: jobEnv });
       options['mcpServers'] = { ...(options['mcpServers'] as object | undefined), [server.name]: server };
       options['allowedTools'] = [...((options['allowedTools'] as string[] | undefined) ?? allowedTools), ...JOBS_TOOL_IDS];
     }

package/src/server/scheduler/runner.ts

@@ -182,6 +182,10 @@ function formatEventBlock(e: EventContext): string {
   return `An external event triggered this automation.\nSource: ${e.source}\nEvent data:\n\`\`\`json\n${body}\n\`\`\``;
 }
 
+/** Prefix of every session id a scheduled run mints — the marker that a session belongs to the scheduler. */
+export const SCHEDULED_SESSION_PREFIX = 'sched-';
+export const isScheduledSession = (sessionId: string): boolean => sessionId.startsWith(SCHEDULED_SESSION_PREFIX);
+
 export async function runSchedule(
   schedule: Schedule,
   onEvent: (ev: object) => void,
@@ -192,7 +196,7 @@ export async function runSchedule(
 ): Promise<ScheduleRunSummary> {
   const now = Date.now();
   // Resume reuses the interrupted run's session (same convo) instead of spawning a new one.
-  const sessionId = resume ? resume.sessionId : `sched-${schedule.id}-${now}`;
+  const sessionId = resume ? resume.sessionId : `${SCHEDULED_SESSION_PREFIX}${schedule.id}-${now}`;
   const abortController = new AbortController();
   registerRun(sessionId, abortController);
 
@@ -326,6 +330,7 @@ export async function runSchedule(
           abortController,
           onPermissionRequest,
           foregroundBashCommand: allowedCmd ?? undefined,
+          scheduled: true,
         })) {
           onEvent({ type: 'session_stream', sessionId, event: ev });
           if (ev.type === 'text_delta') {

package/src/server/shraga-config.ts

@@ -44,6 +44,8 @@ function isFullEntry(entry: McpEntry): entry is McpFullEntry {
 
 export interface AgentSettings {
   model?: string;
+  /** Model for scheduled (unattended) runs whose prompt names no `[model:…]`. Unset = `model`. */
+  scheduleModel?: string;
   engine?: string;
   systemPrompt?: string;
   allowedTools?: string[];