@aion0/forge 0.10.75 → 0.10.77

package/RELEASE_NOTES.md

@@ -1,11 +1,12 @@
-# Forge v0.10.75
+# Forge v0.10.77
 
-Released: 2026-06-11
+Released: 2026-06-12
 
-## Changes since v0.10.74
+## Changes since v0.10.76
 
 ### Other
-- fix(pipeline): orphan reaper only kills tasks older than this boot
+- fix(ui): route idpManualUrls open through openPortal too
+- feat(ui): Open-portal buttons route through container Chromium when present
 
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.74...v0.10.75
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.76...v0.10.77

package/components/ConnectorsPanel.tsx

@@ -17,6 +17,7 @@
  */
 
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
+import { openPortal } from '@/lib/ui/openPortal';
 
 interface MarketEntry {
   id: string;
@@ -929,9 +930,8 @@ function TemplateImportModal({
                   {p.url && (
                     <a
                       href={p.url}
-                      target="_blank"
-                      rel="noopener noreferrer"
-                      className="ml-auto text-[10px] text-[var(--accent)] hover:underline"
+                      onClick={(e) => { e.preventDefault(); void openPortal(p.url!); }}
+                      className="ml-auto text-[10px] text-[var(--accent)] hover:underline cursor-pointer"
                       title={p.url}
                     >
                       ↗ {p.url_label || 'Get token'}

package/components/EnterpriseBadge.tsx

@@ -16,6 +16,7 @@
  */
 
 import { useEffect, useRef, useState } from 'react';
+import { openPortal } from '@/lib/ui/openPortal';
 
 interface SourceView {
   tenant_id: string;
@@ -171,7 +172,7 @@ export default function EnterpriseBadge({ onOpenSettings: _onOpenSettings }: { o
           r.source.refresh.url,
         );
         failed.forEach((r, i) => setTimeout(() => {
-          window.open(r.source.refresh.url!, '_blank', 'noopener');
+          void openPortal(r.source.refresh.url!);
         }, i * 250));
       }
     } catch (e) {
@@ -183,7 +184,7 @@ export default function EnterpriseBadge({ onOpenSettings: _onOpenSettings }: { o
 
   const handleOpenWeb = (row: { refresh: { kind: string; url?: string } }) => {
     if (row.refresh.kind === 'open-url' && row.refresh.url) {
-      window.open(row.refresh.url, '_blank', 'noopener');
+      void openPortal(row.refresh.url);
     }
   };
 
@@ -533,10 +534,9 @@ export default function EnterpriseBadge({ onOpenSettings: _onOpenSettings }: { o
                     <div key={i} className="flex items-center gap-1">
                       <a
                         href={u.url}
-                        target="_blank"
-                        rel="noopener"
+                        onClick={(e) => { e.preventDefault(); void openPortal(u.url); }}
                         title={u.error || u.host}
-                        className="flex-1 bg-black/30 px-1.5 py-0.5 rounded font-mono text-[10px] break-all hover:bg-black/40 underline"
+                        className="flex-1 bg-black/30 px-1.5 py-0.5 rounded font-mono text-[10px] break-all hover:bg-black/40 underline cursor-pointer"
                       >
                         {u.url}
                       </a>

package/components/LoginStatusPanel.tsx

@@ -1,6 +1,7 @@
 'use client';
 
 import { useState, useEffect, useCallback } from 'react';
+import { openPortal } from '@/lib/ui/openPortal';
 
 type LoginCategory = 'browser' | 'token' | 'external';
 
@@ -104,7 +105,7 @@ export default function LoginStatusPanel({ onClose }: { onClose: () => void }) {
   const refresh = (source: LoginSource) => {
     const r = source.refresh;
     if (r.kind === 'open-url') {
-      window.open(r.url, '_blank', 'noopener');
+      void openPortal(r.url);
     } else if (r.kind === 'show-command') {
       setShowCmd({ command: r.command, description: r.description });
     } else if (r.kind === 'open-settings') {

package/components/OnboardingWizard.tsx

@@ -14,6 +14,7 @@
  */
 
 import { useEffect, useRef, useState } from 'react';
+import { openPortal } from '@/lib/ui/openPortal';
 
 // ─── Types echoing the API surface ───────────────────────────
 
@@ -746,9 +747,8 @@ export function OnboardingDrawer({ onClose, onComplete, initialSourceId }: { onC
                       {!ok && ref?.kind === 'open-url' && ref.url && (
                         <a
                           href={ref.url}
-                          target="_blank"
-                          rel="noopener noreferrer"
-                          className="text-[var(--accent)] hover:underline ml-auto"
+                          onClick={(e) => { e.preventDefault(); void openPortal(ref.url!); }}
+                          className="text-[var(--accent)] hover:underline ml-auto cursor-pointer"
                           title={ref.description || ref.url}
                         >
                           ↗ login
@@ -1242,7 +1242,7 @@ export function OnboardingDrawer({ onClose, onComplete, initialSourceId }: { onC
                         {!p.required && !isSet && <span className="text-[9px] text-[var(--text-secondary)]">(optional)</span>}
                         {isSet && <span className="text-[9px] text-emerald-500">● currently set</span>}
                         {p.url && (
-                          <a href={p.url} target="_blank" rel="noopener noreferrer" className="ml-auto text-[10px] text-[var(--accent)] hover:underline" title={p.url}>
+                          <a href={p.url} onClick={(e) => { e.preventDefault(); void openPortal(p.url!); }} className="ml-auto text-[10px] text-[var(--accent)] hover:underline cursor-pointer" title={p.url}>
                             ↗ {p.url_label || 'Get token'}
                           </a>
                         )}

package/lib/chat/agent-loop.ts

@@ -1054,6 +1054,30 @@ export async function runTurn(args: RunTurnArgs): Promise<{ ok: boolean; error?:
     // returns at session-not-found and provider-error, and any throw
     // anywhere in the function. Guarantees the turn-control running
     // flag is always cleared so future inputs can start fresh turns.
+    //
+    // Leftover notes: an input can land between the loop's FINAL
+    // consumeNotes and here — enqueueChatInput saw running=true and
+    // merged it, but no iteration will ever consume it. endTurn wipes
+    // notes, so without this drain the message is silently lost and
+    // the sender's UI hangs on "pending" forever. Take them first and
+    // replay through the queue so they start a follow-up turn (or
+    // merge into whichever turn claimed in the meantime).
+    const leftovers = consumeNotes(args.sessionId);
     endTurn(args.sessionId);
+    if (leftovers.length > 0) {
+      // Lazy require: input-queue imports runTurn from this module —
+      // a static import here would be circular.
+      // eslint-disable-next-line @typescript-eslint/no-require-imports
+      const { enqueueChatInput } = require('./input-queue') as typeof import('./input-queue');
+      for (const text of leftovers) {
+        enqueueChatInput({
+          sessionId: args.sessionId,
+          text,
+          mode: 'turn',
+          source: 'user',
+          onEvent: args.callbacks?.onEvent,
+        });
+      }
+    }
   }
 }

package/lib/chat/build-memory-context.ts

@@ -108,6 +108,11 @@ function dropForeignChatHits(hits: SearchHit[], sessionId?: string): SearchHit[]
 }
 
 function isOwnChatOrNotChat(key: string, sessionId: string): boolean {
+  // Local-backend chat-summary documents: doc:chats/<sessionId>.md —
+  // same cross-session noise concern as the legacy chat:* blocks.
+  if (key.startsWith('doc:chats/')) {
+    return key.slice('doc:chats/'.length).replace(/\.md$/, '') === sessionId;
+  }
   if (!key.startsWith('chat:')) return true;
   // key shape: chat:<sessionId>:summary:<ts> → split[1] === sessionId
   return key.split(':', 2)[1] === sessionId;

package/lib/chat/local-memory.ts

@@ -21,7 +21,10 @@ import { getDb } from '../../src/core/db/database';
 import { getDataDir } from '../dirs';
 import type Database from 'better-sqlite3';
 import type {
+  BulkEpisodeResult,
+  DocumentInput,
   EpisodeInput,
+  EpisodeWriteResult,
   MemoryBlock,
   MemoryStore,
   SearchHit,
@@ -198,11 +201,11 @@ export class LocalMemoryStore implements MemoryStore {
     return hits.slice(0, cap);
   }
 
-  async writeEpisode(ep: EpisodeInput, _asyncExtract = true): Promise<boolean> {
-    if (!ep.content || !ep.content.trim()) return false;
+  async writeEpisode(ep: EpisodeInput, _asyncExtract = true): Promise<EpisodeWriteResult> {
+    if (!ep.content || !ep.content.trim()) return { ok: false, skipped: false };
     try {
       const conn = db();
-      conn.prepare(
+      const r = conn.prepare(
         `INSERT INTO memory_episodes(ns, content, tags, source_type, reference_time, created_at)
          VALUES (?, ?, ?, ?, ?, ?)`,
       ).run(
@@ -213,11 +216,39 @@ export class LocalMemoryStore implements MemoryStore {
         ep.reference_time ?? nowIso(),
         nowIso(),
       );
-      return true;
+      return { ok: true, skipped: false, episode_id: String(r.lastInsertRowid) };
     } catch (err) {
       console.warn('[local-memory] writeEpisode failed', err);
-      return false;
+      return { ok: false, skipped: false };
+    }
+  }
+
+  /** Local has no bulk endpoint — loop. Same per-item semantics. */
+  async writeEpisodesBulk(items: EpisodeInput[], _opts: { saga?: string } = {}): Promise<BulkEpisodeResult> {
+    const ids: string[] = [];
+    let skipped = 0;
+    for (const ep of items.slice(0, 200)) {
+      const r = await this.writeEpisode(ep);
+      if (r.ok && r.episode_id) ids.push(r.episode_id);
+      else skipped += 1;
     }
+    return { ok: true, episode_ids: ids, skipped_count: skipped };
+  }
+
+  /** Documents fall back to a `doc:<path>` block — keeps summaries
+   *  addressable + searchable without a separate table. */
+  async putDocument(path: string, doc: DocumentInput): Promise<boolean> {
+    return this.putBlock(`doc:${path}`, { title: doc.title, content: doc.content, tags: doc.tags }, {
+      description: doc.title.slice(0, 120),
+    });
+  }
+
+  async getDocument(path: string): Promise<{ title: string; content: string } | null> {
+    const b = await this.getBlock(`doc:${path}`);
+    if (!b || typeof b.value !== 'object' || b.value === null) return null;
+    const v = b.value as { title?: string; content?: string };
+    if (typeof v.content !== 'string') return null;
+    return { title: v.title || path, content: v.content };
   }
 
   async listBlocks(opts: { pinned?: boolean; scope?: 'own' | 'global' | 'both' } = {}): Promise<MemoryBlock[]> {

package/lib/chat/memory-store.ts

@@ -18,9 +18,9 @@
 import { loadSettings } from '../settings';
 import { TemperClient } from './temper';
 import { LocalMemoryStore } from './local-memory';
-import type { EpisodeInput, MemoryBlock, SearchHit } from './temper';
+import type { BulkEpisodeResult, DocumentInput, EpisodeInput, EpisodeWriteResult, MemoryBlock, SearchHit } from './temper';
 
-export type { EpisodeInput, MemoryBlock, SearchHit } from './temper';
+export type { BulkEpisodeResult, DocumentInput, EpisodeInput, EpisodeWriteResult, MemoryBlock, SearchHit } from './temper';
 
 export interface MemoryStore {
   readonly enabled: boolean;
@@ -28,7 +28,9 @@ export interface MemoryStore {
   readonly kind: 'temper' | 'local';
 
   search(query: string, limit?: number): Promise<SearchHit[]>;
-  writeEpisode(ep: EpisodeInput, asyncExtract?: boolean): Promise<boolean>;
+  writeEpisode(ep: EpisodeInput, asyncExtract?: boolean): Promise<EpisodeWriteResult>;
+  /** One round trip for many episodes (≤200). Local backend loops. */
+  writeEpisodesBulk(items: EpisodeInput[], opts?: { saga?: string }): Promise<BulkEpisodeResult>;
   listBlocks(opts?: { pinned?: boolean; scope?: 'own' | 'global' | 'both' }): Promise<MemoryBlock[]>;
   getBlock(key: string, scope?: 'own' | 'global'): Promise<MemoryBlock | null>;
   putBlock(
@@ -36,6 +38,11 @@ export interface MemoryStore {
     value: unknown,
     extras?: { pinned?: boolean; priority?: number; description?: string; scope?: 'own' | 'global' },
   ): Promise<boolean>;
+  /** Long-form addressable content (chat summaries, reports). Temper:
+   *  /v1/documents upsert with revisions. Local: stored as a
+   *  `doc:<path>` block so it stays searchable. */
+  putDocument(path: string, doc: DocumentInput): Promise<boolean>;
+  getDocument(path: string): Promise<{ title: string; content: string } | null>;
   ping(): Promise<{ ok: boolean; message: string; pinned: number }>;
 }
 
@@ -79,9 +86,12 @@ function makeTemperWrapper(c: TemperClient): MemoryStore {
     },
     search: (q, n) => c.search(q, n),
     writeEpisode: (ep, a) => c.writeEpisode(ep, a),
+    writeEpisodesBulk: (items, opts) => c.writeEpisodesBulk(items, opts),
     listBlocks: (opts) => c.listBlocks(opts ?? {}),
     getBlock: (k, scope) => c.getBlock(k, scope),
     putBlock: (k, v, extras) => c.putBlock(k, v, extras),
+    putDocument: (p, d) => c.putDocument(p, d),
+    getDocument: (p) => c.getDocument(p),
     ping: () => c.ping(),
   };
 }

package/lib/chat/memory-tools.ts

@@ -149,8 +149,12 @@ export function buildMemoryTools(store: MemoryStore): MemoryTool[] {
       },
       handle: async (input) => {
         const { content, tags } = input as { content: string; tags?: string[] };
-        const ok = await store.writeEpisode({ content, tags, source_type: 'text' });
-        return ok ? 'event recorded' : 'event write failed';
+        const r = await store.writeEpisode({ content, tags, source_type: 'text' });
+        if (!r.ok) return 'event write failed';
+        // skipped = server rejected as duplicate/low-quality — tell the
+        // LLM so it doesn't retry the same content (api-reference §2).
+        if (r.skipped) return `event not stored (${r.skip_reason || 'duplicate or below quality floor'}) — do not retry the same content`;
+        return 'event recorded';
       },
     },
   ];

package/lib/chat/temper.ts

@@ -69,6 +69,33 @@ export interface EpisodeInput {
   namespace?: string;
 }
 
+/** Outcome of an episode write. Per Temper's API contract (docs/
+ *  api-reference.md §2): `skipped:true` arrives with HTTP 200 and means
+ *  the server REJECTED the content (quality floor or dedup window) —
+ *  treat as "don't retry", never as a transient failure. */
+export interface EpisodeWriteResult {
+  ok: boolean;
+  skipped: boolean;
+  skip_reason?: string;
+  episode_id?: string;
+}
+
+export interface BulkEpisodeResult {
+  ok: boolean;
+  episode_ids: string[];
+  skipped_count: number;
+}
+
+export interface DocumentInput {
+  title: string;
+  content: string;
+  content_type?: string;
+  source?: string;
+  source_url?: string;
+  tags?: string[];
+  frontmatter?: Record<string, unknown>;
+}
+
 export class TemperClient {
   constructor(
     private readonly baseUrl: string,
@@ -98,6 +125,19 @@ export class TemperClient {
     return u;
   }
 
+  /** fetch with backoff on 423 (namespace sleeping — consolidation in
+   *  progress, per api-reference.md §12). Only used on WRITE paths;
+   *  per-turn reads fail fast instead so a sleeping namespace never
+   *  stalls a chat turn. */
+  private async fetchRetry423(url: string, init: RequestInit, attempts = 3): Promise<Response> {
+    let r = await fetch(url, init);
+    for (let i = 1; i < attempts && r.status === 423; i++) {
+      await new Promise((res) => setTimeout(res, 2000 * i));
+      r = await fetch(url, init);
+    }
+    return r;
+  }
+
   async search(query: string, limit = 8): Promise<SearchHit[]> {
     if (!this.enabled) return [];
     try {
@@ -121,8 +161,8 @@ export class TemperClient {
     }
   }
 
-  async writeEpisode(ep: EpisodeInput, asyncExtract = true): Promise<boolean> {
-    if (!this.enabled) return false;
+  async writeEpisode(ep: EpisodeInput, asyncExtract = true): Promise<EpisodeWriteResult> {
+    if (!this.enabled) return { ok: false, skipped: false };
     try {
       const u = new URL(this.url('/v1/episodes'));
       if (asyncExtract) u.searchParams.set('async_extract', 'true');
@@ -132,18 +172,89 @@ export class TemperClient {
         ...(this.namespace && !ep.namespace ? { namespace: this.namespace } : {}),
         ...ep,
       };
-      const r = await fetch(u.toString(), {
+      const r = await this.fetchRetry423(u.toString(), {
         method: 'POST',
         headers: this.headers({ 'content-type': 'application/json' }),
         body: JSON.stringify(body),
       });
-      return r.ok;
+      if (!r.ok) return { ok: false, skipped: false };
+      const j = await r.json().catch(() => ({})) as { skipped?: boolean; skip_reason?: string | null; episode_id?: string };
+      return {
+        ok: true,
+        skipped: j.skipped === true,
+        skip_reason: j.skip_reason ?? undefined,
+        episode_id: j.episode_id || undefined,
+      };
     } catch (err) {
       console.warn('[temper] writeEpisode failed', err);
+      return { ok: false, skipped: false };
+    }
+  }
+
+  /** POST /v1/episodes/bulk — one round trip for ≤200 items. Floor +
+   *  dedup apply per item; dropped ones land in skipped_count. Prefer
+   *  this over per-item writeEpisode for summarizer fan-outs — the
+   *  graph DB behind it is single-worker (api-reference.md §12). */
+  async writeEpisodesBulk(items: EpisodeInput[], opts: { saga?: string } = {}): Promise<BulkEpisodeResult> {
+    if (!this.enabled || items.length === 0) return { ok: false, episode_ids: [], skipped_count: 0 };
+    try {
+      const r = await this.fetchRetry423(this.url('/v1/episodes/bulk'), {
+        method: 'POST',
+        headers: this.headers({ 'content-type': 'application/json' }),
+        body: JSON.stringify({
+          ...(this.namespace ? { namespace: this.namespace } : {}),
+          ...(opts.saga ? { saga: opts.saga } : {}),
+          items: items.slice(0, 200).map((ep) => ({
+            source_type: 'text',
+            reference_time: new Date().toISOString(),
+            ...ep,
+          })),
+        }),
+      });
+      if (!r.ok) return { ok: false, episode_ids: [], skipped_count: 0 };
+      const j = await r.json().catch(() => ({})) as { episode_ids?: string[]; skipped_count?: number };
+      return { ok: true, episode_ids: j.episode_ids || [], skipped_count: j.skipped_count || 0 };
+    } catch (err) {
+      console.warn('[temper] writeEpisodesBulk failed', err);
+      return { ok: false, episode_ids: [], skipped_count: 0 };
+    }
+  }
+
+  /** PUT /v1/documents/{path} — upsert, revisions kept server-side.
+   *  The right primitive for chat summaries: ONE doc per chat,
+   *  overwritten with the latest (api-reference.md §6), instead of an
+   *  ever-growing pile of chat:* blocks. */
+  async putDocument(path: string, doc: DocumentInput): Promise<boolean> {
+    if (!this.enabled) return false;
+    try {
+      const u = this.withNs(new URL(this.url(`/v1/documents/${encodeURIComponent(path)}`)));
+      const r = await this.fetchRetry423(u.toString(), {
+        method: 'PUT',
+        headers: this.headers({ 'content-type': 'application/json' }),
+        body: JSON.stringify(doc),
+      });
+      return r.ok;
+    } catch (err) {
+      console.warn('[temper] putDocument failed', err);
       return false;
     }
   }
 
+  async getDocument(path: string): Promise<{ title: string; content: string } | null> {
+    if (!this.enabled) return null;
+    try {
+      const u = this.withNs(new URL(this.url(`/v1/documents/${encodeURIComponent(path)}`)));
+      const r = await fetch(u.toString(), { headers: this.headers() });
+      if (!r.ok) return null;
+      const j = await r.json().catch(() => null) as { title?: string; content?: string } | null;
+      if (!j || typeof j.content !== 'string') return null;
+      return { title: j.title || path, content: j.content };
+    } catch (err) {
+      console.warn('[temper] getDocument failed', err);
+      return null;
+    }
+  }
+
   async listBlocks(opts: { pinned?: boolean; scope?: 'own' | 'global' | 'both' } = {}): Promise<MemoryBlock[]> {
     if (!this.enabled) return [];
     try {

package/lib/help-docs/01-settings.md

@@ -254,7 +254,7 @@ The Settings modal has these sections:
 | **Agents** | Detected CLI agents + configuration |
 | **Profiles** | Agent profiles (CLI + API) — API profiles also power Forge chat |
 | **Marketplace Providers** | Enterprise marketplace keys — add/remove tenants whose private connector + pipeline + wizard repos overlay on top of public |
-| **Memory (Temper)** | Long-term memory backend for the chat agent. When Temper URL+key are blank, chat falls back to a local SQLite store with the same block/episode tools (keyword search only — no semantic/graph search). |
+| **Memory (Temper)** | Long-term memory backend for the chat agent. When Temper URL+key are blank, chat falls back to a local SQLite store with the same block/episode tools (keyword search only — no semantic/graph search). Chat summaries are stored as ONE Temper document per chat (`chats/<session>.md`, overwritten with the latest; local backend stores them as `doc:*` blocks); extracted facts go to episodes only. Duplicate / low-quality writes are rejected server-side and never retried. |
 | **Chat backend** | Pick the default API profile for chat (extension / CLI / Telegram) |
 | **Telegram** | Bot token, chat ID, notification toggles |
 | **Display** | Name, email |

package/lib/memory/temper-summary.ts

@@ -20,14 +20,9 @@
 
 import {
   cursorKey,
-  factKey,
   healthKey,
-  stableHash,
-  summaryKey,
   type CursorValue,
-  type FactValue,
   type HealthValue,
-  type SummaryValue,
 } from './keys';
 import { estimateTokens } from './token-estimate';
 import { compressMessagesForSummarizer } from './compress-messages';
@@ -97,77 +92,63 @@ export async function summarizeAndIngest(args: SummarizeAndIngestArgs): Promise<
     return { ok: false, error: 'empty summary in response', promptTokens };
   }
 
-  // Persist
+  // Persist. Summary goes to the documents primitive — ONE doc per chat,
+  // overwritten with the latest (Temper api-reference §6, revisions kept
+  // server-side). Replaces the per-cursor chat:* summary blocks that
+  // violated the block discipline (§5) and grew without bound.
   const now = Date.now();
-  const summaryValue: SummaryValue = {
-    text: summary,
-    from_ts: fromTs,
-    to_ts: toTs,
-    message_count: messages.length,
-    model: provider.model,
-    provider: provider.type,
-    ingest_ts: now,
-  };
-  try {
-    await store.putBlock(
-      summaryKey(scope, toTs),
-      summaryValue,
-      { description: summary.slice(0, 120), scope: 'own' },
-    );
-  } catch (err) {
-    return { ok: false, error: 'putBlock summary: ' + (err instanceof Error ? err.message : String(err)), promptTokens };
-  }
-
-  // Dual-write: putBlock above gives us upsert/cursor/recall by key,
-  // but Temper's KG (Graphiti) only ingests writeEpisode payloads. Push
-  // the same summary text as an episode so entity/relation extraction
-  // sees chat history. Failure here doesn't block the pass.
   try {
-    await store.writeEpisode({
+    const okDoc = await store.putDocument(`chats/${scope}.md`, {
+      title: `Chat summary — ${scope}`,
       content: summary,
-      source_type: 'text',
-      source_description: `chat:${scope} summary @ ${toTs}`,
-      tags: ['summarizer', 'session_summary', `chat:${scope}`],
+      tags: ['summarizer', 'chat'],
+      source: 'forge-summarizer',
+      frontmatter: {
+        from_ts: fromTs,
+        to_ts: toTs,
+        message_count: messages.length,
+        model: provider.model,
+        provider: provider.type,
+        ingest_ts: now,
+      },
     });
+    if (!okDoc) {
+      return { ok: false, error: 'putDocument summary failed', promptTokens };
+    }
   } catch (err) {
-    console.warn(`[temper-summary] writeEpisode(summary) failed for ${scope}:`, err instanceof Error ? err.message : err);
+    return { ok: false, error: 'putDocument summary: ' + (err instanceof Error ? err.message : String(err)), promptTokens };
   }
 
-  let factCount = 0;
-  for (const f of facts) {
-    if (!f.content || !f.subject) continue;
-    const v: FactValue = {
-      content: f.content,
-      subject_kind: f.subject_kind || 'fact',
-      subject: f.subject,
-      source_ref: `chat:${scope}@${toTs}`,
-      confidence: null,
-      extracted_by: 'summarizer',
-    };
-    try {
-      await store.putBlock(
-        factKey(f.scope || 'other', f.subject, stableHash(f.content)),
-        v,
-        { description: f.content.slice(0, 120), scope: 'own' },
-      );
-      factCount += 1;
-    } catch (err) {
-      console.warn(`[temper-summary] fact putBlock failed for ${f.subject}:`, err instanceof Error ? err.message : err);
-    }
-    // Episode-mirror each fact so the KG sees structured propositions.
-    // Per-fact rather than batched so Graphiti can attribute extraction
-    // to the right subject without re-parsing.
-    try {
-      await store.writeEpisode({
-        content: `${f.subject_kind || 'fact'} about ${f.subject}: ${f.content}`,
+  // KG ingestion: Temper's graph (Graphiti) only extracts from episodes.
+  // Bundle summary + per-fact propositions into ONE bulk call — the graph
+  // DB is single-worker; per-item round trips were its worst access
+  // pattern (api-reference §12). skipped_count = server-side dedup /
+  // quality-floor drops; rejections, not failures — never retried.
+  // Fact blocks (fact:*) are gone entirely: facts live in episodes only,
+  // per the documented block discipline.
+  const factItems = facts.filter((f) => f.content && f.subject);
+  try {
+    const bulk = await store.writeEpisodesBulk([
+      {
+        content: summary,
         source_type: 'text',
+        source_description: `chat:${scope} summary @ ${toTs}`,
+        tags: ['summarizer', 'session_summary', `chat:${scope}`],
+      },
+      ...factItems.map((f) => ({
+        content: `${f.subject_kind || 'fact'} about ${f.subject}: ${f.content}`,
+        source_type: 'text' as const,
         source_description: `chat:${scope} fact: ${f.subject}`,
         tags: ['summarizer', 'fact', f.scope || 'other', f.subject_kind || 'fact'],
-      });
-    } catch (err) {
-      console.warn(`[temper-summary] writeEpisode(fact) failed for ${f.subject}:`, err instanceof Error ? err.message : err);
+      })),
+    ]);
+    if (bulk.skipped_count > 0) {
+      console.log(`[temper-summary] ${scope}: ${bulk.skipped_count} episode(s) skipped by server (dedup/quality floor)`);
     }
+  } catch (err) {
+    console.warn(`[temper-summary] writeEpisodesBulk failed for ${scope}:`, err instanceof Error ? err.message : err);
   }
+  const factCount = factItems.length;
 
   // Advance cursor (B9)
   const newCursor: CursorValue = {

package/lib/ui/openPortal.ts

@@ -0,0 +1,60 @@
+/**
+ * openPortal — open a vendor login / portal URL in the RIGHT browser.
+ *
+ * Mac-native Forge: the UI runs in the user's own browser, which holds
+ * their SSO cookies → window.open is correct.
+ *
+ * Container deploy: the UI renders in the user's browser but the agent
+ * drives a Chromium INSIDE the container, where all SSO cookies live.
+ * window.open would land in the host browser (no corp session, useless).
+ * So when an extension is connected — the same signal the Login-status
+ * probe already relies on — route the open through the bridge so the
+ * extension runs chrome.tabs.create in the container Chromium.
+ *
+ * Pure client helper (fetch + DOM). Reference/help links should keep
+ * using a plain window.open / <a target="_blank"> — they genuinely
+ * belong in the user's own browser.
+ */
+
+function portalToast(msg: string): void {
+  if (typeof document === 'undefined') return;
+  const el = document.createElement('div');
+  el.textContent = msg;
+  el.style.cssText =
+    'position:fixed;bottom:20px;left:50%;transform:translateX(-50%);z-index:99999;' +
+    'background:#1e293b;color:#fff;padding:8px 16px;border-radius:8px;font-size:13px;' +
+    'box-shadow:0 4px 12px rgba(0,0,0,.3);opacity:0;transition:opacity .2s';
+  document.body.appendChild(el);
+  requestAnimationFrame(() => { el.style.opacity = '1'; });
+  setTimeout(() => { el.style.opacity = '0'; setTimeout(() => el.remove(), 300); }, 3000);
+}
+
+export async function openPortal(url: string): Promise<void> {
+  if (!url) return;
+  try {
+    const status = await fetch('/api/browser-bridge?action=status')
+      .then((r) => (r.ok ? r.json() : null))
+      .catch(() => null);
+    const connected = Number(status?.connected_extensions || 0) > 0;
+    if (connected) {
+      const r = await fetch('/api/browser-bridge', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          action: 'rpc',
+          method: 'browser.open_tab',
+          params: { url, active: true },
+        }),
+      });
+      // proxy returns the bridge rpc envelope: {ok, value} | {ok:false, error}
+      const j = await r.json().catch(() => null);
+      if (r.ok && j && j.ok !== false) {
+        portalToast('Opened in workspace browser (visible via stream)');
+        return;
+      }
+    }
+  } catch {
+    /* fall through to host-browser open */
+  }
+  window.open(url, '_blank', 'noopener');
+}

package/package.json

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