aw-ecc 1.4.23 → 1.4.31

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

@@ -6,6 +6,7 @@
  */
 
 const { execFileSync } = require('child_process');
+const fs = require('fs');
 const path = require('path');
 
 const MAX_STDIN = 1024 * 1024;
@@ -22,7 +23,18 @@ function readStdin() {
 }
 
 function getPluginRoot() {
-  return path.resolve(__dirname, '..', '..');
+  const homeStyleRoot = path.resolve(__dirname, '..');
+  const repoStyleRoot = path.resolve(__dirname, '..', '..');
+
+  if (
+    fs.existsSync(path.join(repoStyleRoot, 'package.json'))
+    && fs.existsSync(path.join(repoStyleRoot, 'scripts', 'hooks'))
+    && fs.existsSync(path.join(repoStyleRoot, '.cursor', 'hooks'))
+  ) {
+    return repoStyleRoot;
+  }
+
+  return homeStyleRoot;
 }
 
 function transformToClaude(cursorInput, overrides = {}) {
@@ -83,12 +95,31 @@ function runManagedCommand(command, args, stdinData) {
 }
 
 function runExistingHook(scriptName, stdinData) {
-  const scriptPath = path.join(getPluginRoot(), 'scripts', 'hooks', scriptName);
+  const root = getPluginRoot();
+  const candidates = [
+    path.join(root, 'scripts', 'hooks', scriptName),
+    path.join(root, 'hooks', scriptName),
+  ];
+  const scriptPath = candidates.find(candidate => fs.existsSync(candidate)) || candidates[0];
   return runManagedCommand('node', [scriptPath], stdinData);
 }
 
 function runManagedShellHook(relativeScriptPath, stdinData) {
-  const scriptPath = path.join(getPluginRoot(), relativeScriptPath);
+  const root = getPluginRoot();
+  const normalized = String(relativeScriptPath || '').replace(/\\/g, '/');
+  const fallbackCandidates = [
+    normalized,
+    normalized.replace(/^\.cursor\//, ''),
+    normalized.replace(/^scripts\//, ''),
+    normalized.replace(/^hooks\//, ''),
+    path.posix.join('.cursor', normalized),
+    path.posix.join('scripts', normalized),
+    path.posix.join('hooks', normalized),
+  ];
+  const scriptPath = fallbackCandidates
+    .map(candidate => path.join(root, candidate))
+    .find(candidate => fs.existsSync(candidate))
+    || path.join(root, normalized);
   return runManagedCommand('bash', [scriptPath], stdinData);
 }
 

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

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+const {
+  SHARED_AW_PHASE_STEPS: CURSOR_AW_PHASE_STEPS,
+  getSharedAwPhaseSteps: getCursorAwPhaseSteps,
+} = require('./shared/aw-phase-definitions');
+
+module.exports = {
+  CURSOR_AW_PHASE_STEPS,
+  getCursorAwPhaseSteps,
+};

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

@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+RAW="$(cat || true)"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+RESULT="$(printf '%s' "$RAW" | node "$SCRIPT_DIR/before-submit-prompt.js" 2>&1 1>/tmp/aw_cursor_before_submit_stdout.$$)"
+STATUS=$?
+STDOUT_CONTENT="$(cat /tmp/aw_cursor_before_submit_stdout.$$ 2>/dev/null || true)"
+rm -f /tmp/aw_cursor_before_submit_stdout.$$
+
+if [ -n "$RESULT" ]; then
+  printf '%s\n' "$RESULT" >&2
+fi
+
+printf '%s' "${STDOUT_CONTENT:-$RAW}"
+exit "$STATUS"

package/scripts/cursor-aw-hooks/session-start.sh

@@ -0,0 +1,36 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+RAW="$(cat || true)"
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+
+RESULT="$(printf '%s' "$RAW" | bash "$SCRIPT_DIR/shared/session-start.sh")"
+
+if [ -z "$RESULT" ]; then
+  printf '%s' "$RAW"
+  exit 0
+fi
+
+JSON_CONTEXT="$(
+  printf '%s' "$RESULT" | node -e '
+    let input = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", chunk => input += chunk);
+    process.stdin.on("end", () => {
+      try {
+        const parsed = JSON.parse(input || "{}");
+        const context =
+          (parsed && parsed.hookSpecificOutput && parsed.hookSpecificOutput.additionalContext) ||
+          parsed.additional_context ||
+          "";
+        if (typeof context === "string" && context.trim()) {
+          process.stdout.write(JSON.stringify({ additional_context: context }, null, 2) + "\n");
+          return;
+        }
+      } catch {}
+      process.stdout.write(process.env.ECC_FALLBACK_RAW || "");
+    });
+  ' ECC_FALLBACK_RAW="$RAW"
+)"
+
+printf '%s' "$JSON_CONTEXT"

package/scripts/hooks/session-start-rules-context.sh

@@ -2,4 +2,11 @@
 set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-exec bash "$SCRIPT_DIR/shared/user-prompt-submit.sh"
+REMINDER="$(bash "$SCRIPT_DIR/shared/user-prompt-submit.sh" || true)"
+
+if [[ -z "${REMINDER}" ]]; then
+  exit 0
+fi
+
+JSON_REMINDER="$(printf '%s' "$REMINDER" | python3 -c 'import json, sys; print(json.dumps(sys.stdin.read()))')"
+printf '{"hookSpecificOutput":{"hookEventName":"UserPromptSubmit","additionalContext":%s}}\n' "$JSON_REMINDER"

package/scripts/hooks/shared/aw-phase-definitions.js

@@ -6,6 +6,7 @@ const SHARED_AW_PHASE_STEPS = Object.freeze({
       runner: 'shell',
       relativeScriptPath: '.cursor/hooks/shared/session-start.sh',
       payloadMode: 'raw',
+      outputMode: 'cursor-session-start',
     },
   ],
   'user-prompt-submit': [
@@ -157,24 +158,6 @@ const SHARED_AW_PHASE_STEPS = Object.freeze({
   ],
 });
 
-/**
- * Canonical string constants for all AW hook phase names.
- * Use these instead of raw string literals to get typo-safety and IDE
- * auto-complete in files that call runNamedCursorAwPhase() or equivalent.
- */
-const PHASE_NAMES = Object.freeze({
-  SESSION_START: 'session-start',
-  USER_PROMPT_SUBMIT: 'user-prompt-submit',
-  PRE_TOOL_USE_SHELL: 'pre-tool-use-shell',
-  PRE_TOOL_USE_MCP: 'pre-tool-use-mcp',
-  POST_TOOL_USE_SHELL: 'post-tool-use-shell',
-  POST_TOOL_USE_FILE_EDIT: 'post-tool-use-file-edit',
-  POST_TOOL_USE_MCP: 'post-tool-use-mcp',
-  PRE_COMPACT: 'pre-compact',
-  SESSION_END: 'session-end',
-  STOP: 'stop',
-});
-
 function getSharedAwPhaseSteps(phaseName) {
   const steps = SHARED_AW_PHASE_STEPS[phaseName];
   if (!steps) {
@@ -184,7 +167,6 @@ function getSharedAwPhaseSteps(phaseName) {
 }
 
 module.exports = {
-  PHASE_NAMES,
   SHARED_AW_PHASE_STEPS,
   getSharedAwPhaseSteps,
 };

package/scripts/hooks/shared/aw-phase-runner.js

@@ -26,6 +26,37 @@ function executeStep(runtime, step, payload) {
   return runtime.runManagedNodeHook(step.relativeScriptPath, payload);
 }
 
+function formatCursorSessionStartOutput(stdout, fallbackRaw) {
+  if (typeof stdout !== 'string' || stdout.trim() === '') {
+    return fallbackRaw;
+  }
+
+  try {
+    const payload = JSON.parse(stdout);
+    const additionalContext = payload?.hookSpecificOutput?.additionalContext
+      || payload?.additional_context;
+
+    if (typeof additionalContext === 'string' && additionalContext.trim() !== '') {
+      return `${JSON.stringify({ additional_context: additionalContext }, null, 2)}\n`;
+    }
+  } catch {}
+
+  return fallbackRaw;
+}
+
+function resolveStepOutput(step, execution, fallbackRaw) {
+  if (!execution) {
+    return null;
+  }
+
+  switch (step.outputMode) {
+    case 'cursor-session-start':
+      return formatCursorSessionStartOutput(execution.stdout, fallbackRaw);
+    default:
+      return null;
+  }
+}
+
 async function runSharedAwPhase({ raw, steps, deps = {} }) {
   const runtime = {
     transformToClaude: deps.transformToClaude,
@@ -43,6 +74,7 @@ async function runSharedAwPhase({ raw, steps, deps = {} }) {
 
   const needsClaudeInput = steps.some(step => (step.payloadMode || 'claude') === 'claude');
   const claudeInput = needsClaudeInput ? runtime.transformToClaude(parsedInput) : null;
+  let result = raw;
 
   for (const step of steps) {
     if (!shouldRunStep(step, runtime)) {
@@ -50,10 +82,14 @@ async function runSharedAwPhase({ raw, steps, deps = {} }) {
     }
 
     const payload = resolveStepPayload(step, raw, parsedInput, claudeInput);
-    await executeStep(runtime, step, payload);
+    const execution = await executeStep(runtime, step, payload);
+    const nextResult = resolveStepOutput(step, execution, raw);
+    if (typeof nextResult === 'string') {
+      result = nextResult;
+    }
   }
 
-  return raw;
+  return result;
 }
 
 module.exports = {

package/scripts/hooks/shared/user-prompt-submit.sh

@@ -1,71 +1,51 @@
 #!/usr/bin/env bash
-# UserPromptSubmit hook — emit a small, reliable AW routing reminder.
-#
-# This hook intentionally stays simple:
-# - drain stdin so the harness can always finish writing payloads
-# - remind the model to re-apply using-aw-skills
-# - point at AGENTS.md and the canonical .aw_rules/platform tree when present
-
 set -euo pipefail
 
-cat >/dev/null || true
-
-# On Windows (Git Bash / MSYS), pwd returns POSIX paths (/tmp/...)
-# but callers use native Windows paths (C:\Users\...).
-# Convert via cygpath when available so paths match the caller's format.
-if command -v cygpath >/dev/null 2>&1; then
-  CWD="$(cygpath -w "$(pwd)")"
-else
-  CWD="$(pwd)"
-fi
-AGENTS_PATH="$CWD/AGENTS.md"
-RULES_ROOT=""
-
-for candidate in \
-  "$CWD/.aw_rules/platform" \
-  "$HOME/.aw_rules/platform" \
-  "$HOME/.aw/.aw_rules/platform"
-do
-  if [ -d "$candidate" ]; then
-    RULES_ROOT="$candidate"
-    break
-  fi
-done
-
-RULE_REFS=()
+RAW="$(cat || true)"
+
+extract_workspace_root() {
+  printf '%s' "$1" | sed -n 's/.*"workspace_roots"[[:space:]]*:[[:space:]]*\[[[:space:]]*"\([^"]*\)".*/\1/p' | head -n 1
+}
+
+extract_cwd() {
+  printf '%s' "$1" | sed -n 's/.*"cwd"[[:space:]]*:[[:space:]]*"\([^"]*\)".*/\1/p' | head -n 1
+}
+
+resolve_rules_root() {
+  local root="${1:-}"
+  local cwd_dir
+  cwd_dir="$(pwd)"
+  local candidate
+
+  for candidate in \
+    "$root/.aw/.aw_rules/platform" \
+    "$root/.aw_rules/platform" \
+    "$cwd_dir/.aw/.aw_rules/platform" \
+    "$cwd_dir/.aw_rules/platform" \
+    "$HOME/.aw/.aw_rules/platform" \
+    "$HOME/.aw_rules/platform" \
+    "$HOME/.aw/.aw_registry/.aw_rules/platform"
+  do
+    if [ -n "$candidate" ] && [ -d "$candidate" ]; then
+      printf '%s' "$candidate"
+      return 0
+    fi
+  done
 
-if [ -f "$AGENTS_PATH" ]; then
-  RULE_REFS+=("$AGENTS_PATH")
-fi
+  return 1
+}
 
-if [ -n "$RULES_ROOT" ]; then
-  if [ -f "$RULES_ROOT/universal/AGENTS.md" ]; then
-    RULE_REFS+=("$RULES_ROOT/universal/AGENTS.md")
-  fi
-  if [ -f "$RULES_ROOT/security/AGENTS.md" ]; then
-    RULE_REFS+=("$RULES_ROOT/security/AGENTS.md")
-  fi
-  RULE_SCOPE="Applicable domain rules live under $RULES_ROOT."
-else
-  RULE_SCOPE="Applicable domain rules live under .aw_rules/platform when synced."
+WORKSPACE_ROOT="$(extract_workspace_root "$RAW")"
+if [ -z "$WORKSPACE_ROOT" ]; then
+  WORKSPACE_ROOT="$(extract_cwd "$RAW")"
 fi
 
-if [ "${#RULE_REFS[@]}" -gt 0 ]; then
-  RULE_PATHS=""
-  while IFS= read -r line; do
-    if [ -z "$RULE_PATHS" ]; then
-      RULE_PATHS="$line"
-    else
-      RULE_PATHS="$RULE_PATHS, $line"
-    fi
-  done < <(printf '%s\n' "${RULE_REFS[@]}" | awk '!seen[$0]++')
-else
-  RULE_PATHS="AGENTS.md"
+RULES_ROOT="$(resolve_rules_root "$WORKSPACE_ROOT" || true)"
+if [ -z "$RULES_ROOT" ]; then
+  RULES_ROOT="$HOME/.aw_rules/platform"
 fi
 
 cat <<EOF
-[AW Router reminder] Re-apply using-aw-skills for this prompt and select the smallest correct AW route and stage skill before substantive work.
-[Rules reminder] Start with $RULE_PATHS. Universal and security rules always apply. $RULE_SCOPE
+[AW Router reminder] Re-apply using-aw-skills and select the smallest correct AW route before substantive work.
+[Rule reminder] Read ${RULES_ROOT}/universal/AGENTS.md and ${RULES_ROOT}/security/AGENTS.md, then the touched domain AGENTS.md plus references/ on demand.
 EOF
-
-exit 0

package/scripts/lib/cursor-aw-hook-files.js

@@ -9,9 +9,11 @@ const CURSOR_AW_HOOK_FILES = Object.freeze([
   'before-mcp-execution.js',
   'before-shell-execution.js',
   'before-submit-prompt.js',
+  'before-submit-prompt.sh',
   'pre-compact.js',
   'session-end.js',
   'session-start.js',
+  'session-start.sh',
   'stop.js',
 ]);
 

package/scripts/lib/cursor-hook-config.js

@@ -1,16 +1,46 @@
 const { getCursorMappedEventNames } = require('./aw-hook-contract');
 
+function buildManagedCursorHookCommand(scriptFileName) {
+  const scriptName = String(scriptFileName || '').replace(/\\/g, '/');
+  const launcher = [
+    "const fs=require('fs')",
+    "const path=require('path')",
+    "const os=require('os')",
+    `const scriptName=${JSON.stringify(scriptName)}`,
+    "const candidates=[path.join(process.cwd(), '.cursor', 'hooks', scriptName),path.join(os.homedir(), '.cursor', 'hooks', scriptName)]",
+    "const target=candidates.find(candidate => fs.existsSync(candidate))",
+    "if(!target) process.exit(0)",
+    "require(target)",
+  ].join(';');
+
+  return `node -e ${JSON.stringify(launcher)}`;
+}
+
+function buildManagedCursorShellCommand(scriptFileName) {
+  const scriptName = String(scriptFileName || '').replace(/\\/g, '/');
+  const command = [
+    'bash -lc',
+    JSON.stringify(
+      `for candidate in "$PWD/.cursor/hooks/${scriptName}" "$HOME/.cursor/hooks/${scriptName}"; do ` +
+        `if [ -f "$candidate" ]; then exec bash "$candidate"; fi; ` +
+      'done; exit 0'
+    ),
+  ].join(' ');
+
+  return command;
+}
+
 const CURSOR_HOOK_ENTRIES = Object.freeze({
   sessionStart: [
     {
-      command: 'node .cursor/hooks/session-start.js',
+      command: buildManagedCursorShellCommand('session-start.sh'),
       event: 'sessionStart',
       description: 'Load previous context and detect environment',
     },
   ],
   sessionEnd: [
     {
-      command: 'node .cursor/hooks/session-end.js',
+      command: buildManagedCursorHookCommand('session-end.js'),
       event: 'sessionEnd',
       description: 'Persist session state and evaluate patterns',
     },
@@ -22,91 +52,91 @@ const CURSOR_HOOK_ENTRIES = Object.freeze({
       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',
+      command: buildManagedCursorHookCommand('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',
+      command: buildManagedCursorHookCommand('after-shell-execution.js'),
       event: 'afterShellExecution',
       description: 'PR URL logging, build analysis',
     },
   ],
   afterFileEdit: [
     {
-      command: 'node .cursor/hooks/after-file-edit.js',
+      command: buildManagedCursorHookCommand('after-file-edit.js'),
       event: 'afterFileEdit',
       description: 'Auto-format, TypeScript check, console.log warning',
     },
   ],
   beforeMCPExecution: [
     {
-      command: 'node .cursor/hooks/before-mcp-execution.js',
+      command: buildManagedCursorHookCommand('before-mcp-execution.js'),
       event: 'beforeMCPExecution',
       description: 'MCP audit logging and untrusted server warning',
     },
   ],
   afterMCPExecution: [
     {
-      command: 'node .cursor/hooks/after-mcp-execution.js',
+      command: buildManagedCursorHookCommand('after-mcp-execution.js'),
       event: 'afterMCPExecution',
       description: 'MCP result logging',
     },
   ],
   beforeReadFile: [
     {
-      command: 'node .cursor/hooks/before-read-file.js',
+      command: buildManagedCursorHookCommand('before-read-file.js'),
       event: 'beforeReadFile',
       description: 'Warn when reading sensitive files (.env, .key, .pem)',
     },
   ],
   beforeSubmitPrompt: [
     {
-      command: 'node .cursor/hooks/before-submit-prompt.js',
+      command: buildManagedCursorShellCommand('before-submit-prompt.sh'),
       event: 'beforeSubmitPrompt',
       description: 'Detect secrets in prompts (sk-, ghp_, AKIA patterns)',
     },
   ],
   subagentStart: [
     {
-      command: 'node .cursor/hooks/subagent-start.js',
+      command: buildManagedCursorHookCommand('subagent-start.js'),
       event: 'subagentStart',
       description: 'Log agent spawning for observability',
     },
   ],
   subagentStop: [
     {
-      command: 'node .cursor/hooks/subagent-stop.js',
+      command: buildManagedCursorHookCommand('subagent-stop.js'),
       event: 'subagentStop',
       description: 'Log agent completion',
     },
   ],
   beforeTabFileRead: [
     {
-      command: 'node .cursor/hooks/before-tab-file-read.js',
+      command: buildManagedCursorHookCommand('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',
+      command: buildManagedCursorHookCommand('after-tab-file-edit.js'),
       event: 'afterTabFileEdit',
       description: 'Auto-format Tab edits',
     },
   ],
   preCompact: [
     {
-      command: 'node .cursor/hooks/pre-compact.js',
+      command: buildManagedCursorHookCommand('pre-compact.js'),
       event: 'preCompact',
       description: 'Save state before context compaction',
     },
   ],
   stop: [
     {
-      command: 'node .cursor/hooks/stop.js',
+      command: buildManagedCursorHookCommand('stop.js'),
       event: 'stop',
       description: 'Console.log audit on all modified files',
     },
@@ -144,5 +174,7 @@ module.exports = {
   CURSOR_HOOK_ENTRIES,
   buildCursorHookEntries,
   buildCursorHookConfig,
+  buildManagedCursorHookCommand,
+  buildManagedCursorShellCommand,
   serializeCursorHookConfig,
 };

package/scripts/lib/install-executor.js

@@ -418,6 +418,13 @@ function planCursorLegacyInstall(context) {
     sourceRelativeDir: path.join('.cursor', 'commands'),
     destinationDir: path.join(targetRoot, 'commands'),
   });
+  addRecursiveCopyOperations(operations, {
+    moduleId: 'legacy-cursor-install',
+    sourceRoot: context.sourceRoot,
+    sourceRelativeDir: path.join('scripts', 'hooks'),
+    destinationDir: path.join(targetRoot, 'scripts', 'hooks'),
+    strategy: 'sync-root-children',
+  });
   addRecursiveCopyOperations(operations, {
     moduleId: 'legacy-cursor-install',
     sourceRoot: context.sourceRoot,

package/scripts/lib/install-targets/cursor-project.js

@@ -49,6 +49,13 @@ module.exports = createInstallTargetAdapter({
         if (sourceRelativePath === '.cursor') {
           return [
             adapter.createScaffoldOperation(module.id, sourceRelativePath, planningInput),
+            createRemappedOperation(
+              adapter,
+              module.id,
+              path.join('scripts', 'hooks'),
+              path.join(targetRoot, 'scripts', 'hooks'),
+              { strategy: 'sync-root-children' }
+            ),
             createRemappedOperation(
               adapter,
               module.id,