@aion0/forge 0.10.64 → 0.10.66

package/RELEASE_NOTES.md

@@ -1,8 +1,11 @@
-# Forge v0.10.64
+# Forge v0.10.66
 
 Released: 2026-06-10
 
-## Changes since v0.10.63
+## Changes since v0.10.65
 
+### Other
+- fix(login-status): IdP probe honors auth_required_selector — no more same-host login-page false positives
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.63...v0.10.64
+
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.65...v0.10.66

package/app/chat/page.tsx

@@ -206,12 +206,42 @@ export default function ChatPage() {
     };
   }, [activeId, loadMessages, refreshSessions]);
 
-  // ─── Auto-scroll on new content ───────────────────────────
+  // ─── Auto-scroll on new content — only when already at the bottom ──
+  // stickRef tracks whether the user is parked near the bottom. If they've
+  // scrolled up to read earlier turns, a refresh / new streamed chunk must
+  // NOT yank them back down. Updated on every scroll (see onScroll below).
+  const stickRef = useRef(true);
   useEffect(() => {
     const el = scrollRef.current;
-    if (el) el.scrollTop = el.scrollHeight;
+    if (el && stickRef.current) el.scrollTop = el.scrollHeight;
   }, [messages, partial]);
 
+  // ─── Jump markers: one tick per user turn along the scroll track ──
+  const [markers, setMarkers] = useState<{ mid: string; pct: number; offset: number; label: string }[]>([]);
+  const recomputeMarkers = useCallback(() => {
+    const el = scrollRef.current;
+    if (!el) return;
+    const h = el.scrollHeight || 1;
+    const nodes = el.querySelectorAll<HTMLElement>('[data-role="user"][data-mid]');
+    setMarkers([...nodes].map((n) => ({
+      mid: n.dataset.mid || '',
+      offset: n.offsetTop,
+      pct: (n.offsetTop / h) * 100,
+      label: (n.dataset.label || '').slice(0, 80),
+    })));
+  }, []);
+  useEffect(() => {
+    const id = requestAnimationFrame(recomputeMarkers);
+    return () => cancelAnimationFrame(id);
+  }, [messages, partial, recomputeMarkers]);
+  useEffect(() => {
+    const el = scrollRef.current;
+    if (!el || typeof ResizeObserver === 'undefined') return;
+    const ro = new ResizeObserver(() => recomputeMarkers());
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, [recomputeMarkers]);
+
   // ─── Prune stale watch chips (no update in >150s = done/gone) ──
   useEffect(() => {
     const t = setInterval(() => {
@@ -643,7 +673,15 @@ export default function ChatPage() {
           </button>
         </header>
 
-        <div ref={scrollRef} className="flex-1 overflow-y-auto">
+        <div className="flex-1 relative min-h-0">
+        <div
+          ref={scrollRef}
+          className="absolute inset-0 overflow-y-auto"
+          onScroll={(e) => {
+            const el = e.currentTarget;
+            stickRef.current = el.scrollHeight - el.scrollTop - el.clientHeight < 80;
+          }}
+        >
           <div className="max-w-3xl mx-auto px-6 py-6 space-y-6">
             {messages.length === 0 && !partial && !streaming && (
               <div className="text-center text-sm text-[var(--text-secondary)] mt-12">
@@ -672,6 +710,25 @@ export default function ChatPage() {
             )}
           </div>
         </div>
+        {/* Jump rail — one tick per user turn, mapped to its position in the
+            scroll content. Click to jump. Hidden until there are ≥2 turns. */}
+        {markers.length >= 2 && (
+          <div className="absolute right-0.5 top-2 bottom-2 w-3 z-10 pointer-events-none">
+            {markers.map((mk) => (
+              <button
+                key={mk.mid}
+                title={mk.label || 'jump to message'}
+                onClick={() => {
+                  const el = scrollRef.current;
+                  if (el) el.scrollTo({ top: Math.max(0, mk.offset - 12), behavior: 'smooth' });
+                }}
+                className="pointer-events-auto absolute right-0 -translate-y-1/2 h-1.5 w-1.5 rounded-full bg-[var(--text-secondary)] opacity-40 hover:opacity-100 hover:w-2.5 hover:bg-[var(--accent)] transition-all"
+                style={{ top: `${Math.min(99, Math.max(1, mk.pct))}%` }}
+              />
+            ))}
+          </div>
+        )}
+        </div>
 
         {Object.keys(watchChips).length > 0 && (
           <div className="px-6 pt-2">
@@ -775,7 +832,7 @@ function fmtTs(ts?: number): string {
   return sameDay ? time : `${d.toLocaleDateString([], { month: 'short', day: 'numeric' })} ${time}`;
 }
 
-function RoleBlock({ role, ts, pending, children }: { role: 'user' | 'assistant'; ts?: number; pending?: boolean; children: React.ReactNode }) {
+function RoleBlock({ role, ts, pending, mid, label, children }: { role: 'user' | 'assistant'; ts?: number; pending?: boolean; mid?: string; label?: string; children: React.ReactNode }) {
   const isUser = role === 'user';
   // User → right-aligned with bubble; assistant → left-aligned (avatar +
   // expanded content for markdown / tool cards). Pending optimistic notes
@@ -783,7 +840,7 @@ function RoleBlock({ role, ts, pending, children }: { role: 'user' | 'assistant'
   // replaces them on the loop's next iteration.
   if (isUser) {
     return (
-      <div className="flex justify-end">
+      <div className="flex justify-end" data-role="user" data-mid={mid} data-label={label}>
         <div className="max-w-[80%]">
           <div className="flex items-baseline gap-2 mb-1 justify-end">
             {pending ? (
@@ -834,8 +891,12 @@ function RoleBlock({ role, ts, pending, children }: { role: 'user' | 'assistant'
 // chat became visibly laggy.
 const MessageView = memo(function MessageView({ m }: { m: Message }) {
   const pending = typeof m.id === 'string' && m.id.startsWith('optimistic-note-');
+  // Label for the jump rail = first text block of a user turn, trimmed.
+  const label = m.role === 'user'
+    ? (m.blocks.find((b) => b.type === 'text')?.text || '').replace(/\s+/g, ' ').trim().slice(0, 80)
+    : undefined;
   return (
-    <RoleBlock role={m.role} ts={m.ts} pending={pending}>
+    <RoleBlock role={m.role} ts={m.ts} pending={pending} mid={String(m.id)} label={label}>
       {m.blocks.map((b, i) => (
         <BlockView key={i} b={b} role={m.role} />
       ))}

package/components/SettingsModal.tsx

@@ -1799,7 +1799,7 @@ function MarketplaceProvidersSection() {
 }
 
 function AgentsSection({ settings, setSettings }: { settings: any; setSettings: (s: any) => void }) {
-  const { registry: modelsRegistry } = useModelsRegistry();
+  const { registry: modelsRegistry, refresh: refreshModels, loading: modelsLoading } = useModelsRegistry();
   const [agents, setAgents] = useState<AgentEntry[]>([]);
   const [loading, setLoading] = useState(true);
   const [expandedAgent, setExpandedAgent] = useState<string | null>(null);
@@ -2126,6 +2126,13 @@ function AgentsSection({ settings, setSettings }: { settings: any; setSettings:
                     {/* Preset models */}
                     <div className="flex items-center gap-1 mt-1.5 flex-wrap">
                       <span className="text-[8px] text-[var(--text-secondary)]">Presets:</span>
+                      <button
+                        type="button"
+                        onClick={() => { void refreshModels(); }}
+                        disabled={modelsLoading}
+                        title="Refresh model list from the public-info registry (bypasses the 24h cache)"
+                        className="text-[8px] px-1 py-0.5 rounded border border-[var(--border)] text-[var(--text-secondary)] hover:text-[var(--text-primary)] disabled:opacity-50"
+                      >{modelsLoading ? '…' : '↻'}</button>
                       {((() => {
                         const ct = (settings.agents?.[a.id] as any)?.cliType || (a.id === 'claude' ? 'claude-code' : a.id === 'codex' ? 'codex' : a.id === 'aider' ? 'aider' : 'generic');
                         // Models pulled from forge-public-info repo (lib/public-info/fetch.ts).

package/lib/auth/idp-login.ts

@@ -56,6 +56,11 @@ export interface IdpTemplateBlock {
    *  `https://<host>/`. Override when the IdP's logged-in landing page
    *  is at a specific path (e.g. `/saml-idp/portal/` for FAC). */
   probe_url?: string;
+  /** DOM selector present ONLY on the login page (e.g. 'input[type=password]').
+   *  Required for IdPs that serve their login form on the SAME host as the
+   *  logged-in page (sso.frval.fortinet-emea.com) — without it the host-only
+   *  probe falsely reports "signed in" when a login screen is showing. */
+  auth_required_selector?: string;
   /** Optional alt hostnames the IdP also uses (e.g. regional SAML servers). */
   alt_hosts?: string[];
   saml_sps?: string[];

package/lib/auth/login-status.ts

@@ -235,7 +235,7 @@ async function checkIdp(
   const block = readIdpBlocks().find((b) => b.host === host);
   const probe_url = block ? idpProbeUrl(block) : `https://${host}/`;
   try {
-    const r = await runBrowserUrlProbe({ id: `idp:${host}`, host, probe_url });
+    const r = await runBrowserUrlProbe({ id: `idp:${host}`, host, probe_url, auth_required_selector: block?.auth_required_selector });
     return {
       ok: !!r.ok,
       message: r.ok ? (r.message || 'ok') : (r.error || `HTTP ${r.status || '?'}`),

package/lib/chat/tool-dispatcher.ts

@@ -116,6 +116,53 @@ async function resolveScratchRefsInArgs(args: Record<string, unknown>): Promise<
   }
 }
 
+// Download channel (mirror of the scratch:// upload path). A connector that
+// fetched a binary (e.g. owa.download_attachment) can't return the bytes
+// through the model — the 16KB tool-result cap would shred any base64. So it
+// returns `_files: [{ filename, content_base64, content_type }]` and we
+// materialize them HERE: decode → write to <dataDir>/tmp/ → strip the base64
+// and replace each entry with a small {filename, path, file_url, size_bytes}
+// pointer the model can hand to read_forge_file / extract_archive. Bytes
+// never reach the LLM. Generic — any protocol's result is scanned.
+async function materializeConnectorFiles(result: ToolResult): Promise<ToolResult> {
+  let parsed: unknown;
+  try { parsed = JSON.parse(result.content); } catch { return result; }
+  if (!parsed || typeof parsed !== 'object') return result;
+  const files = (parsed as { _files?: unknown })._files;
+  if (!Array.isArray(files) || files.length === 0) return result;
+
+  const { mkdir, writeFile } = await import('node:fs/promises');
+  const { dirname, basename } = await import('node:path');
+  const out: Array<Record<string, unknown>> = [];
+  for (const f of files) {
+    const e = (f && typeof f === 'object') ? f as Record<string, unknown> : {};
+    const b64 = typeof e.content_base64 === 'string' ? e.content_base64 : '';
+    const rawName = String(e.filename || e.name || 'download.bin');
+    // Bare, sanitized name under tmp/ — no traversal, no nesting (the cache
+    // janitor only sweeps top-level tmp/ files).
+    const safe = (basename(rawName).replace(/[\0/\\]/g, '_').replace(/^\.+/, '') || 'download.bin').slice(0, 200);
+    if (!b64) { out.push({ ...e, error: 'no content_base64' }); continue; }
+    try {
+      const buf = Buffer.from(b64, 'base64');
+      const target = await resolveTmpPath(safe);
+      await mkdir(dirname(target), { recursive: true });
+      await writeFile(target, buf);
+      out.push({
+        filename: safe,
+        path: `tmp/${safe}`,
+        local_path: target,
+        file_url: `file://${target}`,
+        size_bytes: buf.length,
+        ...(e.content_type ? { content_type: e.content_type } : {}),
+      });
+    } catch (err) {
+      out.push({ filename: safe, error: (err as Error).message });
+    }
+  }
+  const next = { ...(parsed as Record<string, unknown>), _files: out };
+  return { ...result, content: JSON.stringify(next) };
+}
+
 const BUILTINS: Record<string, BuiltinHandler> = {
   get_current_time: async () => new Date().toISOString(),
 
@@ -475,6 +522,82 @@ const BUILTINS: Record<string, BuiltinHandler> = {
     });
   },
 
+  // Extract a zip/tar/gz archive sitting in tmp/ (e.g. one a connector just
+  // downloaded via the _files channel) into tmp/<base>-extracted/, then
+  // return the file listing so the agent can read_forge_file each entry.
+  // The chat agent has no shell, so this shells out to system unzip/tar/
+  // gunzip on its behalf. Stays inside tmp/ on both ends.
+  extract_archive: async (input) => {
+    const params = (input as { filename?: string } | undefined) || {};
+    const raw = String(params.filename || '').trim().replace(/^tmp\//, '');
+    if (!raw) return JSON.stringify({ ok: false, error: 'filename is required (a tmp/ archive, e.g. "report.zip")' });
+    let archive: string;
+    try { archive = await resolveTmpPath(raw); }
+    catch (e) { return JSON.stringify({ ok: false, error: (e as Error).message }); }
+    const { existsSync } = await import('node:fs');
+    if (!existsSync(archive)) return JSON.stringify({ ok: false, error: `archive not found: tmp/${raw}` });
+
+    const lower = raw.toLowerCase();
+    const base = raw.replace(/\.(zip|tar\.gz|tgz|tar|gz)$/i, '');
+    const outRel = `${base}-extracted`;
+    let outDir: string;
+    try { outDir = await resolveTmpPath(outRel); }
+    catch (e) { return JSON.stringify({ ok: false, error: (e as Error).message }); }
+
+    const { execFile } = await import('node:child_process');
+    const { promisify } = await import('node:util');
+    const { mkdir, readdir, stat } = await import('node:fs/promises');
+    const { join, relative } = await import('node:path');
+    const run = promisify(execFile);
+    await mkdir(outDir, { recursive: true });
+
+    try {
+      if (lower.endsWith('.zip')) {
+        await run('unzip', ['-o', '-qq', archive, '-d', outDir], { timeout: 60000 });
+      } else if (lower.endsWith('.tar.gz') || lower.endsWith('.tgz') || lower.endsWith('.tar')) {
+        await run('tar', ['-xf', archive, '-C', outDir], { timeout: 60000 });
+      } else if (lower.endsWith('.gz')) {
+        // single-file gzip → decompress to the same basename inside outDir
+        const { createReadStream, createWriteStream } = await import('node:fs');
+        const { createGunzip } = await import('node:zlib');
+        const { pipeline } = await import('node:stream/promises');
+        const dest = join(outDir, base.split('/').pop() || 'file');
+        await pipeline(createReadStream(archive), createGunzip(), createWriteStream(dest));
+      } else {
+        return JSON.stringify({ ok: false, error: `unsupported archive type: ${raw} (supported: .zip .tar .tar.gz .tgz .gz)` });
+      }
+    } catch (e) {
+      return JSON.stringify({ ok: false, error: `extraction failed: ${(e as Error).message}` });
+    }
+
+    // Walk the extracted tree (capped) and return tmp-relative paths.
+    const files: Array<{ path: string; size_bytes: number }> = [];
+    const { getDataDir } = await import('../dirs');
+    const tmpRoot = join(getDataDir(), 'tmp');
+    async function walk(dir: string, depth: number): Promise<void> {
+      if (files.length >= 500 || depth > 8) return;
+      for (const ent of await readdir(dir, { withFileTypes: true })) {
+        if (files.length >= 500) break;
+        const full = join(dir, ent.name);
+        if (ent.isDirectory()) { await walk(full, depth + 1); continue; }
+        if (ent.isFile()) {
+          const s = await stat(full);
+          files.push({ path: `tmp/${relative(tmpRoot, full)}`, size_bytes: s.size });
+        }
+      }
+    }
+    try { await walk(outDir, 0); } catch { /* partial listing is fine */ }
+
+    return JSON.stringify({
+      ok: true,
+      archive: `tmp/${raw}`,
+      extracted_dir: `tmp/${outRel}`,
+      count: files.length,
+      files,
+      note: 'Read any entry with read_forge_file (pass its `path`). Extracted dir is NOT auto-swept by the cache janitor (it only sweeps top-level tmp/ files).',
+    });
+  },
+
   // List files anywhere under <dataDir>/ (Forge's own data dir).
   // Replaces the "dispatch a task just to `ls`" workaround. The `dir`
   // param is dataDir-relative — pass "tmp" / "scratch" / "flows" /
@@ -626,8 +749,11 @@ const BUILTINS: Record<string, BuiltinHandler> = {
     const p = (input as any) || {};
     const name = String(p.name || '').trim();
     const workflow = String(p.workflow || p.body_ref || '').trim();
+    const promptText = String(p.prompt || '').trim();
     if (!name) return JSON.stringify({ ok: false, error: 'name is required' });
-    if (!workflow) return JSON.stringify({ ok: false, error: 'workflow (pipeline name) is required' });
+    if (!workflow && !promptText) {
+      return JSON.stringify({ ok: false, error: 'provide either prompt (free-text instructions — dispatched as a one-shot Claude task WITH connector tools) or workflow (an existing pipeline name)' });
+    }
 
     // Trigger normalization: prefer every_minutes; accept at (once) or cron.
     let schedule_kind: 'period' | 'once' | 'cron' = 'period';
@@ -647,14 +773,36 @@ const BUILTINS: Record<string, BuiltinHandler> = {
       return JSON.stringify({ ok: false, error: 'one of every_minutes / at / cron is required' });
     }
 
+    // Body resolution. prompt mode (preferred for "run these instructions on
+    // a schedule") wins when both are somehow given — it dispatches a one-shot
+    // Claude task that HAS the full connector toolset (Teams/Mantis/etc.), so
+    // no pipeline YAML is needed. The prompt text is persisted to
+    // prompts/<slug>.yaml and the schedule row just references it by name.
+    let body_kind: 'pipeline' | 'prompt' = 'pipeline';
+    let body_ref = workflow;
+    const skills = Array.isArray(p.skills) ? p.skills : undefined;
+    if (promptText) {
+      const slug = (name.toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'schedule').slice(0, 64);
+      try {
+        const { createPrompt, getPrompt, updatePrompt } = await import('../prompts/store');
+        const execu = skills ? { skills } : undefined;
+        if (getPrompt(slug)) updatePrompt(slug, { prompt: promptText, executor: execu });
+        else createPrompt({ name: slug, prompt: promptText, executor: execu });
+      } catch (e) {
+        return JSON.stringify({ ok: false, error: `failed to save prompt: ${(e as Error).message}` });
+      }
+      body_kind = 'prompt';
+      body_ref = slug;
+    }
+
     const { createSchedule, seedNextRunAt } = await import('../schedules/store');
     try {
       const s = createSchedule({
         name,
-        body_kind: 'pipeline',
-        body_ref: workflow,
+        body_kind,
+        body_ref,
         input: (p.input && typeof p.input === 'object') ? p.input : {},
-        skills: Array.isArray(p.skills) ? p.skills : undefined,
+        skills,
         enabled: p.enabled !== false,
         schedule_kind,
         schedule_interval_minutes,
@@ -889,6 +1037,17 @@ export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
       required: ['filename'],
     },
   },
+  {
+    name: 'extract_archive',
+    description: 'Unpack an archive sitting in tmp/ (e.g. one a connector just downloaded — owa.download_attachment etc.) into tmp/<base>-extracted/, and return the file listing. USE THIS when an attachment / download is a .zip / .tar / .tar.gz / .tgz / .gz and you need to read what is inside — you have no shell, this runs unzip/tar for you. Then read individual entries with read_forge_file using each returned `path`. Returns JSON {ok, extracted_dir, count, files:[{path,size_bytes}]}.',
+    input_schema: {
+      type: 'object',
+      properties: {
+        filename: { type: 'string', description: 'tmp/ archive to extract, e.g. "report.zip" or "tmp/logs.tar.gz". Must already be in tmp/ (a download lands there via the connector _files channel).' },
+      },
+      required: ['filename'],
+    },
+  },
   {
     name: 'list_forge_files',
     description: 'List files / subdirs anywhere under <dataDir>/ (Forge\'s own data dir). PREFER THIS over `dispatch_task` with `ls` — it\'s sync, in-process, no LLM detour. `dir` is dataDir-relative: pass "tmp" for chat-saved temp files, "scratch" for task workspaces, "flows" / "prompts" / "connectors" for configs. Omit `dir` to see the dataDir root. Each entry has `path` (dataDir-relative), `kind` (file/dir), and `file_url` (file://… opens in Chrome on localhost). Sensitive items (encrypt key, sqlite DBs, server log, *-tokens.json) are filtered out automatically.',
@@ -947,12 +1106,13 @@ export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
   },
   {
     name: 'create_schedule',
-    description: 'Create a recurring (or one-off) schedule that fires a Forge pipeline on a timer. NO HTTP, NO auth — runs in-process. Use this when the user says "every N minutes/hours" / "watch X" / "monitor Y" / "auto-run pipeline on schedule". REQUIRED args: name + workflow + ONE of {every_minutes, at, cron}. Returns { ok, schedule_id, next_run_at }.',
+    description: 'Create a recurring (or one-off) schedule on a timer. NO HTTP, NO auth — runs in-process. Use when the user says "every N minutes/hours" / "watch X" / "monitor Y" / "auto-run on schedule". TWO body modes — pick ONE:\n• prompt mode (PREFERRED for "do these instructions on a schedule"): pass `prompt` with free-text instructions. Each fire dispatches a one-shot Claude task that HAS THE FULL CONNECTOR TOOLSET (Teams/Mantis/GitLab/etc.) and your skills. No pipeline YAML needed — do NOT build a throwaway pipeline just to run a prompt on a timer.\n• pipeline mode: pass `workflow` (an existing pipeline name) for a structured multi-node DAG.\nREQUIRED: name + (prompt OR workflow) + ONE of {every_minutes, at, cron}. Returns { ok, schedule_id, next_run_at }.',
     input_schema: {
       type: 'object',
       properties: {
-        name: { type: 'string', description: 'Human-readable name shown in the Schedules UI.' },
-        workflow: { type: 'string', description: 'Pipeline workflow name (file basename of flows/<name>.yaml). Run trigger_pipeline() with NO args first if unsure what names are available.' },
+        name: { type: 'string', description: 'Human-readable name shown in the Schedules UI. Also used as the prompt slug in prompt mode.' },
+        prompt: { type: 'string', description: 'PROMPT MODE: free-text instructions run as a one-shot Claude task on each fire, with full connector tools + skills. Use this for "every hour check Teams channel X and notify me" style asks. Mutually exclusive with workflow.' },
+        workflow: { type: 'string', description: 'PIPELINE MODE: existing pipeline workflow name (basename of flows/<name>.yaml). Run trigger_pipeline() with NO args first to list. Mutually exclusive with prompt.' },
         input: { type: 'object', description: 'Pipeline input fields. Same shape as trigger_pipeline.input. OMIT optional fields to use defaults.' },
         skills: { type: 'array', items: { type: 'string' }, description: 'Skill names to inject into every Claude task this schedule spawns.' },
         every_minutes: { type: 'number', description: 'Period in minutes (e.g. 60 = hourly). Most common trigger.' },
@@ -961,7 +1121,7 @@ export const BUILTIN_TOOL_DEFS: BuiltinToolDef[] = [
         enabled: { type: 'boolean', description: 'Whether to start enabled. Default true.' },
         action: { type: 'string', enum: ['none', 'chat', 'email', 'telegram'], description: 'Post-run notification action. Default "none".' },
       },
-      required: ['name', 'workflow'],
+      required: ['name'],
     },
   },
   {
@@ -1374,6 +1534,14 @@ export async function dispatchTool(
         return { content: `unknown protocol "${protocol}" on tool ${call.name}`, is_error: true };
     }
 
+    // Download channel: materialize any `_files` base64 payload to tmp/ and
+    // strip the bytes before they reach the model (and before the watch
+    // below re-parses the result). No-op when the result has no _files.
+    if (!result.is_error) {
+      try { result = await materializeConnectorFiles(result); }
+      catch (e) { console.warn('[dispatch] materializeConnectorFiles failed', (e as Error).message); }
+    }
+
     // Async (long-task watch): if the tool declared an `async` block and
     // it ran without error, register a background watch that polls to
     // completion and reports back to the originating chat session. The

package/lib/connectors/sync.ts

@@ -335,11 +335,16 @@ export async function fetchSourceFile(source: SourceMeta, relPath: string): Prom
   // directly (no base64 decode needed). Works for private repos given
   // a Fine-grained PAT with Contents: read.
   const repo = (source.repo_url || '').replace(/^github\.com\//, '');
-  const url = `https://api.github.com/repos/${repo}/contents/${relPath}?ref=main`;
+  // &_t + no-cache: the GitHub contents API edge-caches the ?ref=main blob,
+  // so right after a push a plain fetch can return the STALE file — which
+  // made the marketplace keep showing old connector versions even after
+  // "↻ Sync all". The raw mode already busts via cacheBust(); match it here.
+  const url = `https://api.github.com/repos/${repo}/contents/${relPath}?ref=main&_t=${Date.now()}`;
   try {
     return await rawFetch(url, {
       Authorization: `Bearer ${source.github_pat}`,
       Accept: 'application/vnd.github.raw',
+      'Cache-Control': 'no-cache',
     });
   } catch (err) {
     // GitHub returns 404 (not 401) for private repos when the PAT

package/lib/connectors/test-runner.ts

@@ -283,6 +283,12 @@ export async function runBrowserUrlProbe(opts: {
   id: string;            // identifier for telemetry, e.g. 'idp:fac.corp.fortinet.com'
   host: string;          // expected host (e.g. 'fac.corp.fortinet.com')
   probe_url: string;     // URL to navigate to (e.g. 'https://fac.corp.fortinet.com/saml-idp/portal/')
+  // DOM selector present ONLY on the login page (e.g. 'input[type=password]').
+  // Required for IdPs that serve their login form on the SAME host as the
+  // logged-in page (sso.frval.fortinet-emea.com), where the host-only check
+  // can't tell logged-in from a login screen. Extension v0.2.15+ runs the
+  // querySelector and returns ok:false on a match.
+  auth_required_selector?: string;
   timeout_ms?: number;
 }): Promise<TestResult> {
   const t0 = Date.now();
@@ -291,6 +297,7 @@ export async function runBrowserUrlProbe(opts: {
     value = await bridgeRpc('connector.probe', {
       pluginId: opts.id,
       host_match: opts.probe_url,    // extension navigates to this URL directly
+      auth_required_selector: opts.auth_required_selector || undefined,
       runner: 'main',
       timeout_ms: opts.timeout_ms || 15_000,
     });
@@ -303,8 +310,14 @@ export async function runBrowserUrlProbe(opts: {
   // Pass if landed host matches expected. A redirect to a different host
   // (e.g. fac.corp.fortinet.com → ms-login.fortinet.com when SSO expired)
   // means the user needs to re-authenticate.
-  let onExpected = false;
-  try { onExpected = !failedNetwork && new URL(landed).hostname.toLowerCase() === opts.host.toLowerCase(); } catch { /* bad url */ }
+  let hostnameMatch = false;
+  try { hostnameMatch = !failedNetwork && new URL(landed).hostname.toLowerCase() === opts.host.toLowerCase(); } catch { /* bad url */ }
+  // When auth_required_selector is set, the extension flips ok:false if the
+  // login form is on the page — so a same-host login screen no longer passes.
+  // Older extensions / no selector → r.ok is undefined and we fall back to
+  // the host-only check.
+  const loginFormShown = opts.auth_required_selector ? r.ok === false : false;
+  const onExpected = hostnameMatch && !loginFormShown;
   return {
     ok: onExpected,
     message: onExpected ? `Session active · ${landed}` : undefined,
@@ -312,7 +325,9 @@ export async function runBrowserUrlProbe(opts: {
       ? undefined
       : (failedNetwork
         ? `Network unreachable — ${landed || '(no url)'}. VPN / hostname / firewall?`
-        : `Not signed in — redirected to ${landed}`),
+        : loginFormShown
+          ? `Not signed in — login page shown at ${landed}`
+          : `Not signed in — redirected to ${landed}`),
     url: landed,
     duration_ms: Date.now() - t0,
   };

package/lib/help-docs/13-schedules.md

@@ -1,8 +1,20 @@
 # Schedules
 
-**Schedule = a pipeline + input + trigger.** Forge runs the named pipeline with
-your input whenever the trigger fires. The pipeline is the only execution unit;
-Schedule just decides *when* to fire.
+**Schedule = a body + trigger.** The trigger decides *when* to fire; the body
+decides *what* runs. There are two body kinds — pick whichever fits:
+
+- **Prompt** (simplest, most common) — free-text instructions run as a one-shot
+  Claude task on each fire. **The task has the full connector toolset
+  (Teams / Mantis / GitLab / etc.) plus any skills you attach** — so "every hour
+  check the FortiNAC Teams channel and message me anything new" is a single
+  prompt schedule. You do **not** need a pipeline for this. The prompt text is
+  saved to `prompts/<slug>.yaml` and the schedule row references it by name.
+- **Pipeline** — fires an existing pipeline (`flows/<name>.yaml`) with input.
+  Use when you need a structured multi-node DAG, `for_each:` iteration, or
+  per-node project/worktree control.
+
+> Don't build a throwaway pipeline just to run a prompt on a timer — use prompt
+> mode. The chat `create_schedule` tool accepts either `prompt` or `workflow`.
 
 **Note:** Jobs (the older subsystem) is deprecated — its UI is hidden and the
 scheduler no longer ticks. Any existing rows in the `jobs` table are inert.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aion0/forge",
-  "version": "0.10.64",
+  "version": "0.10.66",
   "description": "Unified AI workflow platform — multi-model task orchestration, persistent sessions, web terminal, remote access",
   "type": "module",
   "scripts": {

package/publish.sh

@@ -9,11 +9,18 @@
 
 set -e
 
-# Preflight: fail BEFORE any version bump / commit / tag / push if gh is
-# not authenticated. Otherwise the release step 401s after everything else
-# already happened, leaving a tag pushed without a GitHub Release.
+# Preflight: fail BEFORE any version bump / commit / tag / push if gh can't
+# actually talk to GitHub. We hit a real endpoint (gh api user) instead of
+# `gh auth status` — status only checks a token is STORED, not that it still
+# works; a stale/revoked keyring token passes status but 401s on every call.
+GH_LOGIN_HINT="gh auth login --hostname github.com --web --git-protocol ssh"
 if command -v gh &> /dev/null; then
-  gh auth status &> /dev/null || { echo "✗ gh is not authenticated — run 'gh auth login' first (the GitHub Release step would 401)."; exit 1; }
+  gh api user &> /dev/null || {
+    echo "✗ gh can't authenticate to GitHub (token missing/expired/revoked)."
+    echo "  Re-auth, then re-run ./publish.sh:"
+    echo "    $GH_LOGIN_HINT"
+    exit 1
+  }
 fi
 
 VERSION_ARG=${1:-patch}
@@ -144,8 +151,18 @@ git push origin "v$NEW_VERSION"
 if command -v gh &> /dev/null; then
   echo ""
   echo "Creating GitHub Release..."
-  gh release create "v$NEW_VERSION" --title "v$NEW_VERSION" --notes-file "$RELEASE_NOTES_FILE"
-  echo "✓ GitHub Release created: https://github.com/aiwatching/forge/releases/tag/v$NEW_VERSION"
+  if gh release create "v$NEW_VERSION" --title "v$NEW_VERSION" --notes-file "$RELEASE_NOTES_FILE"; then
+    echo "✓ GitHub Release created: https://github.com/aiwatching/forge/releases/tag/v$NEW_VERSION"
+  else
+    # The tag is already pushed at this point — re-auth and just create the
+    # release, no need to re-run the whole publish. A stale keyring token
+    # 401s here even though `gh auth status` claims you're logged in.
+    echo ""
+    echo "✗ GitHub Release failed (usually a stale gh token — 401). The tag v$NEW_VERSION is already pushed."
+    echo "  Fix: re-auth, then create just the release:"
+    echo "    $GH_LOGIN_HINT"
+    echo "    gh release create v$NEW_VERSION --title v$NEW_VERSION --notes-file $RELEASE_NOTES_FILE"
+  fi
 else
   echo ""
   echo "gh CLI not found. Create release manually:"