@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/core/vision/vision-loop.js

@@ -0,0 +1,220 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+import { loadVision, setObjectiveDone } from "./vision-file.js";
+import { SignalInbox } from "./signals.js";
+import {
+  SEVERITY_RANK
+} from "./types.js";
+function today() {
+  return (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+}
+const realSleep = (ms) => new Promise((r) => setTimeout(r, ms));
+class VisionLoop {
+  opts;
+  inbox;
+  constructor(options) {
+    this.opts = { sleep: realSleep, ...options };
+    this.inbox = new SignalInbox(options.signalsPath);
+  }
+  readState() {
+    const base = {
+      day: today(),
+      iterationsToday: 0,
+      consecutiveFailures: 0,
+      lastTickAt: 0
+    };
+    if (!existsSync(this.opts.statePath)) return base;
+    try {
+      const s = JSON.parse(
+        readFileSync(this.opts.statePath, "utf-8")
+      );
+      if (s.day !== today()) return { ...s, day: today(), iterationsToday: 0 };
+      return s;
+    } catch {
+      return base;
+    }
+  }
+  writeState(s) {
+    const dir = dirname(this.opts.statePath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    writeFileSync(this.opts.statePath, JSON.stringify(s, null, 2));
+  }
+  /** Pick the next unit of work: pending signals outrank pending objectives. */
+  selectCandidate(vision) {
+    const signal = this.inbox.pending()[0];
+    if (signal) {
+      return {
+        kind: "signal",
+        id: signal.id,
+        text: signal.text,
+        priority: 100 + SEVERITY_RANK[signal.severity],
+        refs: signal.refs ?? []
+      };
+    }
+    const idx = vision.objectives.findIndex((o2) => !o2.done);
+    const o = idx >= 0 ? vision.objectives[idx] : void 0;
+    if (o) {
+      return {
+        kind: "objective",
+        id: o.id,
+        text: o.text,
+        priority: 50 - idx,
+        refs: []
+      };
+    }
+    return null;
+  }
+  checkGuardrails(state, vision, iterationThisRun) {
+    const l = vision.limits;
+    if (iterationThisRun >= l.maxIterations) {
+      return {
+        ok: false,
+        reason: `reached maxIterations (${l.maxIterations}) for this run`
+      };
+    }
+    if (state.iterationsToday >= l.maxIterationsPerDay) {
+      return {
+        ok: false,
+        reason: `reached maxIterationsPerDay (${l.maxIterationsPerDay})`
+      };
+    }
+    if (state.consecutiveFailures >= l.maxConsecutiveFailures) {
+      return {
+        ok: false,
+        reason: `circuit breaker: ${state.consecutiveFailures} consecutive failures (limit ${l.maxConsecutiveFailures})`
+      };
+    }
+    return { ok: true };
+  }
+  /** Has the brain already concluded this exact piece of work? */
+  priorConclusion(text) {
+    const hits = this.brainRecall(text);
+    const match = hits.find(
+      (e) => e.title.trim() === text.trim() && e.conclusion.trim().length > 0
+    );
+    return match?.conclusion;
+  }
+  brainRecall(text) {
+    return this.opts.brain.recall({ text, limit: 5 });
+  }
+  async tick(iterationThisRun, dryRun = false) {
+    const vision = loadVision(this.opts.visionPath);
+    if (!vision) {
+      return {
+        candidate: null,
+        guardrail: { ok: false, reason: "no VISION.md found" },
+        skippedAsKnown: false,
+        delegated: false
+      };
+    }
+    const state = this.readState();
+    const guardrail = this.checkGuardrails(state, vision, iterationThisRun);
+    if (!guardrail.ok) {
+      return {
+        candidate: null,
+        guardrail,
+        skippedAsKnown: false,
+        delegated: false
+      };
+    }
+    const candidate = this.selectCandidate(vision);
+    if (!candidate) {
+      return {
+        candidate: null,
+        guardrail: { ok: true },
+        skippedAsKnown: false,
+        delegated: false
+      };
+    }
+    const prior = this.priorConclusion(candidate.text);
+    if (prior) {
+      if (candidate.kind === "objective") {
+        setObjectiveDone(this.opts.visionPath, candidate.id, true);
+      } else {
+        this.inbox.resolve(candidate.id);
+      }
+      return {
+        candidate,
+        guardrail: { ok: true },
+        skippedAsKnown: true,
+        priorConclusion: prior,
+        delegated: false
+      };
+    }
+    if (dryRun || vision.limits.requireApproval) {
+      return {
+        candidate,
+        guardrail: { ok: true },
+        skippedAsKnown: false,
+        delegated: false
+      };
+    }
+    const outcome = await this.opts.delegate(candidate, vision);
+    this.opts.brain.record({
+      title: candidate.text,
+      summary: `Vision loop handled a ${candidate.kind} toward: ${vision.mission}`,
+      conclusion: outcome.conclusion,
+      kind: "experiment",
+      agent: "vision",
+      tags: ["vision", candidate.kind, outcome.success ? "success" : "failure"],
+      refs: [...candidate.refs, ...outcome.refs ?? []],
+      confidence: outcome.success ? 0.8 : 0.4
+    });
+    const next = this.readState();
+    if (outcome.success) {
+      next.iterationsToday += 1;
+      next.consecutiveFailures = 0;
+      if (candidate.kind === "objective") {
+        setObjectiveDone(this.opts.visionPath, candidate.id, true);
+      } else {
+        this.inbox.resolve(candidate.id);
+      }
+    } else {
+      next.consecutiveFailures += 1;
+    }
+    next.lastTickAt = Date.now();
+    this.writeState(next);
+    return {
+      candidate,
+      guardrail: { ok: true },
+      skippedAsKnown: false,
+      delegated: true,
+      outcome
+    };
+  }
+  /** Run ticks until a guardrail stops the loop or there's nothing left. */
+  async run(opts = {}) {
+    const vision = loadVision(this.opts.visionPath);
+    const max = opts.maxIterations ?? vision?.limits.maxIterations ?? 1;
+    const tickInterval = (vision?.limits.tickIntervalSec ?? 60) * 1e3;
+    const decisions = [];
+    let delegated = 0;
+    let skipped = 0;
+    let stopped = "completed run";
+    for (let i = 0; i < max; i++) {
+      const d = await this.tick(i, opts.dryRun);
+      decisions.push(d);
+      if (!d.guardrail.ok) {
+        stopped = d.guardrail.reason ?? "guardrail stop";
+        break;
+      }
+      if (!d.candidate) {
+        stopped = "no work remaining";
+        break;
+      }
+      if (d.skippedAsKnown) skipped++;
+      if (d.delegated) delegated++;
+      if (!opts.dryRun && i < max - 1) {
+        await this.opts.sleep(tickInterval);
+      }
+    }
+    return { decisions, stopped, delegated, skipped };
+  }
+}
+export {
+  VisionLoop
+};

package/dist/src/core/wiki/wiki-compiler.js

@@ -25,7 +25,8 @@ class WikiCompiler {
       entities: join(this.config.wikiDir, "entities"),
       concepts: join(this.config.wikiDir, "concepts"),
       sources: join(this.config.wikiDir, "sources"),
-      synthesis: join(this.config.wikiDir, "synthesis")
+      synthesis: join(this.config.wikiDir, "synthesis"),
+      sops: join(this.config.wikiDir, "sops")
     };
   }
   /** Initialize wiki directory structure */
@@ -92,6 +93,8 @@ class WikiCompiler {
       this.writeArticle(path, this.buildSessionSource(ctx.sessionDigest));
       created.push(path);
     }
+    const derivedSops = this.generateDerivedSops(ctx.anchors);
+    created.push(...derivedSops);
     this.updateIndex();
     this.appendLog(
       `## [${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}] create | full wiki`,
@@ -174,6 +177,8 @@ class WikiCompiler {
       if (existsSync(filepath)) updated.push(path);
       else created.push(path);
     }
+    const derivedSops = this.generateDerivedSops(ctx.anchors);
+    created.push(...derivedSops);
     if (created.length > 0 || updated.length > 0) {
       this.updateIndex();
       this.appendLog(
@@ -525,6 +530,11 @@ class WikiCompiler {
         (f) => f.endsWith(".md")
       ).length;
     }
+    byCategory["entities"] ??= 0;
+    byCategory["concepts"] ??= 0;
+    byCategory["sources"] ??= 0;
+    byCategory["synthesis"] ??= 0;
+    byCategory["sops"] ??= 0;
     const logPath = join(this.dirs.root, "log.md");
     let lastCompile = null;
     if (existsSync(logPath)) {
@@ -826,6 +836,98 @@ class WikiCompiler {
     }
     return groups;
   }
+  /**
+   * Derive Company OS SOPs from recurring frame anchors.
+   * Creates lightweight SOP drafts in wiki/sops/ for DECISION, CONSTRAINT, RISK, FACT anchors.
+   */
+  generateDerivedSops(anchors) {
+    const created = [];
+    const derivedConfig = [
+      {
+        type: "DECISION",
+        id: 401,
+        name: "Decision-derived Process",
+        proseId: "E.9",
+        objective: "Preserve recurring decisions as repeatable guidance so the team does not re-debate settled questions."
+      },
+      {
+        type: "CONSTRAINT",
+        id: 402,
+        name: "Constraint-derived Process",
+        proseId: "E.10",
+        objective: "Preserve recurring constraints as repeatable guidance so the team respects known boundaries."
+      },
+      {
+        type: "RISK",
+        id: 403,
+        name: "Risk-derived Process",
+        proseId: "E.11",
+        objective: "Preserve recurring risks as repeatable guidance so the team mitigates them consistently."
+      },
+      {
+        type: "FACT",
+        id: 404,
+        name: "Fact-derived Process",
+        proseId: "E.12",
+        objective: "Preserve recurring facts as repeatable guidance so the team operates from shared knowledge."
+      }
+    ];
+    for (const config of derivedConfig) {
+      const typeAnchors = anchors.filter((a) => a.type === config.type);
+      if (typeAnchors.length === 0) continue;
+      const path = `sops/SOP-${config.id}-${this.slugify(config.name)}.md`;
+      const items = typeAnchors.slice(-20).map((a) => {
+        const date = new Date(a.created_at * 1e3).toISOString().slice(0, 10);
+        return `- ${a.text} _(observed ${date} in [[sources/${this.slugify(a.frame_name)}]])_`;
+      }).join("\n");
+      const article = [
+        "---",
+        `title: "SOP-${config.id} ${config.name}"`,
+        `category: sop`,
+        `derived_from: "${config.type} anchors"`,
+        `created: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+        `updated: ${(/* @__PURE__ */ new Date()).toISOString()}`,
+        `tags: [sop, derived, ${config.type.toLowerCase()}]`,
+        "---",
+        "",
+        `# SOP-${config.id} ${config.name}`,
+        "",
+        "**Owner:** Derived from frame anchors  ",
+        "**Status:** Active  ",
+        `**Related PROSE Expectation:** [${config.proseId} ${config.name}](../../docs/specs/COMPANY-OS-PROSE.md)`,
+        "",
+        "## Objective",
+        config.objective,
+        "",
+        "## Procedure",
+        "",
+        `1. **Review**`,
+        `   - Review the latest ${config.type} anchors below before taking action.`,
+        "",
+        `2. **Apply**`,
+        `   - Treat these ${config.type.toLowerCase()}s as guidance for current and future work.`,
+        "",
+        `3. **Update**`,
+        `   - When a ${config.type.toLowerCase()} changes, record the new state in a frame so this SOP can be regenerated.`,
+        "",
+        "## Verification",
+        "",
+        `- Run \`stackmemory company-os audit ${config.type.toLowerCase()}-derived\``,
+        `- Expected result: the derived ${config.type.toLowerCase()}s below are reflected in current work.`,
+        "",
+        "### Derived anchors",
+        `${items}`,
+        "",
+        "## Non-compliance",
+        "",
+        `Ignoring or overriding these ${config.type.toLowerCase()}s without a new recorded decision is non-compliant.`,
+        ""
+      ].join("\n");
+      this.writeArticle(path, article);
+      created.push(path);
+    }
+    return created;
+  }
   // ── Reading helpers ──
   readExistingSources() {
     const sources = [];

package/dist/src/daemon/daemon-config.js

@@ -23,6 +23,10 @@ const DEFAULT_DAEMON_CONFIG = {
     retryAttempts: 3,
     retryDelay: 3e4
   },
+  github: {
+    enabled: false,
+    interval: 5
+  },
   maintenance: {
     enabled: true,
     interval: 360,
@@ -53,6 +57,51 @@ const DEFAULT_DAEMON_CONFIG = {
     ignore: ["node_modules", ".git", "dist", "build", ".stackmemory"],
     debounceMs: 2e3
   },
+  telemetry: {
+    enabled: true,
+    // opt-out via STACKMEMORY_TELEMETRY=0
+    interval: 1440,
+    // 24 hours
+    maxSnapshots: 90
+    // ~3 months of daily
+  },
+  desirePaths: {
+    enabled: true,
+    // opt-out via STACKMEMORY_DESIRE_PATHS=0
+    interval: 360,
+    // scan every 6 hours
+    minFrequency: 3,
+    // 3+ occurrences to be a pattern
+    minSessions: 2,
+    // across 2+ distinct sessions
+    maxLogSizeBytes: 10 * 1024 * 1024,
+    // 10MB rotation
+    retentionDays: 30,
+    maxSequenceLength: 8,
+    autoPromoteThreshold: 0.8,
+    autoPromoteMinSessions: 5
+  },
+  researchStream: {
+    enabled: true,
+    // opt-out via STACKMEMORY_RESEARCH_STREAM=0
+    interval: 360,
+    // every 6 hours
+    keywords: [
+      "agent",
+      "ai",
+      "llm",
+      "mcp",
+      "context",
+      "memory",
+      "orchestration",
+      "skill",
+      "workflow",
+      "automation",
+      "browser agent",
+      "coding assistant"
+    ],
+    maxSignalsPerScan: 50
+  },
   heartbeatInterval: 60,
   // 1 minute
   inactivityTimeout: 0,
@@ -96,6 +145,7 @@ function loadDaemonConfig() {
       ...config,
       context: { ...DEFAULT_DAEMON_CONFIG.context, ...config.context },
       linear: { ...DEFAULT_DAEMON_CONFIG.linear, ...config.linear },
+      github: { ...DEFAULT_DAEMON_CONFIG.github, ...config.github },
       maintenance: {
         ...DEFAULT_DAEMON_CONFIG.maintenance,
         ...config.maintenance
@@ -115,6 +165,7 @@ function saveDaemonConfig(config) {
     ...config,
     context: { ...currentConfig.context, ...config.context },
     linear: { ...currentConfig.linear, ...config.linear },
+    github: { ...currentConfig.github, ...config.github },
     maintenance: { ...currentConfig.maintenance, ...config.maintenance },
     memory: { ...currentConfig.memory, ...config.memory },
     fileWatch: { ...currentConfig.fileWatch, ...config.fileWatch }
@@ -128,6 +179,7 @@ function readDaemonStatus() {
     services: {
       context: { enabled: false },
       linear: { enabled: false },
+      github: { enabled: false },
       maintenance: { enabled: false },
       memory: { enabled: false },
       fileWatch: { enabled: false }