@ghl-ai/aw 0.1.37-beta.8 → 0.1.37

package/slack-sim/http.mjs

@@ -0,0 +1,170 @@
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export async function createHttpTransport(opts = {}) {
+  let pg;
+  try {
+    ({ default: pg } = await import('pg'));
+  } catch {
+    throw new Error('HTTP mode requires the `pg` package in this repo environment');
+  }
+  const apiBase = (opts.apiBase || 'http://localhost:3100/agentic-workspace/api').replace(/\/$/, '');
+  const headers = {
+    'content-type': 'application/json',
+    ...(opts.orgId ? { 'x-org-id': opts.orgId } : {}),
+    ...(opts.teamId ? { 'x-team-id': opts.teamId } : {}),
+    ...(process.env.API_KEY ? { 'x-api-key': process.env.API_KEY } : {}),
+  };
+
+  const pool = new pg.Pool({
+    host: process.env.PGHOST ?? 'localhost',
+    port: parseInt(process.env.PGPORT ?? '5433', 10),
+    user: process.env.PGUSER ?? 'ghl_ai',
+    ...(process.env.PGPASSWORD ? { password: process.env.PGPASSWORD } : {}),
+    database: process.env.PGDATABASE ?? 'ghl_ai_orchestrator',
+  });
+
+  async function post(path, body) {
+    const res = await fetch(`${apiBase}${path}`, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(body),
+    });
+    const text = await res.text();
+    return { status: res.status, body: text ? JSON.parse(text) : {} };
+  }
+
+  async function get(path) {
+    const res = await fetch(`${apiBase}${path}`, { headers });
+    const text = await res.text();
+    return { status: res.status, body: text ? JSON.parse(text) : {} };
+  }
+
+  async function runAction(action, scenario) {
+    const channel = action.channel || scenario.defaults.channel;
+    const user = action.user || scenario.defaults.user;
+    const ts = action.ts || `${Date.now()}.001`;
+    const threadTs = action.threadTs || action.thread_ts || scenario.defaults.threadTs;
+
+    switch (action.type) {
+      case 'app_mention_top_level':
+        await post('/slack/events', {
+          type: 'event_callback',
+          event_id: action.eventId || `evt-${ts}`,
+          event: { type: 'app_mention', channel, user, text: action.text, ts, event_ts: ts, files: action.files },
+        });
+        return { channel, threadTs: ts, ts };
+      case 'app_mention_thread':
+        await post('/slack/events', {
+          type: 'event_callback',
+          event_id: action.eventId || `evt-${ts}`,
+          event: { type: 'app_mention', channel, user, text: action.text, ts, thread_ts: threadTs, event_ts: ts, files: action.files },
+        });
+        return { channel, threadTs, ts };
+      case 'message_thread_untagged':
+        await post('/slack/events', {
+          type: 'event_callback',
+          event_id: action.eventId || `evt-${ts}`,
+          event: { type: 'message', channel, user, text: action.text, ts, thread_ts: threadTs, event_ts: ts, files: action.files },
+        });
+        return { channel, threadTs, ts };
+      case 'dispatch_confirm':
+        if (!action.value) throw new Error('HTTP mode dispatch_confirm requires action.value');
+        await post('/slack/interact', {
+          payload: JSON.stringify({
+            type: 'block_actions',
+            user: { id: user },
+            channel: { id: channel },
+            message: { ts: action.messageTs || threadTs, thread_ts: threadTs },
+            container: { channel_id: channel, message_ts: action.messageTs || threadTs },
+            actions: [{ action_id: 'dispatch_confirm', value: action.value }],
+            state: {
+              values: {
+                dispatch_resource: { dispatch_resource: { selected_option: { value: action.resource || 'ship-lfg' } } },
+                dispatch_repo: { dispatch_repo: { selected_option: action.repo ? { value: action.repo } : undefined } },
+              },
+            },
+          }),
+        });
+        return { channel, threadTs, ts };
+      case 'button_click':
+        if (!action.value) {
+          const state = await getState({ channel, threadTs });
+          if (action.actionId === 'approve_plan' && state.backendRef) {
+            action.value = JSON.stringify({ agentId: state.backendRef });
+          } else {
+            throw new Error('HTTP mode button_click requires action.value (or a resolvable backendRef for approve_plan)');
+          }
+        }
+        await post('/slack/interact', {
+          payload: JSON.stringify({
+            type: 'block_actions',
+            user: { id: user },
+            channel: { id: channel },
+            message: { ts: action.messageTs || threadTs, thread_ts: threadTs },
+            container: { channel_id: channel, message_ts: action.messageTs || threadTs },
+            actions: [{ action_id: action.actionId, value: action.value }],
+          }),
+        });
+        return { channel, threadTs, ts };
+      case 'cursor_webhook': {
+        const state = await getState({ channel, threadTs });
+        await post('/slack/cursor-webhook', {
+          id: action.agentId || state.backendRef,
+          status: action.status,
+          summary: action.summary,
+          source: action.source,
+          target: action.target,
+          linesAdded: action.linesAdded,
+          linesRemoved: action.linesRemoved,
+          filesChanged: action.filesChanged,
+        });
+        return { channel, threadTs, ts };
+      }
+      case 'wait':
+        await sleep(action.ms || 1000);
+        return { channel, threadTs, ts };
+      case 'assert':
+        return { channel, threadTs, ts };
+      default:
+        throw new Error(`Unsupported action type in HTTP mode: ${action.type}`);
+    }
+  }
+
+  async function getState({ channel, threadTs }) {
+    const latest = await get('/dispatch/latest').then((r) => r.body).catch(() => null);
+    const dbRow = await pool.query(
+      `SELECT st.thread_ts, cr.id AS command_run_id, cr.backend_ref, cr.status, cr.output
+       FROM slack_threads st
+       JOIN command_runs cr ON cr.id = st.command_run_id
+       WHERE st.channel_id = $1 AND st.thread_ts = $2
+       ORDER BY st.created_at DESC
+       LIMIT 1`,
+      [channel, threadTs],
+    ).catch(() => ({ rows: [] }));
+    const row = dbRow.rows?.[0] || latest;
+    return {
+      channel,
+      threadTs,
+      commandRunId: row?.command_run_id || row?.id || null,
+      backendRef: row?.backend_ref || null,
+      status: row?.status || null,
+      checkpointActive: Boolean(row?.output?.checkpoint?.active),
+      prRole: row?.output?.slackPrPresentation?.prRole || null,
+      prUrl: row?.output?.slackPrPresentation?.primaryPrUrl || null,
+      branch: row?.output?.slackPrPresentation?.branch || null,
+      pollerActive: undefined,
+      messages: [],
+      messagesUnavailable: true,
+    };
+  }
+
+  return {
+    mode: 'http',
+    start: async () => {},
+    close: async () => { await pool.end(); },
+    runAction,
+    getState,
+  };
+}

