@geravant/sinain 1.1.0 → 1.2.0

package/index.ts

@@ -560,8 +560,10 @@ export default function sinainHudPlugin(api: OpenClawPluginApi): void {
           `sinain-hud: session summary written (${toolCount} tools, ${Math.round(durationMs / 1000)}s)`,
         );
 
-        // Fire-and-forget: ingest session summary into triple store
-        if (state.workspaceDir) {
+        // Fire-and-forget: ingest session summary into knowledge graph
+        // NOTE: Main knowledge integration happens in heartbeat tick (session_distiller + knowledge_integrator).
+        // This is a lightweight best-effort path for when agent_end fires (won't fire on kill).
+        if (false && state.workspaceDir) {
           api.runtime.system.runCommandWithTimeout(
             ["uv", "run", "--with", "requests", "python3",
              "sinain-memory/triple_ingest.py",

package/install.js

@@ -3,6 +3,7 @@ import fs from "fs";
 import path from "path";
 import os from "os";
 import { execSync } from "child_process";
+import { randomBytes } from "crypto";
 
 const HOME        = os.homedir();
 const PLUGIN_DIR  = path.join(HOME, ".openclaw/extensions/sinain-hud");
@@ -18,7 +19,9 @@ const SKILL      = path.join(PKG_DIR, "SKILL.md");
 
 console.log("\nInstalling sinain plugin...");
 
-// 1. Stage plugin files to local ~/.openclaw (used by both paths)
+// 1. Copy plugin files (remove stale extensions/sinain dir if present from old installs)
+const stalePluginDir = path.join(HOME, ".openclaw/extensions/sinain");
+if (fs.existsSync(stalePluginDir)) fs.rmSync(stalePluginDir, { recursive: true, force: true });
 fs.mkdirSync(PLUGIN_DIR, { recursive: true });
 fs.copyFileSync(path.join(PKG_DIR, "index.ts"),             path.join(PLUGIN_DIR, "index.ts"));
 fs.copyFileSync(path.join(PKG_DIR, "openclaw.plugin.json"), path.join(PLUGIN_DIR, "openclaw.plugin.json"));
@@ -115,6 +118,8 @@ async function installNemoClaw({ sandboxName }) {
       sessionKey:    "agent:main:sinain"
     }
   };
+  // Remove stale "sinain" entry if present from a previous install
+  delete cfg.plugins.entries["sinain"];
   if (!cfg.plugins.allow.includes("sinain-hud")) cfg.plugins.allow.push("sinain-hud");
   cfg.agents                                         ??= {};
   cfg.agents.defaults                                ??= {};
@@ -145,6 +150,19 @@ async function installNemoClaw({ sandboxName }) {
     }
   }
 
+  // Knowledge snapshot repo (optional) — inside sandbox
+  const snapshotUrl = process.env.SINAIN_SNAPSHOT_REPO;
+  if (snapshotUrl) {
+    try {
+      await checkRepoPrivacy(snapshotUrl);
+      run(`ssh -T openshell-${sandboxName} 'mkdir -p ~/.sinain/knowledge-snapshots && cd ~/.sinain/knowledge-snapshots && ([ -d .git ] || (git init && git config user.name sinain-knowledge && git config user.email sinain@local)) && (git remote get-url origin >/dev/null 2>&1 && git remote set-url origin "${snapshotUrl}" || git remote add origin "${snapshotUrl}") && (git fetch origin && git checkout -B main origin/main) 2>/dev/null || true'`);
+      console.log("  ✓ Snapshot repo configured in sandbox");
+    } catch (e) {
+      console.error("\n  ✗ Snapshot repo setup aborted:", e.message, "\n");
+      process.exit(1);
+    }
+  }
+
   // Restart openclaw gateway inside sandbox (kill existing PID + start fresh)
   try {
     // Find the gateway PID, kill it, then start a new instance detached
@@ -201,6 +219,10 @@ async function installLocal() {
       sessionKey:    "agent:main:sinain"
     }
   };
+  // Remove stale "sinain" entry if present from a previous install
+  delete cfg.plugins.entries["sinain"];
+  cfg.plugins.allow ??= [];
+  if (!cfg.plugins.allow.includes("sinain-hud")) cfg.plugins.allow.push("sinain-hud");
   cfg.agents                                         ??= {};
   cfg.agents.defaults                                ??= {};
   cfg.agents.defaults.sandbox                        ??= {};
@@ -241,25 +263,69 @@ async function installLocal() {
     }
   }
 
-  // Reload gateway
+  // Knowledge snapshot repo (optional)
+  await setupSnapshotRepo();
+
+  // Start / restart gateway
   try {
-    execSync("openclaw reload", { stdio: "pipe" });
-    console.log("  ✓ Gateway reloaded");
+    execSync("openclaw gateway restart --background", { stdio: "pipe" });
+    console.log("  ✓ Gateway restarted");
   } catch {
     try {
-      execSync("openclaw stop && sleep 1 && openclaw start --background", { stdio: "pipe" });
-      console.log("  ✓ Gateway restarted");
+      execSync("openclaw gateway start --background", { stdio: "pipe" });
+      console.log("  ✓ Gateway started");
     } catch {
       console.warn("  ⚠ Could not start gateway — run: openclaw gateway");
     }
   }
 
-  console.log(`
-✓ sinain installed successfully.
-  Plugin config: ~/.openclaw/openclaw.json
-  Auth token:    check your Brev dashboard → 'Gateway Token'
-  Then run ./setup-nemoclaw.sh on your Mac.
-`);
+  console.log("\n✓ sinain installed successfully.");
+  console.log("  Plugin config: ~/.openclaw/openclaw.json");
+  console.log(`  Auth token:    ${authToken}`);
+  console.log("  Next: run 'openclaw gateway' in a new terminal, then run ./setup-nemoclaw.sh on your Mac.\n");
+}
+
+// ── Knowledge snapshot repo setup (shared) ──────────────────────────────────
+
+const SNAPSHOT_DIR = path.join(HOME, ".sinain", "knowledge-snapshots");
+
+async function setupSnapshotRepo() {
+  const snapshotUrl = process.env.SINAIN_SNAPSHOT_REPO;
+  if (!snapshotUrl) return;
+
+  try {
+    await checkRepoPrivacy(snapshotUrl);
+    fs.mkdirSync(SNAPSHOT_DIR, { recursive: true });
+
+    if (!fs.existsSync(path.join(SNAPSHOT_DIR, ".git"))) {
+      execSync(`git init "${SNAPSHOT_DIR}"`, { stdio: "pipe" });
+      execSync(`git -C "${SNAPSHOT_DIR}" config user.name "sinain-knowledge"`, { stdio: "pipe" });
+      execSync(`git -C "${SNAPSHOT_DIR}" config user.email "sinain@local"`, { stdio: "pipe" });
+    }
+
+    // Set remote (add or update)
+    try {
+      run_capture(`git -C "${SNAPSHOT_DIR}" remote get-url origin`);
+      execSync(`git -C "${SNAPSHOT_DIR}" remote set-url origin "${snapshotUrl}"`, { stdio: "pipe" });
+    } catch {
+      execSync(`git -C "${SNAPSHOT_DIR}" remote add origin "${snapshotUrl}"`, { stdio: "pipe" });
+    }
+
+    // Pull existing snapshots if remote has content
+    try {
+      execSync(`git -C "${SNAPSHOT_DIR}" fetch origin`, { stdio: "pipe", timeout: 15_000 });
+      execSync(`git -C "${SNAPSHOT_DIR}" checkout -B main origin/main`, { stdio: "pipe" });
+      console.log("  ✓ Snapshot repo restored from", snapshotUrl);
+    } catch {
+      console.log("  ✓ Snapshot repo configured (empty remote)");
+    }
+  } catch (e) {
+    if (e.message?.startsWith("SECURITY") || e.message?.startsWith("Refusing")) {
+      console.error("\n  ✗ Snapshot repo setup aborted:", e.message, "\n");
+      process.exit(1);
+    }
+    console.warn("  ⚠ Snapshot repo setup failed:", e.message);
+  }
 }
 
 // ── Detection ────────────────────────────────────────────────────────────────

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@geravant/sinain",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "sinain — AI overlay system for macOS (npx @geravant/sinain start)",
   "type": "module",
   "bin": {

package/sinain-agent/CLAUDE.md

@@ -12,8 +12,10 @@ You have MCP tools from `sinain-mcp-server`:
 - `sinain_get_feedback` — get feedback signals from recent escalations
 - `sinain_post_feed` — push an arbitrary message to the HUD
 - `sinain_health` — check system health
-- `sinain_knowledge_query` — query the knowledge graph for relevant context
-- `sinain_heartbeat_tick` — run the full curation pipeline (git backup, signals, insights, playbook)
+- `sinain_get_knowledge` — get the portable knowledge document (playbook + long-term facts + sessions)
+- `sinain_knowledge_query` — query the knowledge graph for facts about specific entities/domains
+- `sinain_distill_session` — explicitly distill the current session into knowledge updates
+- `sinain_heartbeat_tick` — run the heartbeat pipeline (git backup, signals, distillation, insights)
 - `sinain_module_guidance` — get active module guidance
 
 ## Main Loop
@@ -23,7 +25,7 @@ Your primary job is an escalation response loop:
 1. Call `sinain_get_escalation` to check for pending escalations
 2. If an escalation is present:
    a. Read the escalation message carefully — it contains screen OCR, audio transcripts, app context, and the local agent's digest
-   b. Optionally call `sinain_knowledge_query` with key context from the escalation to enrich your response
+   b. Optionally call `sinain_get_knowledge` to read the knowledge document, or `sinain_knowledge_query` with specific entities to enrich your response
    c. Optionally call `sinain_module_guidance` to get active module instructions
    d. Craft a response and call `sinain_respond` with the escalation ID and your response
 3. If no escalation is pending, wait a few seconds and poll again
@@ -47,10 +49,12 @@ When responding to escalations:
 2. The tool runs the full pipeline automatically:
    - Git backup of memory directory
    - Signal analysis (detects opportunities from session patterns)
+   - **Session distillation** — fetches new feed items from sinain-core, distills patterns/learnings
+   - **Knowledge integration** — updates playbook (working memory) and knowledge graph (long-term memory)
    - Insight synthesis (generates suggestions from accumulated patterns)
-   - Playbook curation (updates effective playbook based on feedback)
 3. If the result contains a suggestion or insight, post it to the HUD via `sinain_post_feed`
-4. Optionally call `sinain_get_feedback` to review recent escalation scores
+4. Optionally call `sinain_get_knowledge` to review the portable knowledge document
+5. Optionally call `sinain_get_feedback` to review recent escalation scores
 
 ## Spawning Background Tasks
 
@@ -69,8 +73,11 @@ Rules:
 ## Files You Manage
 
 Your working memory lives at `~/.openclaw/workspace/memory/`:
-- `playbook.md` — your effective playbook (updated by curation pipeline)
-- `triplestore.db` — knowledge graph (SQLite, managed by Python scripts)
+- `sinain-playbook.md` — your effective playbook (working memory, updated by knowledge integrator)
+- `knowledge-graph.db` — long-term knowledge graph (SQLite, curated facts with confidence tracking)
+- `sinain-knowledge.md` — portable knowledge document (<8KB, playbook + top graph facts + recent sessions)
+- `session-digests.jsonl` — session distillation history
+- `distill-state.json` — watermark for what's been distilled
 - `playbook-logs/YYYY-MM-DD.jsonl` — decision logs
 
 ## Privacy

package/sinain-core/src/escalation/escalator.ts

@@ -9,7 +9,7 @@ import { OpenClawWsClient } from "./openclaw-ws.js";
 import { EscalationSlot } from "./escalation-slot.js";
 import type { SlotEntry, QueueFeedbackCtx } from "./escalation-slot.js";
 import { shouldEscalate, calculateEscalationScore } from "./scorer.js";
-import { isCodingContext, buildEscalationMessage } from "./message-builder.js";
+import { isCodingContext, buildEscalationMessage, fetchKnowledgeFacts } from "./message-builder.js";
 import { loadPendingTasks, savePendingTasks, type PendingTaskEntry } from "../util/task-store.js";
 import { log, warn, error } from "../log.js";
 
@@ -32,6 +32,7 @@ export interface EscalatorDeps {
   profiler?: Profiler;
   feedbackStore?: FeedbackStore;
   signalCollector?: SignalCollector;
+  queryKnowledgeFacts?: (entities: string[], maxFacts: number) => Promise<string>;
 }
 
 /**
@@ -159,7 +160,7 @@ export class Escalator {
    * Called after every agent analysis tick.
    * Decides whether to escalate and enqueues the message for delivery.
    */
-  onAgentAnalysis(entry: AgentEntry, contextWindow: ContextWindow): void {
+  async onAgentAnalysis(entry: AgentEntry, contextWindow: ContextWindow): Promise<void> {
     // Skip WS escalations when circuit is open (HTTP transport bypasses this)
     const transport = this.deps.escalationConfig.transport;
     if (this.wsClient.isCircuitOpen && transport !== "http") {
@@ -198,7 +199,7 @@ export class Escalator {
     this.lastEscalationContext = contextWindow;
 
     const escalationReason = score.reasons.join(", ");
-    const message = buildEscalationMessage(
+    let message = buildEscalationMessage(
       entry.digest,
       contextWindow,
       entry,
@@ -206,6 +207,21 @@ export class Escalator {
       escalationReason,
     );
 
+    // Enrich with long-term knowledge facts (best-effort, 5s max)
+    if (this.deps.queryKnowledgeFacts) {
+      try {
+        const knowledgeSection = await fetchKnowledgeFacts(
+          contextWindow, entry.digest, this.deps.queryKnowledgeFacts,
+        );
+        if (knowledgeSection) {
+          message = message + "\n\n" + knowledgeSection;
+          log(TAG, `knowledge enrichment injected (${knowledgeSection.length} chars)`);
+        }
+      } catch (err) {
+        log(TAG, `knowledge enrichment failed: ${String(err)}`);
+      }
+    }
+
     const slotId = createHash("sha256").update(this.deps.openclawConfig.sessionKey + entry.ts).digest("hex").slice(0, 16);
     const slotEntry: SlotEntry = {
       id: slotId,

package/sinain-core/src/escalation/message-builder.ts

@@ -292,6 +292,53 @@ the local analyzer reported idle/no-change. Provide a PROACTIVE response:
   return sections.join("\n\n");
 }
 
+/**
+ * Fetch relevant long-term knowledge facts for the current escalation context.
+ * Extracts entities from the context and queries the knowledge graph.
+ * Returns a formatted section or empty string if no relevant facts found.
+ */
+export async function fetchKnowledgeFacts(
+  context: ContextWindow,
+  digest: string,
+  queryFn?: (entities: string[], maxFacts: number) => Promise<string>,
+): Promise<string> {
+  if (!queryFn) return "";
+
+  // Extract entities from context: current app + error types + domain keywords
+  const entities: string[] = [];
+  const app = normalizeAppName(context.currentApp).toLowerCase().replace(/\s+/g, "-");
+  if (app && app.length > 2) entities.push(app);
+
+  // Extract error type keywords from digest
+  const errorPatterns = digest.matchAll(
+    /(?:Error|Exception|TypeError|SyntaxError|ReferenceError|HTTP\s*\d{3}|ENOENT|EACCES)/gi,
+  );
+  for (const m of errorPatterns) {
+    entities.push(m[0].toLowerCase());
+  }
+
+  // Extract technology keywords
+  const techKeywords = [
+    "react-native", "react", "flutter", "swift", "kotlin", "python",
+    "typescript", "node", "docker", "metro", "gradle", "cocoapods",
+    "intellij", "vscode", "xcode", "sinain",
+  ];
+  const lowerDigest = digest.toLowerCase();
+  for (const kw of techKeywords) {
+    if (lowerDigest.includes(kw)) entities.push(kw);
+  }
+
+  if (entities.length === 0) return "";
+
+  try {
+    const factsText = await queryFn(entities.slice(0, 5), 5);
+    if (factsText && factsText.trim().length > 20) {
+      return `## Past Experience\nBased on long-term knowledge relevant to this context:\n${factsText.trim()}`;
+    }
+  } catch {}
+  return "";
+}
+
 /**
  * Format a compact inline feedback section for escalation messages.
  * Shows recent performance so the agent can calibrate its response style.

package/sinain-core/src/index.ts

@@ -78,6 +78,17 @@ async function main() {
     openclawConfig: config.openclawConfig,
     profiler,
     feedbackStore: feedbackStore ?? undefined,
+    queryKnowledgeFacts: async (entities: string[], maxFacts: number) => {
+      const workspace = process.env.SINAIN_WORKSPACE || `${process.env.HOME}/.openclaw/workspace`;
+      const dbPath = `${workspace}/memory/knowledge-graph.db`;
+      const scriptPath = `${workspace}/sinain-memory/graph_query.py`;
+      try {
+        const { execFileSync } = await import("node:child_process");
+        const args = [scriptPath, "--db", dbPath, "--max-facts", String(maxFacts), "--format", "text"];
+        if (entities.length > 0) args.push("--entities", JSON.stringify(entities));
+        return execFileSync("python3", args, { timeout: 5000, encoding: "utf-8" });
+      } catch { return ""; }
+    },
   });
 
   // ── Initialize agent loop (event-driven) ──
@@ -382,6 +393,25 @@ async function main() {
     // Bare agent HTTP escalation bridge
     getEscalationPending: () => escalator.getPendingHttp(),
     respondEscalation: (id: string, response: string) => escalator.respondHttp(id, response),
+
+    // Knowledge graph integration
+    getKnowledgeDocPath: () => {
+      const workspace = process.env.SINAIN_WORKSPACE || `${process.env.HOME}/.openclaw/workspace`;
+      const p = `${workspace}/memory/sinain-knowledge.md`;
+      try { if (require("node:fs").existsSync(p)) return p; } catch {}
+      return null;
+    },
+    queryKnowledgeFacts: async (entities: string[], maxFacts: number) => {
+      const workspace = process.env.SINAIN_WORKSPACE || `${process.env.HOME}/.openclaw/workspace`;
+      const dbPath = `${workspace}/memory/knowledge-graph.db`;
+      const scriptPath = `${workspace}/sinain-memory/graph_query.py`;
+      try {
+        const { execFileSync } = await import("node:child_process");
+        const args = [scriptPath, "--db", dbPath, "--max-facts", String(maxFacts), "--format", "text"];
+        if (entities.length > 0) args.push("--entities", JSON.stringify(entities));
+        return execFileSync("python3", args, { timeout: 5000, encoding: "utf-8" });
+      } catch { return ""; }
+    },
   });
 
   // ── Wire overlay profiling ──

package/sinain-core/src/server.ts

@@ -36,6 +36,8 @@ export interface ServerDeps {
   feedbackStore?: FeedbackStore;
   getEscalationPending?: () => any;
   respondEscalation?: (id: string, response: string) => any;
+  getKnowledgeDocPath?: () => string | null;
+  queryKnowledgeFacts?: (entities: string[], maxFacts: number) => Promise<string>;
 }
 
 function readBody(req: IncomingMessage, maxBytes: number): Promise<string> {
@@ -207,6 +209,43 @@ export function createAppServer(deps: ServerDeps) {
         return;
       }
 
+      // ── /knowledge ──
+      if (req.method === "GET" && url.pathname === "/knowledge") {
+        // Return portable knowledge document
+        const knowledgePath = deps.getKnowledgeDocPath?.();
+        if (knowledgePath) {
+          try {
+            const { readFileSync } = await import("node:fs");
+            const content = readFileSync(knowledgePath, "utf-8");
+            res.end(JSON.stringify({ ok: true, content }));
+          } catch {
+            res.end(JSON.stringify({ ok: true, content: "" }));
+          }
+        } else {
+          res.end(JSON.stringify({ ok: true, content: "" }));
+        }
+        return;
+      }
+
+      if (req.method === "GET" && url.pathname === "/knowledge/facts") {
+        // Query knowledge graph for entity-matched facts
+        const entitiesParam = url.searchParams.get("entities") || "";
+        const maxFacts = Math.min(parseInt(url.searchParams.get("max") || "5"), 20);
+        const entities = entitiesParam.split(",").map(e => e.trim()).filter(Boolean);
+
+        if (deps.queryKnowledgeFacts) {
+          try {
+            const facts = await deps.queryKnowledgeFacts(entities, maxFacts);
+            res.end(JSON.stringify({ ok: true, facts }));
+          } catch (err) {
+            res.end(JSON.stringify({ ok: true, facts: [], error: String(err) }));
+          }
+        } else {
+          res.end(JSON.stringify({ ok: true, facts: [] }));
+        }
+        return;
+      }
+
       // ── /traces ──
       if (req.method === "GET" && url.pathname === "/traces") {
         const after = parseInt(url.searchParams.get("after") || "0");

package/sinain-knowledge/curation/engine.ts

@@ -6,11 +6,37 @@
  * external process execution.
  */
 
+import { readFileSync, existsSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+
 import type { Logger, ScriptRunner } from "../data/schema.js";
 import type { KnowledgeStore } from "../data/store.js";
 import type { ResilienceManager } from "./resilience.js";
 import type { GitSnapshotStore } from "../data/git-store.js";
 
+// ============================================================================
+// Distillation State
+// ============================================================================
+
+interface DistillState {
+  lastDistilledFeedId: number;
+  lastDistilledTs: string;
+}
+
+function readDistillState(workspaceDir: string): DistillState {
+  const p = join(workspaceDir, "memory", "distill-state.json");
+  try {
+    if (existsSync(p)) return JSON.parse(readFileSync(p, "utf-8"));
+  } catch {}
+  return { lastDistilledFeedId: 0, lastDistilledTs: "" };
+}
+
+function writeDistillState(workspaceDir: string, state: DistillState): void {
+  const dir = join(workspaceDir, "memory");
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(join(dir, "distill-state.json"), JSON.stringify(state, null, 2), "utf-8");
+}
+
 // ============================================================================
 // Types
 // ============================================================================
@@ -43,14 +69,17 @@ export type ContextAssemblyOpts = {
 export class CurationEngine {
   private curationInterval: ReturnType<typeof setInterval> | null = null;
   private gitSnapshotStore: GitSnapshotStore | null = null;
+  private sinainCoreUrl: string;
 
   constructor(
     private store: KnowledgeStore,
     private runScript: ScriptRunner,
     private resilience: ResilienceManager,
-    private config: { userTimezone: string },
+    private config: { userTimezone: string; sinainCoreUrl?: string },
     private logger: Logger,
-  ) {}
+  ) {
+    this.sinainCoreUrl = config.sinainCoreUrl || process.env.SINAIN_CORE_URL || "http://localhost:9500";
+  }
 
   /** Attach a git-backed snapshot store for periodic saves. */
   setGitSnapshotStore(gitStore: GitSnapshotStore): void {
@@ -143,15 +172,87 @@ export class CurationEngine {
         confidence: 0,
       };
 
-      // Fire-and-forget: ingest signal into triple store
-      const tickTs = new Date().toISOString();
-      runPythonScript([
-        "sinain-memory/triple_ingest.py",
-        "--memory-dir", "memory/",
-        "--tick-ts", tickTs,
-        "--signal-result", JSON.stringify(signalResult),
-        "--embed",
-      ], 15_000).catch(() => {});
+    }
+
+    // 2b. Session distillation check — fetch new feed items and distill if needed
+    try {
+      const distillState = readDistillState(workspaceDir);
+      const feedUrl = `${this.sinainCoreUrl}/feed?after=${distillState.lastDistilledFeedId}`;
+      const historyUrl = `${this.sinainCoreUrl}/agent/history?limit=10`;
+
+      const [feedResp, historyResp] = await Promise.all([
+        fetch(feedUrl).then(r => r.json()).catch(() => null),
+        fetch(historyUrl).then(r => r.json()).catch(() => null),
+      ]);
+
+      const feedItems = (feedResp as { messages?: unknown[] })?.messages ?? [];
+      const agentHistory = (historyResp as { results?: unknown[] })?.results ?? [];
+
+      // Only distill if there's meaningful new content (>3 non-trivial items)
+      const significantItems = (feedItems as Array<{ text?: string }>).filter(
+        (item) => item.text && !item.text.startsWith("[PERIODIC]") && item.text.length > 20,
+      );
+
+      if (significantItems.length > 3) {
+        this.logger.info(
+          `sinain-hud: distillation check — ${significantItems.length} new feed items since id=${distillState.lastDistilledFeedId}`,
+        );
+
+        // Combine feed + agent history as transcript
+        const transcript = JSON.stringify([...significantItems, ...agentHistory].slice(0, 100));
+        const sessionMeta = JSON.stringify({
+          ts: new Date().toISOString(),
+          sessionKey: params.sessionSummary,
+          feedItemCount: significantItems.length,
+        });
+
+        // Step 1: Distill
+        const distillT0 = Date.now();
+        const digest = await runPythonScript([
+          "sinain-memory/session_distiller.py",
+          "--memory-dir", "memory/",
+          "--transcript", transcript,
+          "--session-meta", sessionMeta,
+        ], 30_000);
+        latencyMs.distillation = Date.now() - distillT0;
+
+        if (digest && !digest.isEmpty && !digest.error) {
+          // Step 2: Integrate into playbook + knowledge graph
+          const integrateT0 = Date.now();
+          const integration = await runPythonScript([
+            "sinain-memory/knowledge_integrator.py",
+            "--memory-dir", "memory/",
+            "--digest", JSON.stringify(digest),
+          ], 60_000);
+          latencyMs.integration = Date.now() - integrateT0;
+
+          if (integration) {
+            this.logger.info(
+              `sinain-hud: knowledge integrated — changes=${JSON.stringify(integration.changes ?? {})}, graph=${JSON.stringify(integration.graphStats ?? {})}`,
+            );
+            result.distillation = { digest, integration };
+
+            // Regenerate effective playbook after integration
+            this.store.generateEffectivePlaybook();
+
+            // Render knowledge doc
+            this.store.renderKnowledgeDoc();
+          }
+        } else {
+          this.logger.info(`sinain-hud: distillation produced empty/error result, skipping integration`);
+        }
+
+        // Update watermark — always, even if distillation was empty, to advance past these items
+        const maxFeedId = (feedItems as Array<{ id?: number }>).reduce(
+          (max, item) => Math.max(max, item.id ?? 0), distillState.lastDistilledFeedId,
+        );
+        writeDistillState(workspaceDir, {
+          lastDistilledFeedId: maxFeedId,
+          lastDistilledTs: new Date().toISOString(),
+        });
+      }
+    } catch (err) {
+      this.logger.warn(`sinain-hud: distillation check error: ${String(err)}`);
     }
 
     // 3. Insight synthesis (60s timeout)
@@ -438,20 +539,32 @@ export class CurationEngine {
     const moduleGuidance = this.store.getActiveModuleGuidance();
     if (moduleGuidance) contextParts.push(moduleGuidance);
 
-    // Knowledge graph context (10s timeout)
+    // Knowledge document (pre-rendered, synchronous — replaces triple_query.py)
+    const knowledgeDocPath = join(workspaceDir, "memory", "sinain-knowledge.md");
     try {
-      const ragResult = await this.runScript(
-        ["uv", "run", "--with", "requests", "python3",
-         "sinain-memory/triple_query.py",
-         "--memory-dir", "memory",
-         "--context", "current session",
-         "--max-chars", "1500"],
-        { timeoutMs: 10_000, cwd: workspaceDir },
-      );
-      if (ragResult.code === 0) {
-        const parsed = JSON.parse(ragResult.stdout.trim());
-        if (parsed.context && parsed.context.length > 50) {
-          contextParts.push(`[KNOWLEDGE GRAPH CONTEXT]\n${parsed.context}`);
+      if (existsSync(knowledgeDocPath)) {
+        const knowledgeDoc = readFileSync(knowledgeDocPath, "utf-8");
+        if (knowledgeDoc.length > 50) {
+          contextParts.push(`[KNOWLEDGE]\n${knowledgeDoc}`);
+        }
+      }
+    } catch {}
+
+    // Dynamic graph enrichment for situation-specific facts (10s timeout)
+    try {
+      const situationEntities = this.store.extractSituationEntities();
+      if (situationEntities.length > 0) {
+        const graphResult = await this.runScript(
+          ["uv", "run", "--with", "requests", "python3",
+           "sinain-memory/graph_query.py",
+           "--db", "memory/knowledge-graph.db",
+           "--entities", JSON.stringify(situationEntities),
+           "--max-facts", "5",
+           "--format", "text"],
+          { timeoutMs: 10_000, cwd: workspaceDir },
+        );
+        if (graphResult.code === 0 && graphResult.stdout.trim().length > 20) {
+          contextParts.push(`[SITUATION-SPECIFIC KNOWLEDGE]\n${graphResult.stdout.trim()}`);
         }
       }
     } catch {}

package/sinain-knowledge/data/git-store.ts

@@ -193,9 +193,33 @@ export class GitSnapshotStore {
     this.git("commit", "-m", message);
     const hash = this.git("rev-parse", "--short", "HEAD");
     this.logger.info(`sinain-knowledge: snapshot saved → ${hash}`);
+    await this.push();
     return hash;
   }
 
+  // ── Push ─────────────────────────────────────────────────────────────────
+
+  private async push(): Promise<void> {
+    try {
+      const remotes = this.git("remote");
+      if (!remotes) return;
+
+      // Use a longer timeout for network operations
+      execFileSync("git", ["push", "origin", "HEAD"], {
+        cwd: this.repoPath,
+        encoding: "utf-8",
+        timeout: 30_000,
+        stdio: "pipe",
+      });
+      this.logger.info("sinain-knowledge: snapshot pushed to remote");
+    } catch (err) {
+      // Warn only if there IS a remote but push failed
+      this.logger.warn(
+        `sinain-knowledge: push failed (${err instanceof Error ? err.message.split("\n")[0] : String(err)})`,
+      );
+    }
+  }
+
   // ── List ─────────────────────────────────────────────────────────────────
 
   /**