@pleri/olam-cli 0.1.159 → 0.1.160

package/hermes-bundle/version.json

@@ -1,4 +1,4 @@
 {
-  "bundledAt": "2026-05-21T16:31:13.129Z",
+  "bundledAt": "2026-05-22T05:49:33.599Z",
   "kgFirstSha": "29a9ccce1b115d049e375c4a90eb5cf7c123e610e2d0590270a4db2cdbc64a28"
 }

package/host-cp/k8s/manifests/50-deployment.yaml

@@ -111,7 +111,7 @@ spec:
         # k3d), started by `olam upgrade` Step 0.7 — not inside this Pod.
       containers:
         - name: olam-host-cp
-          image: ghcr.io/pleri/olam-host-cp@sha256:53c6548f6930231a6f905f4a3ae1f49dbc66e52233b64a09e539b4ffa21180db
+          image: ghcr.io/pleri/olam-host-cp@sha256:3bf4a89af3544e382bf2d708ff73baa6704cf91a0b509f8b1a153fbe603a4223
           imagePullPolicy: IfNotPresent
           securityContext:
             runAsNonRoot: true

package/host-cp/k8s/manifests/auth-service/50-deployment.yaml

@@ -70,7 +70,7 @@ spec:
               mountPath: /data
       containers:
         - name: olam-auth-service
-          image: ghcr.io/pleri/olam-auth@sha256:d1b13f12d87d5b119d6495214c26d8c8255deb996d37193f3b4fa47363ab9367
+          image: ghcr.io/pleri/olam-auth@sha256:a7b1e4c0ddee4fc6bfb2689c4d23d8bc0fcc95bc7b42a28d977b990f1408505b
           imagePullPolicy: IfNotPresent
           securityContext:
             runAsNonRoot: true

package/host-cp/k8s/manifests/kg-service/50-deployment.yaml

@@ -61,7 +61,7 @@ spec:
               mountPath: /data
       containers:
         - name: olam-kg-service
-          image: ghcr.io/pleri/olam-kg-service@sha256:e7276f9ea4d359dcb8a0d623e701e290f51c565fc8b6e3c14bea75b1b780d23d
+          image: ghcr.io/pleri/olam-kg-service@sha256:72fdfb96981903cd83d0b6ad997985bad86a7892c0d1ec7c5dcc9b4d9f8f44db
           imagePullPolicy: IfNotPresent
           securityContext:
             runAsNonRoot: true

package/host-cp/k8s/manifests/mcp-auth-service/50-deployment.yaml

@@ -68,7 +68,7 @@ spec:
               mountPath: /data
       containers:
         - name: olam-mcp-auth-service
-          image: ghcr.io/pleri/olam-mcp-auth@sha256:d53a7538ca405f4d8c0c4be67d3961617304f07623839eb0de75f9cd2b47b914
+          image: ghcr.io/pleri/olam-mcp-auth@sha256:d8fb62e437142bf352e0d6f637c2b912baa592f25f4abbac1acc2c8cced976c2
           imagePullPolicy: IfNotPresent
           securityContext:
             runAsNonRoot: true

package/host-cp/k8s/manifests/memory-service/30-configmap.yaml

@@ -22,3 +22,14 @@ data:
   # AGENTMEMORY_HOST=0.0.0.0 but ConfigMap override is explicit defense against
   # a future image regression reverting to 127.0.0.1.
   AGENTMEMORY_HOST: "0.0.0.0"
+  # III_REST_PORT is the env var the agentmemory CLI wrapper reads when it
+  # polls its iii subprocess for readiness (cli.mjs:155 — `process.env
+  # ["III_REST_PORT"] || "3111"`). The iii engine itself binds the port
+  # declared in iii-config.yaml's iii-http worker (overridden via the
+  # olam-memory-service-iii-config ConfigMap to 3110, so it does not
+  # collide with the metrics-proxy on 3111). Without this env var the
+  # wrapper polls 3111 forever, prints "iii-engine did not become ready",
+  # and exits — entrypoint propagates the exit, container restarts, and
+  # the liveness probe returns 502 from the proxy (its backend was never
+  # up). Must equal the iii-http port in 35-configmap-iii-config.yaml.
+  III_REST_PORT: "3110"