package/slack-sim/in-process.mjs

@@ -0,0 +1,263 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+import { createRequire } from 'node:module';
+import { FakeSlackClient } from './fake-slack.mjs';
+
+const require = createRequire(import.meta.url);
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function findRepoRoot(start = process.cwd()) {
+  let dir = start;
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, 'apps/api/src/app.module.ts')) && existsSync(join(dir, 'package.json'))) {
+      return dir;
+    }
+    dir = dirname(dir);
+  }
+  throw new Error('Could not find repo root containing apps/api/src/app.module.ts');
+}
+
+export async function createInProcessTransport(opts = {}) {
+  const repoRoot = findRepoRoot(opts.repoRoot);
+  try {
+    require('ts-node/register/transpile-only');
+    require('tsconfig-paths/register');
+  } catch {
+    throw new Error('In-process mode requires local repo dev dependencies: ts-node and tsconfig-paths');
+  }
+  const { runWithRequestSession } = require(join(repoRoot, 'apps/api/src/config/request-session.context.ts'));
+  const { NestFactory } = require('@nestjs/core');
+  const { AppModule } = require(join(repoRoot, 'apps/api/src/app.module.ts'));
+  const { SlackController } = require(join(repoRoot, 'apps/api/src/slack/slack.controller.ts'));
+  const { SlackWebhookController } = require(join(repoRoot, 'apps/api/src/slack/slack-webhook.controller.ts'));
+  const { SlackService } = require(join(repoRoot, 'apps/api/src/slack/slack.service.ts'));
+  const { DatabaseService } = require(join(repoRoot, 'apps/api/src/database/database.service.ts'));
+
+  const app = await NestFactory.createApplicationContext(AppModule, { logger: false });
+  const slackController = app.get(SlackController);
+  const webhookController = app.get(SlackWebhookController);
+  const slackService = app.get(SlackService);
+  const db = app.get(DatabaseService);
+  const fakeSlack = new FakeSlackClient();
+
+  slackService.slack = fakeSlack;
+  slackService.botUserId = fakeSlack.botUserId;
+  slackService.botBotId = fakeSlack.botBotId;
+  slackController.botUserId = fakeSlack.botUserId;
+
+  async function withSession(session, fn) {
+    return await runWithRequestSession(session, fn);
+  }
+
+  async function settle() {
+    await sleep(5);
+    await new Promise((resolve) => setImmediate(resolve));
+    await sleep(5);
+  }
+
+  function makeFiles(files = []) {
+    return files.map((file, index) => ({
+      id: file.id || `F_SIM_${index + 1}`,
+      name: file.name,
+      title: file.title,
+      filetype: file.filetype,
+      mimetype: file.mimetype,
+      original_w: file.width || file.original_w,
+      original_h: file.height || file.original_h,
+      contentBase64: file.contentBase64 || file.data,
+      plain_text: file.plain_text,
+      preview: file.preview,
+    }));
+  }
+
+  async function runAction(action, scenario) {
+    const channel = action.channel || scenario.defaults.channel;
+    const user = action.user || scenario.defaults.user;
+    const ts = action.ts || fakeSlack.nextTs();
+    const threadTs = action.threadTs || action.thread_ts || scenario.defaults.threadTs;
+    const files = makeFiles(action.files || []);
+    const session = scenario.session;
+
+    switch (action.type) {
+      case 'app_mention_top_level': {
+        fakeSlack.addIncomingMessage({ channel, user, text: action.text, ts, files });
+        await withSession(session, () => slackController.handleEvent({
+          body: {
+            type: 'event_callback',
+            event_id: action.eventId || `evt-${ts}`,
+            event: {
+              type: 'app_mention',
+              channel,
+              user,
+              text: action.text,
+              ts,
+              event_ts: ts,
+              files,
+            },
+          },
+        }));
+        await settle();
+        return { channel, threadTs: ts, ts };
+      }
+      case 'app_mention_thread': {
+        const rootTs = threadTs;
+        if (!fakeSlack.findMessage(channel, rootTs)) {
+          fakeSlack.addIncomingMessage({ channel, user: action.rootUser || user, text: action.rootText || 'thread root', ts: rootTs });
+        }
+        fakeSlack.addIncomingMessage({ channel, user, text: action.text, ts, thread_ts: rootTs, files });
+        await withSession(session, () => slackController.handleEvent({
+          body: {
+            type: 'event_callback',
+            event_id: action.eventId || `evt-${ts}`,
+            event: {
+              type: 'app_mention',
+              channel,
+              user,
+              text: action.text,
+              ts,
+              thread_ts: rootTs,
+              event_ts: ts,
+              files,
+            },
+          },
+        }));
+        await settle();
+        return { channel, threadTs: rootTs, ts };
+      }
+      case 'message_thread_untagged': {
+        const rootTs = threadTs;
+        if (!fakeSlack.findMessage(channel, rootTs)) {
+          fakeSlack.addIncomingMessage({ channel, user: action.rootUser || user, text: action.rootText || 'thread root', ts: rootTs });
+        }
+        fakeSlack.addIncomingMessage({ channel, user, text: action.text, ts, thread_ts: rootTs, files });
+        await withSession(session, () => slackController.handleEvent({
+          body: {
+            type: 'event_callback',
+            event_id: action.eventId || `evt-${ts}`,
+            event: {
+              type: 'message',
+              channel,
+              user,
+              text: action.text,
+              ts,
+              thread_ts: rootTs,
+              event_ts: ts,
+              files,
+            },
+          },
+        }));
+        await settle();
+        return { channel, threadTs: rootTs, ts };
+      }
+      case 'dispatch_confirm': {
+        const rootTs = threadTs;
+        const last = fakeSlack.findLastBotMessageWithAction(channel, rootTs, 'dispatch_confirm');
+        if (!last) throw new Error('No dispatch_confirm button found in thread');
+        const payload = {
+          type: 'block_actions',
+          user: { id: user },
+          channel: { id: channel },
+          message: { ts: last.message.ts, thread_ts: rootTs },
+          container: { channel_id: channel, message_ts: last.message.ts },
+          actions: [{ action_id: 'dispatch_confirm', value: last.action.value }],
+          state: {
+            values: {
+              dispatch_resource: { dispatch_resource: { selected_option: { value: action.resource || 'ship-lfg' } } },
+              dispatch_repo: { dispatch_repo: { selected_option: action.repo ? { value: action.repo } : undefined } },
+            },
+          },
+        };
+        await withSession(session, () => slackController.handleInteract({ body: { payload: JSON.stringify(payload) } }));
+        await settle();
+        return { channel, threadTs: rootTs, ts: last.message.ts };
+      }
+      case 'button_click': {
+        const rootTs = threadTs;
+        const target = fakeSlack.findLastBotMessageWithAction(channel, rootTs, action.actionId);
+        const value = action.value || target?.action?.value || '{}';
+        const msgTs = target?.message?.ts || action.messageTs || rootTs;
+        await withSession(session, () => slackController.handleInteract({
+          body: {
+            payload: JSON.stringify({
+              type: 'block_actions',
+              user: { id: user },
+              channel: { id: channel },
+              message: { ts: msgTs, thread_ts: rootTs },
+              container: { channel_id: channel, message_ts: msgTs },
+              actions: [{ action_id: action.actionId, value }],
+            }),
+          },
+        }));
+        await settle();
+        return { channel, threadTs: rootTs, ts: msgTs };
+      }
+      case 'cursor_webhook': {
+        const state = await getState({ channel, threadTs: threadTs || scenario.defaults.threadTs });
+        await withSession(session, () => webhookController.handleCursorWebhook({
+          id: action.agentId || state.backendRef,
+          status: action.status,
+          summary: action.summary,
+          source: action.source,
+          target: action.target,
+          linesAdded: action.linesAdded,
+          linesRemoved: action.linesRemoved,
+          filesChanged: action.filesChanged,
+        }));
+        await settle();
+        return { channel, threadTs: threadTs || scenario.defaults.threadTs, ts };
+      }
+      case 'wait': {
+        await sleep(action.ms || 1000);
+        return { channel, threadTs, ts };
+      }
+      case 'assert':
+        return { channel, threadTs, ts };
+      default:
+        throw new Error(`Unsupported action type: ${action.type}`);
+    }
+  }
+
+  async function getState({ channel, threadTs }) {
+    const thread = await db.query(async (client) => {
+      const { rows } = await client.query(
+        `SELECT st.*, cr.status, cr.backend_ref, cr.output
+         FROM slack_threads st
+         JOIN command_runs cr ON cr.id = st.command_run_id
+         WHERE st.channel_id = $1 AND st.thread_ts = $2
+         ORDER BY st.created_at DESC
+         LIMIT 1`,
+        [channel, threadTs],
+      );
+      return rows[0] || null;
+    }).catch(() => null);
+
+    return {
+      channel,
+      threadTs,
+      commandRunId: thread?.command_run_id || null,
+      backendRef: thread?.backend_ref || null,
+      status: thread?.status || null,
+      checkpointActive: Boolean(thread?.output?.checkpoint?.active),
+      prRole: thread?.output?.slackPrPresentation?.prRole || null,
+      prUrl: thread?.output?.slackPrPresentation?.primaryPrUrl || null,
+      branch: thread?.output?.slackPrPresentation?.branch || null,
+      pollerActive: thread?.backend_ref ? slackService.pollers?.has?.(thread.backend_ref) : false,
+      messages: fakeSlack.latestThreadMessages(channel, threadTs),
+    };
+  }
+
+  return {
+    mode: 'in-process',
+    start: async () => {},
+    close: async () => {
+      await slackService.onModuleDestroy?.();
+      await app.close();
+    },
+    runAction,
+    getState,
+  };
+}

