@pleri/olam-cli 0.1.78 → 0.1.79

package/dist/image-digests.json

@@ -1,9 +1,9 @@
 {
   "auth": "sha256:ee6b1d1046933c76acc8d28cd83ac3871bc69057d2401014252872dc5ec42db7",
-  "devbox": "sha256:d68dc8b55aecdedd2f2af6eb535673b68733f262e882be008d74fb1b99f93c43",
-  "host-cp": "sha256:9aa95a49f058da39e402862bcb6e9a9a8272c5246577cfa58770165e2ee84b31",
+  "devbox": "sha256:33f96024c3627ecc41592f4ef777b38c72537d9fc3674ee7e37f0074015bf514",
+  "host-cp": "sha256:bd752b9631b1f593573c51e76bd7488d86527e822a9f4f53d1f16d43ecab4c75",
   "mcp-auth": "sha256:e47169ad3fbc9cab216248fecbc56874343a5daab84b1f18d67529b7d415cf95",
   "$schema_version": 1,
-  "$published_version": "0.1.78",
+  "$published_version": "0.1.79",
   "$registry": "ghcr.io/pleri"
 }

package/host-cp/compose.yaml

@@ -132,6 +132,13 @@ services:
       # currently-running host-cp image (which has the olam CLI +
       # docker CLI + gh CLI baked in by Dockerfile).
       OLAM_UPGRADER_IMAGE: "${OLAM_UPGRADER_IMAGE:-ghcr.io/pleri/olam-host-cp:latest}"
+      # Plan DB persistence fix (Bug 1): os.homedir() inside the container is
+      # /root, but ~/.olam is bind-mounted to /data — not /root/.olam. Without
+      # these overrides, plan.db lands in the container's ephemeral layer and is
+      # destroyed by every `docker compose up --force-recreate` (i.e. olam upgrade).
+      # Pointing to /data/ routes all writes through the bind-mount to the host.
+      OLAM_PLAN_DB_PATH: "/data/plan.db"
+      OLAM_PLAN_DIR: "/data/plan"
     volumes:
       # ~/.olam/ from operator's home → /data/ inside container. B4
       # writes the startup token here (chmod 600). B6 reads workspaces

package/host-cp/src/plan-orchestrator.mjs

@@ -23,9 +23,29 @@ import { RopeEngine } from './plan/rope-engine.mjs';
 import { loadAuthorityConfig } from './plan/authority-config.mjs';
 
 // ── Paths ─────────────────────────────────────────────────────────────────────
+//
+// Inside the Docker container, os.homedir() → /root, but compose.yaml mounts
+// ${HOME}/.olam → /data. Without env overrides, plan.db would be written to
+// /root/.olam/plan.db (container ephemeral layer) and lost on every
+// `docker compose up --force-recreate` (i.e. every `olam upgrade`).
+//
+// OLAM_PLAN_DB_PATH and OLAM_PLAN_DIR are set to /data/plan.db and /data/plan
+// in compose.yaml so all writes land in the bind-mounted host directory.
+// On bare-host installs (no container) neither env var is set and the paths
+// fall back to the original ~/.olam locations — no behaviour change.
+//
+// Paths are resolved at construction time (not module load) so tests can pass
+// explicit paths via constructor opts without any module re-import tricks.
+
+/** @returns {string} */
+function defaultPlanDbPath() {
+  return process.env.OLAM_PLAN_DB_PATH ?? path.join(os.homedir(), '.olam', 'plan.db');
+}
 
-const PLAN_DB_PATH = path.join(os.homedir(), '.olam', 'plan.db');
-const PLAN_DIR = path.join(os.homedir(), '.olam', 'plan');
+/** @returns {string} */
+function defaultPlanDir() {
+  return process.env.OLAM_PLAN_DIR ?? path.join(os.homedir(), '.olam', 'plan');
+}
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
 