package/host-cp/k8s/manifests/memory-service/35-configmap-iii-config.yaml

@@ -0,0 +1,76 @@
+# Overrides the iii-config.yaml shipped inside the agentmemory image so the
+# iii engine binds the INTERNAL port (3110) instead of the EXTERNAL port
+# (3111). The shipped yaml hardcodes `port: 3111` and the agentmemory CLI
+# reads its bind from yaml (NOT from the AGENTMEMORY_PORT env var), so
+# entrypoint.sh's `AGENTMEMORY_PORT=3110` override has no effect.
+#
+# Without this override, the engine and the metrics-proxy both try to bind
+# 0.0.0.0:3111. The proxy starts first and wins the port; the engine fails
+# silently. Probes to /agentmemory/livez hit the proxy and get forwarded to
+# 127.0.0.1:3110, where nothing is listening — proxy returns 502, readiness
+# fails, container restarts.
+#
+# Mounted at /usr/local/lib/node_modules/@agentmemory/agentmemory/dist/iii-config.yaml
+# via subPath in 50-deployment.yaml.
+apiVersion: v1
+kind: ConfigMap
+metadata:
+  name: olam-memory-service-iii-config
+  namespace: olam
+  labels:
+    app: olam-memory-service
+    olam.io/component: peripheral
+data:
+  iii-config.yaml: |
+    workers:
+      - name: iii-http
+        config:
+          port: 3110
+          host: 0.0.0.0
+          default_timeout: 180000
+          cors:
+            allowed_origins: ["http://localhost:3111", "http://localhost:3113", "http://127.0.0.1:3111", "http://127.0.0.1:3113"]
+            allowed_methods: [GET, POST, PUT, DELETE, OPTIONS]
+      - name: iii-state
+        config:
+          adapter:
+            name: kv
+            config:
+              store_method: file_based
+              file_path: ./data/state_store.db
+      - name: iii-queue
+        config:
+          adapter:
+            name: builtin
+      - name: iii-pubsub
+        config:
+          adapter:
+            name: local
+      - name: iii-cron
+        config:
+          adapter:
+            name: kv
+      - name: iii-stream
+        config:
+          port: 3112
+          host: 0.0.0.0
+          adapter:
+            name: kv
+            config:
+              store_method: file_based
+              file_path: ./data/stream_store
+      - name: iii-observability
+        config:
+          enabled: true
+          service_name: agentmemory
+          exporter: memory
+          sampling_ratio: 1.0
+          metrics_enabled: true
+          logs_enabled: true
+          logs_console_output: true
+      - name: iii-exec
+        config:
+          watch:
+            - src/**/*.ts
+          exec:
+            - node dist/index.mjs

package/host-cp/k8s/manifests/memory-service/50-deployment.yaml

@@ -70,7 +70,7 @@ spec:
           # bootstrap-placeholder comment + run `npm run refresh:manifest-digests`
           # once ghcr.io/pleri/olam-memory-service has a real published digest.
           # bootstrap-placeholder: pre-publish; refresh after first release
-          image: ghcr.io/pleri/olam-memory-service@sha256:023bde810b0594829c8aa553b88a64cf53b81b6374085c7a92fb6102450fa3ff
+          image: ghcr.io/pleri/olam-memory-service@sha256:bc377f94911baff74f7b91c44ea471580fdfdc1947e757dd6f550675084312d6
           imagePullPolicy: IfNotPresent
           securityContext:
             runAsNonRoot: true
@@ -93,6 +93,13 @@ spec:
               mountPath: /data
             - name: tmp
               mountPath: /tmp
+            # Overrides the shipped iii-config.yaml so the engine binds the
+            # internal port (3110) instead of colliding with the metrics-proxy
+            # on 3111. See 35-configmap-iii-config.yaml for full rationale.
+            - name: iii-config-override
+              mountPath: /usr/local/lib/node_modules/@agentmemory/agentmemory/dist/iii-config.yaml
+              subPath: iii-config.yaml
+              readOnly: true
           readinessProbe:
             httpGet:
               # D15 (LOAD-BEARING): memory-service health path is /agentmemory/livez.
@@ -126,3 +133,6 @@ spec:
             claimName: olam-memory-data
         - name: tmp
           emptyDir: {}
