@aion0/forge 0.9.16 → 0.9.19

package/lib/memory/keys.ts

@@ -0,0 +1,82 @@
+/**
+ * Key-naming conventions for the chat memory summarizer.
+ *
+ * MemoryStore is a flat key/value API; this module encodes the
+ * design's "scope + subject" classification into deterministic key
+ * strings so that:
+ *   - cursor / health blocks land on a single stable key (upsert covers)
+ *   - repeated ingest of the same fact maps to the same key (upsert
+ *     replaces, not appends — this is what "memory reinforcement" looks
+ *     like at the storage layer)
+ *   - buildMemoryContext can post-filter by prefix to keep internal
+ *     bookkeeping blocks (cursor / health) out of the LLM prompt
+ *
+ * See forge-chat-memory-summarizer-design.md §4.2 for the full table.
+ */
+
+import { createHash } from 'node:crypto';
+
+/** Stable 12-char content hash. Used in fact keys so re-ingesting the
+ *  same fact maps to the same memory block (upsert = reinforcement). */
+export function stableHash(input: string): string {
+  return createHash('sha256').update(input).digest('hex').slice(0, 12);
+}
+
+/** Session summary at a given cursor end-ts. */
+export function summaryKey(sessionId: string, toTs: number): string {
+  return `chat:${sessionId}:summary:${toTs}`;
+}
+
+/** Long-term fact. scope/subject classify it; hash keys re-ingest. */
+export function factKey(scope: string, subject: string, contentHash: string): string {
+  return `fact:${scope}:${subject}:${contentHash}`;
+}
+
+/** Per-session ingest progress cursor. One row per session. */
+export function cursorKey(sessionId: string): string {
+  return `forge.summarizer.cursor:${sessionId}`;
+}
+
+/** Per-session summarizer health (last_run, errors, counts). */
+export function healthKey(sessionId: string): string {
+  return `forge.summarizer.health:${sessionId}`;
+}
+
+/** Prefixes buildMemoryContext should exclude when rendering context —
+ *  bookkeeping blocks the LLM shouldn't see. */
+export const INTERNAL_KEY_PREFIXES: readonly string[] = [
+  'forge.summarizer.cursor:',
+  'forge.summarizer.health:',
+];
+
+export interface CursorValue {
+  last_ingested_ts: number;
+  last_run_ts: number;
+  ingest_count: number;
+}
+
+export interface SummaryValue {
+  text: string;
+  from_ts: number;
+  to_ts: number;
+  message_count: number;
+  model: string;
+  provider: string;
+  ingest_ts: number;
+}
+
+export interface FactValue {
+  content: string;
+  subject_kind: string;
+  subject: string;
+  source_ref: string;
+  confidence: number | null;
+  extracted_by: 'summarizer' | string;
+}
+
+export interface HealthValue {
+  last_run_ts: number;
+  error: string | null;
+  ingest_count: number;
+  last_token_estimate: number;
+}

package/lib/memory/temper-summary.ts

