@aion0/forge 0.10.74 → 0.10.76

package/RELEASE_NOTES.md

@@ -1,8 +1,12 @@
-# Forge v0.10.74
+# Forge v0.10.76
 
-Released: 2026-06-11
+Released: 2026-06-12
 
-## Changes since v0.10.73
+## Changes since v0.10.75
 
+### Other
+- feat(memory): align Temper client with documented API contract
+- fix(chat): drain leftover notes at turn end — late-merged input no longer lost
 
-**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.73...v0.10.74
+
+**Full Changelog**: https://github.com/aiwatching/forge/compare/v0.10.75...v0.10.76

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/pipeline.ts

@@ -1663,13 +1663,20 @@ function reapOrphanedPipelineTasks() {
   if (reapedOrphans) return;
   reapedOrphans = true;
   try {
+    // This timer arms on MODULE load, which in a lazy-loading Next.js worker
+    // can be minutes after the actual server boot — by then this very boot
+    // may have live tasks. Only treat a task as a previous-boot corpse if it
+    // started BEFORE this process did; a live task can never predate its
+    // own parent.
+    const bootAt = Date.now() - process.uptime() * 1000;
     const pipelines = listPipelines().filter(p => p.status === 'running');
     let reaped = 0;
     for (const pipeline of pipelines) {
       for (const node of Object.values(pipeline.nodes)) {
         if (node.status === 'running' && node.taskId) {
           const t = getTask(node.taskId);
-          if (t && t.status === 'running') {
+          const tStart = Date.parse(t?.startedAt || t?.createdAt || '') || 0;
+          if (t && t.status === 'running' && tStart > 0 && tStart < bootAt) {
             try {
               cancelTask(node.taskId);
               reaped += 1;

package/package.json

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