package/slack-sim/render.mjs

@@ -0,0 +1,42 @@
+import * as fmt from '../fmt.mjs';
+
+export function printScenarioIntro(scenario, mode) {
+  fmt.banner('slack sim', {
+    icon: '⟁',
+    subtitle: `${fmt.chalk.dim('scenario:')} ${scenario.id}  ${fmt.chalk.dim('mode:')} ${mode}`,
+  });
+}
+
+export function printDryRun(scenario) {
+  fmt.note(
+    scenario.actions.map((action, index) => `${index + 1}. ${action.type}`).join('\n'),
+    'Actions',
+  );
+}
+
+export function printState(index, action, state) {
+  fmt.logStep(`Action ${index + 1}: ${action.type}`);
+  const lines = [
+    `channel: ${state.channel || '-'}`,
+    `thread: ${state.threadTs || '-'}`,
+    `run: ${state.commandRunId || '-'}`,
+    `backend: ${state.backendRef || '-'}`,
+    `status: ${state.status || '-'}`,
+    `checkpoint: ${state.checkpointActive ? 'active' : 'inactive'}`,
+    `poller: ${state.pollerActive === undefined ? 'unknown' : state.pollerActive ? 'active' : 'inactive'}`,
+    `pr role: ${state.prRole || '-'}`,
+    `pr url: ${state.prUrl || '-'}`,
+    `branch: ${state.branch || '-'}`,
+  ];
+  fmt.note(lines.join('\n'), 'State');
+
+  if (state.messages?.length) {
+    const rendered = state.messages
+      .slice(-6)
+      .map((m) => `[${m.ts}] ${m.user}: ${String(m.text).slice(0, 180)}`)
+      .join('\n');
+    fmt.note(rendered, 'Thread');
+  } else if (state.messagesUnavailable) {
+    fmt.note('Thread transcript unavailable in HTTP mode; use --in-process for captured Slack-like output.', 'Thread');
+  }
+}