+        - name: iii-config-override
+          configMap:
+            name: olam-memory-service-iii-config

package/host-cp/src/crystallize-planning.mjs

@@ -0,0 +1,261 @@
+// crystallize-planning — atomic-or-compensating chunk-copy from a planning
+// session (_planning world) into a freshly provisioned real world.
+//
+// APPEND-ONLY CONSTRAINT: The chunks table has a NO_DELETE + NO_UPDATE
+// trigger (chunks_append_only_trigger). If chunk-copy fails mid-batch,
+// any chunks already INSERTed under the new worldId STAY in the database.
+// Compensating cleanup only calls destroyWorld (world container teardown) —
+// it CANNOT delete the orphaned chunks. Those orphan chunks are harmless:
+//   • idx_chunks_planning only covers world_id='_planning' rows.
+//   • The destroyed world container no longer exists, so no subscriber
+//     will ever observe those orphans through the normal shape proxy.
+//   • Any future re-crystallize creates a fresh worldId, fresh session_id.
+//
+// IDEMPOTENCY:
+//   • If crystallize_status is 'crystallized' (with a stored worldId),
+//     return immediately — the work is already done.
+//   • If crystallize_status is 'in_progress', we cannot safely resume
+//     (we don't know how far the previous copy got, and the chunk INSERT
+//     is not idempotent by worldId+sessionId alone — the PRIMARY KEY is
+//     (message_id, seq), so the same chunk could be re-inserted into a
+//     different new session without collision). Safe behavior: return
+//     the current status so the UI can display "in progress" and the
+//     operator can force-retry after manual inspection.
+//
+// SLUG RULE: lowercased, non-alphanum → hyphens, max 40 chars.
+// Matches the dev-substrate stub in plan-chat-spa/src/server/index.ts
+// (confirmed by reading that file's crystallize stub, around line 983).
+
+import { randomUUID } from 'node:crypto';
+import { PLANNING_WORLD_ID } from '@olam/chunks/schema';
+import { setCrystallizeStatus } from './planning-sessions.mjs';
+
+/**
+ * Slug a plan title into a world-name-safe string.
+ * Lowercased, non-alphanum → hyphens, max 40 chars, leading/trailing
+ * hyphens removed. Falls back to 'plan' if result is empty.
+ *
+ * @param {string} title
+ * @returns {string}
+ */
+function slugTitle(title) {
+  const base = title
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 40);
+  return base || 'plan';
+}
+
+/**
+ * Read the current crystallize_status + crystallized_world_id for a session.
+ *
+ * @param {object} pool
+ * @param {string} sessionId
+ * @returns {Promise<{crystallize_status: string, crystallized_world_id: string | null}>}
+ */
+async function readCrystallizeState(pool, sessionId) {
+  const result = await pool.query(
+    `SELECT crystallize_status, crystallized_world_id
+     FROM planning_sessions
+     WHERE session_id = $1`,
+    [sessionId],
+  );
+  if (result.rows.length === 0) {
+    return { crystallize_status: 'open', crystallized_world_id: null };
+  }
+  const row = result.rows[0];
+  return {
+    crystallize_status: row.crystallize_status,
+    crystallized_world_id: row.crystallized_world_id ?? null,
+  };
+}
+
+/**
+ * SELECT all planning chunks for a session, ordered by seq.
+ *
+ * @param {object} pool
+ * @param {string} sessionId
+ * @returns {Promise<Array<{world_id, session_id, message_id, seq, actor_id, actor_type, role, chunk, chunk_type}>>}
+ */
+async function selectPlanningChunks(pool, sessionId) {
+  const result = await pool.query(
+    `SELECT world_id, session_id, message_id, seq, actor_id, actor_type, role, chunk, chunk_type
+     FROM chunks
+     WHERE world_id = $1 AND session_id = $2
+     ORDER BY seq ASC`,
+    [PLANNING_WORLD_ID, sessionId],
+  );
+  return result.rows;
+}
+
+/**
+ * INSERT a single chunk into the new world's session.
+ * Uses the original message_id + seq verbatim; only world_id and
+ * session_id change to point at the new world's session.
+ *
+ * @param {object} pool
+ * @param {object} chunk   — row from the planning session
+ * @param {string} newWorldId
+ * @param {string} newSessionId
+ * @returns {Promise<void>}
+ */
+async function insertChunkIntoNewWorld(pool, chunk, newWorldId, newSessionId) {
+  await pool.query(
+    `INSERT INTO chunks
+       (world_id, session_id, message_id, seq, actor_id, actor_type, role, chunk, chunk_type)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+    [
+      newWorldId,
+      newSessionId,
+      chunk.message_id,
+      chunk.seq,
+      chunk.actor_id,
+      chunk.actor_type,
+      chunk.role,
+      chunk.chunk,
+      chunk.chunk_type,
+    ],
+  );
+}
+
+/**
+ * INSERT a system marker chunk into the ORIGINAL planning session to
+ * leave an audit trail of crystallization. The marker lands at
+ * world_id='_planning' + the original sessionId.
+ *
+ * @param {object} pool
+ * @param {string} sessionId   — original planning session id
+ * @param {string} worldId     — newly created world id
+ * @param {number} phaseCount  — number of phases in the plan
+ * @returns {Promise<void>}
+ */
+async function insertMarkerChunk(pool, sessionId, worldId, phaseCount) {
+  const messageId = randomUUID();
+  // Find the current max seq so the marker doesn't collide.
+  const seqResult = await pool.query(
+    `SELECT COALESCE(MAX(seq), -1) AS max_seq
+     FROM chunks
+     WHERE world_id = $1 AND session_id = $2`,
+    [PLANNING_WORLD_ID, sessionId],
+  );
+  const nextSeq = Number(seqResult.rows[0].max_seq) + 1;
+  await pool.query(
+    `INSERT INTO chunks
+       (world_id, session_id, message_id, seq, actor_id, actor_type, role, chunk, chunk_type)
+     VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
+    [
+      PLANNING_WORLD_ID,
+      sessionId,
+      messageId,
+      nextSeq,
+      'system',
+      'system',
+      'system',
+      `Plan crystallized into world "${worldId}" (${phaseCount} phase${phaseCount === 1 ? '' : 's'}).`,
+      'text',
+    ],
+  );
+}
+
+/**
+ * crystallizePlanningSession
+ *
+ * 4-phase atomic-or-compensating process:
+ *   1. Set crystallize_status='in_progress'
+ *   2. Call createWorld({ name: slugged-title }) → { id: worldId }
+ *   3. SELECT all chunks in _planning/sessionId; INSERT each into new world
+ *   4. Set crystallize_status='crystallized' (with worldId); INSERT marker chunk
+ *
+ * Compensating pattern on partial failure:
+ *   - If createWorld throws: set status='failed', rethrow. destroyWorld NOT called.
+ *   - If chunk-copy throws mid-batch: set status='failed', call destroyWorld(worldId),
+ *     rethrow. Orphan chunks already INSERTed stay (append-only; see file header).
+ *
+ * Idempotency:
+ *   - Already 'crystallized': return immediately without re-running.
+ *   - Already 'in_progress': return current status (safe short-circuit; see header).
+ *
+ * @param {object} opts
+ * @param {object}   opts.pool           — pg.Pool-compatible with .query()
+ * @param {string}   opts.sessionId      — planning session to crystallize
+ * @param {string}   opts.planTitle      — plan title (used for world name slug)
+ * @param {Array}    opts.planPhases     — array of phase objects (name, acceptance, risks?)
+ * @param {Function} opts.createWorld    — async ({ name }) => { id: string, ... }
+ * @param {Function} opts.destroyWorld   — async (worldId) => void
+ *
+ * @returns {Promise<{worldId: string, status: string, new_session_id: string}>}
+ * @throws  on failure (crystallize_status already set to 'failed' when thrown)
+ */
+export async function crystallizePlanningSession({
+  pool,
+  sessionId,
+  planTitle,
+  planPhases,
+  createWorld,
+  destroyWorld,
+}) {
+  // ── Idempotency guard ────────────────────────────────────────────────────
+  const currentState = await readCrystallizeState(pool, sessionId);
+
+  if (currentState.crystallize_status === 'crystallized') {
+    return {
+      worldId: currentState.crystallized_world_id,
+      status: `crystallized:${currentState.crystallized_world_id}`,
+      new_session_id: null,
+    };
+  }
+
+  if (currentState.crystallize_status === 'in_progress') {
+    // Cannot safely resume without knowing how far the copy got.
+    // Return current status so the UI shows 'in_progress'.
+    return {
+      worldId: currentState.crystallized_world_id,
+      status: 'in_progress',
+      new_session_id: null,
+    };
+  }
+
+  // ── Phase 1: mark in_progress ────────────────────────────────────────────
+  await setCrystallizeStatus({ pool, sessionId, status: 'in_progress', worldId: null });
+
+  // ── Phase 2: create world ────────────────────────────────────────────────
+  let worldId;
+  try {
+    const worldName = slugTitle(planTitle);
+    const world = await createWorld({ name: worldName });
+    worldId = world.id;
+  } catch (err) {
+    await setCrystallizeStatus({ pool, sessionId, status: 'failed', worldId: null });
+    throw err;
+  }
+
+  // ── Phase 3: copy chunks into new world ──────────────────────────────────
+  const newSessionId = randomUUID();
+  try {
+    const chunks = await selectPlanningChunks(pool, sessionId);
+    for (const chunk of chunks) {
+      await insertChunkIntoNewWorld(pool, chunk, worldId, newSessionId);
+    }
+  } catch (err) {
+    await setCrystallizeStatus({ pool, sessionId, status: 'failed', worldId: null });
+    try {
+      await destroyWorld(worldId);
+    } catch {
+      // Compensating destroy failure is non-fatal — the world may already
+      // be partially torn down or the destroy operation may not be
+      // reversible. Log is left to the caller's context.
+    }
+    throw err;
+  }
+
+  // ── Phase 4: mark crystallized + insert marker ───────────────────────────
+  await setCrystallizeStatus({ pool, sessionId, status: 'crystallized', worldId });
+  await insertMarkerChunk(pool, sessionId, worldId, planPhases.length);
+
+  return {
+    worldId,
+    status: `crystallized:${worldId}`,
+    new_session_id: newSessionId,
+  };
+}

