@stackmemoryai/stackmemory 1.10.5 → 1.14.0

package/dist/src/core/tasks/md-task-parser.js

@@ -0,0 +1,138 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { readFileSync, writeFileSync } from "fs";
+const HEADER_RE = /^\|\s*id\s*\|/i;
+const SEPARATOR_RE = /^\|[\s-|]+\|$/;
+const PRIORITIES = ["P0", "P1", "P2", "P3"];
+const STATUSES = ["todo", "active", "done", "blocked", "cut"];
+const SYNCS = ["local", "linear", "gh"];
+function parseMasterTasks(content) {
+  const lines = content.split("\n");
+  const tasks = [];
+  let inTable = false;
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|")) {
+      if (inTable) break;
+      continue;
+    }
+    if (HEADER_RE.test(trimmed)) {
+      inTable = true;
+      continue;
+    }
+    if (SEPARATOR_RE.test(trimmed)) continue;
+    if (!inTable) continue;
+    const cells = trimmed.split("|").slice(1, -1).map((c) => c.trim());
+    if (cells.length < 8) continue;
+    const [id, priority, status, owner, sync, task, branchPr, notes] = cells;
+    if (!id || !PRIORITIES.includes(priority)) continue;
+    tasks.push({
+      id,
+      priority,
+      status: STATUSES.includes(status) ? status : "todo",
+      owner: owner || "@me",
+      sync: SYNCS.includes(sync) ? sync : "local",
+      task: task || "",
+      branchPr: branchPr || "",
+      notes: notes || ""
+    });
+  }
+  return tasks;
+}
+function serializeTaskRows(tasks) {
+  return tasks.map(
+    (t) => `| ${t.id} | ${t.priority} | ${t.status} | ${t.owner} | ${t.sync} | ${t.task} | ${t.branchPr} | ${t.notes} |`
+  ).join("\n");
+}
+function updateTaskInFile(filePath, taskId, updates) {
+  const content = readFileSync(filePath, "utf-8");
+  const lines = content.split("\n");
+  let found = false;
+  const updated = lines.map((line) => {
+    const trimmed = line.trim();
+    if (!trimmed.startsWith("|") || HEADER_RE.test(trimmed) || SEPARATOR_RE.test(trimmed)) {
+      return line;
+    }
+    const cells = trimmed.split("|").slice(1, -1).map((c) => c.trim());
+    if (cells.length < 8 || cells[0] !== taskId) return line;
+    found = true;
+    const task = {
+      id: cells[0],
+      priority: updates.priority ?? cells[1],
+      status: updates.status ?? cells[2],
+      owner: updates.owner ?? cells[3],
+      sync: updates.sync ?? cells[4],
+      task: updates.task ?? cells[5],
+      branchPr: updates.branchPr ?? cells[6],
+      notes: updates.notes ?? cells[7]
+    };
+    return `| ${task.id} | ${task.priority} | ${task.status} | ${task.owner} | ${task.sync} | ${task.task} | ${task.branchPr} | ${task.notes} |`;
+  });
+  if (!found) throw new Error(`Task ${taskId} not found in ${filePath}`);
+  writeFileSync(filePath, updated.join("\n"), "utf-8");
+}
+function addTaskToFile(filePath, task) {
+  const content = readFileSync(filePath, "utf-8");
+  const existing = parseMasterTasks(content);
+  const maxNum = existing.reduce((max, t) => {
+    const n = parseInt(t.id.replace(/^T/, ""), 10);
+    return isNaN(n) ? max : Math.max(max, n);
+  }, 0);
+  const id = `T${String(maxNum + 1).padStart(2, "0")}`;
+  const newRow = `| ${id} | ${task.priority} | ${task.status} | ${task.owner} | ${task.sync} | ${task.task} | ${task.branchPr} | ${task.notes} |`;
+  const lines = content.split("\n");
+  let insertIdx = -1;
+  let inTable = false;
+  for (let i = 0; i < lines.length; i++) {
+    const trimmed = lines[i].trim();
+    if (HEADER_RE.test(trimmed)) {
+      inTable = true;
+      continue;
+    }
+    if (inTable && trimmed.startsWith("|") && !SEPARATOR_RE.test(trimmed)) {
+      insertIdx = i;
+    }
+    if (inTable && !trimmed.startsWith("|") && trimmed !== "") {
+      break;
+    }
+  }
+  if (insertIdx === -1) {
+    for (let i = 0; i < lines.length; i++) {
+      if (SEPARATOR_RE.test(lines[i].trim())) {
+        insertIdx = i;
+        break;
+      }
+    }
+  }
+  lines.splice(insertIdx + 1, 0, newRow);
+  writeFileSync(filePath, lines.join("\n"), "utf-8");
+  return id;
+}
+function getNextTask(tasks) {
+  const actionable = tasks.filter(
+    (t) => t.status === "todo" || t.status === "active"
+  );
+  if (actionable.length === 0) return void 0;
+  const ownerRank = {
+    "@agent": 0,
+    "@me": 1,
+    "@defer": 2
+  };
+  actionable.sort((a, b) => {
+    const pDiff = PRIORITIES.indexOf(a.priority) - PRIORITIES.indexOf(b.priority);
+    if (pDiff !== 0) return pDiff;
+    const aRank = ownerRank[a.owner] ?? 1;
+    const bRank = ownerRank[b.owner] ?? 1;
+    return aRank - bRank;
+  });
+  return actionable[0];
+}
+export {
+  addTaskToFile,
+  getNextTask,
+  parseMasterTasks,
+  serializeTaskRows,
+  updateTaskInFile
+};