package/slack-sim/scenario.mjs

@@ -0,0 +1,64 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, extname, join, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const BUILTIN_DIR = join(fileURLToPath(new URL('.', import.meta.url)), 'scenarios');
+const DEFAULT_ORG_ID = process.env.DEV_ORG_ID || 'e755eaad-1b31-4348-b545-981ef25dab04';
+const DEFAULT_TEAM_ID = process.env.DEV_TEAM_ID || 'c6d24de4-75e0-4e60-b8f2-de4a1cd0357d';
+
+export function listBuiltInScenarios() {
+  return readdirSync(BUILTIN_DIR)
+    .filter((name) => name.endsWith('.json'))
+    .map((name) => ({
+      name: name.replace(/\.json$/, ''),
+      path: join(BUILTIN_DIR, name),
+    }));
+}
+
+export function resolveScenarioPath(specifier) {
+  if (!specifier) throw new Error('Scenario path or built-in scenario name is required');
+  const direct = resolve(process.cwd(), specifier);
+  if (existsSync(direct)) return direct;
+
+  const withJson = extname(specifier) ? specifier : `${specifier}.json`;
+  const builtin = join(BUILTIN_DIR, withJson);
+  if (existsSync(builtin)) return builtin;
+
+  throw new Error(`Scenario not found: ${specifier}`);
+}
+
+export function loadScenario(specifier) {
+  const file = resolveScenarioPath(specifier);
+  const raw = readFileSync(file, 'utf8');
+  const scenario = JSON.parse(raw);
+  validateScenario(scenario, file);
+  return {
+    ...scenario,
+    id: scenario.id || basename(file, '.json'),
+    session: {
+      orgId: scenario.session?.orgId || DEFAULT_ORG_ID,
+      teamId: scenario.session?.teamId || DEFAULT_TEAM_ID,
+    },
+    defaults: {
+      channel: scenario.defaults?.channel || 'C_SIM',
+      user: scenario.defaults?.user || 'U_SIM',
+      threadTs: scenario.defaults?.threadTs || '1000.001',
+      rootTs: scenario.defaults?.rootTs || '1000.001',
+    },
+    __file: file,
+  };
+}
+
+function validateScenario(scenario, file) {
+  if (!scenario || typeof scenario !== 'object') {
+    throw new Error(`Invalid scenario in ${file}: expected object`);
+  }
+  if (!Array.isArray(scenario.actions) || scenario.actions.length === 0) {
+    throw new Error(`Invalid scenario in ${file}: actions[] is required`);
+  }
+  for (const [index, action] of scenario.actions.entries()) {
+    if (!action || typeof action !== 'object' || typeof action.type !== 'string') {
+      throw new Error(`Invalid scenario in ${file}: action[${index}] must have a type`);
+    }
+  }
+}