@@ -0,0 +1,485 @@
+/**
+ * Temper Summary — the v1 memory-standalone sub-task.
+ *
+ * One pass scans every chat_session: for each, reads the ingest cursor
+ * from the memory_store, fetches chat_messages since cursor, decides
+ * whether the new chunk crosses the trigger thresholds, and if so calls
+ * summarizeAndIngest() to compress it and push summary + extracted
+ * facts back into memory_store. Cursor + health blocks are upserted at
+ * the same keys (see lib/memory/keys.ts) so two ticks racing the same
+ * session converge instead of duplicating work.
+ *
+ * The core function is split out as a generic
+ *   summarizeAndIngest({ store, messages, scope, cursorKey, provider })
+ * so the Phase E6 global skill (workspace smiths / pipeline nodes /
+ * task claude subprocesses) can reuse it without going through the
+ * chat-session-scanner wrapper.
+ *
+ * See forge-chat-memory-summarizer-design.md §4 and §5.
+ */
+
+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';
+import { listSessions, listMessages } from '../chat/session-store';
+import { getMemoryStore, type MemoryStore } from '../chat/memory-store';
+import { resolveProvider, type ProviderResolution } from '../chat/agent-loop';
+import type { Message } from '../chat/types';
+import type { MemorySubTask } from '../memory-standalone';
+
+// ── Tunables (see design §8) ──────────────────────────────────────────
+const WORKING_BUFFER_MSGS = 40;
+const TRIGGER_MIN_MSGS = 30;
+const TRIGGER_MIN_TOKENS = 4000;
+const SUMMARIZER_INPUT_TOKEN_BUDGET = 12000;
+const SUMMARIZER_MAX_OUTPUT_TOKENS = 2000;
+
+// ── Public types ──────────────────────────────────────────────────────
+export interface FactInput {
+  scope: string;        // e.g. 'user' / 'project' / 'preference'
+  subject_kind: string; // free-form, set by the LLM
+  subject: string;      // 'zliu', 'forge-project', …
+  content: string;
+}
+
+export interface SummarizeAndIngestArgs {
+  store: MemoryStore;
+  /** The slice of conversation to compress (compressed, not raw blocks). */
+  messages: Message[];
+  /** Logical scope passed to keys.ts (e.g. session id). */
+  scope: string;
+  /** Where the cursor lives in memory_store. Caller owns the key shape. */
+  cursorKeyName: string;
+  /** Optional previous cursor value — used to bump ingest_count. */
+  prevCursor: CursorValue | null;
+  /** Resolved API provider. */
+  provider: ProviderResolution;
+  /** The to_ts boundary of this slice (last message ts in the slice). */
+  toTs: number;
+}
+
+export interface SummarizeAndIngestResult {
+  ok: boolean;
+  summary?: string;
+  factCount?: number;
+  error?: string;
+  promptTokens?: number;
+  completionTokens?: number;
+}
+
+// ── Generic summarize + ingest (Phase B1 + B5 + B7 + B8 + B9) ─────────
+export async function summarizeAndIngest(args: SummarizeAndIngestArgs): Promise<SummarizeAndIngestResult> {
+  const { store, messages, scope, cursorKeyName, prevCursor, provider, toTs } = args;
+  const fromTs = messages[0]?.ts ?? toTs;
+  const transcript = compressMessagesForSummarizer(messages);
+  const promptTokens = estimateTokens(transcript);
+
+  // Call LLM
+  let raw: string;
+  try {
+    raw = await callSummarizerLlm(provider, transcript);
+  } catch (err) {
+    return { ok: false, error: 'llm: ' + (err instanceof Error ? err.message : String(err)), promptTokens };
+  }
+
+  const { summary, facts } = parseSummarizerResponse(raw);
+  if (!summary) {
+    return { ok: false, error: 'empty summary in response', promptTokens };
+  }
+
+  // Persist
+  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({
+      content: summary,
+      source_type: 'text',
+      source_description: `chat:${scope} summary @ ${toTs}`,
+      tags: ['summarizer', 'session_summary', `chat:${scope}`],
+    });
+  } catch (err) {
+    console.warn(`[temper-summary] writeEpisode(summary) failed for ${scope}:`, err instanceof Error ? err.message : err);
+  }
+
+  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}`,
+        source_type: 'text',
+        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);
+    }
+  }
+
+  // Advance cursor (B9)
+  const newCursor: CursorValue = {
+    last_ingested_ts: toTs,
+    last_run_ts: now,
+    ingest_count: (prevCursor?.ingest_count ?? 0) + 1,
+  };
+  try {
+    await store.putBlock(
+      cursorKeyName,
+      newCursor,
+      { description: `summarizer cursor for ${scope}`, scope: 'own' },
+    );
+  } catch (err) {
+    // Cursor failed to advance — next tick will retry the same range.
+    return { ok: false, error: 'putBlock cursor: ' + (err instanceof Error ? err.message : String(err)), promptTokens };
+  }
+
+  return {
+    ok: true,
+    summary,
+    factCount,
+    promptTokens,
+    completionTokens: estimateTokens(raw),
+  };
+}
+
+// ── Per-session scanner (B1 wrapper around summarizeAndIngest) ────────
+async function tickSession(store: MemoryStore, sessionId: string, sessionProvider: string | null, sessionModel: string | null): Promise<void> {
+  const ck = cursorKey(sessionId);
+  const prev = await readCursor(store, ck);
+  const lastTs = prev?.last_ingested_ts ?? 0;
+
+  const newMsgs = listMessages(sessionId, { after_ts: lastTs, limit: 5000 });
+  if (newMsgs.length === 0) return;
+
+  // Reserve the most recent N messages — they belong to the working
+  // window the agent-loop reads directly.
+  const candidates = newMsgs.slice(0, Math.max(0, newMsgs.length - WORKING_BUFFER_MSGS));
+  if (candidates.length === 0) return;
+
+  // Double-threshold trigger.
+  const tokenEstimate = estimateTokens(candidates);
+  if (candidates.length < TRIGGER_MIN_MSGS && tokenEstimate < TRIGGER_MIN_TOKENS) return;
+
+  // Cap input by token budget — take from the front until we hit it.
+  const slice = takeFromFrontUntilBudget(candidates, SUMMARIZER_INPUT_TOKEN_BUDGET);
+  if (slice.length === 0) return;
+
+  // Resolve provider (B6).
+  const provider = resolveProvider(sessionProvider, sessionModel);
+  if ('error' in provider) {
+    await writeHealth(store, sessionId, { error: `provider: ${provider.error}`, ingestCount: prev?.ingest_count ?? 0, tokenEstimate });
+    return;
+  }
+
+  const toTs = slice[slice.length - 1]!.ts;
+  const sliceTokens = estimateTokens(slice);
+  console.log(`[temper-summary] session=${sessionId} ingesting ${slice.length}/${candidates.length} msgs (~${sliceTokens}t, candidates ~${tokenEstimate}t) up to ts=${toTs}`);
+  const result = await summarizeAndIngest({
+    store,
+    messages: slice,
+    scope: sessionId,
+    cursorKeyName: ck,
+    prevCursor: prev ?? null,
+    provider,
+    toTs,
+  });
+
+  await writeHealth(store, sessionId, {
+    error: result.ok ? null : result.error ?? 'unknown',
+    ingestCount: result.ok ? (prev?.ingest_count ?? 0) + 1 : (prev?.ingest_count ?? 0),
+    tokenEstimate: result.promptTokens ?? tokenEstimate,
+  });
+
+  if (result.ok) {
+    console.log(`[temper-summary] session=${sessionId} ok (${result.factCount} fact${result.factCount === 1 ? '' : 's'})`);
+  } else {
+    console.warn(`[temper-summary] session=${sessionId} failed: ${result.error}`);
+  }
+}
+
+// ── Sub-task export (B1) ──────────────────────────────────────────────
+export function temperSummaryTask(): MemorySubTask {
+  return {
+    name: 'temper-summary',
+    async tick() {
+      const store = getMemoryStore();
+      if (!store.enabled) {
+        console.log('[temper-summary] memory store not enabled, skipping tick');
+        return;
+      }
+      const sessions = listSessions(500);
+      for (const s of sessions) {
+        try {
+          await tickSession(store, s.id, s.provider, s.model);
+        } catch (err) {
+          console.warn(`[temper-summary] session ${s.id} tick crashed:`, err instanceof Error ? err.message : err);
+        }
+      }
+    },
+  };
+}
+
+// ── Helpers ────────────────────────────────────────────────────────────
+
+async function readCursor(store: MemoryStore, key: string): Promise<CursorValue | null> {
+  try {
+    const b = await store.getBlock(key);
+    if (!b) return null;
+    const v = b.value as Partial<CursorValue> | undefined;
+    if (!v || typeof v.last_ingested_ts !== 'number') return null;
+    return {
+      last_ingested_ts: v.last_ingested_ts,
+      last_run_ts: typeof v.last_run_ts === 'number' ? v.last_run_ts : 0,
+      ingest_count: typeof v.ingest_count === 'number' ? v.ingest_count : 0,
+    };
+  } catch (err) {
+    console.warn('[temper-summary] readCursor failed:', err instanceof Error ? err.message : err);
+    return null;
+  }
+}
+
+async function writeHealth(
+  store: MemoryStore,
+  sessionId: string,
+  opts: { error: string | null; ingestCount: number; tokenEstimate: number },
+): Promise<void> {
+  const v: HealthValue = {
+    last_run_ts: Date.now(),
+    error: opts.error,
+    ingest_count: opts.ingestCount,
+    last_token_estimate: opts.tokenEstimate,
+  };
+  try {
+    await store.putBlock(
+      healthKey(sessionId),
+      v,
+      { description: opts.error ? `summarizer error: ${opts.error.slice(0, 80)}` : 'summarizer ok', scope: 'own' },
+    );
+  } catch (err) {
+    console.warn('[temper-summary] writeHealth failed:', err instanceof Error ? err.message : err);
+  }
+}
+
+function takeFromFrontUntilBudget(messages: Message[], budget: number): Message[] {
+  const out: Message[] = [];
+  let used = 0;
+  for (const m of messages) {
+    const cost = estimateTokens(m);
+    if (used + cost > budget && out.length > 0) break;
+    out.push(m);
+    used += cost;
+  }
+  return out;
+}
+
+// ── LLM call (B5) ─────────────────────────────────────────────────────
+const SUMMARIZER_INSTRUCTIONS = [
+  'You are a chat memory ingestor. Read the conversation segment below and produce:',
+  '1. A concise prose summary capturing decisions, facts, and the user\'s state at the END of this segment.',
+  '2. A JSON list of long-term facts worth remembering across sessions:',
+  '   - user identity / preferences / role',
+  '   - project decisions / constraints',
+  '   - named third-party facts ("Alice prefers Postgres")',
+  'DO NOT include speculation. Only what\'s explicitly stated or unambiguously implied.',
+  '',
+  'OUTPUT FORMAT (strict):',
+  '<summary>',
+  '...prose summary, max ~800 chars...',
+  '</summary>',
+  '<facts>',
+  '[ {"scope":"user|project|other", "subject_kind":"...", "subject":"...", "content":"..."} ]',
+  '</facts>',
+].join('\n');
+
+/**
+ * Direct HTTP call to the provider, bypassing the ai-sdk wrapper.
+ *
+ * Why not streamLlm: ai-sdk's streamText injects a `tools` field even
+ * when we don't pass one. Strict OpenAI-spec gateways (litellm + vLLM)
+ * reject `tools: []` with 400 per the OpenAI Chat Completions spec
+ * ("if present, must contain at least one tool"). Summarizer has no
+ * tools by design, so we just don't send the field at all.
+ *
+ * Supports openai-compatible (litellm, openai, deepseek-direct, etc.)
+ * and anthropic. Both protocols are simple enough that hand-rolling a
+ * single-shot non-streaming call is shorter than fighting the wrapper.
+ */
+async function callSummarizerLlm(provider: ProviderResolution, transcript: string): Promise<string> {
+  const userText = 'CONVERSATION SEGMENT:\n' + transcript;
+  if (provider.type === 'anthropic') {
+    return callAnthropic(provider, userText);
+  }
+  return callOpenAI(provider, userText);
+}
+
+async function callOpenAI(provider: ProviderResolution, userText: string): Promise<string> {
+  const url = joinUrl(provider.baseUrl, '/v1/chat/completions', '/chat/completions');
+  const body = {
+    model: provider.model,
+    messages: [
+      { role: 'system', content: SUMMARIZER_INSTRUCTIONS },
+      { role: 'user', content: userText },
+    ],
+    max_tokens: SUMMARIZER_MAX_OUTPUT_TOKENS,
+    stream: false,
+  };
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      authorization: `Bearer ${provider.apiKey}`,
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`openai ${res.status}: ${text.slice(0, 300)}`);
+  }
+  const json = await res.json() as { choices?: Array<{ message?: { content?: string } }> };
+  const content = json.choices?.[0]?.message?.content;
+  if (typeof content !== 'string' || content.length === 0) {
+    throw new Error(`openai response missing choices[0].message.content: ${JSON.stringify(json).slice(0, 300)}`);
+  }
+  return content;
+}
+
+async function callAnthropic(provider: ProviderResolution, userText: string): Promise<string> {
+  const url = joinUrl(provider.baseUrl, '/v1/messages', '/messages');
+  const body = {
+    model: provider.model,
+    system: SUMMARIZER_INSTRUCTIONS,
+    messages: [{ role: 'user', content: [{ type: 'text', text: userText }] }],
+    max_tokens: SUMMARIZER_MAX_OUTPUT_TOKENS,
+  };
+  const res = await fetch(url, {
+    method: 'POST',
+    headers: {
+      'content-type': 'application/json',
+      'x-api-key': provider.apiKey,
+      'anthropic-version': '2023-06-01',
+    },
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const text = await res.text().catch(() => '');
+    throw new Error(`anthropic ${res.status}: ${text.slice(0, 300)}`);
+  }
+  const json = await res.json() as { content?: Array<{ type?: string; text?: string }> };
+  const text = (json.content || [])
+    .filter((b) => b.type === 'text' && typeof b.text === 'string')
+    .map((b) => b.text)
+    .join('\n');
+  if (!text) {
+    throw new Error(`anthropic response missing text blocks: ${JSON.stringify(json).slice(0, 300)}`);
+  }
+  return text;
+}
+
+/** Strip trailing slash + try preferred path first; if base already
+ *  ends with /v1 don't double it. */
+function joinUrl(base: string, ...candidates: string[]): string {
+  const b = base.replace(/\/+$/, '');
+  const path = candidates[0]!;
+  // If user-configured baseUrl already ends with /v1, fall back to the
+  // second candidate (path without the v1 prefix) so we don't get /v1/v1/…
+  if (/\/v\d+$/i.test(b) && candidates.length > 1) {
+    return b + candidates[1];
+  }
+  return b + path;
+}
+
+// ── Response parser (B7) ──────────────────────────────────────────────
+export interface ParsedSummarizerResponse {
+  summary: string;
+  facts: FactInput[];
+}
+
+export function parseSummarizerResponse(raw: string): ParsedSummarizerResponse {
+  const summary = extractTag(raw, 'summary').trim();
+  const factsRaw = extractTag(raw, 'facts').trim();
+
+  // If both tags missing, treat the whole output as summary.
+  if (!summary && !factsRaw) {
+    return { summary: raw.trim(), facts: [] };
+  }
+
+  let facts: FactInput[] = [];
+  if (factsRaw) {
+    try {
+      const parsed = JSON.parse(factsRaw);
+      if (Array.isArray(parsed)) {
+        facts = parsed
+          .filter((f): f is Record<string, unknown> => typeof f === 'object' && f !== null)
+          .map((f) => ({
+            scope: typeof f.scope === 'string' ? f.scope : 'other',
+            subject_kind: typeof f.subject_kind === 'string' ? f.subject_kind : 'fact',
+            subject: typeof f.subject === 'string' ? f.subject : '',
+            content: typeof f.content === 'string' ? f.content : '',
+          }))
+          .filter((f) => f.subject && f.content);
+      }
+    } catch (err) {
+      console.warn('[temper-summary] facts JSON parse failed, ignoring:', err instanceof Error ? err.message : err);
+    }
+  }
+
+  return { summary: summary || raw.trim(), facts };
+}
+
+function extractTag(s: string, tag: string): string {
+  const m = s.match(new RegExp(`<${tag}>([\\s\\S]*?)<\\/${tag}>`, 'i'));
+  return m ? m[1]! : '';
+}

package/lib/memory/token-estimate.ts

@@ -0,0 +1,28 @@
+/**
+ * Cheap token estimator used by the summarizer triggers and the
+ * working-window cap.
+ *
+ * `len / 4` is the standard back-of-envelope for English text under
+ * GPT/Claude tokenizers; on CJK it under-counts (closer to len * 0.6)
+ * and on code it over-counts. Good enough for "do we summarize yet?"
+ * gating — the real token count comes back from the provider after
+ * each call and can be used to recalibrate.
+ *
+ * No tiktoken dep on purpose: this runs inside lib/ which loads under
+ * tsx standalone, and we don't want native or wasm baggage on the cold
+ * path.
+ */
+
+export function estimateTokens(input: unknown): number {
+  if (input == null) return 0;
+  const s = typeof input === 'string' ? input : safeStringify(input);
+  return Math.ceil(s.length / 4);
+}
+
+function safeStringify(v: unknown): string {
+  try {
+    return JSON.stringify(v) ?? '';
+  } catch {
+    return String(v);
+  }
+}

package/lib/memory-standalone.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env -S npx tsx
+/**
+ * Standalone Memory worker.
+ *
+ * Generic process container for background memory operations. Hosts a
+ * registry of MemorySubTask implementations and ticks each one on a
+ * fixed interval. v1 only ships the Temper Summary sub-task (chat raw
+ * → memory_store ingest); decay / profile compaction / cross-session
+ * linking land in v1.x as additional sub-tasks under the same loop.
+ *
+ * Lifecycle:
+ *  - Spawned by bin/forge-server.mjs alongside terminal/workspace/telegram
+ *  - --forge-port=<webPort> tag for cleanupOrphans (multi-instance safe)
+ *  - SIGTERM is honored; the current tick finishes before exit
+ *  - No HTTP port; pure poller
+ *
+ * Failure isolation: a sub-task's tick() rejecting is logged and the
+ * next sub-task still runs in the same cycle.
+ */
+
+const MEMORY_TICK_SEC = 120;
+
+export interface MemorySubTask {
+  /** Stable identifier for logs + future health introspection. */
+  readonly name: string;
+  /** One pass of work. Errors are caught at the supervisor level. */
+  tick(): Promise<void>;
+}
+
+const subTasks: MemorySubTask[] = [];
+
+function registerSubTask(task: MemorySubTask): void {
+  subTasks.push(task);
+  console.log(`[memory] registered sub-task: ${task.name}`);
+}
+
+let running = true;
+let tickInProgress = false;
+
+async function runTick(): Promise<void> {
+  if (!running) return;
+  tickInProgress = true;
+  const cycleStart = Date.now();
+  for (const t of subTasks) {
+    const start = Date.now();
+    try {
+      await t.tick();
+      console.log(`[memory] ${t.name} tick ok (${Date.now() - start}ms)`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.warn(`[memory] ${t.name} tick failed: ${msg}`);
+    }
+  }
+  console.log(`[memory] cycle done (${Date.now() - cycleStart}ms, ${subTasks.length} sub-task${subTasks.length === 1 ? '' : 's'})`);
+  tickInProgress = false;
+}
+
+async function loop(): Promise<void> {
+  await runTick();
+  if (!running) return;
+  setTimeout(loop, MEMORY_TICK_SEC * 1000);
+}
+
+async function main(): Promise<void> {
+  console.log(`[memory] starting standalone (tick every ${MEMORY_TICK_SEC}s)`);
+
+  // Register v1 sub-tasks. Lazy import keeps this entry declarative
+  // and means a sub-task module failing to load doesn't kill the
+  // process — the supervisor loop still runs (with one fewer task).
+  await safeRegister('temper-summary', async () => {
+    const { temperSummaryTask } = await import('./memory/temper-summary');
+    return temperSummaryTask();
+  });
+
+  if (subTasks.length === 0) {
+    console.log('[memory] no sub-tasks registered, exiting');
+    return;
+  }
+
+  await loop();
+}
+
+async function safeRegister(name: string, factory: () => Promise<MemorySubTask>): Promise<void> {
+  try {
+    registerSubTask(await factory());
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.warn(`[memory] failed to register ${name}: ${msg}`);
+  }
+}
+
+process.on('SIGTERM', () => {
+  console.log('[memory] SIGTERM received');
+  running = false;
+  // Let the in-flight tick finish; exit after a generous grace window.
+  setTimeout(() => process.exit(0), tickInProgress ? 30000 : 0);
+});
+
+process.on('SIGINT', () => {
+  console.log('[memory] SIGINT received');
+  running = false;
+  setTimeout(() => process.exit(0), tickInProgress ? 30000 : 0);
+});
+
+main().catch((err) => {
+  console.error('[memory] fatal:', err);
+  process.exit(1);
+});