package/host-cp/src/plan-chat-service.mjs

@@ -35,6 +35,8 @@ import { Readable } from 'node:stream';
 import { URL } from 'node:url';
 import pg from 'pg';
 import { ensureSecret, timingSafeEqual, SECRET_PATH } from './plan-chat-secret.mjs';
+import { listPlanningSessions } from './planning-sessions.mjs';
+import { crystallizePlanningSession } from './crystallize-planning.mjs';
 
 const DEFAULT_PORT = 3200;
 const DEFAULT_DB_URL = 'postgres://postgres:spike@localhost:54321/chunks';
@@ -42,6 +44,7 @@ const DEFAULT_ELECTRIC_URL = 'http://localhost:30001';
 
 const ACTOR_TYPES = new Set(['agent', 'operator', 'codex', 'system']);
 const ROLES = new Set(['user', 'assistant', 'tool', 'system']);
+const CHUNK_TYPES = new Set(['text', 'tool_use']);
 
 // PB2 — scope-ID shape. world_id + session_id query params are interpolated
 // into the upstream Electric `where` clause; the regex IS the SQL-injection
@@ -172,6 +175,10 @@ function validateChunkInput(body) {
   if (!Number.isInteger(body.seq) || body.seq < 0) return 'seq must be a non-negative integer';
   if (typeof body.chunk !== 'string') return 'chunk must be a string';
   if (!ROLES.has(body.role)) return `role must be one of ${[...ROLES].join(', ')}`;
+  // Optional chunk_type field — defaults to 'text' when absent.
+  if ('chunk_type' in body && !CHUNK_TYPES.has(body.chunk_type)) {
+    return `chunk_type must be one of ${[...CHUNK_TYPES].join(', ')}`;
+  }
   // actor_id and actor_type from the client are IGNORED (server-derived).
   return null;
 }
