@pleri/olam-cli 0.1.185 → 0.1.188

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

@@ -219,6 +219,17 @@ function validateChunkInput(body) {
   return null;
 }
 
+// P1 — promote idempotency window. Keyed by chunk_id; value is
+// { worldId, specPath, promoteId, createdAt }. Entries expire after
+// PROMOTE_DEDUPE_TTL_MS so a genuine re-promote (after operator intent)
+// is allowed rather than silently re-routing to the original world.
+// In-memory only: a process restart clears the map. For v1 this is
+// sufficient — the same Linear-retry window (seconds) is far shorter
+// than the TTL (30s). Persistent dedup (across restarts / multi-replica)
+// is deferred to U2.
+const PROMOTE_DEDUPE_TTL_MS = 30_000;
+const _promoteDedupe = new Map(); // chunk_id → { worldId, specPath, promoteId, createdAt }
+
 /**
  * Build the HTTP request handler. Pure factory — easy to test against a
  * stubbed pool. Production callers pass a real pg.Pool.
@@ -240,6 +251,17 @@ export function createHandler({
   shapeDebugLog,
   createWorld,
   destroyWorld,
+  /**
+   * P1 — injectable dispatchTask callback. Accepts { worldId, containerName,
+   * task, tier } and dispatches the task to the newly-created world.
+   * Production callers wire in autoDispatchTask from @olam/core; tests inject
+   * a stub. When omitted, the promote endpoint returns 501.
+   *
+   * Tier routing: the caller is responsible for reading compute.default
+   * from the workspace config and passing it as opts.tier when applicable.
+   * This keeps plan-chat-service free from workspace-config coupling.
+   */
+  dispatchTask,
   /** B4 — optional override for tests. When supplied, replaces principalFromBearer
    *  so the test harness can inject a hardcoded server-resolved actor_id and verify
    *  the mismatch guard. Production callers omit this. */
