@davvidbaker/flambe-cli 0.1.1 → 0.1.3

package/src/local/store.mjs

@@ -5,8 +5,8 @@ import { DatabaseSync } from 'node:sqlite';
 
 import { pickName, usableName } from './agents.mjs';
 
-const LIFECYCLE_PHASES = ['B', 'E', 'S', 'R'];
-const OPEN_PHASES = ['B', 'R'];
+const LIFECYCLE_PHASES = ['B', 'E', 'S', 'R', 'X', 'J', 'V'];
+const OPEN_PHASES = ['B', 'R', 'X'];
 
 const SCHEMA = `
 PRAGMA foreign_keys = ON;
@@ -60,6 +60,10 @@ CREATE TABLE IF NOT EXISTS activities (
   weight INTEGER,
   agent_id TEXT,
   agent_name TEXT,
+  scheduled_start_ms INTEGER,
+  scheduled_end_ms INTEGER,
+  proposed_by_agent_id TEXT,
+  proposed_by_agent_name TEXT,
   export_id TEXT NOT NULL UNIQUE
 );
 
@@ -79,13 +83,6 @@ CREATE TABLE IF NOT EXISTS events (
   export_id TEXT NOT NULL UNIQUE
 );
 
-CREATE TABLE IF NOT EXISTS todos (
-  id INTEGER PRIMARY KEY,
-  user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
-  name TEXT NOT NULL,
-  description TEXT
-);
-
 CREATE TABLE IF NOT EXISTS mantras (
   id INTEGER PRIMARY KEY,
   user_id INTEGER NOT NULL REFERENCES users(id) ON DELETE CASCADE,
@@ -142,11 +139,25 @@ export const EXPORT_FORMAT = 'flambe-local-export';
 export const EXPORT_VERSION = 1;
 
 export const DEFAULT_CATEGORIES = [
-  { name: 'coding', color_background: '#efc360', color_text: '#000000' },
-  { name: 'investigation', color_background: '#60a5fa', color_text: '#000000' },
-  { name: 'review', color_background: '#a78bfa', color_text: '#ffffff' },
-  { name: 'operations', color_background: '#34d399', color_text: '#000000' },
-  { name: 'failure', color_background: '#fb7185', color_text: '#000000' },
+  { name: 'bug fixing', color_background: '#ff4747', color_text: '#000000' },
+  { name: 'research', color_background: '#cd94f1', color_text: '#000000' },
+  { name: 'cleaning', color_background: '#ffbd69', color_text: '#000000' },
+  { name: 'bug hunting', color_background: '#ef60ab', color_text: '#000000' },
+  { name: 'design', color_background: '#dce7ea', color_text: '#000000' },
+  { name: 'writing tests', color_background: '#50f035', color_text: '#000000' },
+  { name: 'toil', color_background: '#8b6125', color_text: '#ffffff' },
+  { name: 'analytics', color_background: '#f9f9f9', color_text: '#4598d6' },
+  { name: 'oss', color_background: '#60ef6c', color_text: '#000000' },
+  { name: 'enhancements', color_background: '#55defb', color_text: '#ffffff' },
+  { name: 'refactoring components', color_background: '#ffd368', color_text: '#000000' },
+  { name: 'Fundamentals', color_background: '#acefdb', color_text: '#000000' },
+  { name: 'jarring ui', color_background: '#f22d6a', color_text: '#ffffff' },
+  { name: 'writing', color_background: '#ffefce', color_text: '#000000' },
+  { name: 'risky', color_background: '#ff2a22', color_text: '#ffffff' },
+  { name: 'dependency upgrades', color_background: '#b58e38', color_text: '#ffffff' },
+  { name: 'shiny', color_background: '#f5ff86', color_text: '#000000' },
+  { name: 'performance', color_background: '#60efc7', color_text: '#000000' },
+  { name: 'learning', color_background: '#d3f791', color_text: '#000000' },
 ];
 
 export function hashToken(rawToken) {
@@ -169,6 +180,17 @@ export class LocalStore {
     this.db = new DatabaseSync(dbPath);
     this.db.exec('PRAGMA foreign_keys = ON');
     this.db.exec(SCHEMA);
+    this.db.exec('DROP TABLE IF EXISTS todos');
+    for (const column of [
+      'scheduled_start_ms INTEGER',
+      'scheduled_end_ms INTEGER',
+      'proposed_by_agent_id TEXT',
+      'proposed_by_agent_name TEXT',
+    ]) {
+      const name = column.split(' ')[0];
+      const exists = this.db.prepare('PRAGMA table_info(activities)').all().some(row => row.name === name);
+      if (!exists) this.db.exec(`ALTER TABLE activities ADD COLUMN ${column}`);
+    }
     this.#seed();
   }
 
@@ -224,7 +246,9 @@ export class LocalStore {
     const events = this.db.prepare(`
       SELECT events.*, activities.name AS activity_name, activities.parent_id,
         activities.thread_id, activities.weight, activities.agent_id, activities.agent_name,
