@geravant/sinain 1.1.0 → 1.2.1

package/sinain-core/src/types.ts

@@ -66,8 +66,21 @@ export interface ProfilingMessage {
   ts: number;
 }
 
+/** Overlay → sinain-core: user command to augment next escalation */
+export interface UserCommandMessage {
+  type: "user_command";
+  text: string;
+}
+
 export type OutboundMessage = FeedMessage | StatusMessage | PingMessage | SpawnTaskMessage;
-export type InboundMessage = UserMessage | CommandMessage | PongMessage | ProfilingMessage;
+export type InboundMessage = UserMessage | CommandMessage | PongMessage | ProfilingMessage | UserCommandMessage;
+
+/** Abstraction for user commands (text now, voice later). */
+export interface UserCommand {
+  text: string;
+  ts: number;
+  source: "text" | "voice";
+}
 
 // ── Feed buffer types ──
 
@@ -411,7 +424,6 @@ export interface PrivacyConfig {
 export interface CoreConfig {
   port: number;
   audioConfig: AudioPipelineConfig;
-  audioAltDevice: string;
   micConfig: AudioPipelineConfig;
   micEnabled: boolean;
   transcriptionConfig: TranscriptionConfig;

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 ─────────────────────────────────────────────────────────────────
 
   /**

package/sinain-knowledge/data/store.ts

@@ -485,4 +485,121 @@ export class KnowledgeStore {
     writeFileSync(tmpPath, content, "utf-8");
     renameSync(tmpPath, situationPath);
   }
+
+  // ── Knowledge Document ─────────────────────────────────────────────────
+
+  /**
+   * Render sinain-knowledge.md — the portable knowledge document (<8KB).
+   * Combines: playbook (working memory) + top graph facts (long-term memory)
+   * + recent session digests + active module guidance.
+   */
+  renderKnowledgeDoc(): boolean {
+    try {
+      const parts: string[] = [];
+      const now = new Date().toISOString();
+
+      parts.push(`# Sinain Knowledge`);
+      parts.push(`<!-- exported: ${now}, version: 3 -->\n`);
+
+      // Playbook (working memory)
+      const playbook = this.readPlaybook();
+      if (playbook) {
+        // Strip header/footer comments for the doc
+        const body = playbook
+          .split("\n")
+          .filter((l) => !l.trim().startsWith("<!--"))
+          .join("\n")
+          .trim();
+        if (body) {
+          parts.push(`## Playbook (Working Memory)\n${body}\n`);
+        }
+      }
+
+      // Recent session digests
+      const digestsPath = join(this.workspaceDir, "memory", "session-digests.jsonl");
+      if (existsSync(digestsPath)) {
+        try {
+          const lines = readFileSync(digestsPath, "utf-8")
+            .split("\n")
+            .filter((l) => l.trim())
+            .slice(-5);
+          if (lines.length > 0) {
+            parts.push(`## Recent Sessions`);
+            for (const line of lines) {
+              try {
+                const d = JSON.parse(line);
+                if (d.whatHappened) {
+                  parts.push(`- ${d.whatHappened}`);
+                }
+              } catch {}
+            }
+            parts.push("");
+          }
+        } catch {}
+      }
+
+      // Active module guidance (brief)
+      const guidance = this.getActiveModuleGuidance();
+      if (guidance && guidance.length > 20) {
+        // Truncate to keep doc under 8KB
+        const truncated = guidance.slice(0, 2000);
+        parts.push(`## Active Modules\n${truncated}\n`);
+      }
+
+      const doc = parts.join("\n").trim() + "\n";
+      const docPath = join(this.workspaceDir, "memory", "sinain-knowledge.md");
+      const memDir = join(this.workspaceDir, "memory");
+      if (!existsSync(memDir)) mkdirSync(memDir, { recursive: true });
+      writeFileSync(docPath, doc, "utf-8");
+      this.logger.info(`sinain-hud: rendered sinain-knowledge.md (${doc.length} chars)`);
+      return true;
+    } catch (err) {
+      this.logger.warn(`sinain-hud: failed to render knowledge doc: ${String(err)}`);
+      return false;
+    }
+  }
+
+  /**
+   * Extract entity keywords from SITUATION.md for dynamic graph enrichment.
+   * Returns lowercase entity names found in the situation text.
+   */
+  extractSituationEntities(): string[] {
+    const situation = this.readSituation();
+    if (!situation) return [];
+
+    const entities: Set<string> = new Set();
+
+    // Extract from "Active Application:" line
+    const appMatch = situation.match(/Active Application:\s*(.+)/i);
+    if (appMatch) {
+      const app = appMatch[1].trim().toLowerCase().replace(/\s+/g, "-");
+      if (app.length > 2) entities.add(app);
+    }
+
+    // Extract from "Detected Errors:" section
+    const errorMatch = situation.match(/Detected Errors:[\s\S]*?(?=\n##|\n---|\Z)/i);
+    if (errorMatch) {
+      // Look for common error type patterns
+      const errorPatterns = errorMatch[0].matchAll(
+        /(?:Error|Exception|TypeError|SyntaxError|ReferenceError|HTTP\s*\d{3}|ENOENT|EACCES|timeout)/gi,
+      );
+      for (const m of errorPatterns) {
+        entities.add(m[0].toLowerCase());
+      }
+    }
+
+    // Extract technology keywords
+    const techKeywords = [
+      "react-native", "react", "flutter", "swift", "kotlin", "python",
+      "typescript", "javascript", "node", "docker", "kubernetes",
+      "intellij", "vscode", "xcode", "metro", "gradle", "cocoapods",
+      "openrouter", "anthropic", "gemini", "openclaw", "sinain",
+    ];
+    const lowerSituation = situation.toLowerCase();
+    for (const kw of techKeywords) {
+      if (lowerSituation.includes(kw)) entities.add(kw);
+    }
+
+    return [...entities].slice(0, 10);
+  }
 }

package/sinain-mcp-server/index.ts

@@ -184,26 +184,106 @@ server.tool(
   },
 );
 
-// 8. sinain_knowledge_query
+// 8. sinain_get_knowledge
+server.tool(
+  "sinain_get_knowledge",
+  "Get the portable knowledge document (playbook + long-term facts + recent sessions)",
+  {},
+  async () => {
+    try {
+      // Read pre-rendered knowledge doc (fast, no subprocess)
+      const docPath = resolve(MEMORY_DIR, "sinain-knowledge.md");
+      if (existsSync(docPath)) {
+        const content = readFileSync(docPath, "utf-8");
+        return textResult(stripPrivateTags(content));
+      }
+      // Fallback: read playbook directly
+      const playbookPath = resolve(MEMORY_DIR, "sinain-playbook.md");
+      if (existsSync(playbookPath)) {
+        return textResult(stripPrivateTags(readFileSync(playbookPath, "utf-8")));
+      }
+      return textResult("No knowledge document available yet");
+    } catch (err: any) {
+      return textResult(`Error reading knowledge: ${err.message}`);
+    }
+  },
+);
+
+// 8b. sinain_knowledge_query (graph query — entity-based lookup)
 server.tool(
   "sinain_knowledge_query",
-  "Query the knowledge graph / memory triples for relevant context",
+  "Query the knowledge graph for facts about specific entities/domains",
   {
-    context: z.string(),
-    max_chars: z.number().optional().default(1500),
+    entities: z.array(z.string()).optional().default([]),
+    max_facts: z.number().optional().default(5),
   },
-  async ({ context, max_chars }) => {
+  async ({ entities, max_facts }) => {
     try {
-      const scriptPath = resolve(SCRIPTS_DIR, "triple_query.py");
-      const output = await runScript([
-        scriptPath,
-        "--memory-dir", MEMORY_DIR,
-        "--context", context,
-        "--max-chars", String(max_chars),
-      ]);
+      const dbPath = resolve(MEMORY_DIR, "knowledge-graph.db");
+      const scriptPath = resolve(SCRIPTS_DIR, "graph_query.py");
+      const args = [scriptPath, "--db", dbPath, "--max-facts", String(max_facts)];
+      if (entities.length > 0) {
+        args.push("--entities", JSON.stringify(entities));
+      }
+      const output = await runScript(args);
       return textResult(stripPrivateTags(output));
     } catch (err: any) {
-      return textResult(`Error querying knowledge: ${err.message}`);
+      return textResult(`Error querying graph: ${err.message}`);
+    }
+  },
+);
+
+// 8c. sinain_distill_session
+server.tool(
+  "sinain_distill_session",
+  "Distill the current session into knowledge (playbook updates + graph facts)",
+  {
+    session_summary: z.string().optional().default("Bare agent session distillation"),
+  },
+  async ({ session_summary }) => {
+    const results: string[] = [];
+
+    try {
+      // Fetch feed items from sinain-core
+      const coreUrl = process.env.SINAIN_CORE_URL || "http://localhost:9500";
+      const feedResp = await fetch(`${coreUrl}/feed?after=0`).then(r => r.json());
+      const historyResp = await fetch(`${coreUrl}/agent/history?limit=10`).then(r => r.json());
+
+      const feedItems = (feedResp as any).messages ?? [];
+      const agentHistory = (historyResp as any).results ?? [];
+
+      if (feedItems.length < 3) {
+        return textResult("Not enough feed items to distill (need >3)");
+      }
+
+      // Step 1: Distill
+      const transcript = JSON.stringify([...feedItems, ...agentHistory].slice(0, 100));
+      const meta = JSON.stringify({ ts: new Date().toISOString(), sessionKey: session_summary });
+
+      const distillOutput = await runScript([
+        resolve(SCRIPTS_DIR, "session_distiller.py"),
+        "--memory-dir", MEMORY_DIR,
+        "--transcript", transcript,
+        "--session-meta", meta,
+      ], 30_000);
+      results.push(`[session_distiller] ${distillOutput.trim().slice(0, 500)}`);
+
+      const digest = JSON.parse(distillOutput.trim());
+      if (digest.isEmpty || digest.error) {
+        return textResult(`Distillation skipped: ${digest.error || "empty session"}`);
+      }
+
+      // Step 2: Integrate
+      const integrateOutput = await runScript([
+        resolve(SCRIPTS_DIR, "knowledge_integrator.py"),
+        "--memory-dir", MEMORY_DIR,
+        "--digest", JSON.stringify(digest),
+      ], 60_000);
+      results.push(`[knowledge_integrator] ${integrateOutput.trim().slice(0, 500)}`);
+
+      return textResult(stripPrivateTags(results.join("\n\n")));
+    } catch (err: any) {
+      return textResult(`Distillation error: ${err.message}`);
     }
   },
 );
@@ -287,7 +367,22 @@ server.tool(
   },
 );
 
-// 10. sinain_module_guidance
+// 10. sinain_user_command
+server.tool(
+  "sinain_user_command",
+  "Queue a user command to augment the next escalation context (forces escalation on next agent tick)",
+  { text: z.string().describe("The command text to inject into the next escalation") },
+  async ({ text }) => {
+    try {
+      const data = await coreRequest("POST", "/user/command", { text });
+      return textResult(JSON.stringify(data, null, 2));
+    } catch (err: any) {
+      return textResult(`Error queuing user command: ${err.message}`);
+    }
+  },
+);
+
+// 11. sinain_module_guidance
 server.tool(
   "sinain_module_guidance",
   "Read guidance from all active modules in the workspace",