aw-ecc 1.4.21

package/scripts/codex/merge-mcp-config.js

@@ -0,0 +1,304 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Merge ECC-recommended MCP servers into a Codex config.toml.
+ *
+ * Strategy: ADD-ONLY by default.
+ *   - Parse the TOML to detect which mcp_servers.* sections exist.
+ *   - Append raw TOML text for any missing servers (preserves existing file byte-for-byte).
+ *   - Log warnings when an existing server's config differs from the ECC recommendation.
+ *   - With --update-mcp, also replace existing ECC-managed servers.
+ *
+ * Uses the repo's package-manager abstraction (scripts/lib/package-manager.js)
+ * so MCP launcher commands respect the user's configured package manager.
+ *
+ * Usage:
+ *   node merge-mcp-config.js <config.toml> [--dry-run] [--update-mcp]
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let TOML;
+try {
+  TOML = require('@iarna/toml');
+} catch {
+  console.error('[ecc-mcp] Missing dependency: @iarna/toml');
+  console.error('[ecc-mcp] Run: npm install   (from the ECC repo root)');
+  process.exit(1);
+}
+
+// ---------------------------------------------------------------------------
+// Package manager detection
+// ---------------------------------------------------------------------------
+
+let pmConfig;
+try {
+  const { getPackageManager } = require(path.join(__dirname, '..', 'lib', 'package-manager.js'));
+  pmConfig = getPackageManager();
+} catch {
+  // Fallback: if package-manager.js isn't available, default to npx
+  pmConfig = { name: 'npm', config: { name: 'npm', execCmd: 'npx' } };
+}
+
+// Yarn 1.x doesn't support `yarn dlx` — fall back to npx for classic Yarn.
+let resolvedExecCmd = pmConfig.config.execCmd;
+if (pmConfig.name === 'yarn' && resolvedExecCmd === 'yarn dlx') {
+  try {
+    const { execFileSync } = require('child_process');
+    const ver = execFileSync('yarn', ['--version'], { encoding: 'utf8', timeout: 5000 }).trim();
+    if (ver.startsWith('1.')) {
+      resolvedExecCmd = 'npx';
+    }
+  } catch {
+    // Can't detect version — keep yarn dlx and let it fail visibly
+  }
+}
+
+const PM_NAME = pmConfig.config.name || pmConfig.name;
+const PM_EXEC = resolvedExecCmd; // e.g. "pnpm dlx", "npx", "bunx", "yarn dlx"
+const PM_EXEC_PARTS = PM_EXEC.split(/\s+/); // ["pnpm", "dlx"] or ["npx"] or ["bunx"]
+
+// ---------------------------------------------------------------------------
+// ECC-recommended MCP servers
+// ---------------------------------------------------------------------------
+
+// GitHub bootstrap uses bash for token forwarding — this is intentionally
+// shell-based regardless of package manager, since Codex runs on macOS/Linux.
+const GH_BOOTSTRAP = `token=$(gh auth token 2>/dev/null || true); if [ -n "$token" ]; then export GITHUB_PERSONAL_ACCESS_TOKEN="$token"; fi; exec ${PM_EXEC} @modelcontextprotocol/server-github`;
+
+/**
+ * Build a server spec with the detected package manager.
+ * Returns { fields, toml } where fields is for drift detection and
+ * toml is the raw text appended to the file.
+ */
+function dlxServer(name, pkg, extraFields, extraToml) {
+  const args = [...PM_EXEC_PARTS.slice(1), pkg];
+  const fields = { command: PM_EXEC_PARTS[0], args, ...extraFields };
+  const argsStr = JSON.stringify(args).replace(/,/g, ', ');
+  let toml = `[mcp_servers.${name}]\ncommand = "${PM_EXEC_PARTS[0]}"\nargs = ${argsStr}`;
+  if (extraToml) toml += '\n' + extraToml;
+  return { fields, toml };
+}
+
+/** Each entry: key = section name under mcp_servers, value = { toml, fields } */
+const ECC_SERVERS = {
+  supabase: dlxServer('supabase', '@supabase/mcp-server-supabase@latest', { startup_timeout_sec: 20.0, tool_timeout_sec: 120.0 }, 'startup_timeout_sec = 20.0\ntool_timeout_sec = 120.0'),
+  playwright: dlxServer('playwright', '@playwright/mcp@latest'),
+  'context7-mcp': dlxServer('context7-mcp', '@upstash/context7-mcp'),
+  exa: {
+    fields: { url: 'https://mcp.exa.ai/mcp' },
+    toml: `[mcp_servers.exa]\nurl = "https://mcp.exa.ai/mcp"`
+  },
+  github: {
+    fields: { command: 'bash', args: ['-lc', GH_BOOTSTRAP] },
+    toml: `[mcp_servers.github]\ncommand = "bash"\nargs = ["-lc", ${JSON.stringify(GH_BOOTSTRAP)}]`
+  },
+  memory: dlxServer('memory', '@modelcontextprotocol/server-memory'),
+  'sequential-thinking': dlxServer('sequential-thinking', '@modelcontextprotocol/server-sequential-thinking')
+};
+
+// Append --features arg for supabase after dlxServer builds the base
+ECC_SERVERS.supabase.fields.args.push('--features=account,docs,database,debugging,development,functions,storage,branching');
+ECC_SERVERS.supabase.toml = ECC_SERVERS.supabase.toml.replace(/^(args = \[.*)\]$/m, '$1, "--features=account,docs,database,debugging,development,functions,storage,branching"]');
+
+// Legacy section names that should be treated as an existing ECC server.
+// e.g. old configs shipped [mcp_servers.context7] instead of [mcp_servers.context7-mcp].
+const LEGACY_ALIASES = {
+  'context7-mcp': ['context7']
+};
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function log(msg) {
+  console.log(`[ecc-mcp] ${msg}`);
+}
+
+function warn(msg) {
+  console.warn(`[ecc-mcp] WARNING: ${msg}`);
+}
+
+/** Shallow-compare two objects (one level deep, arrays by JSON). */
+function configDiffers(existing, recommended) {
+  for (const key of Object.keys(recommended)) {
+    const a = existing[key];
+    const b = recommended[key];
+    if (Array.isArray(b)) {
+      if (JSON.stringify(a) !== JSON.stringify(b)) return true;
+    } else if (a !== b) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Remove a TOML section and its key-value pairs from raw text.
+ * Matches the section header even if followed by inline comments or whitespace
+ * (e.g. `[mcp_servers.github] # comment`).
+ * Returns the text with the section removed.
+ */
+function removeSectionFromText(text, sectionHeader) {
+  const escaped = sectionHeader.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const headerPattern = new RegExp(`^${escaped}(\\s*(#.*)?)?$`);
+  const lines = text.split('\n');
+  const result = [];
+  let skipping = false;
+  for (const line of lines) {
+    const trimmed = line.replace(/\r$/, '');
+    if (headerPattern.test(trimmed)) {
+      skipping = true;
+      continue;
+    }
+    if (skipping && /^\[/.test(trimmed)) {
+      skipping = false;
+    }
+    if (!skipping) {
+      result.push(line);
+    }
+  }
+  return result.join('\n');
+}
+
+/**
+ * Collect all TOML sub-section headers for a given server name.
+ * @iarna/toml nests subtables, so `[mcp_servers.supabase.env]` appears as
+ * `parsed.mcp_servers.supabase.env` (nested), NOT as a flat dotted key.
+ * Walk the nested object to find sub-objects that represent TOML sub-tables.
+ */
+function findSubSections(serverObj, prefix) {
+  const sections = [];
+  if (!serverObj || typeof serverObj !== 'object') return sections;
+  for (const key of Object.keys(serverObj)) {
+    const val = serverObj[key];
+    if (val && typeof val === 'object' && !Array.isArray(val)) {
+      const subPath = `${prefix}.${key}`;
+      sections.push(subPath);
+      sections.push(...findSubSections(val, subPath));
+    }
+  }
+  return sections;
+}
+
+/**
+ * Remove a server and all its sub-sections from raw TOML text.
+ * Uses findSubSections to walk the parsed nested object (not flat keys).
+ */
+function removeServerFromText(raw, serverName, existing) {
+  let result = removeSectionFromText(raw, `[mcp_servers.${serverName}]`);
+  const serverObj = existing[serverName];
+  if (serverObj) {
+    for (const sub of findSubSections(serverObj, serverName)) {
+      result = removeSectionFromText(result, `[mcp_servers.${sub}]`);
+    }
+  }
+  return result;
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function main() {
+  const args = process.argv.slice(2);
+  const configPath = args.find(a => !a.startsWith('-'));
+  const dryRun = args.includes('--dry-run');
+  const updateMcp = args.includes('--update-mcp');
+
+  if (!configPath) {
+    console.error('Usage: merge-mcp-config.js <config.toml> [--dry-run] [--update-mcp]');
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(configPath)) {
+    console.error(`[ecc-mcp] Config file not found: ${configPath}`);
+    process.exit(1);
+  }
+
+  log(`Package manager: ${PM_NAME} (exec: ${PM_EXEC})`);
+
+  let raw = fs.readFileSync(configPath, 'utf8');
+  let parsed;
+  try {
+    parsed = TOML.parse(raw);
+  } catch (err) {
+    console.error(`[ecc-mcp] Failed to parse ${configPath}: ${err.message}`);
+    process.exit(1);
+  }
+
+  const existing = parsed.mcp_servers || {};
+  const toAppend = [];
+  const toRemoveLog = [];
+
+  for (const [name, spec] of Object.entries(ECC_SERVERS)) {
+    const entry = existing[name];
+    const aliases = LEGACY_ALIASES[name] || [];
+    const legacyName = aliases.find(a => existing[a] && typeof existing[a].command === 'string');
+
+    // Prefer canonical entry over legacy alias
+    const hasCanonical = entry && typeof entry.command === 'string';
+    const resolvedEntry = hasCanonical ? entry : legacyName ? existing[legacyName] : null;
+    // For URL-based servers (exa), check for url field instead of command
+    const urlEntry = !resolvedEntry && entry && typeof entry.url === 'string' ? entry : null;
+    const finalEntry = resolvedEntry || urlEntry;
+    const resolvedLabel = hasCanonical ? name : legacyName || name;
+
+    if (finalEntry) {
+      if (updateMcp) {
+        // --update-mcp: remove existing section (and legacy alias), will re-add below
+        toRemoveLog.push(`mcp_servers.${resolvedLabel}`);
+        raw = removeServerFromText(raw, resolvedLabel, existing);
+        if (resolvedLabel !== name) {
+          raw = removeServerFromText(raw, name, existing);
+        }
+        toAppend.push(spec.toml);
+      } else {
+        // Add-only mode: skip, but warn about drift
+        if (legacyName && !hasCanonical) {
+          warn(`mcp_servers.${legacyName} is a legacy name for ${name} (run with --update-mcp to migrate)`);
+        } else if (configDiffers(finalEntry, spec.fields)) {
+          warn(`mcp_servers.${name} differs from ECC recommendation (run with --update-mcp to refresh)`);
+        } else {
+          log(`  [ok] mcp_servers.${name}`);
+        }
+      }
+    } else {
+      log(`  [add] mcp_servers.${name}`);
+      toAppend.push(spec.toml);
+    }
+  }
+
+  if (toAppend.length === 0) {
+    log('All ECC MCP servers already present. Nothing to do.');
+    return;
+  }
+
+  const appendText = '\n' + toAppend.join('\n\n') + '\n';
+
+  if (dryRun) {
+    if (toRemoveLog.length > 0) {
+      log('Dry run — would remove and re-add:');
+      for (const label of toRemoveLog) log(`  [remove] ${label}`);
+    }
+    log('Dry run — would append:');
+    console.log(appendText);
+    return;
+  }
+
+  // Write: for add-only, append to preserve existing content byte-for-byte.
+  // For --update-mcp, we modified `raw` above, so write the full file + appended sections.
+  if (updateMcp) {
+    for (const label of toRemoveLog) log(`  [update] ${label}`);
+    const cleaned = raw.replace(/\n+$/, '\n');
+    fs.writeFileSync(configPath, cleaned + appendText, 'utf8');
+  } else {
+    fs.appendFileSync(configPath, appendText, 'utf8');
+  }
+
+  log(`Done. ${toAppend.length} server(s) ${updateMcp ? 'updated' : 'added'}.`);
+}
+
+main();

package/scripts/cursor-aw-home/hooks.json

@@ -0,0 +1,115 @@
+{
+  "version": 1,
+  "hooks": {
+    "sessionStart": [
+      {
+        "command": "node .cursor/hooks/session-start.js",
+        "event": "sessionStart",
+        "description": "Load previous context and detect environment"
+      }
+    ],
+    "sessionEnd": [
+      {
+        "command": "node .cursor/hooks/session-end.js",
+        "event": "sessionEnd",
+        "description": "Persist session state and evaluate patterns"
+      }
+    ],
+    "beforeShellExecution": [
+      {
+        "command": "npx block-no-verify@1.1.2",
+        "event": "beforeShellExecution",
+        "description": "Block git hook-bypass flag to protect pre-commit, commit-msg, and pre-push hooks from being skipped"
+      },
+      {
+        "command": "node .cursor/hooks/before-shell-execution.js",
+        "event": "beforeShellExecution",
+        "description": "Tmux dev server blocker, tmux reminder, git push review"
+      }
+    ],
+    "afterShellExecution": [
+      {
+        "command": "node .cursor/hooks/after-shell-execution.js",
+        "event": "afterShellExecution",
+        "description": "PR URL logging, build analysis"
+      }
+    ],
+    "afterFileEdit": [
+      {
+        "command": "node .cursor/hooks/after-file-edit.js",
+        "event": "afterFileEdit",
+        "description": "Auto-format, TypeScript check, console.log warning"
+      }
+    ],
+    "beforeMCPExecution": [
+      {
+        "command": "node .cursor/hooks/before-mcp-execution.js",
+        "event": "beforeMCPExecution",
+        "description": "MCP audit logging and untrusted server warning"
+      }
+    ],
+    "afterMCPExecution": [
+      {
+        "command": "node .cursor/hooks/after-mcp-execution.js",
+        "event": "afterMCPExecution",
+        "description": "MCP result logging"
+      }
+    ],
+    "beforeReadFile": [
+      {
+        "command": "node .cursor/hooks/before-read-file.js",
+        "event": "beforeReadFile",
+        "description": "Warn when reading sensitive files (.env, .key, .pem)"
+      }
+    ],
+    "beforeSubmitPrompt": [
+      {
+        "command": "node .cursor/hooks/before-submit-prompt.js",
+        "event": "beforeSubmitPrompt",
+        "description": "Detect secrets in prompts (sk-, ghp_, AKIA patterns)"
+      }
+    ],
+    "subagentStart": [
+      {
+        "command": "node .cursor/hooks/subagent-start.js",
+        "event": "subagentStart",
+        "description": "Log agent spawning for observability"
+      }
+    ],
+    "subagentStop": [
+      {
+        "command": "node .cursor/hooks/subagent-stop.js",
+        "event": "subagentStop",
+        "description": "Log agent completion"
+      }
+    ],
+    "beforeTabFileRead": [
+      {
+        "command": "node .cursor/hooks/before-tab-file-read.js",
+        "event": "beforeTabFileRead",
+        "description": "Block Tab from reading secrets (.env, .key, .pem, credentials)"
+      }
+    ],
+    "afterTabFileEdit": [
+      {
+        "command": "node .cursor/hooks/after-tab-file-edit.js",
+        "event": "afterTabFileEdit",
+        "description": "Auto-format Tab edits"
+      }
+    ],
+    "preCompact": [
+      {
+        "command": "node .cursor/hooks/pre-compact.js",
+        "event": "preCompact",
+        "description": "Save state before context compaction"
+      }
+    ],
+    "stop": [
+      {
+        "command": "node .cursor/hooks/stop.js",
+        "event": "stop",
+        "description": "Console.log audit on all modified files"
+      }
+    ]
+  }
+}

package/scripts/cursor-aw-hooks/adapter.js

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+/**
+ * Cursor-to-Claude Code Hook Adapter
+ * Transforms Cursor stdin JSON to Claude Code hook format,
+ * then delegates to existing scripts/hooks/*.js
+ */
+
+const { execFileSync } = require('child_process');
+const path = require('path');
+
+const MAX_STDIN = 1024 * 1024;
+
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = '';
+    process.stdin.setEncoding('utf8');
+    process.stdin.on('data', chunk => {
+      if (data.length < MAX_STDIN) data += chunk.substring(0, MAX_STDIN - data.length);
+    });
+    process.stdin.on('end', () => resolve(data));
+  });
+}
+
+function getPluginRoot() {
+  return path.resolve(__dirname, '..', '..');
+}
+
+function transformToClaude(cursorInput, overrides = {}) {
+  const server = cursorInput.server || cursorInput.mcp_server || '';
+  const tool = cursorInput.tool || cursorInput.mcp_tool || '';
+  const inferredToolName = cursorInput.tool_name
+    || (server && tool ? `mcp__${server}__${tool}` : '');
+
+  return {
+    tool_name: inferredToolName,
+    server,
+    tool,
+    tool_input: {
+      command: cursorInput.command || cursorInput.args?.command || '',
+      file_path: cursorInput.path || cursorInput.file || cursorInput.args?.filePath || '',
+      server,
+      mcp_server: server,
+      tool,
+      mcp_tool: tool,
+      ...overrides.tool_input,
+    },
+    tool_output: {
+      output: cursorInput.output || cursorInput.result || '',
+      ...overrides.tool_output,
+    },
+    transcript_path: cursorInput.transcript_path || cursorInput.transcriptPath || cursorInput.session?.transcript_path || '',
+    _cursor: {
+      conversation_id: cursorInput.conversation_id,
+      hook_event_name: cursorInput.hook_event_name,
+      workspace_roots: cursorInput.workspace_roots,
+      model: cursorInput.model,
+    },
+  };
+}
+
+function runManagedCommand(command, args, stdinData) {
+  try {
+    const stdout = execFileSync(command, args, {
+      input: typeof stdinData === 'string' ? stdinData : JSON.stringify(stdinData),
+      stdio: ['pipe', 'pipe', 'pipe'],
+      timeout: 15000,
+      cwd: process.cwd(),
+      encoding: 'utf8',
+    });
+
+    return {
+      stdout: stdout || '',
+      stderr: '',
+    };
+  } catch (e) {
+    if (e.status === 2) process.exit(2);
+
+    return {
+      stdout: typeof e.stdout === 'string' ? e.stdout : String(e.stdout || ''),
+      stderr: typeof e.stderr === 'string' ? e.stderr : String(e.stderr || ''),
+    };
+  }
+}
+
+function runExistingHook(scriptName, stdinData) {
+  const scriptPath = path.join(getPluginRoot(), 'scripts', 'hooks', scriptName);
+  return runManagedCommand('node', [scriptPath], stdinData);
+}
+
+function runManagedShellHook(relativeScriptPath, stdinData) {
+  const scriptPath = path.join(getPluginRoot(), relativeScriptPath);
+  return runManagedCommand('bash', [scriptPath], stdinData);
+}
+
+function hookEnabled(hookId, allowedProfiles = ['standard', 'strict']) {
+  const rawProfile = String(process.env.ECC_HOOK_PROFILE || 'standard').toLowerCase();
+  const profile = ['minimal', 'standard', 'strict'].includes(rawProfile) ? rawProfile : 'standard';
+
+  const disabled = new Set(
+    String(process.env.ECC_DISABLED_HOOKS || '')
+      .split(',')
+      .map(v => v.trim().toLowerCase())
+      .filter(Boolean)
+  );
+
+  if (disabled.has(String(hookId || '').toLowerCase())) {
+    return false;
+  }
+
+  return allowedProfiles.includes(profile);
+}
+
+module.exports = {
+  readStdin,
+  getPluginRoot,
+  transformToClaude,
+  runExistingHook,
+  runManagedShellHook,
+  hookEnabled,
+};

package/scripts/cursor-aw-hooks/after-file-edit.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const { readStdin } = require('./adapter');
+const { runNamedCursorAwPhase } = require('./aw-phase-adapter');
+const { PHASE_NAMES } = require('./shared/aw-phase-definitions');
+
+readStdin().then(raw => {
+  return runNamedCursorAwPhase({
+    phaseName: PHASE_NAMES.POST_TOOL_USE_FILE_EDIT,
+    raw,
+  }).then(output => process.stdout.write(output));
+}).catch(() => process.exit(0));

package/scripts/cursor-aw-hooks/after-mcp-execution.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const { readStdin } = require('./adapter');
+const { runNamedCursorAwPhase } = require('./aw-phase-adapter');
+const { PHASE_NAMES } = require('./shared/aw-phase-definitions');
+
+readStdin().then(raw => {
+  return runNamedCursorAwPhase({
+    phaseName: PHASE_NAMES.POST_TOOL_USE_MCP,
+    raw,
+  }).then(output => process.stdout.write(output));
+}).catch(() => process.exit(0));

package/scripts/cursor-aw-hooks/after-shell-execution.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const { readStdin } = require('./adapter');
+const { runNamedCursorAwPhase } = require('./aw-phase-adapter');
+const { PHASE_NAMES } = require('./shared/aw-phase-definitions');
+
+readStdin().then(raw => {
+  return runNamedCursorAwPhase({
+    phaseName: PHASE_NAMES.POST_TOOL_USE_SHELL,
+    raw,
+  }).then(output => process.stdout.write(output));
+}).catch(() => process.exit(0));

package/scripts/cursor-aw-hooks/aw-phase-adapter.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+const {
+  transformToClaude,
+  runExistingHook,
+  runManagedShellHook,
+  hookEnabled,
+} = require('./adapter');
+const { getSharedAwPhaseSteps: getCursorAwPhaseSteps } = require('./shared/aw-phase-definitions');
+const { runSharedAwPhase } = require('./shared/aw-phase-runner');
+
+function runManagedNodeHook(relativeScriptPath, payload) {
+  const scriptName = String(relativeScriptPath || '')
+    .replace(/^scripts\/hooks\//, '')
+    .replace(/^\.cursor\/hooks\//, '');
+  return runExistingHook(scriptName, payload);
+}
+
+async function runCursorAwPhase({ raw, steps, deps = {} }) {
+  return runSharedAwPhase({
+    raw,
+    steps,
+    deps: {
+      transformToClaude: deps.transformToClaude || transformToClaude,
+      runManagedNodeHook: deps.runManagedNodeHook || runManagedNodeHook,
+      runManagedShellHook: deps.runManagedShellHook || runManagedShellHook,
+      hookEnabled: deps.hookEnabled || hookEnabled,
+    },
+  });
+}
+
+function runNamedCursorAwPhase({ phaseName, raw, deps = {} }) {
+  return runCursorAwPhase({
+    raw,
+    steps: getCursorAwPhaseSteps(phaseName),
+    deps,
+  });
+}
+
+module.exports = {
+  runCursorAwPhase,
+  runNamedCursorAwPhase,
+};

package/scripts/cursor-aw-hooks/before-mcp-execution.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const { readStdin } = require('./adapter');
+const { runNamedCursorAwPhase } = require('./aw-phase-adapter');
+const { PHASE_NAMES } = require('./shared/aw-phase-definitions');
+
+readStdin().then(raw => {
+  return runNamedCursorAwPhase({
+    phaseName: PHASE_NAMES.PRE_TOOL_USE_MCP,
+    raw,
+  }).then(output => process.stdout.write(output));
+}).catch(() => process.exit(0));

package/scripts/cursor-aw-hooks/before-shell-execution.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+const { readStdin } = require('./adapter');
+const { runNamedCursorAwPhase } = require('./aw-phase-adapter');
+const { PHASE_NAMES } = require('./shared/aw-phase-definitions');
+
+readStdin().then(raw => {
+  return runNamedCursorAwPhase({
+    phaseName: PHASE_NAMES.PRE_TOOL_USE_SHELL,
+    raw,
+  }).then(output => process.stdout.write(output));
+}).catch(() => process.exit(0));

package/scripts/cursor-aw-hooks/before-submit-prompt.js

@@ -0,0 +1,41 @@
+#!/usr/bin/env node
+const { readStdin, runManagedShellHook } = require('./adapter');
+
+function emitAwPromptReminder(raw) {
+  const result = runManagedShellHook('.cursor/hooks/shared/user-prompt-submit.sh', raw);
+  if (result.stderr) {
+    process.stderr.write(result.stderr);
+  }
+  if (result.stdout) {
+    process.stderr.write(result.stdout.endsWith('\n') ? result.stdout : `${result.stdout}\n`);
+  }
+}
+
+readStdin().then(raw => {
+  try {
+    const input = JSON.parse(raw);
+    const prompt = input.prompt || input.content || input.message || '';
+    const secretPatterns = [
+      /sk-[a-zA-Z0-9]{20,}/,       // OpenAI API keys
+      /ghp_[a-zA-Z0-9]{36,}/,      // GitHub personal access tokens
+      /AKIA[A-Z0-9]{16}/,          // AWS access keys
+      /xox[bpsa]-[a-zA-Z0-9-]+/,   // Slack tokens
+      /-----BEGIN (RSA |EC )?PRIVATE KEY-----/, // Private keys
+    ];
+    for (const pattern of secretPatterns) {
+      if (pattern.test(prompt)) {
+        console.error('[ECC] WARNING: Potential secret detected in prompt!');
+        console.error('[ECC] Remove secrets before submitting. Use environment variables instead.');
+        break;
+      }
+    }
+  } catch (_error) {
+    // Best-effort prompt scanning should never block prompt submission.
+  }
+  try {
+    emitAwPromptReminder(raw);
+  } catch (_error) {
+    // Reminder emission is advisory and should not break the prompt flow.
+  }
+  process.stdout.write(raw);
+}).catch(() => process.exit(0));