package/slack-sim/scenarios/checkpoint-approve.json

@@ -0,0 +1,21 @@
+{
+  "id": "checkpoint-approve",
+  "description": "Threaded checkpoint flow with approve/continue.",
+  "actions": [
+    {
+      "type": "app_mention_thread",
+      "text": "<@U_GHL_AW> /ship-lfg propose a plan first",
+      "threadTs": "2000.001",
+      "rootText": "Need a plan for this task"
+    },
+    {
+      "type": "wait",
+      "ms": 1000
+    },
+    {
+      "type": "button_click",
+      "actionId": "approve_plan",
+      "threadTs": "2000.001"
+    }
+  ]
+}

package/slack-sim/scenarios/image-thread.json

@@ -0,0 +1,27 @@
+{
+  "id": "image-thread",
+  "description": "Threaded image attachment flow using inline base64 test data.",
+  "actions": [
+    {
+      "type": "app_mention_thread",
+      "text": "<@U_GHL_AW> /ship-lfg audit this screenshot",
+      "threadTs": "3000.001",
+      "rootText": "Original bug thread",
+      "files": [
+        {
+          "id": "F_IMG_1",
+          "name": "bug.png",
+          "filetype": "png",
+          "mimetype": "image/png",
+          "width": 1,
+          "height": 1,
+          "contentBase64": "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAusB9WnSle8AAAAASUVORK5CYII="
+        }
+      ]
+    },
+    {
+      "type": "wait",
+      "ms": 1000
+    }
+  ]
+}