@@ -248,6 +270,11 @@ export function createHandler({
    *  default per-bearer rate limiter (60 req/min). Tests inject a stub with
    *  lower capacity to exercise the 429 path quickly. Production callers omit. */
   rateLimiter,
+  /**
+   * P1 — override the dedupe map for tests. Allows tests to pre-populate
+   * or inspect the idempotency store. Production callers omit this.
+   */
+  _promoteDedupe: promoteDedupe = _promoteDedupe,
 }) {
   if (!pool) throw new Error('createHandler: { pool } required');
   if (typeof bearer !== 'string' || bearer.length === 0) {
@@ -837,6 +864,181 @@ export function createHandler({
     }
   }
 
+  // P1 — POST /v1/prototypes/:id/promote
+  //
+  // Accepts a prototype chunk_id in the URL path. Validates the chunk exists
+  // and is a prototype-shaped tool_use chunk, then dispatches a docker world
+  // to implement it. Returns 202 Accepted with { worldId, promoteId, specPath }
+  // before the docker world finishes booting (the boot is async).
+  //
+  // Idempotency: same chunk_id within PROMOTE_DEDUPE_TTL_MS returns
+  // 202 { action: "deduplicated", worldId } without creating a second world.
+  // Rationale: Linear retries on non-2xx; a 409 would trigger infinite retries.
+  // 202 + action body is the correct idempotent-promote semantic.
+  //
+  // Tier routing: the injected `dispatchTask` callback owns tier selection.
+  // The caller (production: WorldManager glue in server.mjs) passes the
+  // workspace's `compute.default` tier as part of the dispatchTask closure.
+  // This keeps plan-chat-service free from workspace config coupling.
+  async function handlePostPrototypePromote(req, res, chunkId) {
+    if (!checkAuth(req)) return unauthorized(res);
+
+    // createWorld + dispatchTask must both be wired. If either is absent,
+    // surface a clear 501 rather than crashing (mirrors crystallize guard).
+    if (typeof createWorld !== 'function' || typeof dispatchTask !== 'function') {
+      return send(res, 501, {
+        error: 'promote-not-wired',
+        message: 'createWorld and dispatchTask callbacks are required',
+      });
+    }
+
+    // Idempotency: check dedupe map before any DB reads.
+    const now = Date.now();
+    const existing = promoteDedupe.get(chunkId);
+    if (existing && now - existing.createdAt < PROMOTE_DEDUPE_TTL_MS) {
+      return send(res, 202, {
+        action: 'deduplicated',
+        worldId: existing.worldId,
+        promoteId: existing.promoteId,
+        specPath: existing.specPath,
+      });
+    }
+
+    // Parse optional body { targetWorldName?, specName? }
+    let body = {};
+    try {
+      body = await readJson(req);
+    } catch (err) {
+      return send(res, err?.status ?? 400, { error: err?.message ?? 'bad-request' });
+    }
+
+    // Look up the chunk by id in the chunks table.
+    let chunk;
+    try {
+      const result = await pool.query(
+        `SELECT world_id, session_id, message_id, seq, actor_id, actor_type,
+                role, chunk, chunk_type
+           FROM chunks WHERE message_id = $1
+           LIMIT 1`,
+        [chunkId],
+      );
+      chunk = result.rows[0] ?? null;
+    } catch (err) {
+      return send(res, 500, {
+        error: 'query-failed',
+        message: String(err?.message ?? err),
+      });
+    }
+
+    if (!chunk) {
+      return send(res, 404, {
+        error: 'chunk-not-found',
+        message: `No chunk found with id '${chunkId}'`,
+      });
+    }
+
+    // Validate: must be a tool_use chunk with a prototype-shaped name.
+    if (chunk.chunk_type !== 'tool_use') {
+      return send(res, 400, {
+        error: 'invalid-chunk-type',
+        message: `chunk must have chunk_type='tool_use', got '${chunk.chunk_type}'`,
+      });
+    }
+
+    let parsedChunk;
+    try {
+      parsedChunk = JSON.parse(chunk.chunk);
+    } catch {
+      return send(res, 400, {
+        error: 'invalid-chunk-json',
+        message: 'chunk content is not valid JSON',
+      });
+    }
+
+    const toolName = typeof parsedChunk?.name === 'string' ? parsedChunk.name : '';
+    if (!toolName.includes('prototype')) {
+      return send(res, 400, {
+        error: 'not-a-prototype-chunk',
+        message: `chunk tool name '${toolName}' does not match prototype shape (name must include 'prototype')`,
+      });
+    }
+
+    // Derive world name and spec path from the chunk's input.
+    const input = parsedChunk.input ?? {};
+    const rawTitle =
+      (typeof body.specName === 'string' && body.specName.length > 0
+        ? body.specName
+        : typeof input.title === 'string' && input.title.length > 0
+          ? input.title
+          : 'prototype')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 40) || 'prototype';
+
+    const worldName =
+      typeof body.targetWorldName === 'string' && body.targetWorldName.length > 0
+        ? body.targetWorldName
+        : `proto-${rawTitle}`;
+
+    const specPath = `design-specs/${rawTitle}-v1.spec.html`;
+    const specSource =
+      typeof input.source === 'string' ? input.source : JSON.stringify(input);
+
+    // Build the dispatch prompt: embed the spec source + instruct the agent
+    // to write it at specPath on first tool use. Per D3: the agent inside
+    // the world writes the file — host-cp does not need docker mount access.
+    const dispatchPrompt = [
+      `## Prototype implementation task`,
+      ``,
+      `A prototype has been promoted for implementation. Write the spec file`,
+      `at \`${specPath}\` as your first action, then implement it production-ready.`,
+      ``,
+      `### Spec source (write verbatim to ${specPath})`,
+      ``,
+      `\`\`\`html`,
+      specSource,
+      `\`\`\``,
+      ``,
+      `After writing the spec file, implement it fully — components, styles,`,
+      `tests, and documentation. The spec is the source of truth.`,
+      `If a file already exists at \`${specPath}\`, surface a conflict chunk`,
+      `to the operator before overwriting (per D4 of the promote endpoint plan).`,
+    ].join('\n');
+
+    // Create the world.
+    let worldId;
+    try {
+      const world = await createWorld({ name: worldName });
+      worldId = world.id;
+    } catch (err) {
+      return send(res, 500, {
+        error: 'world-creation-failed',
+        message: String(err?.message ?? err),
+      });
+    }
+
+    // Dispatch the task to the new world.
+    try {
+      await dispatchTask({ worldId, task: dispatchPrompt });
+    } catch (err) {
+      // The world was created but dispatch failed. Surface 502 so the caller
+      // can retry dispatch manually via `olam dispatch <id> "<task>"`.
+      return send(res, 502, {
+        error: 'dispatch-failed',
+        worldId,
+        message: String(err?.message ?? err),
+      });
+    }
+
+    const promoteId = `promote-${chunkId}-${worldId}`;
+
+    // Record in dedupe map before returning.
+    promoteDedupe.set(chunkId, { worldId, specPath, promoteId, createdAt: now });
+
+    return send(res, 202, { worldId, promoteId, specPath, status: 'dispatched' });
+  }
+
   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 });
