nemoris 0.1.0

package/src/runtime/scheduler-state.js

@@ -0,0 +1,434 @@
+import path from "node:path";
+import { DatabaseSync } from "node:sqlite";
+import { ensureDir, readJson, removePath } from "../utils/fs.js";
+
+function clone(value) {
+  return value == null ? value : JSON.parse(JSON.stringify(value));
+}
+
+export class SchedulerStateStore {
+  constructor({ rootDir }) {
+    this.rootDir = rootDir;
+    this.dbPath = path.join(rootDir, "scheduler.sqlite");
+    this.legacyFilePath = path.join(rootDir, "jobs.json");
+    this.db = null;
+  }
+
+  async ensureReady() {
+    if (this.db) return this.db;
+    await ensureDir(this.rootDir);
+    this.db = new DatabaseSync(this.dbPath, {
+      timeout: 5000
+    });
+    this.db.exec("pragma busy_timeout = 5000;");
+    this.db.exec("pragma journal_mode = wal;");
+    this.db.exec("pragma synchronous = normal;");
+    this.db.exec(`
+      create table if not exists scheduler_jobs (
+        job_id text primary key,
+        state_json text not null
+      );
+      create table if not exists scheduler_meta (
+        key text primary key,
+        value_json text not null
+      );
+      create table if not exists follow_up_completions (
+        scoped_key text primary key,
+        parent_key text not null,
+        follow_up_id text not null,
+        status text not null,
+        completed_at text not null,
+        ttl_expires_at text not null
+      );
+      create index if not exists idx_followup_parent on follow_up_completions(parent_key);
+    `);
+    this.db.exec(`
+      create table if not exists interactive_jobs (
+        job_id text primary key,
+        agent_id text not null,
+        input text not null,
+        source text not null,
+        chat_id text not null,
+        status text not null default 'queued',
+        created_at text not null
+      );
+      create index if not exists idx_interactive_status on interactive_jobs(status);
+      create table if not exists chat_sessions (
+        chat_id text primary key,
+        agent_id text not null,
+        previous_agent_id text,
+        bound_at text not null,
+        bound_by text not null,
+        conversation_context text
+      );
+      create table if not exists usage_log (
+        id text primary key,
+        session_id text not null,
+        job_id text not null,
+        ts integer not null,
+        model text not null,
+        tokens_in integer not null default 0,
+        tokens_out integer not null default 0,
+        cost_usd real,
+        provider text not null
+      );
+      create index if not exists idx_usage_log_session on usage_log(session_id, ts);
+      create index if not exists idx_usage_log_ts on usage_log(ts);
+    `);
+    // Tool result cache (Sub-project 3)
+    this.db.exec(`
+      create table if not exists tool_results (
+        call_hash text primary key,
+        tool_id text not null,
+        brief text not null,
+        raw text not null,
+        index_terms text,
+        created_at text not null default (datetime('now'))
+      );
+    `);
+    // Self-healing daemon tables
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS repair_log (
+        id            INTEGER PRIMARY KEY AUTOINCREMENT,
+        ts            TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+        source        TEXT    NOT NULL,
+        type          TEXT    NOT NULL,
+        context       TEXT,
+        action        TEXT,
+        result        TEXT    NOT NULL,
+        severity      TEXT    NOT NULL,
+        diagnosis     TEXT,
+        config_before TEXT,
+        config_after  TEXT,
+        escalated     INTEGER NOT NULL DEFAULT 0,
+        attempts      INTEGER NOT NULL DEFAULT 1,
+        parent_id     INTEGER REFERENCES repair_log(id)
+      );
+      CREATE INDEX IF NOT EXISTS idx_repair_log_type ON repair_log(type);
+      CREATE INDEX IF NOT EXISTS idx_repair_log_ts ON repair_log(ts);
+      CREATE INDEX IF NOT EXISTS idx_repair_log_result_ts ON repair_log(result, ts);
+      CREATE INDEX IF NOT EXISTS idx_repair_log_escalated ON repair_log(escalated) WHERE escalated = 1;
+      CREATE INDEX IF NOT EXISTS idx_repair_log_parent ON repair_log(parent_id) WHERE parent_id IS NOT NULL;
+
+      CREATE TABLE IF NOT EXISTS rule_staging (
+        id             INTEGER PRIMARY KEY AUTOINCREMENT,
+        ts             TEXT    NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+        proposed_by    TEXT    NOT NULL DEFAULT 'pattern_miner',
+        match_type     TEXT    NOT NULL,
+        match_context  TEXT,
+        action         TEXT    NOT NULL,
+        severity       TEXT    NOT NULL,
+        action_class   TEXT    NOT NULL,
+        cooldown_minutes INTEGER NOT NULL DEFAULT 5,
+        priority       INTEGER NOT NULL DEFAULT 10,
+        evidence       TEXT,
+        status         TEXT    NOT NULL DEFAULT 'pending',
+        promoted_at    TEXT,
+        expires_at     TEXT
+      );
+    `);
+    // Agent dispatch columns (Sub-project 2)
+    this._addColumnIfMissing("interactive_jobs", "triggered_by", "TEXT");
+    this._addColumnIfMissing("interactive_jobs", "completion_target", "TEXT");
+    this._addColumnIfMissing("interactive_jobs", "trigger_correlation_id", "TEXT");
+    this._addColumnIfMissing("interactive_jobs", "completion_pinged_at", "TEXT");
+    this._addColumnIfMissing("interactive_jobs", "completion_ping_attempts", "INTEGER DEFAULT 0");
+    this._addColumnIfMissing("chat_sessions", "model_override", "TEXT");
+    // Hardening sprint columns
+    this._addColumnIfMissing("interactive_jobs", "waiting_for_human", "INTEGER DEFAULT 0");
+    // Inter-agent routing columns (Gap 35)
+    this._addColumnIfMissing("interactive_jobs", "source_type", "TEXT DEFAULT 'human'");
+    this._addColumnIfMissing("interactive_jobs", "reply_session_key", "TEXT");
+    this._addColumnIfMissing("interactive_jobs", "source_agent_id", "TEXT");
+    this._addColumnIfMissing("chat_sessions", "focus_mode", "TEXT");
+    // Slash command parity columns
+    this._addColumnIfMissing("usage_log", "cache_in", "INTEGER DEFAULT 0");
+    this._addColumnIfMissing("usage_log", "cache_creation", "INTEGER DEFAULT 0");
+    this._addColumnIfMissing("chat_sessions", "think_mode", "TEXT");
+    this._addColumnIfMissing("interactive_jobs", "image_refs", "TEXT");
+    await this.migrateLegacyState();
+    return this.db;
+  }
+
+  _addColumnIfMissing(table, column, type) {
+    const cols = this.db.prepare(`pragma table_info(${table})`).all();
+    if (!cols.some((c) => c.name === column)) {
+      this.db.exec(`alter table ${table} add column ${column} ${type}`);
+    }
+  }
+
+  runTransaction(fn) {
+    this.db.exec("begin immediate");
+    try {
+      const result = fn(this.db);
+      this.db.exec("commit");
+      return result;
+    } catch (error) {
+      try {
+        this.db.exec("rollback");
+      } catch {}
+      throw error;
+    }
+  }
+
+  async migrateLegacyState() {
+    const count = this.db.prepare("select count(*) as count from scheduler_jobs").get().count;
+    if (count > 0) return;
+    const legacy = await readJson(this.legacyFilePath, null);
+    if (!legacy?.jobs || Object.keys(legacy.jobs).length === 0) return;
+
+    const insert = this.db.prepare(`
+      insert into scheduler_jobs(job_id, state_json) values (?, ?)
+      on conflict(job_id) do update set state_json = excluded.state_json
+    `);
+    this.db.exec("begin immediate");
+    try {
+      for (const [jobId, state] of Object.entries(legacy.jobs)) {
+        insert.run(jobId, JSON.stringify(state || {}));
+      }
+      this.db.exec("commit");
+    } catch (error) {
+      try {
+        this.db.exec("rollback");
+      } catch {}
+      throw error;
+    }
+
+    await removePath(this.legacyFilePath);
+  }
+
+  async load() {
+    const db = await this.ensureReady();
+    const rows = db.prepare("select job_id, state_json from scheduler_jobs order by job_id asc").all();
+    return {
+      jobs: Object.fromEntries(rows.map((row) => [row.job_id, JSON.parse(row.state_json)]))
+    };
+  }
+
+  async save(state) {
+    const db = await this.ensureReady();
+    const jobs = state?.jobs || {};
+    const insert = db.prepare(`
+      insert into scheduler_jobs(job_id, state_json) values (?, ?)
+      on conflict(job_id) do update set state_json = excluded.state_json
+    `);
+
+    this.runTransaction(() => {
+      db.prepare("delete from scheduler_jobs").run();
+      for (const [jobId, jobState] of Object.entries(jobs)) {
+        insert.run(jobId, JSON.stringify(jobState || {}));
+      }
+    });
+    return {
+      jobs: clone(jobs)
+    };
+  }
+
+  async updateJob(jobId, patch) {
+    return this.mutateJob(jobId, (current) => ({
+      ...current,
+      ...patch
+    }));
+  }
+
+  async getMeta(key, fallback = null) {
+    const db = await this.ensureReady();
+    const row = db.prepare("select value_json from scheduler_meta where key = ?").get(String(key));
+    return row ? JSON.parse(row.value_json) : fallback;
+  }
+
+  async setMeta(key, value) {
+    const db = await this.ensureReady();
+    this.runTransaction(() => {
+      db.prepare(`
+        insert into scheduler_meta(key, value_json) values (?, ?)
+        on conflict(key) do update set value_json = excluded.value_json
+      `).run(String(key), JSON.stringify(value ?? null));
+    });
+    return clone(value);
+  }
+
+  async mutateMeta(key, mutator) {
+    const db = await this.ensureReady();
+    return this.runTransaction(() => {
+      const row = db.prepare("select value_json from scheduler_meta where key = ?").get(String(key));
+      const current = row ? JSON.parse(row.value_json) : null;
+      const next = clone(mutator(clone(current)) ?? current);
+      db.prepare(`
+        insert into scheduler_meta(key, value_json) values (?, ?)
+        on conflict(key) do update set value_json = excluded.value_json
+      `).run(String(key), JSON.stringify(next));
+      return next;
+    });
+  }
+
+  async mutateJob(jobId, mutator) {
+    const db = await this.ensureReady();
+    return this.runTransaction(() => {
+      const row = db.prepare("select state_json from scheduler_jobs where job_id = ?").get(jobId);
+      const current = row ? JSON.parse(row.state_json) : {};
+      const next = clone(mutator(clone(current), null) || current);
+
+      db.prepare(`
+        insert into scheduler_jobs(job_id, state_json) values (?, ?)
+        on conflict(job_id) do update set state_json = excluded.state_json
+      `).run(jobId, JSON.stringify(next));
+
+      return next;
+    });
+  }
+
+  getFollowUpCompletion(scopedKey) {
+    const row = this.db.prepare(
+      "select scoped_key, parent_key, follow_up_id, status, completed_at, ttl_expires_at from follow_up_completions where scoped_key = ?"
+    ).get(scopedKey);
+    return row || null;
+  }
+
+  setFollowUpCompletion(scopedKey, parentKey, followUpId, status, ttlExpiresAt = null) {
+    const now = new Date().toISOString();
+    // TTL is computed by caller using: slotInterval * completion_ttl_multiplier
+    // Falls back to 24h if no explicit TTL is provided (e.g. in tests)
+    const expiresAt = ttlExpiresAt || new Date(Date.now() + 24 * 60 * 60 * 1000).toISOString();
+    this.db.prepare(`
+      insert into follow_up_completions (scoped_key, parent_key, follow_up_id, status, completed_at, ttl_expires_at)
+      values (?, ?, ?, ?, ?, ?)
+      on conflict(scoped_key) do update set status = excluded.status, completed_at = excluded.completed_at, ttl_expires_at = excluded.ttl_expires_at
+    `).run(scopedKey, parentKey, followUpId, status, now, expiresAt);
+  }
+
+  clearFollowUpCompletion(scopedKey) {
+    this.db.prepare("delete from follow_up_completions where scoped_key = ?").run(scopedKey);
+  }
+
+  purgeExpiredFollowUps(nowIso) {
+    this.db.prepare("delete from follow_up_completions where ttl_expires_at < ?").run(nowIso);
+  }
+
+  enqueueInteractiveJob({ jobId, agentId, input, source, chatId, imageRefs = null, sourceType = 'human', replySessionKey = null, sourceAgentId = null }) {
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      insert or ignore into interactive_jobs (job_id, agent_id, input, source, chat_id, status, created_at, source_type, reply_session_key, source_agent_id, image_refs)
+      values (?, ?, ?, ?, ?, 'queued', ?, ?, ?, ?, ?)
+    `).run(jobId, agentId, input, source, chatId, now, sourceType, replySessionKey, sourceAgentId, imageRefs);
+  }
+
+  getInteractiveJob(jobId) {
+    const row = this.db.prepare(
+      "select job_id, agent_id, input, source, chat_id, status, created_at, triggered_by, completion_target, trigger_correlation_id, completion_pinged_at, completion_ping_attempts, source_type, reply_session_key, source_agent_id, image_refs from interactive_jobs where job_id = ?"
+    ).get(jobId);
+    return row || null;
+  }
+
+  interactiveJobExists(jobId) {
+    const row = this.db.prepare("select 1 from interactive_jobs where job_id = ?").get(jobId);
+    return Boolean(row);
+  }
+
+  drainQueuedInteractiveJobs() {
+    return this.runTransaction(() => {
+      const rows = this.db.prepare(
+        "select job_id, agent_id, input, source, chat_id, status, created_at, triggered_by, completion_target, trigger_correlation_id, source_type, reply_session_key, source_agent_id, image_refs from interactive_jobs where status = 'queued' order by created_at asc"
+      ).all();
+      if (rows.length > 0) {
+        const ids = rows.map((r) => r.job_id);
+        const placeholders = ids.map(() => "?").join(", ");
+        this.db.prepare(
+          `update interactive_jobs set status = 'running' where job_id in (${placeholders})`
+        ).run(...ids);
+      }
+      return rows;
+    });
+  }
+
+  updateInteractiveJobStatus(jobId, status) {
+    this.db.prepare("update interactive_jobs set status = ? where job_id = ?").run(status, jobId);
+  }
+
+  enqueueDispatchJob({ jobId, agentId, input, source, chatId, triggeredBy, completionTarget, triggerCorrelationId }) {
+    const now = new Date().toISOString();
+    this.db.prepare(`
+      insert or ignore into interactive_jobs (job_id, agent_id, input, source, chat_id, status, created_at, triggered_by, completion_target, trigger_correlation_id, completion_ping_attempts)
+      values (?, ?, ?, ?, ?, 'queued', ?, ?, ?, ?, 0)
+    `).run(jobId, agentId, input, source, chatId || "", now, triggeredBy || null, completionTarget || null, triggerCorrelationId || null);
+  }
+
+  getCompletedDispatchJobs() {
+    return this.db.prepare(
+      "select job_id, agent_id, input, source, chat_id, status, created_at, triggered_by, completion_target, trigger_correlation_id, completion_pinged_at, completion_ping_attempts from interactive_jobs where status in ('succeeded', 'failed') and completion_target is not null and completion_pinged_at is null"
+    ).all();
+  }
+
+  markCompletionPinged(jobId) {
+    this.db.prepare("update interactive_jobs set completion_pinged_at = ? where job_id = ?").run(new Date().toISOString(), jobId);
+  }
+
+  incrementCompletionPingAttempts(jobId) {
+    this.db.prepare("update interactive_jobs set completion_ping_attempts = completion_ping_attempts + 1 where job_id = ?").run(jobId);
+    const job = this.getInteractiveJob(jobId);
+    if (job && job.completion_ping_attempts >= 3) {
+      this.db.prepare("update interactive_jobs set completion_pinged_at = 'FAILED' where job_id = ?").run(jobId);
+    }
+  }
+
+  getRecentAgentJobs(limit = 5) {
+    return this.db.prepare(
+      "select job_id, agent_id, source_agent_id, input, status, created_at from interactive_jobs where source_type = 'agent' order by created_at desc limit ?"
+    ).all(limit);
+  }
+
+  getChatSession(chatId) {
+    const row = this.db.prepare(
+      "select chat_id, agent_id, previous_agent_id, bound_at, bound_by, conversation_context, model_override, focus_mode, think_mode from chat_sessions where chat_id = ?"
+    ).get(chatId);
+    return row || null;
+  }
+
+  getRunningInteractiveJobCount() {
+    const row = this.db.prepare("select count(*) as count from interactive_jobs where status = 'running'").get();
+    return row.count;
+  }
+
+  bindChatSession({ chatId, agentId, boundBy }) {
+    const now = new Date().toISOString();
+    const existing = this.getChatSession(chatId);
+    if (existing) {
+      this.db.prepare(`
+        update chat_sessions
+        set agent_id = ?, previous_agent_id = ?, bound_at = ?, bound_by = ?, conversation_context = null
+        where chat_id = ?
+      `).run(agentId, existing.agent_id, now, boundBy, chatId);
+    } else {
+      this.db.prepare(`
+        insert into chat_sessions (chat_id, agent_id, previous_agent_id, bound_at, bound_by, conversation_context)
+        values (?, ?, null, ?, ?, null)
+      `).run(chatId, agentId, now, boundBy);
+    }
+  }
+
+  updateConversationContext(chatId, contextJson) {
+    this.db.prepare("update chat_sessions set conversation_context = ? where chat_id = ?").run(contextJson, chatId);
+  }
+
+  // --- Tool result cache ---
+
+  getCachedToolResult(callHash) {
+    return this.db.prepare(
+      "select call_hash, tool_id, brief, raw, index_terms, created_at from tool_results where call_hash = ?"
+    ).get(callHash) || null;
+  }
+
+  cacheToolResult({ callHash, toolId, brief, raw, indexTerms }) {
+    this.db.prepare(`
+      insert into tool_results (call_hash, tool_id, brief, raw, index_terms)
+      values (?, ?, ?, ?, ?)
+      on conflict(call_hash) do update set brief = excluded.brief, raw = excluded.raw, index_terms = excluded.index_terms
+    `).run(callHash, toolId, brief, raw, JSON.stringify(indexTerms || []));
+  }
+
+  close() {
+    if (!this.db) return;
+    this.db.close();
+    this.db = null;
+  }
+}