@@ -60,6 +80,7 @@ export function deriveTitle(content, maxLen = 40) {
 
 export class PlanOrchestrator {
   #db;
+  #planDir;
   #authServiceUrl;
   #authServiceSecret;
   #registry;
@@ -88,17 +109,44 @@ export class PlanOrchestrator {
   #currentChunkRefs = new Map();
 
   /**
-   * @param {{ authServiceUrl: string, authServiceSecret: string }} opts
+   * @param {{
+   *   authServiceUrl: string,
+   *   authServiceSecret: string,
+   *   planDbPath?: string,
+   *   planDirPath?: string,
+   * }} opts
+   *
+   * planDbPath / planDirPath default to OLAM_PLAN_DB_PATH / OLAM_PLAN_DIR env vars,
+   * falling back to ~/.olam/plan.db and ~/.olam/plan. Pass explicitly in tests to
+   * avoid touching real home-dir paths.
    */
-  constructor({ authServiceUrl, authServiceSecret }) {
+  constructor({ authServiceUrl, authServiceSecret, planDbPath, planDirPath } = {}) {
     this.#authServiceUrl = authServiceUrl;
     this.#authServiceSecret = authServiceSecret;
 
+    const legacyDbPath = path.join(os.homedir(), '.olam', 'plan.db');
+    const resolvedDbPath = planDbPath ?? defaultPlanDbPath();
+    this.#planDir = planDirPath ?? defaultPlanDir();
+
     this.#registry = new AgentRegistry({ authServiceUrl, authServiceSecret });
     this.#handoffEngine = new HandoffEngine(this.#registry);
 
-    fs.mkdirSync(path.dirname(PLAN_DB_PATH), { recursive: true });
-    this.#db = new Database(PLAN_DB_PATH);
+    fs.mkdirSync(path.dirname(resolvedDbPath), { recursive: true });
+
+    // One-time migration: if the resolved DB path differs from the legacy default and
+    // the target doesn't exist yet, copy any existing DB from the old location.
+    // This preserves conversations on a hot-restart after deploying the compose.yaml fix.
+    // On full container recreate the legacy path is already gone — this is a no-op.
+    if (resolvedDbPath !== legacyDbPath && !fs.existsSync(resolvedDbPath) && fs.existsSync(legacyDbPath)) {
+      try {
+        fs.copyFileSync(legacyDbPath, resolvedDbPath);
+        console.info('[plan] Migrated plan.db from legacy path to', resolvedDbPath);
+      } catch (err) {
+        console.warn('[plan] plan.db migration failed (non-fatal):', err.message);
+      }
+    }
+
+    this.#db = new Database(resolvedDbPath);
     this.#db.exec(`
       CREATE TABLE IF NOT EXISTS plan_conversations (
         id TEXT PRIMARY KEY,
@@ -152,6 +200,12 @@ export class PlanOrchestrator {
         ON plan_sidebar_signals(chunk_id);
     `);
 
+    // Migration guard: add pinned column if the table predates this feature.
+    const planConvCols = this.#db.prepare(`PRAGMA table_info(plan_conversations)`).all();
+    if (!planConvCols.some(c => c.name === 'pinned')) {
+      this.#db.exec(`ALTER TABLE plan_conversations ADD COLUMN pinned INTEGER NOT NULL DEFAULT 0`);
+    }
+
     const authorityConfig = loadAuthorityConfig();
     this.#ropeEngine = new RopeEngine({
       registry: this.#registry,
@@ -194,7 +248,7 @@ export class PlanOrchestrator {
     const id = randomUUID();
     const created_at = Date.now();
 
-    const sessionDir = path.join(PLAN_DIR, id);
+    const sessionDir = path.join(this.#planDir, id);
     fs.mkdirSync(sessionDir, { recursive: true });
     initSessionFile(path.join(sessionDir, 'session.jsonl'), id);
 
@@ -210,17 +264,76 @@ export class PlanOrchestrator {
     return { id, title: title ?? null, persona: DEFAULT_PERSONA_ID, created_at };
   }
 
-  /** @returns {Array<{id, title, created_at, last_turn_at, persona}>} */
+  /** @returns {Array<{id, title, pinned, created_at, last_turn_at, persona, snippet}>} */
   listConversations() {
     return this.#db
       .prepare(
-        `SELECT id, title, created_at, last_turn_at, persona
-         FROM plan_conversations
-         ORDER BY created_at DESC, rowid DESC`,
+        `SELECT
+           c.id, c.title, c.pinned, c.created_at, c.last_turn_at, c.persona,
+           (SELECT pt.content FROM plan_turns pt
+            WHERE pt.conversation_id = c.id
+            ORDER BY pt.created_at DESC LIMIT 1) AS snippet
+         FROM plan_conversations c
+         ORDER BY c.pinned DESC, COALESCE(c.last_turn_at, c.created_at) DESC`,
       )
       .all();
   }
 
+  /**
+   * Patch a conversation's title and/or pinned state.
+   * @param {string} id
+   * @param {{ title?: string, pinned?: boolean }} updates
+   * @returns {object|null} Updated row, or null if not found.
+   */
+  patchConversation(id, updates) {
+    const parts = [];
+    const values = [];
+    if (updates.title !== undefined) {
+      parts.push('title = ?');
+      values.push(updates.title || null);
+    }
+    if (updates.pinned !== undefined) {
+      parts.push('pinned = ?');
+      values.push(updates.pinned ? 1 : 0);
+    }
+    if (parts.length === 0) return null;
+    values.push(id);
+    const changed = this.#db
+      .prepare(`UPDATE plan_conversations SET ${parts.join(', ')} WHERE id = ?`)
+      .run(...values);
+    if (changed.changes === 0) return null;
+    return this.#db
+      .prepare(`SELECT id, title, pinned, created_at, last_turn_at, persona FROM plan_conversations WHERE id = ?`)
+      .get(id) ?? null;
+  }
+
+  /**
+   * Delete a conversation and all its associated data.
+   * @param {string} id
+   * @returns {boolean} true if deleted, false if not found.
+   */
+  deleteConversation(id) {
+    const exists = this.#db
+      .prepare(`SELECT 1 FROM plan_conversations WHERE id = ?`)
+      .get(id);
+    if (!exists) return false;
+
+    this.#db.prepare(`DELETE FROM plan_turns WHERE conversation_id = ?`).run(id);
+    this.#db.prepare(`DELETE FROM plan_lookout_agents WHERE conversation_id = ?`).run(id);
+    this.#db.prepare(`DELETE FROM plan_sidebar_signals WHERE conversation_id = ?`).run(id);
+    this.#db.prepare(`DELETE FROM plan_conversations WHERE id = ?`).run(id);
+
+    this.#activePersona.delete(id);
+    this.#sinks.delete(id);
+    this.#activeTurns.delete(id);
+    this.#currentChunkRefs.delete(id);
+
+    const sessionDir = path.join(PLAN_DIR, id);
+    try { fs.rmSync(sessionDir, { recursive: true }); } catch { /* ok if missing */ }
+
+    return true;
+  }
+
   /**
    * @param {string} id
    * @returns {{ id, title, persona, created_at, last_turn_at, tree } | null}
@@ -235,10 +348,10 @@ export class PlanOrchestrator {
 
     if (!row) return null;
 
-    const sessionFile = path.join(PLAN_DIR, id, 'session.jsonl');
+    const sessionFile = path.join(this.#planDir, id, 'session.jsonl');
     let tree = [];
     try {
-      const mgr = SessionManager.open(sessionFile, path.join(PLAN_DIR, id));
+      const mgr = SessionManager.open(sessionFile, path.join(this.#planDir, id));
       tree = mgr.getTree();
     } catch {
       // Session file missing or corrupt — return empty tree.

package/host-cp/src/server.mjs

@@ -114,6 +114,12 @@ const OLAM_REPO_HOST_PATH = process.env.OLAM_REPO_HOST_PATH ?? '';
 const OLAM_GH_CONFIG_HOST_PATH = process.env.OLAM_GH_CONFIG_HOST_PATH ?? '';
 const OLAM_UPGRADER_IMAGE = process.env.OLAM_UPGRADER_IMAGE ?? 'ghcr.io/pleri/olam-host-cp:latest';
 const WORKSPACES_DIR = process.env.OLAM_WORKSPACES_DIR ?? '/data/workspaces';
+// Bug 1 fix: plan.db must land in the bind-mounted /data dir, not the
+// container-ephemeral /root/.olam. compose.yaml sets these to /data/plan.db
+// and /data/plan. On bare-host installs the env vars are unset and the
+// PlanOrchestrator falls back to ~/.olam defaults.
+const PLAN_DB_PATH = process.env.OLAM_PLAN_DB_PATH ?? null;
+const PLAN_DIR_PATH = process.env.OLAM_PLAN_DIR ?? null;
 const WORLD_NAMES_PATH =
   process.env.OLAM_WORLD_NAMES_PATH ??
   (HOST_CP_MODE === 'container'
@@ -386,6 +392,8 @@ const worldsDbReconciler = startWorldsDbReconciler({
 const planOrchestrator = new PlanOrchestrator({
   authServiceUrl: AUTH_SERVICE_URL,
   authServiceSecret: AUTH_SERVICE_SECRET,
+  ...(PLAN_DB_PATH ? { planDbPath: PLAN_DB_PATH } : {}),
+  ...(PLAN_DIR_PATH ? { planDirPath: PLAN_DIR_PATH } : {}),
 });
 
 /**
@@ -1444,6 +1452,40 @@ const server = http.createServer(async (req, res) => {
     }
   }
 
+  if (planConvMatch && req.method === 'PATCH') {
+    if (!await requirePlanCredential(res)) return;
+    const id = decodeURIComponent(planConvMatch[1]);
+    let body;
+    try { body = await readRequestBody(req); } catch (err) {
+      return jsonReply(res, 400, { error: 'invalid_json', message: err.message });
+    }
+    const updates = {};
+    if (body && typeof body.title === 'string') updates.title = body.title.trim();
+    if (body && typeof body.pinned === 'boolean') updates.pinned = body.pinned;
+    if (Object.keys(updates).length === 0) {
+      return jsonReply(res, 400, { error: 'no_valid_fields' });
+    }
+    try {
+      const conv = planOrchestrator.patchConversation(id, updates);
+      if (!conv) return jsonReply(res, 404, { error: 'not_found', id });
+      return jsonReply(res, 200, conv);
+    } catch (err) {
+      return jsonReply(res, 500, { error: 'patch_failed', message: err.message });
+    }
+  }
+
+  if (planConvMatch && req.method === 'DELETE') {
+    if (!await requirePlanCredential(res)) return;
+    const id = decodeURIComponent(planConvMatch[1]);
+    try {
+      const deleted = planOrchestrator.deleteConversation(id);
+      if (!deleted) return jsonReply(res, 404, { error: 'not_found', id });
+      return jsonReply(res, 204, null);
+    } catch (err) {
+      return jsonReply(res, 500, { error: 'delete_failed', message: err.message });
+    }
+  }
+
   const planTurnMatch = /^\/api\/plan\/conversations\/([^/?#]+)\/turns$/.exec(url.pathname);
   if (planTurnMatch && req.method === 'POST') {
     if (!await requirePlanCredential(res)) return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pleri/olam-cli",
-  "version": "0.1.78",
+  "version": "0.1.79",
   "type": "module",
   "bin": {
     "olam": "./bin/olam.cjs"