@@ -859,6 +1061,16 @@ export function createHandler({
       if (req.method === 'PATCH') return handlePatchArtifact(req, res, id);
       return send(res, 405, { error: 'method-not-allowed' });
     }
+
+    // P1 — /v1/prototypes/:id/promote
+    // startsWith + endsWith guard prevents shadowing a future /v1/prototypes
+    // GET list route (per risk note in the plan). The match is exact.
+    const promoteMatch = /^\/v1\/prototypes\/([^/]+)\/promote$/.exec(url.pathname);
+    if (promoteMatch && req.method === 'POST') {
+      const chunkId = decodeURIComponent(promoteMatch[1]);
+      return handlePostPrototypePromote(req, res, chunkId);
+    }
+
     return send(res, 404, { error: 'not-found' });
   };
 }
@@ -889,8 +1101,12 @@ export async function startService(opts = {}) {
     electricUrl,
     shapeDebug: opts.shapeDebug,
     shapeDebugLog: opts.shapeDebugLog,
+    createWorld: opts.createWorld,
+    destroyWorld: opts.destroyWorld,
+    dispatchTask: opts.dispatchTask,
     resolveActor: opts.resolveActor,
     rateLimiter: opts.rateLimiter,
+    _promoteDedupe: opts._promoteDedupe,
   });
   const server = http.createServer((req, res) => {
     handler(req, res).catch((err) => {

package/host-cp/src/pr-cache.mjs

@@ -127,7 +127,7 @@ async function fetchPrData(prUrl, getToken) {
 /**
  * Create a PR data cache with TTL and concurrent-fetch coalescing.
  *
- * @returns {{ getPr: (prUrl: string, getToken: () => Promise<string|null>) => Promise<PrData|null> }}
+ * @returns {{ getPr: (prUrl: string, getToken: () => Promise<string|null>) => Promise<PrData|null>, deletePr: (prUrl: string) => void }}
  */
 export function createPrCache() {
   /** @type {Map<string, PrCacheEntry>} */
@@ -197,5 +197,14 @@ export function createPrCache() {
     }
   }
 
-  return { getPr };
+  /**
+   * Evict a PR entry from the cache (call on world destroy).
+   *
+   * @param {string} prUrl
+   */
+  function deletePr(prUrl) {
+    cache.delete(prUrl);
+  }
+
+  return { getPr, deletePr };
 }

package/host-cp/src/server.mjs

@@ -510,6 +510,9 @@ const prPoller = createPrMergePoller({
       WORLDS = next;
       persistRegistry();
     }
+    const prState = prStateStore.get(worldId);
+    if (prState?.pr_url) prCache.deletePr(prState.pr_url);
+    progressCache.delete(worldId);
   },
   pollIntervalMs: PR_POLL_INTERVAL_MS,
   gracePeriodMs: MERGE_GRACE_MS,
@@ -1366,6 +1369,9 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
       WORLDS = next;
       persistRegistry();
     }
+    const prStateForDelete = prStateStore.get(id);
+    if (prStateForDelete?.pr_url) prCache.deletePr(prStateForDelete.pr_url);
+    progressCache.delete(id);
     return jsonReply(res, 200, { worlds: WORLDS });
   }
 
@@ -1526,7 +1532,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
   if (url.pathname === '/api/repos' && req.method === 'GET') {
     const config = loadGlobalConfig();
     if ('error' in config) {
-      return jsonReply(res, 500, { error: config.error });
+      return jsonReply(res, 500, { error: config.error, message: config.error });
     }
     return jsonReply(res, 200, { repos: config.repos });
   }
@@ -1536,7 +1542,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
   if (url.pathname === '/api/runbooks' && req.method === 'GET') {
     const config = loadGlobalConfig();
     if ('error' in config) {
-      return jsonReply(res, 500, { error: config.error });
+      return jsonReply(res, 500, { error: config.error, message: config.error });
     }
     return jsonReply(res, 200, { runbooks: config.runbooks });
   }
@@ -1679,7 +1685,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
       const body = await readRequestBody(req);
       const provider = body && typeof body === 'object' && body.provider ? String(body.provider) : 'claude';
       const label = body && typeof body === 'object' && body.label ? String(body.label) : '';
-      if (!label) return jsonReply(res, 400, { error: 'label_required' });
+      if (!label) return jsonReply(res, 400, { error: 'label_required', message: 'label field is required' });
       const upstream = await authServiceFetch('POST', '/credentials/add', { provider, label });
       const data = await upstream.json();
       return jsonReply(res, upstream.status, data);
@@ -1996,9 +2002,9 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     req.on('data', (c) => { body += c; });
     req.on('end', () => {
       let parsed;
-      try { parsed = JSON.parse(body || '{}'); } catch { return jsonReply(res, 400, { error: 'invalid_json' }); }
+      try { parsed = JSON.parse(body || '{}'); } catch (e) { return jsonReply(res, 400, { error: 'invalid_json', message: e.message }); }
       const { worldId, prUrl, prNumber, prRepo } = parsed ?? {};
-      if (!worldId || !prUrl) return jsonReply(res, 400, { error: 'worldId and prUrl required' });
+      if (!worldId || !prUrl) return jsonReply(res, 400, { error: 'missing_fields', message: 'worldId and prUrl required' });
       prStateStore.set(worldId, {
         pr_url: prUrl,
         pr_number: prNumber ?? null,
@@ -2023,9 +2029,9 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     req.on('data', (c) => { body += c; });
     req.on('end', () => {
       let parsed;
-      try { parsed = JSON.parse(body || '{}'); } catch { return jsonReply(res, 400, { error: 'invalid_json' }); }
+      try { parsed = JSON.parse(body || '{}'); } catch (e) { return jsonReply(res, 400, { error: 'invalid_json', message: e.message }); }
       const existing = prStateStore.get(worldId);
-      if (!existing) return jsonReply(res, 404, { error: 'world not in PR state store' });
+      if (!existing) return jsonReply(res, 404, { error: 'not_found', message: 'world not in PR state store' });
       const updates = {};
       if (typeof parsed.autoDestroyOnMerge === 'boolean') updates.auto_destroy_on_merge = parsed.autoDestroyOnMerge;
       prStateStore.set(worldId, updates);
@@ -2108,7 +2114,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     const id = decodeURIComponent(planConvMatch[1]);
     try {
       const conv = planOrchestrator.getConversation(id);
-      if (!conv) return jsonReply(res, 404, { error: 'not_found', id });
+      if (!conv) return jsonReply(res, 404, { error: 'not_found', id, message: 'conversation not found' });
       // Return persisted turns alongside conversation metadata.
       const turns = planOrchestrator.getTurns(id);
       return jsonReply(res, 200, { ...conv, turns });
@@ -2128,7 +2134,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     const content = (body && typeof body === 'object' && typeof body.content === 'string')
       ? body.content.trim()
       : '';
-    if (!content) return jsonReply(res, 400, { error: 'content_required' });
+    if (!content) return jsonReply(res, 400, { error: 'content_required', message: 'turn content must be a non-empty string' });
     const personaOverride = (body && typeof body === 'object' && typeof body.personaOverride === 'string')
       ? body.personaOverride
       : undefined;
@@ -2139,7 +2145,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
       const result = await planOrchestrator.submitTurn({ conversationId, content, personaOverride, mentionedPersonas });
       return jsonReply(res, 202, result);
     } catch (err) {
-      if (err.code === 'NOT_FOUND') return jsonReply(res, 404, { error: 'not_found', id: conversationId });
+      if (err.code === 'NOT_FOUND') return jsonReply(res, 404, { error: 'not_found', id: conversationId, message: 'conversation not found' });
       return jsonReply(res, 500, { error: 'submit_failed', message: err.message });
     }
   }
@@ -2154,7 +2160,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     }
     const toPersona = body?.toPersona;
     if (typeof toPersona !== 'string' || !toPersona) {
-      return jsonReply(res, 400, { error: 'toPersona_required' });
+      return jsonReply(res, 400, { error: 'toPersona_required', message: 'toPersona field is required' });
     }
     const mode = ['full', 'distilled', 'quoted'].includes(body?.mode) ? body.mode : 'full';
     const selectedTurnIds = Array.isArray(body?.selectedTurnIds) ? body.selectedTurnIds : [];
@@ -2164,7 +2170,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
       });
       return jsonReply(res, 200, result);
     } catch (err) {
-      if (err.code === 'NOT_FOUND') return jsonReply(res, 404, { error: 'not_found', id: conversationId });
+      if (err.code === 'NOT_FOUND') return jsonReply(res, 404, { error: 'not_found', id: conversationId, message: 'conversation not found' });
       return jsonReply(res, 500, { error: 'handoff_failed', message: err.message });
     }
   }
@@ -2174,7 +2180,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     if (!await requirePlanCredential(res)) return;
     const conversationId = decodeURIComponent(planStreamMatch[1]);
     const conv = planOrchestrator.getConversation(conversationId);
-    if (!conv) return jsonReply(res, 404, { error: 'not_found', id: conversationId });
+    if (!conv) return jsonReply(res, 404, { error: 'not_found', id: conversationId, message: 'conversation not found' });
 
     res.writeHead(200, {
       'Content-Type': 'text/event-stream; charset=utf-8',
@@ -2214,7 +2220,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     const conversationId = decodeURIComponent(planAgentInviteMatch[1]);
     const personaId = decodeURIComponent(planAgentInviteMatch[2]);
     const conv = planOrchestrator.getConversation(conversationId);
-    if (!conv) return jsonReply(res, 404, { error: 'not_found', id: conversationId });
+    if (!conv) return jsonReply(res, 404, { error: 'not_found', id: conversationId, message: 'conversation not found' });
     const agent = planOrchestrator.inviteLookout(conversationId, personaId);
     return jsonReply(res, 200, agent);
   }
@@ -2232,7 +2238,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     if (typeof body?.muted === 'boolean') updates.muted = body.muted;
     if (typeof body?.mode === 'string') updates.mode = body.mode;
     const agent = planOrchestrator.updateLookout(conversationId, personaId, updates);
-    if (!agent) return jsonReply(res, 404, { error: 'not_found' });
+    if (!agent) return jsonReply(res, 404, { error: 'not_found', message: 'lookout agent not found' });
     return jsonReply(res, 200, agent);
   }
 
@@ -2253,7 +2259,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     const changed = action === 'dismiss'
       ? planOrchestrator.dismissSignal(conversationId, signalId)
       : planOrchestrator.useSignal(conversationId, signalId);
-    if (!changed) return jsonReply(res, 404, { error: 'not_found' });
+    if (!changed) return jsonReply(res, 404, { error: 'not_found', message: 'signal not found' });
     return jsonReply(res, 200, { ok: true });
   }
 
@@ -2717,7 +2723,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
   if (serversMatch && req.method === 'GET') {
     const worldId = decodeURIComponent(serversMatch[1]);
     if (!(worldId in WORLDS)) {
-      return jsonReply(res, 404, { error: 'unknown_world', worldId });
+      return jsonReply(res, 404, { error: 'unknown_world', worldId, message: 'world not in registry' });
     }
     return handleListServers(req, res, worldId);
   }
@@ -2727,7 +2733,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
     const worldId = decodeURIComponent(bridgesMatch[1]);
     const portSegment = bridgesMatch[3] ? parseInt(bridgesMatch[3], 10) : null;
     if (!(worldId in WORLDS)) {
-      return jsonReply(res, 404, { error: 'unknown_world', worldId });
+      return jsonReply(res, 404, { error: 'unknown_world', worldId, message: 'world not in registry' });
     }
     return handleServerBridges(req, res, worldId, portSegment);
   }
