@ghl-ai/aw 0.1.44-beta.5 → 0.1.44-beta.8

package/c4/cursorRulesShim.mjs

@@ -0,0 +1,222 @@
+/**
+ * c4/cursorRulesShim.mjs — Cursor Cloud slash-command expansion shim.
+ *
+ * Why: Cursor Cloud Agent's chat UI does not pre-expand `/aw:<NAME>` slash
+ * commands the way Cursor Desktop's plugin does. The model sees the raw
+ * literal `/aw:...` and falls through to natural-language interpretation,
+ * losing the contract from the matching command file even though the file
+ * is correctly installed on disk by `commandSurface.mjs`.
+ *
+ * Workaround: write `<repoRoot>/.cursor/rules/aw-slash-expand.mdc` — a
+ * Cursor project rule that teaches the MODEL itself to read the matching
+ * command file and execute its contract verbatim. Cursor's `.mdc` rule
+ * format is honored in Agent mode (verified via Cursor docs); the rule
+ * loads on every session when `alwaysApply: true`.
+ *
+ * Per-harness behavior:
+ *   - cursor-cloud → write the rule (idempotent on byte-equal content)
+ *   - claude-web   → skip (UI expands slash commands natively)
+ *   - codex-web    → skip (different routing surface — see
+ *                    aw-c4-codex-slash-shim future work in overview.md)
+ *   - any other    → skip (defensive default)
+ *
+ * Refs: .aw_docs/features/aw-c4-cursor-slash-shim/{overview,spec,tasks}.md
+ */
+
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from 'node:fs';
+import { join } from 'node:path';
+
+const RULE_FILENAME = 'aw-slash-expand.mdc';
+const CURSOR_RULES_SUBPATH = '.cursor/rules';
+
+/**
+ * Canonical project-rule body. Exported so tests can assert the on-disk
+ * file matches byte-for-byte without re-reading from a fixture. Must NOT
+ * be mutated at runtime.
+ *
+ * The body lives here (not in a separate fixture file) so that bumping
+ * the rule wording is a single-file change that ships with `@ghl-ai/aw`
+ * via npm — no additional asset bundling needed.
+ */
+export const CURSOR_SLASH_SHIM_RULE = `---
+description: Expand \`/aw:<NAME>\` user messages by reading the matching command file
+alwaysApply: true
+---
+
+# AW slash-command expansion (Cursor Cloud workaround)
+
+When the user message starts with \`/aw:<NAME>\` (case-sensitive; \`<NAME>\` may
+contain hyphens — both in the namespace path and in the command name), do
+the following BEFORE producing any other response.
+
+## 1. Stage-command lookup (primary)
+
+Read \`~/.cursor/commands/aw/<NAME>.md\`. If the file exists, jump to step 3
+with its content as the resolved instructions.
+
+## 2. Registry-command lookup (fallback, hyphen-disambiguation)
+
+If step 1 did not resolve and \`<NAME>\` contains at least one hyphen, the
+slash form is a flattened \`<ns_segments...>-<cmd_segments...>\` token. The
+boundary between namespace and command is ambiguous because both can
+contain hyphens (registry has e.g. \`pr-review\`, \`capture-learning\`,
+\`ship-auto\`, \`draw-architecture\`).
+
+Disambiguate by **iterating every hyphen position in \`<NAME>\` from
+RIGHTMOST to LEFTMOST**, and use the first candidate file that exists. The
+repo registry root is \`.aw/.aw_registry/\` (relative to the agent's CWD —
+the repo root in Cursor Cloud).
+
+For each split position \`i\` from rightmost to leftmost:
+- \`prefix = <NAME>[:i]\` (everything before the hyphen at position \`i\`)
+- \`suffix = <NAME>[i+1:]\` (everything after; may itself contain hyphens)
+- candidate = \`.aw/.aw_registry/<prefix-with-hyphens-replaced-by-slashes>/commands/<suffix>.md\`
+- Try \`Read\` on the candidate. If the file exists, jump to step 3 with
+  that content.
+
+### Worked examples
+
+| User typed                                         | Registry file                                              | Splits tried (rightmost first)                                                                                          |
+|----------------------------------------------------|------------------------------------------------------------|-------------------------------------------------------------------------------------------------------------------------|
+| \`/aw:platform-core-brainstorm\`                     | \`platform/core/commands/brainstorm.md\`                     | \`platform/core/commands/brainstorm.md\` ✓ (first try)                                                                    |
+| \`/aw:platform-core-pr-review\`                      | \`platform/core/commands/pr-review.md\`                      | \`platform/core/pr/commands/review.md\` ❌ → \`platform/core/commands/pr-review.md\` ✓                                      |
+| \`/aw:platform-core-capture-learning\`               | \`platform/core/commands/capture-learning.md\`               | \`platform/core/capture/commands/learning.md\` ❌ → \`platform/core/commands/capture-learning.md\` ✓                        |
+| \`/aw:platform-data-clickhouse-cluster-creation\`    | \`platform/data/clickhouse/commands/cluster-creation.md\`    | \`…/cluster/commands/creation.md\` ❌ → \`platform/data/clickhouse/commands/cluster-creation.md\` ✓                         |
+
+## 3. Execute
+
+Treat the resolved file's full content as your operating instructions for
+this turn. Execute the command's phased contract on the text that follows
+the slash command in the user message. Do not summarize or paraphrase the
+command file — execute it verbatim, including any "ask one question at a
+time and wait" interaction protocol.
+
+## 4. No match
+
+If neither lookup resolves to an existing file, do NOT silently fall back
+to natural-language interpretation. Reply with exactly:
+
+> \`/aw:<NAME>\` is not a registered AW command on this machine. Run
+> \`aw c4 --diagnose\` and check the output of
+> \`ls ~/.cursor/commands/aw/\` for available stage commands and
+> \`find .aw/.aw_registry -path '*/commands/*.md'\` for available registry
+> commands.
+
+This precise reply text is the smoke-test fingerprint for the rule itself.
+The string is unique enough that it cannot be confused with the model's
+natural-language fallback.
+
+---
+
+This rule exists because Cursor Cloud's chat UI does not pre-expand slash
+commands the way Cursor Desktop does. The command files ARE installed on
+disk by \`aw c4\`; this rule teaches the model to load them itself. See
+\`.aw_docs/features/aw-c4-cursor-slash-shim/overview.md\` for context. Do
+not edit this file by hand — \`aw c4 --harness cursor-cloud\` regenerates
+it on every run.
+`;
+
+/**
+ * @typedef {object} InstallCursorSlashShimResult
+ * @property {string} harness        The harness echoed from input.
+ * @property {string} path           Absolute path of the rule file (or '' on skip).
+ * @property {'wrote'|'unchanged'|'skipped:harness'|'skipped:no-repo-root'} action
+ */
+
+/**
+ * Write the canonical AW slash-expand rule into the pilot repo.
+ *
+ * Idempotent: a re-run on byte-equal content returns 'unchanged' and does
+ * NOT touch the file (mtime preserved). Drift recovery: any stale content
+ * (including a symlink at the rule path) is replaced with a regular file
+ * containing the canonical template.
+ *
+ * @param {object} opts
+ * @param {string} opts.harness    'cursor-cloud' (writes) or other (skips).
+ * @param {string} opts.repoRoot   Absolute path to the repo root.
+ * @returns {InstallCursorSlashShimResult}
+ */
+export function installCursorSlashShim(opts) {
+  if (!opts || typeof opts !== 'object') {
+    throw new Error('installCursorSlashShim: opts object is required');
+  }
+  const { harness, repoRoot } = opts;
+
+  if (harness !== 'cursor-cloud') {
+    return { harness, path: '', action: 'skipped:harness' };
+  }
+
+  if (!repoRoot || typeof repoRoot !== 'string' || !isExistingDir(repoRoot)) {
+    return { harness, path: '', action: 'skipped:no-repo-root' };
+  }
+
+  const rulesDir = join(repoRoot, CURSOR_RULES_SUBPATH);
+  const rulePath = join(rulesDir, RULE_FILENAME);
+
+  // Idempotency check: if a regular file with byte-identical content
+  // already exists, return 'unchanged' WITHOUT writing — preserves mtime
+  // for the test contract and avoids spurious file-watcher noise.
+  if (isRegularFileWithIdenticalContent(rulePath)) {
+    return { harness, path: rulePath, action: 'unchanged' };
+  }
+
+  // Drift recovery: clear the existing entry (regular file with stale
+  // bytes, or any symlink) before writing a fresh regular file. Symlinks
+  // get unlinked rather than overwritten so we never write through to
+  // their targets.
+  if (lstatExists(rulePath)) {
+    try {
+      unlinkSync(rulePath);
+    } catch {
+      // Ignore — writeFileSync below will overwrite a regular file
+      // anyway. If it's something stranger (e.g. a directory we can't
+      // delete), the writeFileSync will throw and bubble up to safe().
+    }
+  }
+
+  mkdirSync(rulesDir, { recursive: true });
+  writeFileSync(rulePath, CURSOR_SLASH_SHIM_RULE, 'utf8');
+
+  return { harness, path: rulePath, action: 'wrote' };
+}
+
+function isExistingDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+
+function lstatExists(p) {
+  try {
+    lstatSync(p);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function isRegularFileWithIdenticalContent(rulePath) {
+  if (!existsSync(rulePath)) return false;
+  let isSym = false;
+  try {
+    isSym = lstatSync(rulePath).isSymbolicLink();
+  } catch {
+    return false;
+  }
+  if (isSym) return false; // Always replace symlinks with regular files.
+  try {
+    return readFileSync(rulePath, 'utf8') === CURSOR_SLASH_SHIM_RULE;
+  } catch {
+    return false;
+  }
+}

package/c4/diagnostics.mjs

@@ -112,6 +112,16 @@ export function summarizeAsOneLine(state) {
 
   if (state.mcpProbe) parts.push(`mcp ${state.mcpProbe}`);
 
+  if (state.slashShim) {
+    parts.push(`slashShim ${slashShimSummaryToken(state.slashShim.action)}`);
+  }
+
+  // Proxy state — only surfaced when actually applied. Skipping the
+  // token on no-proxy harnesses keeps the summary line short.
+  if (state.proxy && state.proxy.applied && state.proxy.source) {
+    parts.push(`proxy ${state.proxy.source}`);
+  }
+
   const seconds = Number(state.durationMs ?? 0) / 1000;
   parts.push(`init ${seconds.toFixed(1)}s`);
   parts.push(state.didInit ? 'ready' : 'skipped');
@@ -119,6 +129,18 @@ export function summarizeAsOneLine(state) {
   return parts.join(DOT);
 }
 
+/**
+ * Map the structured slashShim action into a 1-token line summary glyph.
+ * 'wrote' is loud (something changed). 'unchanged' is quiet ('ok'). Both
+ * skip variants collapse to 'skip' so the line stays short on Claude/Codex
+ * harnesses where slashShim is a no-op.
+ */
+function slashShimSummaryToken(action) {
+  if (action === 'wrote') return 'wrote';
+  if (action === 'unchanged') return 'ok';
+  return 'skip';
+}
+
 /* ─────────────────────────────────────────────────────────────────────────
  * diagnoseAwRouterView
  * ───────────────────────────────────────────────────────────────────────── */
@@ -455,6 +477,31 @@ export function dumpPostInitState(opts = {}) {
   for (const skillPath of sampleRegistrySkillPaths(opts.awHome, 10)) {
     lines.push(`  ${skillPath}`);
   }
+  lines.push('');
+
+  // Cursor slash-shim block (cursor-cloud only; opt.slashShim absent on
+  // other harnesses, where the block is intentionally suppressed).
+  if (opts.slashShim && typeof opts.slashShim === 'object') {
+    const shim = opts.slashShim;
+    lines.push('slashShim:');
+    lines.push(`  harness=${shim.harness ?? '<unknown>'}`);
+    lines.push(`  action=${shim.action ?? '<unknown>'}`);
+    if (shim.path) lines.push(`  path=${shim.path}`);
+    lines.push('');
+  }
+
+  // Proxy block (always emitted when opts.proxy is provided, so operators
+  // can confirm whether HTTPS_PROXY was honored. Codex Cloud diagnostics
+  // depends on this being present.)
+  if (opts.proxy && typeof opts.proxy === 'object') {
+    const proxy = opts.proxy;
+    lines.push('proxy:');
+    lines.push(`  applied=${proxy.applied ? 'true' : 'false'}`);
+    if (proxy.source) lines.push(`  source=${proxy.source}`);
+    if (proxy.proxyUrl) lines.push(`  url=${proxy.proxyUrl}`);
+    lines.push('');
+  }
+
   lines.push('─── end ───');
   lines.push('');
 

package/c4/gitAuth.mjs

@@ -349,12 +349,21 @@ export async function verifyAuth(mode, token, { shell = defaultShell, fetchImpl
  *   c FAIL      → 'rewrite-conflict' (the Cursor scenario)
  *   else        → 'ok'
  *
+ * Note: 'pat-invalid' is misnamed when `authStatus` is undefined (i.e. the
+ * REST `fetch()` errored out before getting an HTTP status). The Codex
+ * Cloud failure mode is exactly that: HTTPS_PROXY is set but Node fetch
+ * doesn't honor it, so the REST probe returns `{ ok:false, error:'fetch failed' }`
+ * with no status. Callers must distinguish the two by looking at
+ * `authStatus` and `lsRemoteWithAuthOk`.
+ *
  * @param {string} token
  * @param {object} [opts]
  * @returns {Promise<{
  *   apiOk: boolean,
  *   lsRemoteWithAuthOk: boolean,
  *   lsRemoteViaRewriteOk: boolean,
+ *   authStatus: number | undefined,
+ *   authError: string | undefined,
  *   diagnosis: 'ok' | 'pat-invalid' | 'rewrite-conflict' | 'helper-mismatch' | 'network'
  * }>}
  */
@@ -380,5 +389,12 @@ export async function preflightPlatformDocs(token, opts = {}) {
     diagnosis = 'ok';
   }
 
-  return { apiOk, lsRemoteWithAuthOk, lsRemoteViaRewriteOk, diagnosis };
+  return {
+    apiOk,
+    lsRemoteWithAuthOk,
+    lsRemoteViaRewriteOk,
+    authStatus: a.status,
+    authError: a.error,
+    diagnosis,
+  };
 }

package/c4/index.mjs

@@ -50,11 +50,13 @@ export { MCP_URL_DEFAULT, registerGhlAiMcp } from './mcpServer.mjs';
 export { probeMcpServer } from './mcpSmokeProbe.mjs';
 export { ensureClaudeMarketplace } from './claudePluginRegistry.mjs';
 export { ensureCommandSurface, diagnoseCommandResolution } from './commandSurface.mjs';
+export { installCursorSlashShim, CURSOR_SLASH_SHIM_RULE } from './cursorRulesShim.mjs';
 export { ensureRepoLocalClaudeSettings } from './repoLocalClaudeSettings.mjs';
 export { copyRepoRootInstructions } from './repoRootInstructions.mjs';
 export { ensureRepoLocalIgnore } from './repoLocalIgnore.mjs';
 export { jsonMergeWithDedup, claudeHooksMerge } from './jsonMerge.mjs';
 export { runPreflight } from './preflight.mjs';
+export { configureUndiciProxy } from './proxyConfig.mjs';
 export {
   summarizeAsOneLine,
   diagnoseAwRouterView,

package/c4/proxyConfig.mjs

@@ -0,0 +1,127 @@
+/**
+ * c4/proxyConfig.mjs — install undici proxy dispatcher from env.
+ *
+ * Why this exists:
+ *   Codex Cloud (and other corporate-MITM cloud agents) force outbound
+ *   HTTPS through a proxy via HTTPS_PROXY. Standard tools (curl, git, npm)
+ *   honor that variable transparently. Node's native fetch (undici) does
+ *   NOT honor proxy env vars before Node 24, so REST preflight in
+ *   `aw c4` fails with `fetch failed: ENETUNREACH` even though the same
+ *   PAT works fine via `git ls-remote` and `curl`.
+ *
+ *   This module reads the proxy URL from env in the documented priority
+ *   order and installs an undici ProxyAgent as the global dispatcher
+ *   exactly once at orchestrator entry. After this runs, every fetch()
+ *   call inside aw-c4 routes through the proxy.
+ *
+ * Why dynamic import:
+ *   Keeps the no-proxy fast path zero-cost (no undici namespace resolution)
+ *   and lets unit tests inject a synthetic { setGlobalDispatcher, ProxyAgent }
+ *   pair via opts.undiciImpl without going through vi.mock module-graph
+ *   plumbing.
+ *
+ * Failure isolation:
+ *   If ProxyAgent construction or setGlobalDispatcher throws, we swallow
+ *   it and report `applied: false`. A misconfigured proxy URL must NEVER
+ *   crash `aw c4` — the orchestrator continues and surfaces the failure
+ *   in diagnostics so the user can see what happened.
+ *
+ * Contract:
+ *   .aw_docs/features/aw-c4-codex-proxy-fix/spec.md::§"libs/aw/c4/proxyConfig.mjs"
+ */
+
+const PROXY_ENV_PRIORITY = Object.freeze([
+  'HTTPS_PROXY',
+  'https_proxy',
+  'HTTP_PROXY',
+  'http_proxy',
+]);
+
+/**
+ * @typedef {object} ProxyConfigResult
+ * @property {boolean} applied         True iff a global dispatcher was
+ *                                     installed successfully.
+ * @property {string|null} proxyUrl    The URL the agent was constructed
+ *                                     with, or null when no proxy env
+ *                                     var was set.
+ * @property {string|null} source      Exact env-var name the URL was
+ *                                     resolved from, or null. Useful
+ *                                     for diagnostics (so the user can
+ *                                     see "we used HTTPS_PROXY, not
+ *                                     http_proxy").
+ */
+
+/**
+ * Resolve the first non-empty proxy URL from env in priority order.
+ *
+ * @param {NodeJS.ProcessEnv} env
+ * @returns {{ url: string, source: string } | null}
+ */
+function resolveProxyFromEnv(env) {
+  for (const name of PROXY_ENV_PRIORITY) {
+    const value = env?.[name];
+    if (typeof value === 'string' && value.length > 0) {
+      return { url: value, source: name };
+    }
+  }
+  return null;
+}
+
+/**
+ * Install an undici ProxyAgent as the global fetch dispatcher when
+ * an HTTP/HTTPS proxy env var is set.
+ *
+ * Calling this with no proxy in env is safe — it returns
+ * `{ applied: false, ... }` without touching undici. Calling it twice
+ * is also safe; the second call replaces the first dispatcher.
+ *
+ * @param {NodeJS.ProcessEnv} [env]
+ * @param {object} [opts]
+ * @param {{ setGlobalDispatcher: Function, ProxyAgent: Function }} [opts.undiciImpl]
+ *   Override for tests. When omitted, undici is dynamically imported.
+ * @returns {ProxyConfigResult}
+ */
+export function configureUndiciProxy(env = process.env, opts = {}) {
+  const resolved = resolveProxyFromEnv(env);
+  if (!resolved) {
+    return { applied: false, proxyUrl: null, source: null };
+  }
+
+  const undici = opts.undiciImpl ?? loadUndiciSync();
+  if (!undici) {
+    return { applied: false, proxyUrl: resolved.url, source: resolved.source };
+  }
+
+  try {
+    const agent = new undici.ProxyAgent(resolved.url);
+    undici.setGlobalDispatcher(agent);
+    return { applied: true, proxyUrl: resolved.url, source: resolved.source };
+  } catch {
+    // ProxyAgent ctor or setGlobalDispatcher rejected the URL. The most
+    // common cause is a malformed URL ("proxy:8080" without scheme).
+    // Caller treats apply-failure same as no-proxy and continues.
+    return { applied: false, proxyUrl: resolved.url, source: resolved.source };
+  }
+}
+
+import { createRequire } from 'node:module';
+
+/**
+ * Load the bundled `undici` synchronously via createRequire so we can
+ * keep `configureUndiciProxy` synchronous (orchestrator entry must not
+ * become async just to install a dispatcher).
+ *
+ * Falls back to `null` if the import is unavailable for any reason —
+ * in which case the caller treats it as a no-op.
+ */
+let cachedUndici;
+function loadUndiciSync() {
+  if (cachedUndici !== undefined) return cachedUndici;
+  try {
+    const localRequire = createRequire(import.meta.url);
+    cachedUndici = localRequire('undici');
+  } catch {
+    cachedUndici = null;
+  }
+  return cachedUndici;
+}

package/commands/c4.mjs

@@ -210,6 +210,21 @@ export async function c4Command(rawArgs, overrides = {}) {
 
   const startTs = now();
 
+  // Step 0 — undici proxy installation.
+  // Codex Cloud (and other corporate-MITM cloud agents) force outbound
+  // HTTPS through HTTPS_PROXY. Standard tools (curl, git, npm) honor it
+  // transparently; Node's native fetch (undici) does not before Node 24.
+  // Install a global ProxyAgent dispatcher BEFORE any other step so every
+  // subsequent fetch() (preflight REST, MCP smoke probe, etc.) routes
+  // through the proxy. Defensive try/catch — proxy install failure must
+  // never crash aw-c4.
+  let proxy = { applied: false, proxyUrl: null, source: null };
+  try {
+    proxy = c4.configureUndiciProxy(env);
+  } catch (err) {
+    writer.stderr(`[aw-c4] configureUndiciProxy failed (non-fatal): ${err?.message ?? err}\n`);
+  }
+
   // Step 1 — harness detection (override wins).
   const cliHarness = args['--harness'];
   const harness = SUPPORTED_HARNESSES.includes(cliHarness) ? cliHarness : c4.detectHarness({ env }).harness;
@@ -228,6 +243,7 @@ export async function c4Command(rawArgs, overrides = {}) {
       authOk: false,
       didInit: false,
       durationMs: now() - startTs,
+      proxy,
     }) + '\n');
     return exit(0);
   }
@@ -263,6 +279,7 @@ export async function c4Command(rawArgs, overrides = {}) {
         bridge: self.view ? { ok: self.view.ok } : undefined,
         injector: self.injector ? { ok: self.injector.ok } : undefined,
         diagnose: true,
+        proxy,
       }) + '\n');
     } catch (err) {
       writer.stderr(`[aw-c4] diagnose: summary line failed: ${err?.message ?? err}\n`);
@@ -282,18 +299,39 @@ export async function c4Command(rawArgs, overrides = {}) {
   // Step 5 — preflight.
   const preflight = await c4.preflightPlatformDocs(token);
   if (preflight.diagnosis === 'pat-invalid') {
-    writer.stderr('[aw-c4] PAT invalid (REST 4xx). Refresh GITHUB_PAT and retry.\n');
-    writer.stdout(c4.summarizeAsOneLine({
-      harness,
-      hasToken: true,
-      tokenSource,
-      authOk: false,
-      didInit: false,
-      durationMs: now() - startTs,
-    }) + '\n');
-    return exit(0);
+    // Disambiguate two failure modes that both end up tagged 'pat-invalid':
+    //   (a) Real bad PAT — REST returned a 4xx HTTP status (`authStatus`
+    //       is a number). Git ls-remote also fails. Exit 0 with the
+    //       actionable "refresh PAT" message.
+    //   (b) Codex Cloud proxy gap — REST `fetch()` failed BEFORE getting
+    //       any HTTP status (`authStatus == null`, `authError` like
+    //       "fetch failed: ENETUNREACH") because Node fetch can't see
+    //       HTTPS_PROXY. Git ls-remote works (libcurl honors the proxy).
+    //       The PAT is fine; proceed with install and surface the real
+    //       cause on stderr.
+    const restStatusKnown = typeof preflight.authStatus === 'number';
+    if (!restStatusKnown && preflight.lsRemoteWithAuthOk) {
+      const cause = preflight.authError ?? 'unknown';
+      writer.stderr(
+        `[aw-c4] api.github.com unreachable from Node fetch (${cause}); ` +
+        `git auth OK, continuing.\n`,
+      );
+      // fall through into normal install flow
+    } else {
+      writer.stderr('[aw-c4] PAT invalid (REST 4xx). Refresh GITHUB_PAT and retry.\n');
+      writer.stdout(c4.summarizeAsOneLine({
+        harness,
+        hasToken: true,
+        tokenSource,
+        authOk: false,
+        didInit: false,
+        durationMs: now() - startTs,
+        proxy,
+      }) + '\n');
+      return exit(0);
+    }
   }
-  if (preflight.diagnosis !== 'ok') {
+  if (preflight.diagnosis !== 'ok' && preflight.diagnosis !== 'pat-invalid') {
     writer.stderr(`[aw-c4] preflight diagnosis: ${preflight.diagnosis} (continuing)\n`);
   }
 
@@ -306,6 +344,7 @@ export async function c4Command(rawArgs, overrides = {}) {
       authOk: preflight.diagnosis === 'ok',
       didInit: false,
       durationMs: now() - startTs,
+      proxy,
     }) + '\n');
     return exit(0);
   }
@@ -346,6 +385,17 @@ export async function c4Command(rawArgs, overrides = {}) {
   // Step 12 — slash command surface.
   safe('ensureCommandSurface', () => c4.ensureCommandSurface({ harness, home, eccHome }), writer);
 
+  // Step 12b — Cursor Cloud slash-expand rule (no-op on other harnesses).
+  // The model-side workaround for Cursor Cloud's chat UI not pre-expanding
+  // `/aw:<NAME>` slash commands. The function self-skips on other
+  // harnesses, so the orchestrator does not pre-filter; the resulting
+  // action is surfaced in the one-line summary and post-init dump.
+  const slashShim = safe(
+    'installCursorSlashShim',
+    () => c4.installCursorSlashShim({ harness, repoRoot: cwd }),
+    writer,
+  );
+
   // Step 13 — repo-root context.
   safe('copyRepoRootInstructions', () => c4.copyRepoRootInstructions(harness, cwd, eccHome), writer);
 
@@ -368,7 +418,14 @@ export async function c4Command(rawArgs, overrides = {}) {
   }
 
   // Step 17 — post-init dump.
-  c4.dumpPostInitState({ harness, cwd, awHome, configPaths: [] });
+  c4.dumpPostInitState({
+    harness,
+    cwd,
+    awHome,
+    configPaths: [],
+    slashShim: slashShim?.ok ? slashShim.value : null,
+    proxy,
+  });
 
   // Step 18 — one-line summary.
   writer.stdout(c4.summarizeAsOneLine({
@@ -381,6 +438,8 @@ export async function c4Command(rawArgs, overrides = {}) {
     bridge: branch?.bridge,
     injector: branch?.injector,
     mcpProbe: mcpProbe?.value?.authStatus,
+    slashShim: slashShim?.ok ? slashShim.value : null,
+    proxy,
   }) + '\n');
 
   return exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ghl-ai/aw",
-  "version": "0.1.44-beta.5",
+  "version": "0.1.44-beta.8",
   "description": "Agentic Workspace CLI — pull, push & manage agents, skills and commands from the registry",
   "type": "module",
   "bin": {