@@ -195,6 +202,8 @@ export function createHandler({
   electricUrl,
   shapeDebug,
   shapeDebugLog,
+  createWorld,
+  destroyWorld,
 }) {
   if (!pool) throw new Error('createHandler: { pool } required');
   if (typeof bearer !== 'string' || bearer.length === 0) {
@@ -231,8 +240,8 @@ export function createHandler({
     try {
       await pool.query(
         `INSERT INTO chunks
-           (world_id, session_id, message_id, seq, actor_id, actor_type, role, chunk)
-         VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`,
+           (world_id, session_id, message_id, seq, actor_id, actor_type, role, chunk, chunk_type)
+         VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
         [
           body.world_id,
           body.session_id,
@@ -242,6 +251,7 @@ export function createHandler({
           principal.actorType,
           body.role,
           body.chunk,
+          body.chunk_type ?? 'text',
         ],
       );
     } catch (err) {
@@ -257,6 +267,7 @@ export function createHandler({
       seq: body.seq,
       actor_id: principal.actorId,
       actor_type: principal.actorType,
+      chunk_type: body.chunk_type ?? 'text',
     });
   }
 
@@ -413,11 +424,82 @@ export function createHandler({
     }
   }
 
+  async function handleGetPlanningSessions(req, res, url) {
+    if (!checkAuth(req)) return unauthorized(res);
+    // Derive actorId from the bearer principal (no body on GET).
+    const principal = principalFromBearer(bearer, null);
+    const limitParam = url.searchParams.get('limit');
+    const limit = limitParam ? Math.min(parseInt(limitParam, 10) || 50, 200) : 50;
+    try {
+      const sessions = await listPlanningSessions({ pool, actorId: principal.actorId, limit });
+      return send(res, 200, { sessions });
+    } catch (err) {
+      return send(res, 500, { error: 'list-failed', message: String(err?.message ?? err) });
+    }
+  }
+
+  async function handlePostCrystallize(req, res) {
+    if (!checkAuth(req)) return unauthorized(res);
+    let body;
+    try {
+      body = await readJson(req);
+    } catch (err) {
+      return send(res, err?.status ?? 400, { error: err?.message ?? 'bad-request' });
+    }
+
+    // Validate required fields: session_id + plan.title + plan.phases
+    if (!body || typeof body.session_id !== 'string' || body.session_id.length === 0) {
+      return badRequest(res, 'session_id required');
+    }
+    if (!body.plan || typeof body.plan.title !== 'string' || body.plan.title.length === 0) {
+      return badRequest(res, 'plan.title required');
+    }
+    if (!Array.isArray(body.plan.phases)) {
+      return badRequest(res, 'plan.phases must be an array');
+    }
+
+    // createWorld + destroyWorld callbacks must be wired at handler creation
+    // time (production: WorldManager closures; tests: stubs). If they are not
+    // provided, surface a clear 501 rather than crashing.
+    if (typeof createWorld !== 'function' || typeof destroyWorld !== 'function') {
+      return send(res, 501, {
+        ok: false,
+        error: 'crystallize-not-wired',
+        status: 'failed',
+      });
+    }
+
+    try {
+      const result = await crystallizePlanningSession({
+        pool,
+        sessionId: body.session_id,
+        planTitle: body.plan.title,
+        planPhases: body.plan.phases,
+        createWorld,
+        destroyWorld,
+      });
+      return send(res, 200, {
+        ok: true,
+        created_world_id: result.worldId,
+        world_url: result.worldId ? `/world/${result.worldId}` : null,
+        status: result.status,
+      });
+    } catch (err) {
+      return send(res, 500, {
+        ok: false,
+        error: String(err?.message ?? err),
+        status: 'failed',
+      });
+    }
+  }
+
   return async function handler(req, res) {
     const url = new URL(req.url ?? '/', `http://${req.headers.host}`);
     if (req.method === 'GET' && url.pathname === '/livez') return send(res, 200, { ok: true });
     if (req.method === 'POST' && url.pathname === '/v1/chunks') return handlePostChunks(req, res);
     if (req.method === 'GET' && url.pathname === '/v1/shape') return handleGetShape(req, res, url);
+    if (req.method === 'GET' && url.pathname === '/v1/planning-sessions') return handleGetPlanningSessions(req, res, url);
+    if (req.method === 'POST' && url.pathname === '/v1/crystallize') return handlePostCrystallize(req, res);
     return send(res, 404, { error: 'not-found' });
   };
 }