package/dist/src/core/trace/trace-event-store.js

@@ -0,0 +1,282 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { v4 as uuidv4 } from "uuid";
+import { logger } from "../monitoring/logger.js";
+class TraceEventStore {
+  db;
+  constructor(db) {
+    this.db = db;
+    this.initSchema();
+  }
+  initSchema() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS trace_events (
+        id TEXT PRIMARY KEY,
+        timestamp TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        trace_id TEXT NOT NULL,
+        parent_trace_id TEXT,
+        tenant_id TEXT NOT NULL DEFAULT 'local',
+        actor_host TEXT NOT NULL DEFAULT 'unknown',
+        actor_agent TEXT NOT NULL DEFAULT 'stackmemory-mcp',
+        actor_user TEXT NOT NULL DEFAULT 'anonymous',
+        operation TEXT NOT NULL,
+        inputs TEXT NOT NULL DEFAULT '{}',
+        outputs TEXT NOT NULL DEFAULT '{}',
+        tokens_in INTEGER NOT NULL DEFAULT 0,
+        tokens_out INTEGER NOT NULL DEFAULT 0,
+        cost_usd REAL NOT NULL DEFAULT 0,
+        duration_ms INTEGER NOT NULL DEFAULT 0,
+        score REAL,
+        feedback TEXT,
+        provenance TEXT NOT NULL DEFAULT '{"sources":[],"derivation":[],"confidence":1}',
+        error TEXT,
+        tags TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_te_session ON trace_events(session_id);
+      CREATE INDEX IF NOT EXISTS idx_te_trace ON trace_events(trace_id);
+      CREATE INDEX IF NOT EXISTS idx_te_operation ON trace_events(operation);
+      CREATE INDEX IF NOT EXISTS idx_te_timestamp ON trace_events(timestamp);
+      CREATE INDEX IF NOT EXISTS idx_te_score ON trace_events(score) WHERE score IS NOT NULL;
+    `);
+  }
+  // ------------------------------------------------------------------
+  // Write
+  // ------------------------------------------------------------------
+  /**
+   * Record a trace event. Generates ID if not present in trace_id.
+   */
+  record(event) {
+    const id = uuidv4();
+    this.db.prepare(
+      `INSERT INTO trace_events (
+          id, timestamp, session_id, trace_id, parent_trace_id, tenant_id,
+          actor_host, actor_agent, actor_user,
+          operation, inputs, outputs,
+          tokens_in, tokens_out, cost_usd, duration_ms,
+          score, feedback, provenance, error, tags
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      id,
+      event.timestamp,
+      event.session_id,
+      event.trace_id,
+      event.parent_trace_id ?? null,
+      event.tenant_id,
+      event.actor.host,
+      event.actor.agent,
+      event.actor.user,
+      event.operation,
+      JSON.stringify(event.inputs),
+      JSON.stringify(event.outputs),
+      event.tokens_in,
+      event.tokens_out,
+      event.cost_usd,
+      event.duration_ms,
+      event.score ?? null,
+      event.feedback ?? null,
+      JSON.stringify(event.provenance),
+      event.error ?? null,
+      event.tags ? JSON.stringify(event.tags) : null
+    );
+    logger.debug(`TraceEvent recorded: ${event.operation} [${id}]`);
+    return id;
+  }
+  /**
+   * Record multiple events in a single transaction.
+   */
+  recordBatch(events) {
+    const ids = [];
+    this.db.transaction(() => {
+      for (const event of events) {
+        ids.push(this.record(event));
+      }
+    })();
+    return ids;
+  }
+  /**
+   * Add score and/or feedback to an existing event.
+   */
+  annotate(id, annotation) {
+    const sets = [];
+    const params = [];
+    if (annotation.score !== void 0) {
+      sets.push("score = ?");
+      params.push(annotation.score);
+    }
+    if (annotation.feedback !== void 0) {
+      sets.push("feedback = ?");
+      params.push(annotation.feedback);
+    }
+    if (sets.length === 0) return false;
+    params.push(id);
+    const result = this.db.prepare(`UPDATE trace_events SET ${sets.join(", ")} WHERE id = ?`).run(...params);
+    return result.changes > 0;
+  }
+  // ------------------------------------------------------------------
+  // Read
+  // ------------------------------------------------------------------
+  /**
+   * Get a single event by ID.
+   */
+  get(id) {
+    const row = this.db.prepare("SELECT * FROM trace_events WHERE id = ?").get(id);
+    return row ? this.rowToEvent(row) : void 0;
+  }
+  /**
+   * Query events with filters.
+   */
+  query(filter = {}) {
+    const conditions = [];
+    const params = [];
+    if (filter.session_id) {
+      conditions.push("session_id = ?");
+      params.push(filter.session_id);
+    }
+    if (filter.operation) {
+      conditions.push("operation = ?");
+      params.push(filter.operation);
+    }
+    if (filter.min_score !== void 0) {
+      conditions.push("score >= ?");
+      params.push(filter.min_score);
+    }
+    if (filter.has_feedback) {
+      conditions.push("feedback IS NOT NULL");
+    }
+    if (filter.since) {
+      conditions.push("timestamp >= ?");
+      params.push(filter.since);
+    }
+    if (filter.until) {
+      conditions.push("timestamp <= ?");
+      params.push(filter.until);
+    }
+    const where = conditions.length ? "WHERE " + conditions.join(" AND ") : "";
+    const limit = filter.limit ?? 100;
+    const offset = filter.offset ?? 0;
+    const rows = this.db.prepare(
+      `SELECT * FROM trace_events ${where} ORDER BY timestamp DESC LIMIT ? OFFSET ?`
+    ).all(...params, limit, offset);
+    return rows.map((r) => this.rowToEvent(r));
+  }
+  /**
+   * Get events for a specific session.
+   */
+  getBySession(sessionId) {
+    return this.query({ session_id: sessionId, limit: 1e3 });
+  }
+  /**
+   * Get events with scores (for GEPA consumption).
+   */
+  getScoredEvents(minScore) {
+    return this.query({
+      min_score: minScore ?? 0,
+      limit: 500
+    });
+  }
+  /**
+   * Get events with feedback (for GEPA ASI consumption).
+   */
+  getFeedbackEvents() {
+    return this.query({ has_feedback: true, limit: 500 });
+  }
+  // ------------------------------------------------------------------
+  // Stats
+  // ------------------------------------------------------------------
+  /**
+   * Aggregate statistics across all events.
+   */
+  getStats(filter) {
+    const conditions = [];
+    const params = [];
+    if (filter?.session_id) {
+      conditions.push("session_id = ?");
+      params.push(filter.session_id);
+    }
+    if (filter?.since) {
+      conditions.push("timestamp >= ?");
+      params.push(filter.since);
+    }
+    const where = conditions.length ? "WHERE " + conditions.join(" AND ") : "";
+    const agg = this.db.prepare(
+      `SELECT
+          COUNT(*) as total_events,
+          COALESCE(SUM(tokens_in), 0) as total_tokens_in,
+          COALESCE(SUM(tokens_out), 0) as total_tokens_out,
+          COALESCE(SUM(cost_usd), 0) as total_cost_usd,
+          AVG(score) as avg_score,
+          SUM(CASE WHEN feedback IS NOT NULL THEN 1 ELSE 0 END) as events_with_feedback,
+          SUM(CASE WHEN error IS NOT NULL THEN 1 ELSE 0 END) as events_with_errors
+        FROM trace_events ${where}`
+    ).get(...params);
+    const opRows = this.db.prepare(
+      `SELECT operation, COUNT(*) as cnt FROM trace_events ${where} GROUP BY operation ORDER BY cnt DESC`
+    ).all(...params);
+    const hostRows = this.db.prepare(
+      `SELECT actor_host, COUNT(*) as cnt FROM trace_events ${where} GROUP BY actor_host ORDER BY cnt DESC`
+    ).all(...params);
+    const operations = {};
+    for (const r of opRows) operations[r.operation] = r.cnt;
+    const hosts = {};
+    for (const r of hostRows) hosts[r.actor_host] = r.cnt;
+    return {
+      total_events: agg["total_events"] || 0,
+      total_tokens_in: agg["total_tokens_in"] || 0,
+      total_tokens_out: agg["total_tokens_out"] || 0,
+      total_cost_usd: agg["total_cost_usd"] || 0,
+      avg_score: agg["avg_score"],
+      events_with_feedback: agg["events_with_feedback"] || 0,
+      events_with_errors: agg["events_with_errors"] || 0,
+      operations,
+      hosts
+    };
+  }
+  // ------------------------------------------------------------------
+  // Lifecycle
+  // ------------------------------------------------------------------
+  /**
+   * Delete events older than the given ISO timestamp.
+   */
+  evict(olderThan) {
+    const result = this.db.prepare("DELETE FROM trace_events WHERE timestamp < ?").run(olderThan);
+    return result.changes;
+  }
+  // ------------------------------------------------------------------
+  // Helpers
+  // ------------------------------------------------------------------
+  rowToEvent(row) {
+    const provenance = JSON.parse(row.provenance);
+    const actor = {
+      host: row.actor_host,
+      agent: row.actor_agent,
+      user: row.actor_user
+    };
+    return {
+      timestamp: row.timestamp,
+      session_id: row.session_id,
+      trace_id: row.trace_id,
+      parent_trace_id: row.parent_trace_id ?? void 0,
+      tenant_id: row.tenant_id,
+      actor,
+      operation: row.operation,
+      inputs: JSON.parse(row.inputs),
+      outputs: JSON.parse(row.outputs),
+      tokens_in: row.tokens_in,
+      tokens_out: row.tokens_out,
+      cost_usd: row.cost_usd,
+      duration_ms: row.duration_ms,
+      score: row.score ?? void 0,
+      feedback: row.feedback ?? void 0,
+      provenance,
+      error: row.error ?? void 0,
+      tags: row.tags ? JSON.parse(row.tags) : void 0
+    };
+  }
+}
+export {
+  TraceEventStore
+};