-        activities.description AS activity_description
+        activities.description AS activity_description,
+        activities.scheduled_start_ms, activities.scheduled_end_ms,
+        activities.proposed_by_agent_id, activities.proposed_by_agent_name
       FROM events
       LEFT JOIN activities ON activities.id = events.activity_id
       WHERE events.trace_id = ?
@@ -236,6 +260,7 @@ export class LocalStore {
       name: trace.name,
       threads: threads.map(thread => ({ id: thread.id, name: thread.name, rank: thread.rank })),
       events: events.map(event => this.#eventPayload(event)),
+      unstarted: this.listUnstarted(trace.id).map(activity => this.#traceActivityPayload(activity)),
     };
   }
 
@@ -317,6 +342,7 @@ export class LocalStore {
   }
 
   listCategories(userId) {
+    this.#ensureDefaultCategories(userId);
     return this.db.prepare(
       'SELECT id, name, color_background, color_text FROM categories WHERE user_id = ? ORDER BY id',
     ).all(userId);
@@ -383,7 +409,7 @@ export class LocalStore {
       .all(userId);
   }
 
-  /** Newest activity in the trace whose latest lifecycle event is B/R, optionally for one agent or thread. */
+  /** Newest running activity in the trace, optionally for one agent or thread. */
   newestActiveActivity(traceId, { agentId, threadId } = {}) {
     const placeholders = LIFECYCLE_PHASES.map(() => '?').join(',');
     const open = OPEN_PHASES.map(() => '?').join(',');
@@ -414,7 +440,19 @@ export class LocalStore {
    * rules apply: an absent parent_id infers this agent's newest active activity, a child
    * lives in its parent's thread and inherits categories, and thread_id may be omitted.
    */
-  createActivity(userId, { traceId, threadId, activity, event, agent, reduce = false }) {
+  createActivity(userId, options) {
+    this.db.exec('SAVEPOINT create_activity');
+    try {
+      const result = this.#createActivity(userId, options);
+      this.db.exec('RELEASE create_activity');
+      return result;
+    } catch (error) {
+      this.db.exec('ROLLBACK TO create_activity; RELEASE create_activity');
+      throw error;
+    }
+  }
+
+  #createActivity(userId, { traceId, threadId, activity, event, agent, reduce = false }) {
     const trace = this.db.prepare('SELECT id FROM traces WHERE id = ? AND user_id = ?').get(Number(traceId), userId);
     if (!trace) return { error: 'not_found' };
 
@@ -471,8 +509,11 @@ export class LocalStore {
       : { agent_id: null, agent_name: null };
 
     const inserted = this.db.prepare(`
-      INSERT INTO activities (thread_id, parent_id, name, description, weight, agent_id, agent_name, export_id)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      INSERT INTO activities (
+        thread_id, parent_id, name, description, weight, agent_id, agent_name,
+        scheduled_start_ms, scheduled_end_ms, proposed_by_agent_id, proposed_by_agent_name, export_id
+      )
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
     `).run(
       thread.id,
       parentId,
@@ -481,6 +522,10 @@ export class LocalStore {
       activity.weight ?? null,
       agentColumns.agent_id,
       agentColumns.agent_name,
+      activity.scheduled_start_integer ?? activity.scheduled_start_ms ?? null,
+      activity.scheduled_end_integer ?? activity.scheduled_end_ms ?? null,
+      activity.proposed_by_agent_id ?? agentColumns.agent_id,
+      activity.proposed_by_agent_name ?? agentColumns.agent_name,
       randomUUID(),
     );
     const activityId = Number(inserted.lastInsertRowid);
@@ -490,11 +535,15 @@ export class LocalStore {
       ).run(activityId, categoryId);
     }
 
-    const timestamp = Number(event.timestamp_integer);
-    const eventRow = this.db.prepare(`
-      INSERT INTO events (trace_id, activity_id, timestamp_ms, phase, message, export_id)
-      VALUES (?, ?, ?, ?, ?, ?)
-    `).run(thread.trace_id, activityId, timestamp, event.phase, event.message ?? null, randomUUID());
+    let createdEvent = null;
+    if (event) {
+      const timestamp = Number(event.timestamp_integer);
+      const eventRow = this.db.prepare(`
+        INSERT INTO events (trace_id, activity_id, timestamp_ms, phase, message, export_id)
+        VALUES (?, ?, ?, ?, ?, ?)
+      `).run(thread.trace_id, activityId, timestamp, event.phase, event.message ?? null, randomUUID());
+      createdEvent = { id: Number(eventRow.lastInsertRowid), phase: event.phase };
+    }
 
     return {
       activity: {
@@ -505,11 +554,43 @@ export class LocalStore {
         parent_id: parentId,
         thread_id: thread.id,
       },
-      event: { id: Number(eventRow.lastInsertRowid), phase: event.phase },
+      event: createdEvent,
       ...(reduce ? { reducer: notes } : {}),
     };
   }
 
+  createUnstarted(userId, { traceId, name, description, weight, agent, scheduledStart, scheduledEnd }) {
+    const thread = this.#defaultThread(Number(traceId));
+    if (!thread) return { error: 'not_found' };
+    const trace = this.db.prepare('SELECT id FROM traces WHERE id = ? AND user_id = ?').get(thread.trace_id, userId);
+    if (!trace) return { error: 'not_found' };
+    const inserted = this.db.prepare(`
+      INSERT INTO activities (
+        thread_id, parent_id, name, description, weight, agent_id, agent_name,
+        scheduled_start_ms, scheduled_end_ms, proposed_by_agent_id, proposed_by_agent_name, export_id
+      ) VALUES (?, NULL, ?, ?, ?, NULL, NULL, ?, ?, ?, ?, ?)
+    `).run(
+      thread.id, name, description ?? null, weight ?? null,
+      scheduledStart ?? null, scheduledEnd ?? null,
+      agent?.agent_id ?? null, agent?.name ?? null, randomUUID(),
+    );
+    return { activity: { id: Number(inserted.lastInsertRowid), name, thread_id: thread.id, parent_id: null } };
+  }
+
+  listUnstarted(traceId) {
+    return this.db.prepare(`
+      SELECT activities.* FROM activities
+      JOIN threads ON threads.id = activities.thread_id
+      WHERE threads.trace_id = ?
+        AND NOT EXISTS (
+          SELECT 1 FROM events
+          WHERE events.activity_id = activities.id
+            AND events.phase IN ('B','Q','R','X','S','E','J','V')
+        )
+      ORDER BY activities.id
+    `).all(Number(traceId));
+  }
+
   #defaultThread(traceId) {
     return this.db.prepare('SELECT id, trace_id FROM threads WHERE trace_id = ? ORDER BY rank, id LIMIT 1').get(traceId) ?? null;
   }
@@ -530,6 +611,8 @@ export class LocalStore {
       weight: row.weight,
       parent_id: row.parent_id,
       thread_id: row.thread_id,
+      agent_id: row.agent_id ?? null,
+      agent_name: row.agent_name ?? null,
     };
   }
 
@@ -545,6 +628,13 @@ export class LocalStore {
       WHERE id = ?
     `).run(attrs.name ?? null, attrs.description ?? null, attrs.weight ?? null, attrs.parent_id ?? null, current.id);
 
+    if (Object.prototype.hasOwnProperty.call(attrs, 'agent_id')) {
+      const agentId = attrs.agent_id == null || attrs.agent_id === '' ? null : String(attrs.agent_id);
+      const agentName = agentId == null ? null : this.#activityAgentName(userId, agentId, attrs);
+      this.db.prepare('UPDATE activities SET agent_id = ?, agent_name = ? WHERE id = ?')
+        .run(agentId, agentName, current.id);
+    }
+
     if (Array.isArray(attrs.category_ids)) {
       this.db.prepare('DELETE FROM activities_categories WHERE activity_id = ?').run(current.id);
       for (const categoryId of attrs.category_ids) {
@@ -628,7 +718,6 @@ export class LocalStore {
       username: user.username,
       traces: this.listTraces(userId),
       categories: this.listCategories(userId),
-      todos: this.db.prepare('SELECT id, name, description FROM todos WHERE user_id = ?').all(userId),
       mantras: this.db.prepare('SELECT id, name, timestamp_ms FROM mantras WHERE user_id = ? ORDER BY id').all(userId)
         .map(row => ({ id: row.id, name: row.name, timestamp: isoFromMs(row.timestamp_ms) })),
       attentionShifts: this.db.prepare(
@@ -654,17 +743,14 @@ export class LocalStore {
         timestamp: isoFromMs(row.timestamp_ms),
       })),
       observations: this.listObservations(userId),
+      agents: this.listAgents(userId).map(agent => ({
+        agent_id: agent.agent_id,
+        name: agent.name,
+        platform: agent.platform ?? null,
+      })),
     };
   }
 
-  createTodo(userId, attrs) {
-    const result = this.db.prepare(
-      'INSERT INTO todos (user_id, name, description) VALUES (?, ?, ?)',
-    ).run(userId, attrs.name, attrs.description ?? null);
-    return this.db.prepare('SELECT id, name, description FROM todos WHERE id = ?')
-      .get(Number(result.lastInsertRowid));
-  }
-
   createMantra(userId, attrs) {
     const timestamp = Number(attrs.timestamp_integer ?? Date.now());
     const result = this.db.prepare(
@@ -792,28 +878,55 @@ export class LocalStore {
     };
   }
 
-  #eventPayload(event) {
-    const categoryIds = event.activity_id == null
-      ? []
-      : this.db.prepare(
-        'SELECT category_id FROM activities_categories WHERE activity_id = ?',
-      ).all(event.activity_id).map(row => row.category_id);
+  #activityAgentName(userId, agentId, attrs) {
+    const known = this.db.prepare(
+      'SELECT name FROM agents WHERE user_id = ? AND agent_id = ?',
+    ).get(userId, agentId);
+    if (known?.name) return known.name;
+    const snapshot = this.db.prepare(`
+      SELECT activities.agent_name FROM activities
+      JOIN threads ON threads.id = activities.thread_id
+      JOIN traces ON traces.id = threads.trace_id
+      WHERE traces.user_id = ? AND activities.agent_id = ?
+        AND activities.agent_name IS NOT NULL AND activities.agent_name != ''
+      LIMIT 1
+    `).get(userId, agentId);
+    if (snapshot?.agent_name) return snapshot.agent_name;
+    if (typeof attrs.agent_name === 'string' && attrs.agent_name !== '') return attrs.agent_name;
+    return agentId;
+  }
 
+  #eventPayload(event) {
     return {
       id: event.id,
       timestamp: isoFromMs(event.timestamp_ms),
       phase: event.phase,
       message: event.message ?? null,
-      activity: event.activity_id == null ? null : {
-        id: event.activity_id,
-        name: event.activity_name,
-        agent_id: event.agent_id ?? null,
-        agent_name: event.agent_name ?? null,
-        parent_id: event.parent_id ?? null,
-        thread: { id: event.thread_id },
-        categories: categoryIds,
-        weight: event.weight ?? null,
-      },
+      activity: event.activity_id == null ? null : this.#traceActivityPayload({
+        ...event, id: event.activity_id, name: event.activity_name,
+        description: event.activity_description,
+      }),
+    };
+  }
+
+  #traceActivityPayload(activity) {
+    const categoryIds = this.db.prepare(
+      'SELECT category_id FROM activities_categories WHERE activity_id = ?',
+    ).all(activity.id).map(row => row.category_id);
+    return {
+      id: activity.id,
+      name: activity.name,
+      agent_id: activity.agent_id ?? null,
+      agent_name: activity.agent_name ?? null,
+      parent_id: activity.parent_id ?? null,
+      thread: { id: activity.thread_id },
+      categories: categoryIds,
+      weight: activity.weight ?? null,
+      description: activity.description ?? null,
+      scheduled_start: activity.scheduled_start_ms ?? null,
+      scheduled_end: activity.scheduled_end_ms ?? null,
+      proposed_by_agent_id: activity.proposed_by_agent_id ?? null,
+      proposed_by_agent_name: activity.proposed_by_agent_name ?? null,
     };
   }
 
@@ -830,15 +943,16 @@ export class LocalStore {
   }
 
   #ensureDefaultCategories(userId) {
-    const existing = this.db.prepare(
-      'SELECT COUNT(*) AS count FROM categories WHERE user_id = ?',
-    ).get(userId);
-    if (existing.count > 0) return;
-
+    const have = new Set(
+      this.db.prepare('SELECT lower(name) AS name FROM categories WHERE user_id = ?')
+        .all(userId)
+        .map(row => row.name),
+    );
     const insert = this.db.prepare(
       'INSERT INTO categories (user_id, name, color_background, color_text, export_id) VALUES (?, ?, ?, ?, ?)',
     );
     for (const category of DEFAULT_CATEGORIES) {
+      if (have.has(category.name.toLowerCase())) continue;
       insert.run(
         userId,
         category.name,

package/src/questions.mjs

@@ -0,0 +1,48 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+// A question the reducer asked and the worker has not answered yet (ADR-014).
+// One open question per trace. The CLI reminds; it never refuses the next command.
+
+export function defaultQuestionsPath() {
+  return join(homedir(), '.flambe', 'open-questions.json');
+}
+
+export function readOpenQuestion(traceId, path = defaultQuestionsPath()) {
+  if (!traceId) return undefined;
+  const stored = readAll(path)[String(traceId)];
+  if (!stored || typeof stored.reply !== 'string' || !stored.reply.trim()) return undefined;
+  return { activityId: stored.activityId, reply: stored.reply };
+}
+
+export function rememberQuestion(traceId, { activityId, reply }, path = defaultQuestionsPath()) {
+  if (!traceId || !reply) return;
+  const all = { ...readAll(path), [String(traceId)]: { activityId, reply } };
+  writeAll(path, all);
+}
+
+export function clearQuestion(traceId, path = defaultQuestionsPath()) {
+  if (!traceId) return;
+  const all = readAll(path);
+  if (!(String(traceId) in all)) return;
+  delete all[String(traceId)];
+  writeAll(path, all);
+}
+
+function readAll(path) {
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+
+function writeAll(path, questions) {
+  mkdirSync(dirname(path), { recursive: true });
+  const tmp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify(questions, null, 2)}\n`);
+  renameSync(tmp, path);
+}

package/src/queue.mjs

@@ -28,14 +28,19 @@ function emptyState() {
 }
 
 export class FlambeQueue {
-  constructor({ baseUrl, traceId, path = defaultQueuePath() }) {
+  constructor({ baseUrl, traceId, agentId, path = defaultQueuePath() }) {
     this.baseUrl = baseUrl;
     this.traceId = Number(traceId);
+    this.agentId = agentId;
     this.path = path;
   }
 
   matches(entry) {
-    return entry.baseUrl === this.baseUrl && entry.traceId === this.traceId;
+    return entry.baseUrl === this.baseUrl
+      && entry.traceId === this.traceId
+      // Version-1 entries created before identity was recorded remain replayable.
+      // New entries may only be replayed by the worker that queued them.
+      && (entry.agentId === undefined || entry.agentId === this.agentId);
   }
 
   async read() {
@@ -70,6 +75,7 @@ export class FlambeQueue {
       type,
       baseUrl: this.baseUrl,
       traceId: this.traceId,
+      ...(this.agentId ? { agentId: this.agentId } : {}),
       ...(localId ? { localId } : {}),
       ...payload,
     });
@@ -107,7 +113,13 @@ export class FlambeQueue {
         } else if (entry.type === 'end' || entry.type === 'suspend' || entry.type === 'resume') {
           const activityId = state.aliases[entry.activityId] ?? entry.activityId;
           const post = { end, suspend, resume }[entry.type];
-          await post({ activityId, message: entry.message, timestamp: entry.timestamp });
+          await post({
+            activityId,
+            message: entry.message,
+            timestamp: entry.timestamp,
+            force: entry.force ?? false,
+            phase: entry.phase,
+          });
           if (entry.type === 'end') delete state.aliases[entry.activityId];
         } else if (entry.type === 'observe') {
           await observe(entry.input);

package/src/runtime.mjs

@@ -0,0 +1,23 @@
+/** Explicit transport boundary; never infer local-only intent from a URL. */
+export function runtimeConfig(env) {
+  const mode = env.FLAMBE_RUNTIME_MODE?.trim();
+  if (!mode) return {};
+  if (!['cloud', 'local_self_contained'].includes(mode)) {
+    throw new Error('FLAMBE_RUNTIME_MODE must be cloud or local_self_contained');
+  }
+  return { runtimeMode: mode };
+}
+
+export function assertRuntimeUrl(value, mode) {
+  if (mode !== 'local_self_contained') return;
+  let url;
+  try { url = new URL(value); } catch {
+    throw new Error('Self-contained mode requires a loopback HTTP URL');
+  }
+  // Numeric addresses avoid DNS resolution changing the trust boundary.
+  if (!['http:', 'https:'].includes(url.protocol)
+    || !['127.0.0.1', '[::1]'].includes(url.hostname)
+    || url.username || url.password) {
+    throw new Error('Self-contained mode requires 127.0.0.1 or [::1]; remote destinations are disabled');
+  }
+}