package/slack-sim/scenarios/implementation-basic.json

@@ -0,0 +1,18 @@
+{
+  "id": "implementation-basic",
+  "description": "Top-level implementation dispatch that should end in a canonical task PR summary.",
+  "actions": [
+    {
+      "type": "app_mention_top_level",
+      "text": "<@U_GHL_AW> /ship-lfg fix the failing flow"
+    },
+    {
+      "type": "wait",
+      "ms": 1000
+    },
+    {
+      "type": "assert",
+      "status": "running"
+    }
+  ]
+}

package/slack-sim/scenarios/poll-webhook-race.json

@@ -0,0 +1,18 @@
+{
+  "id": "poll-webhook-race",
+  "description": "Manual webhook injection template for testing completion races.",
+  "actions": [
+    {
+      "type": "app_mention_top_level",
+      "text": "<@U_GHL_AW> /ship-lfg run the task"
+    },
+    {
+      "type": "wait",
+      "ms": 1000
+    },
+    {
+      "type": "cursor_webhook",
+      "status": "FINISHED"
+    }
+  ]
+}

package/slack-sim/scenarios/review-pr.json

@@ -0,0 +1,14 @@
+{
+  "id": "review-pr",
+  "description": "Review an existing PR and verify the run stays tied to the reviewed PR.",
+  "actions": [
+    {
+      "type": "app_mention_top_level",
+      "text": "<@U_GHL_AW> /review https://github.com/GoHighLevel/example/pull/123"
+    },
+    {
+      "type": "wait",
+      "ms": 1000
+    }
+  ]
+}

package/telemetry.mjs

@@ -191,10 +191,12 @@ export async function startSpan(command, args) {
     async end({ status = 'completed', error_type = null, data = {} } = {}) {
       if (disabled) return;
       const duration_ms = Date.now() - startTime;
-      // Re-read registry_head so completed event reflects post-command state
-      const endEnv = { ...env, registry_head: getRegistryHead() };
+      // Re-read registry_head and namespace so completed event reflects post-command state
+      const endEnv = { ...env, registry_head: getRegistryHead(), namespace: getNamespace() || env.namespace };
       await send({
-        event: status === 'completed' ? 'command_completed' : 'command_failed',
+        event: status === 'completed' ? 'command_completed'
+             : status === 'cancelled' ? 'command_cancelled'
+             : 'command_failed',
         run_id: runId,
         timestamp: new Date().toISOString(),
         env: endEnv,