amalgm 0.1.246 → 0.1.247

package/runtime/scripts/amalgm-mcp/tests/registration.test.js

@@ -1,7 +1,7 @@
 'use strict';
 
 /**
- * The shared registration boundary (`amalgm add`) proving the composed
+ * The shared registration boundary (`amalgm register`) proving the composed
  * story the audits demanded: every enrolled root exposes symlink edges
  * regardless of its mutation adapter; watched ground is ALWAYS
  * registered ground (a followed target gets a tree, a root record, a
@@ -29,8 +29,14 @@ const { shouldEnroll: defaultPolicy } = require('../workspace/tree/inclusion');
 const { installFakeWatch } = require('./fake-watch');
 
 const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-registration-'));
+const rigs = [];
 
 test.after(() => {
+  for (const rig of rigs) {
+    rig.registration.stop();
+    rig.observer.stop();
+    rig.identityDb.close();
+  }
   fs.rmSync(tempRoot, { recursive: true, force: true });
 });
 
@@ -70,7 +76,7 @@ function makeRig(options = {}) {
     emit: (event) => events.push(event),
   });
   ref.current = boot();
-  return {
+  const rig = {
     observer,
     events,
     identityDb,
@@ -82,6 +88,8 @@ function makeRig(options = {}) {
       return ref.current;
     },
   };
+  rigs.push(rig);
+  return rig;
 }
 
 const committedSince = (events, from) => events.slice(from)
@@ -257,7 +265,7 @@ test('chains resolve like the OS resolves: to the final real ground, in-tree and
     'intermediate ground was traversed, never registered: no edge named it as an endpoint');
 });
 
-test('repo-contained targets resolve to the owning entity: the card\'s record answers for its insides', () => {
+test('repo-contained targets resolve to their registered child entities', () => {
   const rig = makeRig();
   const repo = makeDir('territory');
   gitInit(repo);
@@ -270,11 +278,11 @@ test('repo-contained targets resolve to the owning entity: the card\'s record an
   const { record: wsRoot } = rig.registration.add(ws);
   assert.equal(repoRoot.type, 'repo.git');
   const link = rig.registration.tree(ws).registry.activeAt(wsRoot.uuid, 'docs');
-  assert.equal(rig.registration.linkTargets().get(link.uuid), repoRoot.uuid,
-    'the repo is the owning sync entity, so its UUID answers for every address inside it — never a null that pretends no owner exists');
+  const docs = rig.registration.tree(repo).registry.activeAt(repoRoot.uuid, 'docs');
+  assert.equal(rig.registration.linkTargets().get(link.uuid), docs.uuid,
+    'a repo boundary changes realtime semantics, not the child identity map');
 
-  // A nested territory answers the same way: the repo.git record on the
-  // way down the tree owns everything beneath it.
+  // A nested boundary also preserves its registered descendants.
   const rig2 = makeRig();
   const ws2 = makeDir('territory-outer');
   const nested = path.join(ws2, 'vendor');
@@ -289,8 +297,9 @@ test('repo-contained targets resolve to the owning entity: the card\'s record an
   const nestedRecord = rig2.registration.tree(ws2).registry.activeAt(outerRoot.uuid, 'vendor');
   assert.equal(nestedRecord.type, 'repo.git');
   const link2 = rig2.registration.tree(other).registry.activeAt(otherRoot.uuid, 'lib');
-  assert.equal(rig2.registration.linkTargets().get(link2.uuid), nestedRecord.uuid,
-    'a nested boundary\'s record owns its subtree');
+  const nestedLib = rig2.registration.tree(ws2).registry.activeAt(nestedRecord.uuid, 'lib');
+  assert.equal(rig2.registration.linkTargets().get(link2.uuid), nestedLib.uuid,
+    'a nested repo uses its Card for realtime while its children remain addressable');
 });
 
 // --- the four permanent exams of the second audit --------------------------
@@ -891,7 +900,7 @@ test('add is one operation: a bare file registers, covered ground returns its tr
   fs.writeFileSync(filePath, 't');
 
   const solo = rig.registration.add(filePath);
-  assert.equal(solo.record.type, 'file.text', '`amalgm add <file>` is the same primitive: a tree of one');
+  assert.equal(solo.record.type, 'file.text', '`amalgm register <file>` is the same primitive: a tree of one');
 
   const added = rig.registration.add(ws);
   const again = rig.registration.add(path.join(ws, 'a.md'));
@@ -902,6 +911,32 @@ test('add is one operation: a bare file registers, covered ground returns its tr
     'ground that would swallow a registered root refuses loudly');
 });
 
+test('add never claims success when a required watcher cannot open', () => {
+  const dir = makeDir('degraded-add');
+  const observer = createObserver({
+    db: new Database(':memory:'),
+    emit: () => {},
+    shouldEnroll: () => true,
+    watch: () => ({ degraded: true, close: () => {} }),
+  });
+  const identityDb = new Database(':memory:');
+  const registration = createRegistration({
+    observer,
+    openIdentity: () => ({ db: identityDb, ephemeral: true }),
+    classify: () => 'file.text',
+  });
+  try {
+    assert.throws(() => registration.add(dir), /could not start required watcher/,
+      'a registered tree with no live doorbell is an incomplete add, never a success');
+    assert.ok(registration.tree(dir)?.root(),
+      'identity remains durable for a later explicit retry; add only refuses to lie about Watch');
+  } finally {
+    registration.stop();
+    observer.stop();
+    identityDb.close();
+  }
+});
+
 test('the would-swallow edge refusal is visible on the boundary, never silent', () => {
   const rig = makeRig();
   const holder = makeDir('report-holder');

package/runtime/scripts/amalgm-mcp/tests/workspace-materialize.test.js

@@ -0,0 +1,54 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const test = require('node:test');
+const { _private } = require('../workspace/materialize');
+
+test('materializer keeps workspace-tree and code-project identities separate', () => {
+  assert.deepEqual(_private.normalizeRequest({
+    name: 'Shared notes',
+    materializer: {
+      kind: 'workspace-tree',
+      workspaceId: '9a637701-8125-4e32-8454-e89973f60632',
+    },
+  }), {
+    kind: 'workspace-tree',
+    resourceId: '9a637701-8125-4e32-8454-e89973f60632',
+    workspaceId: '9a637701-8125-4e32-8454-e89973f60632',
+    name: 'Shared notes',
+  });
+
+  assert.equal(_private.normalizeRequest({
+    materializer: {
+      kind: 'code-project',
+      resourceId: 'shr_1234567890abcdef',
+    },
+  }).kind, 'code-project');
+});
+
+test('code-project identity is read from the attached wall, not trusted from a client path', () => {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'amalgm-materialize-'));
+  const wallFile = path.join(dir, 'wall.jsonl');
+  fs.writeFileSync(wallFile, [
+    '{"wall":"code-project@3","project":"repo-key","machine":"peer","cards":[]}',
+    '{"partial":',
+  ].join('\n'));
+  assert.equal(_private.repoKeyFromWallFile(wallFile), 'repo-key');
+  fs.rmSync(dir, { recursive: true, force: true });
+});
+
+test('materializer rejects client-supplied kinds and malformed resource ids', () => {
+  assert.throws(
+    () => _private.normalizeRequest({ materializer: { kind: 'filesystem', path: '/tmp' } }),
+    /unsupported workspace materializer/,
+  );
+  assert.throws(
+    () => _private.normalizeRequest({
+      materializer: { kind: 'code-project', resourceId: 'invite-secret' },
+    }),
+    /opaque shared id/,
+  );
+});

package/runtime/scripts/amalgm-mcp/workspace/materialize.js

@@ -0,0 +1,292 @@
+'use strict';
+
+/**
+ * The one local materialization boundary used before an agent contract freezes
+ * its cwd. Workspace trees and code projects deliberately keep their existing,
+ * separate replication machinery; this module only waits for either one to
+ * produce a usable folder.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+const SHARED_ID = /^shr_[A-Za-z0-9_-]{16,128}$/;
+const DEFAULT_TIMEOUT_MS = 60_000;
+const POLL_MS = 250;
+
+function invalid(message, statusCode = 400, code = 'workspace_materialization_invalid') {
+  return Object.assign(new Error(message), { statusCode, code });
+}
+
+function sanitizeName(value, fallback) {
+  return String(value || fallback)
+    .trim()
+    .replace(/[\/\\:\0]/g, '-')
+    .replace(/^\.+$/, fallback)
+    .replace(/^\.+/, '')
+    .slice(0, 120) || fallback;
+}
+
+function normalizeRequest(input) {
+  const materializer = input?.materializer;
+  if (!materializer || typeof materializer !== 'object') {
+    throw invalid('materializer is required');
+  }
+  if (materializer.kind === 'workspace-tree') {
+    const workspaceId = String(materializer.workspaceId || input?.workspaceId || '').toLowerCase();
+    if (!UUID.test(workspaceId)) throw invalid('workspaceId must be a UUID');
+    return {
+      kind: 'workspace-tree',
+      resourceId: workspaceId,
+      workspaceId,
+      name: sanitizeName(input?.name, 'Shared workspace'),
+    };
+  }
+  if (materializer.kind === 'code-project') {
+    const resourceId = String(materializer.resourceId || input?.resourceId || '');
+    if (!SHARED_ID.test(resourceId)) {
+      throw invalid('code project resourceId must be an opaque shared id');
+    }
+    return {
+      kind: 'code-project',
+      resourceId,
+      name: sanitizeName(input?.name, 'Shared code project'),
+    };
+  }
+  throw invalid('unsupported workspace materializer');
+}
+
+function delay(ms) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, ms);
+    timer.unref?.();
+  });
+}
+
+function callRest(handler, body) {
+  return new Promise((resolve, reject) => {
+    Promise.resolve(handler(body, (status, payload) => {
+      if (status >= 400) {
+        reject(invalid(
+          payload?.error || `workspace materialization failed with ${status}`,
+          status,
+          payload?.code || 'workspace_materialization_failed',
+        ));
+      } else {
+        resolve(payload);
+      }
+    })).catch(reject);
+  });
+}
+
+function isInside(root, candidate) {
+  const relative = path.relative(root, candidate);
+  return relative === '' || (
+    relative
+    && !relative.startsWith('..')
+    && !path.isAbsolute(relative)
+  );
+}
+
+function incompleteContentAttachments(rootPath) {
+  const rows = require('../state/db').openLocalDb()
+    .prepare(`
+      SELECT resource_id, local_path, attachment_state, last_error
+      FROM shared_resource_attachments
+    `)
+    .all();
+  return rows.filter((row) => (
+    row.local_path !== rootPath
+    && isInside(rootPath, row.local_path)
+    && row.attachment_state !== 'attached'
+  ));
+}
+
+async function waitForTree(resourceId, timeoutMs) {
+  const replicas = require('../state/replicas');
+  const attachments = require('../state/attachments');
+  const deadline = Date.now() + timeoutMs;
+
+  while (Date.now() < deadline) {
+    const replica = replicas.getReplicaByResourceId(resourceId);
+    const rootAttachment = attachments.getAttachmentByResource(resourceId);
+    if (rootAttachment?.state === 'rejected') {
+      throw invalid(
+        rootAttachment.lastError || 'Cloud workspace attachment was rejected.',
+        409,
+        'workspace_materialization_rejected',
+      );
+    }
+    if (replica?.accessStatus === 'revoked') {
+      throw invalid(
+        'Access to this cloud workspace was removed.',
+        403,
+        'workspace_materialization_revoked',
+      );
+    }
+    if (replica?.localPath && fs.existsSync(replica.localPath)) {
+      const content = incompleteContentAttachments(replica.localPath);
+      const rejected = content.find((row) => row.attachment_state === 'rejected');
+      if (rejected) {
+        throw invalid(
+          rejected.last_error || 'A cloud workspace file could not be downloaded.',
+          409,
+          'workspace_content_materialization_rejected',
+        );
+      }
+      if (content.length === 0) return replica;
+    }
+    await delay(POLL_MS);
+  }
+  throw invalid(
+    'Cloud workspace is still downloading. Try again in a moment.',
+    504,
+    'workspace_materialization_timeout',
+  );
+}
+
+async function chooseCodeProjectPath(name) {
+  const root = require('./rest').getWorkspaceRoot();
+  await fs.promises.mkdir(root, { recursive: true });
+  const base = sanitizeName(name, 'Shared code project');
+  let candidate = path.join(root, base);
+  let suffix = 2;
+  while (fs.existsSync(candidate)) {
+    candidate = path.join(root, `${base}-${suffix}`);
+    suffix += 1;
+  }
+  return candidate;
+}
+
+async function ensureCodeWallAttached(resourceId, timeoutMs) {
+  const wall = require('./wall');
+  const replicas = require('../state/replicas');
+  const attachments = require('../state/attachments');
+  const filePath = wall.projectFile(resourceId);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  if (!fs.existsSync(filePath)) fs.writeFileSync(filePath, '');
+
+  let request = attachments.getAttachmentByResource(resourceId);
+  if (!replicas.getReplicaByResourceId(resourceId) && !request) {
+    await callRest(require('../state/shared-rest').handleAttachmentStart, {
+      resourceId,
+      path: filePath,
+    });
+    request = attachments.getAttachmentByResource(resourceId);
+  }
+
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const replica = replicas.getReplicaByResourceId(resourceId);
+    if (replica) return filePath;
+    request = attachments.getAttachmentByResource(resourceId);
+    if (request?.state === 'rejected') {
+      throw invalid(
+        request.lastError || 'Code project attachment was rejected.',
+        409,
+        'code_project_materialization_rejected',
+      );
+    }
+    await delay(POLL_MS);
+  }
+  throw invalid(
+    'Code project is still downloading. Try again in a moment.',
+    504,
+    'code_project_materialization_timeout',
+  );
+}
+
+function repoKeyFromWallFile(filePath) {
+  const text = fs.readFileSync(filePath, 'utf8');
+  for (const line of text.split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const entry = JSON.parse(line);
+      if (
+        typeof entry?.project === 'string'
+        && entry.project.trim()
+        && String(entry.wall || '').startsWith('code-project@')
+      ) return entry.project.trim();
+    } catch {
+      // A trailing partial JSONL line is expected while an update is folding.
+    }
+  }
+  return null;
+}
+
+async function waitForCodeProject(repoKey, targetPath, timeoutMs) {
+  const reducer = require('./reducer');
+  const deadline = Date.now() + timeoutMs;
+  let lastReason = null;
+  while (Date.now() < deadline) {
+    await reducer.reduceNow();
+    const state = reducer.reducerStats().repos.find((repo) => repo.repoKey === repoKey);
+    lastReason = state?.reason || state?.state || lastReason;
+    if (
+      fs.existsSync(targetPath)
+      && ['hydrated', 'in-sync', 'conflict'].includes(state?.state)
+    ) return state;
+    await delay(POLL_MS);
+  }
+  throw invalid(
+    `Code project could not become ready${lastReason ? `: ${lastReason}` : ''}.`,
+    504,
+    'code_project_materialization_timeout',
+  );
+}
+
+async function materializeWorkspace(input, options = {}) {
+  const request = normalizeRequest(input);
+  const timeoutMs = Math.max(1_000, Number(options.timeoutMs) || DEFAULT_TIMEOUT_MS);
+  const deadline = Date.now() + timeoutMs;
+  const remaining = () => Math.max(1_000, deadline - Date.now());
+
+  if (request.kind === 'workspace-tree') {
+    await callRest(require('./rest').handleCloudWorkspaceAttachment, {
+      workspaceId: request.workspaceId,
+      name: request.name,
+    });
+    const replica = await waitForTree(request.resourceId, remaining());
+    return {
+      state: 'ready',
+      kind: request.kind,
+      resourceId: request.resourceId,
+      cwd: replica.localPath,
+    };
+  }
+
+  const wallFile = await ensureCodeWallAttached(request.resourceId, remaining());
+  const repoKey = repoKeyFromWallFile(wallFile);
+  if (!repoKey) {
+    throw invalid(
+      'Code project metadata is not available yet.',
+      409,
+      'code_project_identity_missing',
+    );
+  }
+  const wall = require('./wall');
+  const existing = wall.projectForRepo(repoKey);
+  const targetPath = existing?.path || await chooseCodeProjectPath(request.name);
+  wall.startWallService();
+  require('./reducer').startWorkspaceReducer();
+  wall.bindProject(repoKey, request.resourceId, null, targetPath);
+  await waitForCodeProject(repoKey, targetPath, remaining());
+  return {
+    state: 'ready',
+    kind: request.kind,
+    resourceId: request.resourceId,
+    repoKey,
+    cwd: targetPath,
+  };
+}
+
+module.exports = {
+  materializeWorkspace,
+  _private: {
+    isInside,
+    normalizeRequest,
+    repoKeyFromWallFile,
+    sanitizeName,
+  },
+};

package/runtime/scripts/chat-core/contract.js

@@ -489,9 +489,24 @@ function resolveCwd(rawCwd, options = {}) {
     || existingDirectory(safeProcessCwd())
     || os.homedir();
   const expanded = expandHome(rawCwd);
-  if (!expanded) return fallback;
+  if (!expanded) {
+    if (options.requireCwd) {
+      throw Object.assign(
+        new Error('Cloud workspace folder is unavailable.'),
+        { code: 'workspace_cwd_unavailable', status: 409 },
+      );
+    }
+    return fallback;
+  }
   const absolute = path.isAbsolute(expanded) ? expanded : path.resolve(fallback, expanded);
-  return existingDirectory(canonicalProjectPath(absolute)) || fallback;
+  const resolved = existingDirectory(canonicalProjectPath(absolute));
+  if (!resolved && options.requireCwd) {
+    throw Object.assign(
+      new Error('Cloud workspace folder is unavailable.'),
+      { code: 'workspace_cwd_unavailable', status: 409 },
+    );
+  }
+  return resolved || fallback;
 }
 
 function nullableString(value) {
@@ -565,7 +580,10 @@ function createContract(payload, options = {}) {
   const reasoningEffort = payload.reasoningEffort || null;
   const fastMode = payload.fastMode === true;
   const cliModel = cliModelFor({ harness, modelId, cliModel: payload.cliModel, reasoningEffort });
-  const cwd = resolveCwd(payload.cwd, options);
+  const cwd = resolveCwd(payload.cwd, {
+    ...options,
+    requireCwd: Boolean(payload.cloudWorkspaceRef),
+  });
   const localBaseUrl = options.localBaseUrl || `http://127.0.0.1:${options.port || runtimePort('chat-server')}`;
   const origin = normalizeOrigin({ ...payload, cwd });
   const userId = payload.userId || options.userId || 'unknown-user';

package/runtime/scripts/chat-core/engine.js

@@ -143,6 +143,14 @@ class ChatCore {
     const onTurnStart = typeof options.onTurnStart === 'function' ? options.onTurnStart : null;
     const sessionId = payload.codeSessionId || payload.sessionId;
     if (sessionId) await this.finalizeActiveTurn(sessionId);
+    const frozenContract = sessionId ? this.contracts.get(sessionId) : null;
+    if (!frozenContract && typeof this.options.prepareWorkspace === 'function') {
+      payload = await this.options.prepareWorkspace(payload);
+    } else if (frozenContract && payload.cloudWorkspaceRef) {
+      // A warm session already owns a frozen cwd. Do not materialize a second
+      // workspace only for contractFor() to discard it as a changed field.
+      payload = { ...payload, cwd: frozenContract.cwd };
+    }
     const contract = this.contractFor(payload);
     await this.beginTurn(contract);
     const input = normalizeInput(payload);

package/runtime/scripts/chat-core/server.js

@@ -16,6 +16,7 @@ const { writeChatStream, writeRawTempStream } = require('./streams');
 const { TurnStore } = require('./stores');
 const { resolveMachineChatPayload } = require('./chat-payload');
 const { authorizeRuntimeHttp } = require('../runtime-auth');
+const { materializePayloadWorkspace } = require('./workspace-preflight');
 
 function readBody(req) {
   return new Promise((resolve, reject) => {
@@ -67,7 +68,16 @@ function createCore(options = {}) {
       pi: () => new PiAdapter(),
     },
   });
-  return new ChatCore({ db, runtime, turns, options: { ...options, port: PORT } });
+  return new ChatCore({
+    db,
+    runtime,
+    turns,
+    options: {
+      ...options,
+      prepareWorkspace: options.prepareWorkspace || materializePayloadWorkspace,
+      port: PORT,
+    },
+  });
 }
 
 function createServer(core = createCore()) {

package/runtime/scripts/chat-core/tests/workspace-preflight.test.js

@@ -0,0 +1,116 @@
+'use strict';
+
+const assert = require('node:assert/strict');
+const test = require('node:test');
+const { createContract } = require('../contract');
+const { ChatCore } = require('../engine');
+const { done } = require('../events');
+const { TurnStore } = require('../stores');
+const { materializePayloadWorkspace } = require('../workspace-preflight');
+
+function contractPayload(overrides = {}) {
+  return {
+    codeSessionId: 'session-cloud',
+    assistantMessageId: 'assistant-cloud',
+    userId: 'user-cloud',
+    agentId: 'codex',
+    authMethod: 'amalgm',
+    modelId: 'openai/gpt-5.5',
+    ...overrides,
+  };
+}
+
+test('workspace preflight replaces cwd before contract creation', async () => {
+  const statuses = [];
+  const payload = await materializePayloadWorkspace(contractPayload({
+    cwd: '/path/that/does/not/exist',
+    cloudWorkspaceRef: {
+      resourceId: '9a637701-8125-4e32-8454-e89973f60632',
+      kind: 'workspace',
+      materializer: {
+        kind: 'workspace-tree',
+        workspaceId: '9a637701-8125-4e32-8454-e89973f60632',
+      },
+    },
+  }), {
+    onStatus: (status) => statuses.push(status.phase),
+    request: async () => ({ cwd: process.cwd() }),
+  });
+
+  assert.equal(payload.cwd, process.cwd());
+  assert.deepEqual(statuses, ['hydrating', 'ready']);
+  assert.equal(createContract(payload).cwd, process.cwd());
+});
+
+test('workspace-bound contracts never substitute home for a missing cwd', () => {
+  assert.throws(
+    () => createContract(contractPayload({
+      cwd: '/path/that/does/not/exist',
+      cloudWorkspaceRef: {
+        resourceId: '9a637701-8125-4e32-8454-e89973f60632',
+        materializer: {
+          kind: 'workspace-tree',
+          workspaceId: '9a637701-8125-4e32-8454-e89973f60632',
+        },
+      },
+    })),
+    (error) => error?.code === 'workspace_cwd_unavailable' && error?.status === 409,
+  );
+});
+
+test('chat core preflights once, before billing and before the first runtime spawn', async () => {
+  const order = [];
+  const core = new ChatCore({
+    db: {
+      saveUserMessage: async () => true,
+      ensureAssistantMessage: async () => true,
+      saveAssistantMessage: async () => true,
+      mergeSessionMetadata: async () => {},
+      logUsage: async () => {},
+    },
+    runtime: {
+      get: () => null,
+      stop: async () => {},
+      destroy: async () => true,
+      async *prompt(contract) {
+        order.push(`runtime:${contract.cwd}`);
+        yield done();
+      },
+    },
+    turns: new TurnStore(),
+    options: {
+      prepareWorkspace: async (payload) => {
+        order.push('preflight');
+        return { ...payload, cwd: process.cwd() };
+      },
+      beginTurn: async () => {
+        order.push('billing');
+      },
+    },
+  });
+  const cloudRef = {
+    resourceId: '9a637701-8125-4e32-8454-e89973f60632',
+    materializer: {
+      kind: 'workspace-tree',
+      workspaceId: '9a637701-8125-4e32-8454-e89973f60632',
+    },
+  };
+
+  await core.runTurn(contractPayload({
+    prompt: 'first',
+    cloudWorkspaceRef: cloudRef,
+  }));
+  await core.runTurn(contractPayload({
+    assistantMessageId: 'assistant-cloud-2',
+    prompt: 'second',
+    cloudWorkspaceRef: cloudRef,
+  }));
+
+  assert.deepEqual(order, [
+    'preflight',
+    'billing',
+    `runtime:${process.cwd()}`,
+    'billing',
+    `runtime:${process.cwd()}`,
+  ]);
+});