@@ -2798,7 +2804,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
   if (v1WorldsStatusMatch && req.method === 'GET') {
     const worldId = decodeURIComponent(v1WorldsStatusMatch[1]);
     if (!V1_WORLD_ID.test(worldId)) {
-      return jsonReply(res, 400, { error: 'invalid_world_id', worldId });
+      return jsonReply(res, 400, { error: 'invalid_world_id', worldId, message: 'worldId contains invalid characters' });
     }
     try {
       const report = await hostCpEngine.getWorldStatus(worldId);
@@ -2816,7 +2822,7 @@ const server = http.createServer(instrumentHandler('host-cp', async (req, res) =
   if (v1WorldsLogsMatch && req.method === 'GET') {
     const worldId = decodeURIComponent(v1WorldsLogsMatch[1]);
     if (!V1_WORLD_ID.test(worldId)) {
-      return jsonReply(res, 400, { error: 'invalid_world_id', worldId });
+      return jsonReply(res, 400, { error: 'invalid_world_id', worldId, message: 'worldId contains invalid characters' });
     }
     const tailParam = url.searchParams.get('tail');
     const followParam = url.searchParams.get('follow');
@@ -3466,6 +3472,7 @@ async function renderSpaShell(filePath, pathname) {
   // block comment above (Phase E5 cutover).
   void skipBootstrap; // wildcard invariant: always true; documents intent
   html = html.replace(/<head>/i, `<head>\n    ${bearerInjection}${cloudInjection}`);
+  if (_spaCacheByKey.size > 10) _spaCacheByKey.clear();
   _spaCacheByKey.set(cacheKey, html);
   return html;
 }
@@ -3660,6 +3667,15 @@ server.listen(PORT, '0.0.0.0', () => {
   } else if (AUTH_SERVICE_URL) {
     console.log(`  auth-service=${AUTH_SERVICE_URL} (X-Olam-Secret configured)`);
   }
+  // Warn when only one of the two cloud env vars is set — the most common
+  // misconfiguration that silently disables the Cloud toggle in the SPA.
+  const hasCloudUrl = Boolean(process.env.OLAM_CLOUD_URL);
+  const hasShowcasePw = Boolean(process.env.OLAM_SHOWCASE_PASSWORD);
+  if (hasCloudUrl && !hasShowcasePw) {
+    console.warn('  [cloud] OLAM_CLOUD_URL set but OLAM_SHOWCASE_PASSWORD missing — cloud_enabled will be false');
+  } else if (hasShowcasePw && !hasCloudUrl) {
+    console.warn('  [cloud] OLAM_SHOWCASE_PASSWORD set but OLAM_CLOUD_URL missing — cloud_enabled will be false');
+  }
 });
 
 // Graceful shutdown so docker compose down → SIGTERM → flush + close.

package/package.json

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