package/dist/src/core/vision/index.js

@@ -0,0 +1,27 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+export * from "./types.js";
+import {
+  parseVision,
+  loadVision,
+  setObjectiveDone,
+  scaffoldVision,
+  objectiveId,
+  VISION_TEMPLATE
+} from "./vision-file.js";
+import { SignalInbox } from "./signals.js";
+import {
+  VisionLoop
+} from "./vision-loop.js";
+export {
+  SignalInbox,
+  VISION_TEMPLATE,
+  VisionLoop,
+  loadVision,
+  objectiveId,
+  parseVision,
+  scaffoldVision,
+  setObjectiveDone
+};

package/dist/src/core/vision/signals.js

@@ -0,0 +1,79 @@
+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,
+  appendFileSync
+} from "fs";
+import { dirname } from "path";
+import { randomUUID } from "crypto";
+class SignalInbox {
+  constructor(path) {
+    this.path = path;
+  }
+  ensureDir() {
+    const dir = dirname(this.path);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  }
+  add(input) {
+    this.ensureDir();
+    const signal = {
+      id: randomUUID(),
+      source: input.source ?? "manual",
+      severity: input.severity ?? "medium",
+      text: input.text,
+      createdAt: Date.now(),
+      ...input.refs ? { refs: input.refs } : {}
+    };
+    appendFileSync(this.path, JSON.stringify(signal) + "\n");
+    return signal;
+  }
+  all() {
+    if (!existsSync(this.path)) return [];
+    return readFileSync(this.path, "utf-8").split(/\r?\n/).filter(Boolean).map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    }).filter((s) => !!s);
+  }
+  /** Unresolved signals, most severe + oldest first. */
+  pending() {
+    const rank = {
+      low: 1,
+      medium: 2,
+      high: 3,
+      critical: 4
+    };
+    return this.all().filter((s) => !s.resolvedAt).sort(
+      (a, b) => rank[b.severity] - rank[a.severity] || a.createdAt - b.createdAt
+    );
+  }
+  /** Rewrite the file marking a signal resolved (compacts the log). */
+  resolve(id) {
+    const signals = this.all();
+    let changed = false;
+    for (const s of signals) {
+      if (s.id === id && !s.resolvedAt) {
+        s.resolvedAt = Date.now();
+        changed = true;
+      }
+    }
+    if (changed) {
+      this.ensureDir();
+      writeFileSync(
+        this.path,
+        signals.map((s) => JSON.stringify(s)).join("\n") + "\n"
+      );
+    }
+    return changed;
+  }
+}
+export {
+  SignalInbox
+};

