@ghl-ai/aw 0.1.70-beta.2 → 0.1.70-beta.4

package/c4/diagnostics.mjs

@@ -9,7 +9,7 @@
  *
  *   diagnoseAwRouterView({ awHome })
  *     Codex-relevant: replays the upstream `find * /skills/* /SKILL.md`
- *     enumeration logic against ~/.aw/.aw_registry/aw/skills/
+ *     enumeration logic against ~/.aw/.aw_registry/platform/core/skills/
  *     and reports which expected stage skills are visible to the
  *     SessionStart hook. Catches Bug A failures (registry path empty
  *     post-init).
@@ -22,7 +22,7 @@
  *     Tests both that the wrapper is registered AND that it actually
  *     emits the router (catches "wrapper installed but does nothing").
  *
- *   diagnoseSkillResolution({ harness, home, awHome, skills })
+ *   diagnoseSkillResolution({ harness, home, awHome, eccHome, skills })
  *     Multi-path × multi-skill probe. For each skill, checks four
  *     candidate paths in priority order. Top-level ok=true ONLY if
  *     using-aw-skills AND every stage skill the slim card promises
@@ -146,8 +146,8 @@ function slashShimSummaryToken(action) {
  * ───────────────────────────────────────────────────────────────────────── */
 
 /**
- * Replay of the AW registry skill scan:
- *   find <awHome>/.aw_registry/aw/skills/<skill>/SKILL.md
+ * Replay of the upstream session-start.sh enumerator scan:
+ *   find <awHome>/.aw_registry/platform -path STAR/skills/STAR/SKILL.md
  *
  * @param {object} opts
  * @param {string} opts.awHome
@@ -156,8 +156,8 @@ function slashShimSummaryToken(action) {
 export function diagnoseAwRouterView({ awHome } = {}) {
   if (!awHome) throw new Error('diagnoseAwRouterView: awHome is required');
 
-  const awSkillsRoot = join(awHome, '.aw_registry/aw/skills');
-  const enumerableSkills = enumerateAwSkills(awSkillsRoot);
+  const platformRoot = join(awHome, '.aw_registry/platform');
+  const enumerableSkills = enumerateRegistrySkills(platformRoot);
   const expected = [...EXPECTED_STAGE_SKILLS];
   const missing = expected.filter((s) => !enumerableSkills.includes(s));
   const ok = missing.length === 0;
@@ -166,23 +166,38 @@ export function diagnoseAwRouterView({ awHome } = {}) {
 }
 
 /**
- * Walk <root>/<skill>/SKILL.md and return the deduped sorted skill names.
+ * Walk <root>/<team>/skills/<skill>/SKILL.md two levels deep, mirroring the
+ * upstream find pattern. Returns the deduped sorted list of skill
+ * directory names.
  */
-function enumerateAwSkills(awSkillsRoot) {
-  if (!existsSync(awSkillsRoot)) return [];
+function enumerateRegistrySkills(platformRoot) {
+  if (!existsSync(platformRoot)) return [];
   const set = new Set();
-  let skills;
+  let teams;
   try {
-    skills = readdirSync(awSkillsRoot, { withFileTypes: true });
+    teams = readdirSync(platformRoot, { withFileTypes: true });
   } catch {
-    // readdir on the AW skills root failed (EACCES, ENOENT). Treat as
+    // readdir on the platform root failed (EACCES, ENOENT). Treat as
     // "no skills enumerable" — the caller's missing-list will surface it.
     return [];
   }
-  for (const skill of skills) {
-    if (!skill.isDirectory()) continue;
-    const skillMd = join(awSkillsRoot, skill.name, 'SKILL.md');
-    if (existsSync(skillMd)) set.add(skill.name);
+  for (const team of teams) {
+    if (!team.isDirectory()) continue;
+    const skillsDir = join(platformRoot, team.name, 'skills');
+    if (!existsSync(skillsDir)) continue;
+    let skills;
+    try {
+      skills = readdirSync(skillsDir, { withFileTypes: true });
+    } catch {
+      // readdir on a team's skills/ subdirectory failed — skip this team
+      // dir but continue probing siblings.
+      continue;
+    }
+    for (const skill of skills) {
+      if (!skill.isDirectory()) continue;
+      const skillMd = join(skillsDir, skill.name, 'SKILL.md');
+      if (existsSync(skillMd)) set.add(skill.name);
+    }
   }
   return [...set].sort();
 }
@@ -322,6 +337,7 @@ function envelopeContainsRouter(output) {
  * @param {Harness} opts.harness
  * @param {string}  opts.home
  * @param {string}  opts.awHome
+ * @param {string}  opts.eccHome
  * @param {string[]} [opts.skills]  Default: DEFAULT_SKILL_LIST
  * @returns {{
  *   perSkill: SkillResolutionResult[],
@@ -334,11 +350,12 @@ export function diagnoseSkillResolution(opts = {}) {
   if (!opts.harness) throw new Error('diagnoseSkillResolution: harness is required');
   if (!opts.home) throw new Error('diagnoseSkillResolution: home is required');
   if (!opts.awHome) throw new Error('diagnoseSkillResolution: awHome is required');
+  if (!opts.eccHome) throw new Error('diagnoseSkillResolution: eccHome is required');
 
-  const { harness, home, awHome } = opts;
+  const { harness, home, awHome, eccHome } = opts;
   const skills = opts.skills ?? [...DEFAULT_SKILL_LIST];
 
-  const perSkill = skills.map((skill) => probeOneSkill(skill, harness, home, awHome));
+  const perSkill = skills.map((skill) => probeOneSkill(skill, harness, home, awHome, eccHome));
   const routerSkill = perSkill.find((e) => e.skill === ROUTER_SKILL) ?? {
     skill: ROUTER_SKILL,
     candidatePathsChecked: [],
@@ -357,11 +374,11 @@ function harnessSkillsDir(harness, home) {
   if (harness === 'claude-web') return join(home, '.claude/skills');
   if (harness === 'cursor-cloud') return join(home, '.cursor/skills');
   // codex-web: registry path is the canonical source; the per-harness skills
-  // dir is conventionally absent. We still probe the AW registry path.
+  // dir is conventionally absent. We still probe the registry + ECC paths.
   return null;
 }
 
-function probeOneSkill(skill, harness, home, awHome) {
+function probeOneSkill(skill, harness, home, awHome, eccHome) {
   const harnessDir = harnessSkillsDir(harness, home);
   const candidatePathsChecked = [];
 
@@ -369,7 +386,8 @@ function probeOneSkill(skill, harness, home, awHome) {
     candidatePathsChecked.push(join(harnessDir, skill, 'SKILL.md'));
     candidatePathsChecked.push(join(harnessDir, `platform-core-${skill}`, 'SKILL.md'));
   }
-  candidatePathsChecked.push(join(awHome, '.aw_registry/aw/skills', skill, 'SKILL.md'));
+  candidatePathsChecked.push(join(awHome, '.aw_registry/platform/core/skills', skill, 'SKILL.md'));
+  candidatePathsChecked.push(join(eccHome, 'skills', skill, 'SKILL.md'));
 
   let found = null;
   for (const p of candidatePathsChecked) {
@@ -526,7 +544,7 @@ function enumerateConfigKeysOnly(filePath) {
 }
 
 function sampleRegistrySkillPaths(awHome, max) {
-  const root = join(awHome, '.aw_registry/aw');
+  const root = join(awHome, '.aw_registry/platform');
   if (!existsSync(root)) return ['  <registry not provisioned>'];
   const out = [];
   walkSkillMd(root, out, max);
@@ -551,7 +569,8 @@ function walkSkillMd(dir, out, max) {
     } else if (e.isDirectory()) {
       walkSkillMd(p, out, max);
     } else if (e.isSymbolicLink()) {
-      // Cheap stat check — symlinks pointing at SKILL.md should still appear.
+      // Cheap stat check — symlinks pointing at SKILL.md (the bridge case)
+      // should still appear in the dump.
       try {
         const st = statSync(p);
         if (st.isFile() && e.name === 'SKILL.md') out.push(p);

package/c4/eccRegistryBridge.mjs

@@ -0,0 +1,236 @@
+/**
+ * c4/eccRegistryBridge.mjs — Codex-only Bug A workaround.
+ *
+ * Codex Web's upstream `aw-session-start.sh` enumerator scans a fixed
+ * registry path:
+ *
+ *   ~/.aw/.aw_registry/platform/core/skills/<name>/SKILL.md
+ *
+ * ECC ships skills under a different path:
+ *
+ *   ~/.aw-ecc/skills/<name>/SKILL.md
+ *
+ * On Codex Web, neither Claude's plugin marketplace nor Cursor's direct
+ * `~/.cursor/skills/...` resolution applies. The only way Codex can see
+ * ECC skills is if the registry path is populated. We bridge by symlinking
+ * each ECC skill's SKILL.md into the registry layout. The default mode keeps
+ * the original non-clobbering behavior. `preferEccSkills` only retargets
+ * existing symlinks; regular files are treated as user-owned and preserved.
+ *
+ * Also installs a fallback symlink at `<homeOf(awHome)>/.aw_registry` →
+ * `<awHome>/.aw_registry` because some legacy hooks read from that path.
+ *
+ * **Scope**: Codex Web only. The orchestrator is responsible for *not*
+ * invoking this on claude-web or cursor-cloud; the module itself is
+ * harness-agnostic and just performs the bridge.
+ */
+
+import {
+  existsSync,
+  lstatSync,
+  readlinkSync,
+  readdirSync,
+  mkdirSync,
+  symlinkSync,
+  unlinkSync,
+} from 'node:fs';
+import { dirname, join } from 'node:path';
+
+/** True iff `path` is a symlink that points to a nonexistent target. */
+function isBrokenSymlink(path) {
+  try {
+    const st = lstatSync(path);
+    if (!st.isSymbolicLink()) return false;
+    return !existsSync(path);
+  } catch {
+    return false;
+  }
+}
+
+/** True iff `path` is a symlink that already points at `target`. */
+function isSymlinkTo(path, target) {
+  try {
+    const st = lstatSync(path);
+    if (!st.isSymbolicLink()) return false;
+    return readlinkSync(path) === target;
+  } catch {
+    return false;
+  }
+}
+
+/** True iff `path` is any symlink, regardless of where it points. */
+function isSymlink(path) {
+  try {
+    return lstatSync(path).isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Install the fallback symlink `~/.aw_registry → ~/.aw/.aw_registry` if not
+ * present and not blocked by an existing real directory. Best-effort.
+ */
+function installRegistryFallbackLink(awHome) {
+  const home = dirname(awHome);
+  const fallback = join(home, '.aw_registry');
+  const target = join(awHome, '.aw_registry');
+
+  if (!existsSync(target)) {
+    // Nothing to point at yet — skip silently.
+    return;
+  }
+
+  let existsAtFallback = false;
+  try {
+    lstatSync(fallback);
+    existsAtFallback = true;
+  } catch {
+    existsAtFallback = false;
+  }
+
+  if (existsAtFallback) return; // do not clobber existing dir/symlink
+
+  try {
+    symlinkSync(target, fallback);
+  } catch {
+    // best-effort
+  }
+}
+
+/**
+ * Symlink every ECC skill into the registry layout. Idempotent.
+ *
+ * Result shape:
+ *   - linked   — skill names freshly bridged this call
+ *   - skipped  — skill names whose registry target already existed and was preserved
+ *   - replaced — skill names whose registry target was replaced with the ECC symlink
+ *   - broken   — skill directories that exist in eccHome/skills/ but have no SKILL.md
+ *                (broken ECC layout — distinct from already-bridged so the orchestrator
+ *                can surface a real diagnostic rather than treating it as success)
+ *   - reason   — only set when the result is fully diagnostic:
+ *                  'ecc-missing'    — eccHome/skills/ does not exist
+ *                  'already-bridged' — every well-formed skill was already linked
+ *                                     and there were no broken skills
+ *
+ * @param {object} opts
+ * @param {string} opts.awHome    Path of the AW home (e.g. ~/.aw).
+ * @param {string} opts.eccHome   Path of the ECC home (e.g. ~/.aw-ecc).
+ * @param {boolean} [opts.preferEccSkills=false]
+ *   Retarget existing registry SKILL.md symlinks to ECC. Regular files are
+ *   never replaced because they may be user-owned overrides.
+ * @returns {{
+ *   linked: string[],
+ *   skipped: string[],
+ *   replaced: string[],
+ *   broken: string[],
+ *   reason?: 'already-bridged' | 'ecc-missing'
+ * }}
+ */
+export function applyEccRegistryBridge({ awHome, eccHome, preferEccSkills = false } = {}) {
+  if (!awHome || !eccHome) {
+    throw new Error('applyEccRegistryBridge: awHome and eccHome are required');
+  }
+
+  const eccSkillsDir = join(eccHome, 'skills');
+  if (!existsSync(eccSkillsDir)) {
+    return { linked: [], skipped: [], broken: [], reason: 'ecc-missing' };
+  }
+
+  const linked = [];
+  const skipped = [];
+  const replaced = [];
+  const broken = [];
+
+  let entries;
+  try {
+    entries = readdirSync(eccSkillsDir, { withFileTypes: true });
+  } catch {
+    return { linked: [], skipped: [], broken: [], reason: 'ecc-missing' };
+  }
+
+  let skillDirCount = 0;
+  for (const entry of entries) {
+    if (!entry.isDirectory()) continue;
+    skillDirCount += 1;
+    const name = entry.name;
+    const source = join(eccSkillsDir, name, 'SKILL.md');
+
+    // ECC skill directory exists but lacks SKILL.md → broken layout.
+    if (!existsSync(source)) {
+      broken.push(name);
+      continue;
+    }
+
+    const targetDir = join(awHome, '.aw_registry/platform/core/skills', name);
+    const target = join(targetDir, 'SKILL.md');
+
+    // If target already exists and is healthy, preserve regular files. The
+    // optional preference mode may only retarget generated symlinks; it must
+    // not delete user-owned registry files.
+    let targetExists = false;
+    try {
+      lstatSync(target);
+      targetExists = true;
+    } catch {
+      targetExists = false;
+    }
+
+    if (targetExists && !isBrokenSymlink(target)) {
+      if (isSymlinkTo(target, source)) {
+        skipped.push(name);
+        continue;
+      }
+
+      if (!preferEccSkills || !isSymlink(target)) {
+        skipped.push(name);
+        continue;
+      }
+
+      try {
+        unlinkSync(target);
+      } catch {
+        broken.push(name);
+        continue;
+      }
+
+      try {
+        symlinkSync(source, target);
+        replaced.push(name);
+      } catch {
+        broken.push(name);
+      }
+      continue;
+    }
+
+    // Either absent or a broken symlink — replace.
+    mkdirSync(targetDir, { recursive: true });
+    if (targetExists) {
+      try { unlinkSync(target); } catch { /* best-effort */ }
+    }
+    try {
+      symlinkSync(source, target);
+      linked.push(name);
+    } catch {
+      // Filesystem may forbid symlinks (rare on Codex Web). Treat as broken
+      // so the orchestrator can surface the real diagnostic.
+      broken.push(name);
+    }
+  }
+
+  installRegistryFallbackLink(awHome);
+
+  const result = { linked, skipped, replaced, broken };
+  // Only flag 'already-bridged' when every well-formed skill was already linked
+  // AND no broken skills exist — i.e. this run was a true no-op.
+  if (
+    skillDirCount > 0 &&
+    linked.length === 0 &&
+    replaced.length === 0 &&
+    broken.length === 0 &&
+    skipped.length === skillDirCount
+  ) {
+    result.reason = 'already-bridged';
+  }
+  return result;
+}

package/c4/index.mjs

@@ -29,6 +29,7 @@ export {
   verifyAuth,
   preflightPlatformDocs,
 } from './gitAuth.mjs';
+export { applyEccRegistryBridge } from './eccRegistryBridge.mjs';
 export {
   SLIM_CARD_HARD_CEILING_BYTES,
   REQUIRED_ENFORCEMENT_PHRASES,
@@ -48,7 +49,7 @@ export {
 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 { ensureCommandSurface, ensureRegistryCommandSurface, diagnoseCommandResolution } from './commandSurface.mjs';
 export { installCursorSlashShim, CURSOR_SLASH_SHIM_RULE } from './cursorRulesShim.mjs';
 export { ensureRepoLocalClaudeSettings } from './repoLocalClaudeSettings.mjs';
 export { copyRepoRootInstructions } from './repoRootInstructions.mjs';

package/c4/preflight.mjs

@@ -2,7 +2,7 @@
  * c4/preflight.mjs — preflight aggregator for `aw c4`.
  *
  * Composes harness, token resolution, REST-API auth verification, gh CLI
- * presence, AW registry-skill probe, and disk-free reporting into a single
+ * presence, ECC bridge-status probe, and disk-free reporting into a single
  * PreflightResult shape with per-failure recommendation strings. Pure
  * orchestration over already-tested c4 primitives — no new I/O patterns.
  *
@@ -71,10 +71,10 @@ const REC = Object.freeze({
     `Insufficient disk: ${mb}MB free (aw c4 needs at least ${DISK_FREE_THRESHOLD_MB}MB ` +
     'for ECC clone + registry pull).',
   bridgeWillInstall:
-    'AW registry skills will be installed during this run from platform-docs ' +
-    '(Codex uses ~/.aw/.aw_registry/aw/skills for stage routing).',
+    'ECC registry bridge will be installed during this run (Codex only — ' +
+    'Bug A workaround that symlinks ECC stage skills into ~/.aw/.aw_registry).',
   bridgeFailed:
-    'AW registry skills are not yet provisioned — aw init will create them ' +
+    'ECC and/or AW registry not yet provisioned — aw init will create them ' +
     'on the first c4 run; re-run preflight afterwards.',
 });
 
@@ -120,18 +120,22 @@ function classifyAuthError(verifyResult) {
   return 'unknown';
 }
 
-function probeBridgeStatus(harness, awHome) {
+function probeBridgeStatus(harness, awHome, eccHome) {
   if (harness !== 'codex-web') return 'ok';
 
-  // AW skills are now owned by platform-docs under the top-level aw namespace.
-  // If aw-plan is already present in the registry path, routing is ready.
-  const awSkillPath = join(
+  // Bridge installs ~/.aw/.aw_registry/platform/core/skills/<aw-*>/SKILL.md
+  // symlinks pointing at ~/.aw-ecc/skills/<aw-*>/SKILL.md. If aw-plan is
+  // already present in the registry path, the bridge is a no-op (ok).
+  const bridgedSkillPath = join(
     awHome,
-    '.aw_registry/aw/skills/aw-plan/SKILL.md',
+    '.aw_registry/platform/core/skills/aw-plan/SKILL.md',
   );
-  if (existsSync(awSkillPath)) return 'ok';
+  if (existsSync(bridgedSkillPath)) return 'ok';
 
-  if (existsSync(awHome)) return 'will-install';
+  // Bridge can install when both ECC home and the registry skeleton exist.
+  // (The aw-plan skill source must exist somewhere — the bridge follows
+  // applyEccRegistryBridge's contract; preflight only certifies feasibility.)
+  if (existsSync(eccHome) && existsSync(awHome)) return 'will-install';
 
   return 'failed';
 }
@@ -176,6 +180,7 @@ function buildRecommendations({
  * @param {typeof globalThis.fetch} [opts.fetchImpl]
  * @param {string}  [opts.home]      Defaults to env.HOME.
  * @param {string}  [opts.awHome]    Defaults to <home>/.aw.
+ * @param {string}  [opts.eccHome]   Defaults to <home>/.aw-ecc.
  * @param {number}  [opts.diskFreeMb]  Inject for tests; production defaults to a real statfs probe.
  * @returns {Promise<PreflightResult>}
  */
@@ -195,6 +200,7 @@ export async function runPreflight(opts = {}) {
   // when env is the injected `{}`, opts.home should have been passed instead.
   const home = opts.home ?? env.HOME ?? '~';
   const awHome = opts.awHome ?? join(home, '.aw');
+  const eccHome = opts.eccHome ?? join(home, '.aw-ecc');
 
   // 1. Token resolution.
   const { token, source: tokenSource } = getGithubToken(env);
@@ -215,7 +221,7 @@ export async function runPreflight(opts = {}) {
   const ghCliPresent = runShell(shell, 'command -v gh').ok;
 
   // 4. Bridge status (codex-web only; other harnesses always 'ok').
-  const bridgeStatus = probeBridgeStatus(harness, awHome);
+  const bridgeStatus = probeBridgeStatus(harness, awHome, eccHome);
 
   // 5. Disk free MB. For tests, callers inject the value directly; in
   //    production the orchestrator passes a measured number. Defaulting to

package/c4/templates/scripts/aw-c4-bootstrap.sh

@@ -129,30 +129,30 @@ aw_c4_exit=$?
 
 # Defense-in-depth: `aw c4` delegates registry sync to `aw init --silent`,
 # which can fail to fetch in silent mode without surfacing an error. When
-# that happens, the registry (~/.aw/.aw_registry) may be empty or incomplete.
-# Re-run `aw pull` post-c4 if the AW skill count looks low.
-verify_registry_skills() {
-  local aw_registry_dir="$HOME/.aw/.aw_registry"
-  local aw_skills_dir="$aw_registry_dir/aw/skills"
-  if [ ! -d "$aw_registry_dir" ]; then
+# that happens, the registry (~/.aw/.aw_registry) may be empty or incomplete
+# and only the 10 hardcoded stage commands get linked. Re-run `aw pull`
+# post-c4 if the command count looks low.
+verify_registry_commands() {
+  local aw_cmd_dir="$HOME/.aw/.aw_registry"
+  if [ ! -d "$aw_cmd_dir" ]; then
     echo "[aw-c4-bootstrap] registry dir missing — running aw init + pull"
     aw init --no-integrations --silent 2>&1 | tail -3 || true
     aw pull 2>&1 | tail -5 || true
     return
   fi
 
-  local skill_count
-  skill_count=$( (find "$aw_skills_dir" -name 'SKILL.md' 2>/dev/null || true) | wc -l | tr -d ' ' )
-  if [ "${skill_count:-0}" -lt 5 ]; then
-    echo "[aw-c4-bootstrap] only ${skill_count} AW registry skills found — running aw pull"
+  local cmd_count
+  cmd_count=$(find "$aw_cmd_dir" -name '*.md' -path '*/commands/*' ! -path '*/evals/*' 2>/dev/null | wc -l | tr -d ' ')
+  if [ "${cmd_count:-0}" -lt 20 ]; then
+    echo "[aw-c4-bootstrap] only ${cmd_count} registry commands found — running aw pull"
     aw pull 2>&1 | tail -5 || true
     local new_count
-    new_count=$( (find "$aw_skills_dir" -name 'SKILL.md' 2>/dev/null || true) | wc -l | tr -d ' ' )
-    echo "[aw-c4-bootstrap] AW registry skills: ${skill_count} -> ${new_count}"
+    new_count=$(find "$aw_cmd_dir" -name '*.md' -path '*/commands/*' ! -path '*/evals/*' 2>/dev/null | wc -l | tr -d ' ')
+    echo "[aw-c4-bootstrap] registry commands: ${cmd_count} → ${new_count}"
   else
-    echo "[aw-c4-bootstrap] registry: ${skill_count} AW skills OK"
+    echo "[aw-c4-bootstrap] registry: ${cmd_count} commands OK"
   fi
 }
-verify_registry_skills || true
+verify_registry_commands || true
 
 exit "$aw_c4_exit"

package/codex.mjs

@@ -88,19 +88,10 @@ set -euo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 ROOT_DIR="$(cd "\${SCRIPT_DIR}/.." && pwd)"
-TARGET_SCRIPT=""
-for candidate in \
-  "\$ROOT_DIR/.aw/.aw_registry/aw/skills/using-aw-skills/hooks/session-start.sh" \
-  "\$ROOT_DIR/.aw_registry/aw/skills/using-aw-skills/hooks/session-start.sh"
-do
-  if [[ -f "\$candidate" ]]; then
-    TARGET_SCRIPT="\$candidate"
-    break
-  fi
-done
-
-if [[ -z "\$TARGET_SCRIPT" ]]; then
-  echo '{"hookSpecificOutput": {"hookEventName": "SessionStart", "additionalContext": "WARNING: AW session-start hook not found at .aw_registry/aw/skills/using-aw-skills/hooks/session-start.sh. Run aw pull platform or aw init."}}'
+TARGET_SCRIPT="\$ROOT_DIR/.aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh"
+
+if [[ ! -f "\$TARGET_SCRIPT" ]]; then
+  echo '{"hookSpecificOutput": {"hookEventName": "SessionStart", "additionalContext": "WARNING: AW session-start hook not found at .aw_registry/platform/core/skills/using-aw-skills/hooks/session-start.sh. Run aw pull platform or aw init."}}'
   exit 0
 fi