package/dist/src/core/vision/types.js

@@ -0,0 +1,22 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+const DEFAULT_LIMITS = {
+  maxIterations: 10,
+  maxIterationsPerDay: 50,
+  maxConsecutiveFailures: 3,
+  tickIntervalSec: 60,
+  requireApproval: false,
+  stopWhenComplete: true
+};
+const SEVERITY_RANK = {
+  low: 1,
+  medium: 2,
+  high: 3,
+  critical: 4
+};
+export {
+  DEFAULT_LIMITS,
+  SEVERITY_RANK
+};

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

@@ -0,0 +1,146 @@
+import { fileURLToPath as __fileURLToPath } from 'url';
+import { dirname as __pathDirname } from 'path';
+const __filename = __fileURLToPath(import.meta.url);
+const __dirname = __pathDirname(__filename);
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { createHash } from "crypto";
+import {
+  DEFAULT_LIMITS
+} from "./types.js";
+function objectiveId(text) {
+  return createHash("sha1").update(text.trim()).digest("hex").slice(0, 10);
+}
+function splitSections(text) {
+  const lines = text.split(/\r?\n/);
+  const sections = /* @__PURE__ */ new Map();
+  const preamble = [];
+  let current = null;
+  for (const line of lines) {
+    const h2 = line.match(/^##\s+(.+?)\s*$/);
+    if (h2?.[1]) {
+      current = { body: [] };
+      sections.set(h2[1].toLowerCase(), current);
+      continue;
+    }
+    if (/^#\s+/.test(line)) continue;
+    if (current) {
+      current.body.push(line);
+    } else {
+      preamble.push(line);
+    }
+  }
+  return { preamble, sections };
+}
+function bulletLines(body) {
+  return body.map((l) => l.match(/^\s*[-*]\s+(.*\S)\s*$/)?.[1]?.trim()).filter((s) => !!s).filter((s) => !/^\[[ xX]\]/.test(s));
+}
+function parseObjectives(body) {
+  const objectives = [];
+  for (const line of body) {
+    const m = line.match(/^\s*[-*]\s+\[([ xX])\]\s+(.*\S)\s*$/);
+    if (!m?.[2]) continue;
+    const text = m[2].trim();
+    objectives.push({
+      id: objectiveId(text),
+      text,
+      done: (m[1] ?? "").toLowerCase() === "x"
+    });
+  }
+  return objectives;
+}
+function parseLimits(body) {
+  const limits = { ...DEFAULT_LIMITS };
+  for (const line of body) {
+    const m = line.match(/^\s*([a-zA-Z]+)\s*:\s*(.+?)\s*$/);
+    if (!m?.[1] || m[2] === void 0) continue;
+    const key = m[1];
+    const raw = m[2];
+    if (!(key in limits)) continue;
+    if (key === "requireApproval" || key === "stopWhenComplete") {
+      limits[key] = /^(true|yes|1)$/i.test(raw);
+    } else {
+      const n = parseInt(raw, 10);
+      if (Number.isFinite(n)) limits[key] = n;
+    }
+  }
+  return limits;
+}
+function parseVision(text) {
+  const { preamble, sections } = splitSections(text);
+  const body = (name) => sections.get(name)?.body ?? [];
+  const mission = preamble.map((l) => l.trim()).filter(Boolean).join(" ").trim();
+  return {
+    mission,
+    guardrails: bulletLines(body("guardrails")),
+    scope: bulletLines(body("scope")),
+    objectives: parseObjectives(body("objectives")),
+    limits: sections.has("limits") ? parseLimits(body("limits")) : { ...DEFAULT_LIMITS }
+  };
+}
+function loadVision(path) {
+  if (!existsSync(path)) return null;
+  return parseVision(readFileSync(path, "utf-8"));
+}
+function setObjectiveDone(path, objId, done) {
+  if (!existsSync(path)) return false;
+  const lines = readFileSync(path, "utf-8").split(/\r?\n/);
+  let changed = false;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line === void 0) continue;
+    const m = line.match(/^(\s*[-*]\s+)\[([ xX])\]\s+(.*\S)\s*$/);
+    if (!m?.[3]) continue;
+    if (objectiveId(m[3].trim()) === objId) {
+      lines[i] = `${m[1] ?? ""}[${done ? "x" : " "}] ${m[3].trim()}`;
+      changed = true;
+      break;
+    }
+  }
+  if (changed) writeFileSync(path, lines.join("\n"));
+  return changed;
+}
+const VISION_TEMPLATE = `# Vision
+
+State the single north-star mission this autonomous loop serves. Keep it to a
+sentence or two \u2014 concrete enough to judge whether a piece of work belongs.
+
+## Guardrails
+
+- Stay within the scope below; do not touch anything outside it.
+- Never modify secrets, production credentials, or deploy/publish.
+- Open a PR for review; never merge to the default branch autonomously.
+- If an objective is ambiguous or risky, stop and ask a human.
+
+## Scope
+
+- src/**
+- docs/**
+
+## Objectives
+
+- [ ] First concrete objective the loop should pursue
+- [ ] Second objective
+- [ ] Third objective
+
+## Limits
+
+maxIterations: 10
+maxIterationsPerDay: 50
+maxConsecutiveFailures: 3
+tickIntervalSec: 60
+requireApproval: false
+stopWhenComplete: true
+`;
+function scaffoldVision(path, force = false) {
+  if (existsSync(path) && !force) return false;
+  writeFileSync(path, VISION_TEMPLATE);
+  return true;
+}
+export {
+  VISION_TEMPLATE,
+  loadVision,
+  objectiveId,
+  parseVision,
+  scaffoldVision,
+  setObjectiveDone
+};