@kaydash9999/banker-plugins 0.21.0 → 0.23.0

package/bin/banker.js

@@ -12,6 +12,7 @@ const os = require('os');
 const path = require('path');
 const cp = require('child_process');
 const { pathToFileURL } = require('url');
+const { codexFrontmatter, commandSkillText } = require('./lib/command-skill.cjs');
 
 const PKG_ROOT = path.resolve(__dirname, '..');
 const MANIFEST = path.join(PKG_ROOT, 'codex', 'manifest.json');
@@ -33,15 +34,22 @@ function isoTime(t) {
   return Number.isNaN(d.getTime()) ? '' : d.toISOString();
 }
 
+// What banker starts by bare name (gh, claude) runs from the home folder with Windows' search of the current folder off:
+// on Windows the program search (cmd, and CreateProcess through libuv) looks in the current folder before PATH, and the
+// current folder may be a project with a planted gh.exe or claude.cmd.
+function bareSpawnOpts() {
+  return { cwd: os.homedir(), env: { ...process.env, NoDefaultCurrentDirectoryInExePath: '1' } };
+}
+
 // GitHub 저장소에 별을 단다 (gh CLI 인증 사용). star 는 repo 쓰기 권한이 필요 없어 인증된 어느 계정으로도
 // 가능하다. gh 미설치/미인증/실패는 {ok:false, reason} 로 반환해 호출부가 URL 안내로 폴백하게 한다.
 // spawn 은 테스트 주입용(기본 cp.spawnSync). 자체 timeout·오류삼킴으로 setup 을 절대 막지 않는다.
 function starRepo(spawn = cp.spawnSync) {
   try {
-    const v = spawn('gh', ['--version'], { stdio: 'ignore', timeout: 3000, windowsHide: true });
+    const v = spawn('gh', ['--version'], { stdio: 'ignore', timeout: 3000, windowsHide: true, ...bareSpawnOpts() });
     if (v.error || v.status !== 0) return { ok: false, reason: 'gh CLI 없음' };
     const r = spawn('gh', ['api', '-X', 'PUT', `/user/starred/${REPO_SLUG}`],
-      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 10000, windowsHide: true });
+      { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'], timeout: 10000, windowsHide: true, ...bareSpawnOpts() });
     if (r.error) return { ok: false, reason: r.error.message };
     if (r.status !== 0) {
       const msg = (`${r.stderr || r.stdout || ''}`).trim().split('\n')[0] || `gh exited ${r.status}`;
@@ -150,29 +158,31 @@ function readSkillName(skillMd) {
 
 // Codex discovers skills by directory and expects the SKILL.md frontmatter `name:` to equal the
 // directory name. Our Codex dir is `banker-<name>` (prefixed to avoid colliding with omx/system
-// skills), so rewrite ONLY the first `name:` line inside the YAML frontmatter to match.
-function setCodexSkillName(skillMd, newName, dryRun) {
-  if (dryRun) { log(`  [dry-run] set frontmatter name: ${newName}`); return; }
+// skills), so rewrite ONLY the first `name:` line inside the YAML frontmatter to match, and the
+// `description:` line when the manifest gives the skill a Codex one (codexDescription).
+function setCodexSkillName(skillMd, newName, dryRun, description) {
+  if (dryRun) { log(`  [dry-run] set frontmatter name: ${newName}${description ? ' and the Codex description' : ''}`); return; }
   let src;
   try { src = fs.readFileSync(skillMd, 'utf8'); } catch { return; }
-  const fm = src.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!fm) return;                                   // no frontmatter — leave untouched
-  let block = fm[1];
-  block = /^name:.*$/m.test(block) ? block.replace(/^name:.*$/m, `name: ${newName}`) : `name: ${newName}\n${block}`;
-  fs.writeFileSync(skillMd, src.slice(0, fm.index) + `---\n${block}\n---` + src.slice(fm.index + fm[0].length));
+  const out = codexFrontmatter(src, newName, description);  // no frontmatter: left untouched
+  if (out !== src) fs.writeFileSync(skillMd, out);
 }
 
-// A command as a Codex skill: the command's description becomes the skill's, under name: <name>. Codex skills get
-// no $ARGUMENTS substitution, so a note says where the arguments come from.
-function writeCommandSkill(src, destDir, name, dryRun) {
+// The name Codex gives a skill (manifest codexName: setup-omc is setup-omx there), and Claude name to Codex name.
+function codexNameOf(s) { return s.codexName || s.name; }
+function codexRenames(m) { return Object.fromEntries(eligible(m).filter(s => s.codexName).map(s => [s.name, s.codexName])); }
+
+// Installed banker-<old> skill folders whose skill Codex now names apart, as [old, new] folder names (found before the sweep).
+function renamedInstalls(skillsDir, m) {
+  return eligible(m).filter(s => s.codexName && fs.existsSync(path.join(skillsDir, `banker-${s.name}`, 'SKILL.md')))
+    .map(s => [`banker-${s.name}`, `banker-${s.codexName}`]);
+}
+
+// A command as a Codex skill (bin/lib/command-skill.cjs, shared with the Codex plugin's codex/command-skills/).
+function writeCommandSkill(src, destDir, name, dryRun, codex = {}) {
   if (dryRun) { log(`  [dry-run] write command skill ${path.relative(PKG_ROOT, src)} -> ${destDir}`); return; }
-  const text = fs.readFileSync(src, 'utf8');
-  const fm = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
-  const desc = fm && fm[1].match(/^description:\s*(.*)$/m);
-  const body = fm ? text.slice(fm[0].length) : text;
-  const note = '> Codex: 이 명령은 스킬로 설치됐다. 본문의 `$ARGUMENTS`, `$1` 은 사용자가 `$' + name + '` 뒤에 쓴 글이다.\n\n';
   fs.mkdirSync(destDir, { recursive: true });
-  fs.writeFileSync(path.join(destDir, 'SKILL.md'), `---\nname: ${name}\ndescription: ${desc ? desc[1] : '""'}\n---\n\n${note}${body}`);
+  fs.writeFileSync(path.join(destDir, 'SKILL.md'), commandSkillText(fs.readFileSync(src, 'utf8'), name, `$${name}`, codex));
 }
 
 /* ---------- Claude Code target ---------- */
@@ -185,7 +195,7 @@ function setupClaude(dryRun) {
   ];
   for (const [bin, args] of steps) {
     if (dryRun) { log(`  [dry-run] ${bin} ${args.join(' ')}`); continue; }
-    try { cp.execFileSync(bin, args, { stdio: 'inherit' }); }
+    try { cp.execFileSync(bin, args, { stdio: 'inherit', ...bareSpawnOpts() }); }
     catch (e) { warn(`  step failed (may already be applied): ${bin} ${args.join(' ')}`); }
   }
   log('  → skills/commands available as /banker:* (reload-plugins or restart to apply).');
@@ -200,30 +210,38 @@ function setupCodex(dryRun, scope) {
   const base = codexBase(scope);
   const skillsDir = path.join(base, 'skills');
   const promptsDir = path.join(base, 'prompts');
+  const renames = renamedInstalls(skillsDir, m);
   // Clean reinstall: remove any prior banker-* first so an update never leaves a stale duplicate.
   const swept = sweepCodexArtifacts(base, dryRun);
   if (swept) log(`  swept ${swept} prior banker-* artifact(s) before reinstall.`);
   let nSkill = 0, nCmd = 0;
   for (const s of eligible(m)) {
     if (s.type === 'skill') {
-      const dest = path.join(skillsDir, `banker-${s.name}`);
+      const dest = path.join(skillsDir, `banker-${codexNameOf(s)}`);
       copyDir(skillSource(s), dest, dryRun);
-      setCodexSkillName(path.join(dest, 'SKILL.md'), `banker-${s.name}`, dryRun); // dir==name (Codex discovery)
+      setCodexSkillName(path.join(dest, 'SKILL.md'), `banker-${codexNameOf(s)}`, dryRun, s.codexDescription); // dir==name (Codex discovery)
       nSkill++;
     } else if (s.type === 'command') {
       const src = path.join(PKG_ROOT, 'commands', `${s.name}.md`);
       copyFile(src, path.join(promptsDir, `banker-${s.name}.md`), dryRun);
-      writeCommandSkill(src, path.join(skillsDir, `banker-${s.name}`), `banker-${s.name}`, dryRun);
+      writeCommandSkill(src, path.join(skillsDir, `banker-${s.name}`), `banker-${s.name}`, dryRun, { description: s.codexDescription, rename: codexRenames(m) });
       nCmd++;
     }
   }
   log(`  → ${nSkill} skills -> ${path.join(base, 'skills', 'banker-*')}, ${nCmd} commands -> skills banker-* and prompts ${path.join(base, 'prompts', 'banker-*.md')}`);
+  reportRenames(renames);
   log('  → Codex 0.144+ has no custom prompts, so each command is also a skill: invoke it as $banker-<name>.');
   log('  → skills are invoked as `banker-<name>` (frontmatter name rewritten to match the dir).');
   log('  → ~/.codex/AGENTS.md is NOT modified (omx regenerates it); skills auto-discovered from ~/.codex/skills/.');
   return true;
 }
 
+// The skills an update installed under their new Codex name, and what a user who turned an old name off must do.
+function reportRenames(renames) {
+  for (const [from, to] of renames) log(`  이름 바뀜: ${from} 에서 ${to} (부를 때는 $${to})`);
+  if (renames.length) log('  옛 이름으로 끈 설정(config.toml 의 [[skills.config]])은 새 이름에 닿지 않으니 새 이름으로 다시 적으십시오.');
+}
+
 /* ---------- doctor ---------- */
 // The newest Codex session record (rollout) under <base>/sessions/YYYY/MM/DD/, or null.
 function newestRollout(base) {
@@ -269,16 +287,72 @@ function doctorCodexShape(base) {
   const file = newestRollout(base);
   if (!file) { log('  Codex record shape: no session record yet (run one Codex session, then doctor again)'); return; }
   const r = codexShapeReport(file);
-  if (r && r.tooLong) { log(`  Codex record shape: ${path.basename(file)} opens with a line over 8 MB, not checked`); return; }
-  if (r && r.fresh) { log(`  Codex record shape: ${path.basename(file)} holds no turn yet (run one Codex turn, then doctor again)`); return; }
-  if (!r || !r.version) { log(`  ⚠ Codex record shape: ${path.basename(file)} does not open with session_meta - lineage, progress and usage counting cannot read it`); return; }
+  const early = shapeEarlyNote(r, path.basename(file));
+  if (early) { log(early); return; }
   const mark = (ok) => (ok ? 'ok' : 'MISSING');
   log(`  Codex record shape (Codex ${r.version}, ${path.basename(file)}): turn start ${mark(r.turnStart)}, user text ${mark(r.userText)}, tool calls ${mark(r.toolCall)}`);
+  doctorShapeVerdict(r);
+}
+
+// What doctor says before the three checks: the first line is too long, no turn yet, or not a Codex record. Lines after
+// session_meta of which banker reads none (no turn start, user text or tool call) are what a Codex update that changed
+// the whole record shape leaves, so they are flagged, not taken for a session with no turn yet.
+function shapeEarlyNote(r, name) {
+  const unread = `  ⚠ Codex record shape: ${name} does not open with session_meta - lineage, progress and usage counting cannot read it`;
+  if (!r) return unread;
+  if (r.tooLong) return `  Codex record shape: ${name} opens with a line over 8 MB, not checked`;
+  if (r.fresh) return `  Codex record shape: ${name} holds no turn yet (run one Codex turn, then doctor again)`;
+  if (r.version && !(r.turnStart || r.userText || r.toolCall)) {
+    return `  ⚠ Codex record shape (Codex ${r.version}, ${name}): it has lines after session_meta but no turn start, user text or tool call banker reads - `
+      + 'the record shape may have changed (lineage stops, progress warns, usage counting misses); update banker. If this session has run no turn yet, run one and doctor again';
+  }
+  return r.version ? '' : unread;
+}
+
+// A turn opens with task_started, then the user's text. Text or tool calls with no turn start, or a turn start with no
+// text, is a record shape banker does not know. Neither one is a session whose first turn has not begun.
+function doctorShapeVerdict(r) {
   if (!r.turnStart || !r.userText) log('  ⚠ banker may not read this Codex version\'s records (lineage stops, progress warns, usage counting misses); update banker');
   else if (!r.toolCall) log('    (no tool calls: fine for a session that used no tools)');
 }
 
-function doctor() {
+// bin/lib/codex-routes.mjs is ESM: the two ways banker gets into Codex (this npm install, and the Codex plugin).
+async function loadCodexRoutes() {
+  return import(pathToFileURL(path.join(__dirname, 'lib', 'codex-routes.mjs')).href);
+}
+// Codex plugin installs of banker in <base> as 'banker@<marketplace> (<versions in the plugin cache>)'.
+async function codexPluginInstalls(base) {
+  const r = await loadCodexRoutes();
+  return r.pluginRoutes(base).map((id) => {
+    let vers = [];
+    try { vers = fs.readdirSync(path.join(base, 'plugins', 'cache', id.slice(id.indexOf('@') + 1), PLUGIN_NAME)); } catch {}
+    return `${id}${vers.length ? ` (${vers.join(', ')})` : ''}`;
+  });
+}
+// Beside the Codex plugin, this npm install shows every skill twice and runs every hook twice. Say so; remove nothing.
+async function warnCodexPlugin(base) {
+  const ids = await codexPluginInstalls(base);
+  if (!ids.length) return;
+  warn(`  ⚠ banker is also installed as a Codex plugin here: ${ids.join(', ')}. Skills show twice ($banker-<name> and $banker:<name>) and the hooks run twice.`);
+  warn(`    Keep one: codex plugin remove ${ids[0].split(' ')[0]}, or banker uninstall --codex.`);
+}
+
+// The plugin's per-skill list was measured on Codex 0.160.1 and later; below that the banker skills may not show.
+async function warnOldCodex(plugins) {
+  if (!plugins.length) return;
+  const r = await loadCodexRoutes();
+  const note = r.pluginVersionNote(r.codexCliVersion(cp.spawnSync));
+  if (note) log(`  ⚠ ${note}`);
+}
+
+// A Codex home inside the folder doctor runs in (not its top .codex, which Codex's sandbox keeps read-only) is one a
+// Codex session opened here can change from the sandbox: its config, the hook copies, the plugins.
+async function warnCodexHomeHere(base) {
+  if (!(await loadCodexRoutes()).homeInSession(base, process.cwd())) return;
+  log(`  ⚠ the Codex home ${base} is inside this folder (not its top .codex): a Codex session opened here can change its config and hooks from the sandbox; use a Codex home outside the folders you open Codex in`);
+}
+
+async function doctor() {
   log(`banker v${version()}  (pkg: ${PKG_ROOT})`);
   log(`plugin.json version: ${(() => { try { return require(PLUGIN_JSON).version; } catch { return '?'; } })()}`);
   log('Claude Code:');
@@ -290,6 +364,7 @@ function doctor() {
   try { installed = fs.readdirSync(sdir).filter(d => d.startsWith('banker-')); } catch {}
   log(`  codex CLI: ${have('codex') ? 'found' : 'NOT found'}`);
   log(`  installed banker skills in ${sdir}: ${installed.length}`);
+  await warnCodexHomeHere(base);
   doctorCodexShape(base);
   // Codex only discovers a skill when its dir name equals the SKILL.md `name:` — flag any mismatch.
   const mismatched = installed
@@ -299,7 +374,14 @@ function doctor() {
     log(`  ⚠ dir/name mismatch (Codex will NOT list these) — reinstall with this version:`);
     for (const x of mismatched) log(`      ${x.d}/  has  name: ${x.name}`);
   }
-  if (have('codex') && installed.length === 0) log('  ⚠ codex found but 0 banker skills installed — run: banker setup --codex');
+  const plugins = await codexPluginInstalls(base);
+  log(`  Codex plugin (codex plugin add): ${plugins.length ? plugins.join(', ') : 'not installed'}`);
+  await warnOldCodex(plugins);
+  doctorTeamwork(base);
+  // A project-scope npm install (banker setup --codex --scope project) in this folder doubles the skills here too.
+  const projectNpm = (await loadCodexRoutes()).projectNpmRoot(process.cwd());
+  if (plugins.length && (installed.length || projectNpm)) log(`  ⚠ banker is installed both ways${projectNpm && !installed.length ? ` (npm in ${path.join(projectNpm, '.codex')})` : ''}: skills show twice ($banker-<name> and $banker:<name>). Keep one: banker uninstall --codex, or codex plugin remove ${plugins[0].split(' ')[0]}`);
+  if (have('codex') && installed.length === 0 && !plugins.length) log('  ⚠ codex found but 0 banker skills installed — run: banker setup --codex, or codex plugin add banker@banker-plugins');
   const m = readManifest();
   const nSkills = eligible(m).filter(s => s.type === 'skill').length;
   log(`  manifest: ${eligible(m).length} codex-eligible surfaces (${nSkills} skills) of ${m.surfaces.length}.`);
@@ -307,13 +389,27 @@ function doctor() {
   log('  → install via /banker:setup (Claude) or the setup-* skills; skills also guide you if a dependency is missing.');
 }
 
+// The Codex-only teamwork skill keeps its engine, hooks and approval rule in the Codex home: say whether the programs it
+// recorded still exist, and whether a rules/teamwork.rules it did not write sits where its rule goes.
+function doctorTeamwork(base) {
+  let st = null;
+  try { st = JSON.parse(fs.readFileSync(path.join(base, 'teamwork', 'state.json'), 'utf8')); } catch { return; }
+  const missing = ['node', 'codex'].filter((k) => !(st.tools && st.tools[k] && fs.existsSync(st.tools[k])));
+  // The hooks' wrapper needs the engine and node only; send and reply start the recorded codex.
+  const fails = [...(missing.includes('node') ? ['its hooks stay silent'] : []), ...(missing.includes('codex') ? ['send and reply fail'] : [])];
+  log(`  teamwork: ${st.enabled ? 'on' : 'off'} (engine ${st.version || '?'})${missing.length ? ` ⚠ recorded ${missing.join(', ')} missing: ${fails.join(' and ')} until $banker-teamwork on runs again` : ''}`);
+  let rules = '';
+  try { rules = fs.readFileSync(path.join(base, 'rules', 'teamwork.rules'), 'utf8'); } catch { return; }
+  if (!rules.startsWith('# teamwork ')) log(`  ⚠ ${path.join(base, 'rules', 'teamwork.rules')} was not written by teamwork; teamwork leaves it as it is and asks for approval on every call`);
+}
+
 /* ---------- uninstall ---------- */
 function uninstallClaude(dryRun) {
   log('• Claude Code uninstall:');
   if (!have('claude')) { warn('  claude CLI not found; skipping.'); return; }
   for (const args of [['plugin', 'uninstall', PLUGIN_NAME], ['plugin', 'marketplace', 'remove', MARKETPLACE]]) {
     if (dryRun) { log(`  [dry-run] claude ${args.join(' ')}`); continue; }
-    try { cp.execFileSync('claude', args, { stdio: 'inherit' }); } catch { warn(`  (not present) claude ${args.join(' ')}`); }
+    try { cp.execFileSync('claude', args, { stdio: 'inherit', ...bareSpawnOpts() }); } catch { warn(`  (not present) claude ${args.join(' ')}`); }
   }
 }
 function uninstallCodex(dryRun, scopes) {
@@ -337,6 +433,21 @@ function uninstallCodex(dryRun, scopes) {
   }
 }
 
+// teamwork (codex-only) goes only when no other way of banker into this Codex home is left: the user-scope npm skills
+// (kept by --scope project) and the Codex plugin. Its own uninstall removes its two hooks, its rule and its state.
+// It runs only with the user scope in the sweep, so a dry run counts the npm skills as gone, as the real run finds them.
+async function uninstallTeamwork(dryRun) {
+  const base = codexBase('user');
+  if (!fs.existsSync(path.join(base, 'teamwork'))) return;
+  const npmLeft = !dryRun && fs.existsSync(path.join(base, 'skills', 'banker-teamwork'));
+  const left = [...(npmLeft ? ['npm skills'] : []), ...(await codexPluginInstalls(base))];
+  if (left.length) { log(`  teamwork kept: banker is still in this Codex home (${left.join(', ')})`); return; }
+  if (dryRun) { log(`  [dry-run] teamwork uninstall in ${base}`); return; }
+  const r = cp.spawnSync(process.execPath, [path.join(PKG_ROOT, 'codex', 'skills', 'teamwork', 'scripts', 'teamwork.mjs'), 'uninstall'], { env: { ...process.env, CODEX_HOME: base }, encoding: 'utf8' });
+  if (r.status === 0) log('  removed teamwork (its hooks, approval rule and state)');
+  else warn(`  teamwork not removed (exit ${r.status}): ${(r.stderr || '').trim()}`);
+}
+
 /* ---------- Codex hooks ---------- */
 // bin/lib/codex-hooks.mjs is ESM; loaded lazily like telemetry-config. Hooks go into the same Codex home as the skills.
 async function loadCodexHooks() {
@@ -353,6 +464,7 @@ async function setupCodexHooks(dryRun, scope) {
   const r = ch.enableHooks(codexHookPaths(ch), ch.DEFAULT_HOOKS, PKG_ROOT);
   if (r.code) { warn(`  Codex hooks not changed: ${r.msg}`); return; }
   log(`  → Codex hooks ${ch.DEFAULT_HOOKS.join(', ')} in ${codexHookPaths(ch).hooks}${r.changed.length ? ` (changed: ${r.changed.join(', ')})` : ' (already in place)'}.`);
+  if (r.note) log(`  → ${r.note}`);
   if (r.changed.length) log(`  → ${ch.TRUST_NOTE}`);
 }
 
@@ -380,7 +492,12 @@ async function hooksCmd(sub, ids) {
   }
   const r = sub === 'enable' ? ch.enableHooks(p, want, PKG_ROOT) : ch.disableHooks(p, want);
   if (r.code) { warn(`banker hooks: not changed: ${r.msg}`); process.exitCode = 1; return; }
+  reportHooks(sub, r, ch);
+}
+
+function reportHooks(sub, r, ch) {
   log(`banker hooks ${sub}: ${r.changed.length ? r.changed.join(', ') : 'nothing to change'}`);
+  if (r.note) log(r.note);
   if (sub === 'enable' && r.changed.length) log(ch.TRUST_NOTE);
   if (r.shifted && r.shifted.length) log(`later ${r.shifted.join(', ')} hooks may need trusting again in /hooks.`);
 }
@@ -543,6 +660,8 @@ Notes:
   - --claude registers the marketplace + installs banker@banker-plugins (skills as /banker:*).
   - --codex copies codex-eligible skills -> ~/.codex/skills/banker-* and commands -> ~/.codex/prompts/banker-*.md
     ($CODEX_HOME instead of ~/.codex when it is set).
+  - Codex can also take banker as a plugin (codex plugin marketplace add smallOpenSource/banker_plugins, then
+    codex plugin add banker@banker-plugins; skills as $banker:<name>). Keep one of the two ways in.
   - telemetry on|off toggles anonymous usage counting opt-out (default-on; config only); status prints counting + update-check state. See PRIVACY.md.
   - Never runs as root. --dry-run prints planned actions without writing.`;
 
@@ -550,14 +669,17 @@ async function main() {
   const a = parseArgs(process.argv.slice(2));
   if (a.version) { log(version()); return; }
   if (a.help || a.cmd === 'help' || !a.cmd) { log(HELP); return; }
-  if (a.cmd === 'doctor') { doctor(); return; }
+  if (a.cmd === 'doctor') { await doctor(); return; }
   if (a.cmd === 'telemetry') { await telemetryCmd(a.sub); return; }
   if (a.cmd === 'hooks') { assertNotRoot(); await hooksCmd(a.sub, a.hookIds); return; }
   assertNotRoot();
   if (a.cmd === 'setup') {
     log(`banker setup${a.dryRun ? ' (dry-run)' : ''}: claude=${a.claude} codex=${a.codex}`);
     if (a.claude) setupClaude(a.dryRun);
-    if (a.codex && setupCodex(a.dryRun, a.scope)) await setupCodexHooks(a.dryRun, a.scope);
+    if (a.codex && setupCodex(a.dryRun, a.scope)) {
+      await setupCodexHooks(a.dryRun, a.scope);
+      if (a.scope === 'user') await warnCodexPlugin(codexBase('user'));
+    }
     // Best-effort first-run prompts (interactive TTY only). A prompt failure must never fail setup.
     try { await maybeFirstRunPrompts(a); } catch { /* non-fatal */ }
     log('done.');
@@ -567,7 +689,7 @@ async function main() {
     if (a.claude) uninstallClaude(a.dryRun);
     if (a.codex) {
       uninstallCodex(a.dryRun, a.scopeExplicit ? [a.scope] : ['user', 'project']);
-      if (!a.scopeExplicit || a.scope === 'user') await uninstallCodexHooks(a.dryRun);
+      if (!a.scopeExplicit || a.scope === 'user') { await uninstallCodexHooks(a.dryRun); await uninstallTeamwork(a.dryRun); }
     }
     log('done.');
     return;

package/bin/lib/codex-hooks.mjs

@@ -6,11 +6,12 @@
  *   돌린다. Codex 는 신뢰한 훅을 샌드박스 밖에서 돌리므로, 작업 폴더 안의 파일을 가리키지 않게 하기 위해서다.
  * - 묶음은 각 이벤트의 맨 뒤에 더한다. Codex 는 신뢰를 <hooks.json>:<이벤트>:<묶음 번호>:<항목 번호> 로 기록해, 앞에
  *   끼우면 OMX 훅의 번호가 밀려 다시 신뢰해야 한다. 빼기는 우리 항목만, 낡은 명령은 같은 자리에서 고친다.
- * - Windows 의 Codex 는 훅 명령을 PowerShell 로 돌린다(Codex 0.160.1 실측): `& '<node>' '<스크립트>' 인자`.
+ * - Windows 의 Codex 는 훅 명령을 PowerShell 로 돌린다(Codex 0.160.1 실측): `& '<node>' -e '<검사>' '<스크립트>' 인자`.
+ *   검사(hookGuard)는 스크립트의 실제 경로가 임시 폴더나 세션 폴더 아래면 돌리지 않는다.
  * - hooks.json 이 링크이거나 JSON 객체가 아니거나 "없음" 말고 다른 이유로 확인할 수 없으면 바꾸지 않는다. 바꿀 때마다
  *   직전 내용을 hooks.json.banker.bak 에 둔다. smart-compact 의 codex-gate.mjs 와 같은 규칙이다.
  */
-import { spawnSync } from 'node:child_process';
+import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
 import path from 'node:path';
@@ -25,6 +26,8 @@ export const HOOKS = {
 export const PAYLOAD = [
   '.claude-plugin/plugin.json',
   'bin/lib/telemetry-config.mjs',
+  'bin/lib/codex-routes.mjs',
+  'bin/lib/codex-names.mjs',
   'hooks/update-notify.mjs',
   'hooks/update-fetch.mjs',
   'hooks/update-checkin.mjs',
@@ -42,8 +45,9 @@ export function codexPaths(env = process.env) {
 
 const isObject = (v) => Boolean(v) && typeof v === 'object' && !Array.isArray(v);
 
+// 임시 파일은 난수 이름과 wx: 남이 미리 심은 같은 이름의 파일이나 링크를 따라가지 않는다.
 function writeAtomic(file, data) {
-  const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+  const tmp = `${file}.${crypto.randomBytes(6).toString('hex')}.tmp`;
   try {
     fs.writeFileSync(tmp, data, { flag: 'wx' });
     const mode = modeOf(file);
@@ -65,19 +69,45 @@ function modeOf(file) {
 }
 
 // 명령 글. POSIX 는 큰따옴표, 셸이 그 안에서 읽는 글자는 거부. Windows 는 PowerShell 호출 연산자와 작은따옴표.
-export function formatCommand(node, script, args, win = process.platform === 'win32') {
+// guard 가 있으면 node -e <guard> <스크립트> 인자 꼴(guard 는 큰따옴표, $, 백틱, 백슬래시가 없는 고정 글).
+export function formatCommand(node, script, args, win = process.platform === 'win32', guard = '') {
   const all = [node, script, ...args].join('');
   if (/[\r\n\0]/.test(all)) return null;
+  const pre = guard ? ['-e'] : [];
   if (win) {
     const q = (s) => `'${s.replace(/['‘-‛]/g, '$&$&')}'`;
-    return ['&', q(node), q(script), ...args].join(' ');
+    return ['&', q(node), ...pre, ...(guard ? [q(guard)] : []), q(script), ...args].join(' ');
   }
   if (/["$`\\]/.test(all)) return null;
-  return [`"${node}"`, `"${script}"`, ...args].join(' ');
+  return [`"${node}"`, ...pre, ...(guard ? [`"${guard}"`] : []), `"${script}"`, ...args].join(' ');
 }
 
+// npm 길 훅 명령이 스크립트를 부르기 전에 하는 검사(Codex 플러그인 훅의 래퍼와 같은 규칙): 스크립트의 실제 경로가 임시
+// 폴더나 세션 폴더(Codex 가 훅을 도는 폴더) 아래면 돌리지 않고 까닭을 알린다. 세션 폴더가 홈 폴더 자체면 세션 폴더
+// 규칙은 쓰지 않는다. Codex 홈이 세션 폴더 깊은 곳(CODEX_HOME=<세션>/deep/.codex)이면 샌드박스가 그 사본을 고칠 수
+// 있기 때문이다. 검사는 신뢰 해시에 묶인 명령 글에 있다. 세션 시작 훅은 systemMessage 로, 다른 훅은 stderr 로 알린다.
+// 실제 경로는 realpathSync.native 로 푼다: Windows 의 JS 판은 8.3 짧은 이름의 임시 폴더(TEMP=C:\Users\LONGNA~1\...)를
+// 긴 이름으로 풀지 않아 임시 폴더 규칙이 빗나간다(Windows 박스 실측).
+export function hookGuard(notice) {
+  const say = notice
+    ? 'process.stdout.write(JSON.stringify({systemMessage:m}))'
+    : 'process.stderr.write(m+String.fromCharCode(10))';
+  return [
+    "const f=require('fs'),p=require('path'),o=require('os');",
+    'const r=(x)=>{try{return f.realpathSync.native(x)}catch{try{return f.realpathSync(x)}catch{return x}}};',
+    'const s=r(process.argv[1]),w=r(process.cwd()),h=r(o.homedir());',
+    "const u=(d)=>{const q=p.relative(d,s);return q===''||!(q.startsWith('..')||p.isAbsolute(q))};",
+    "if([o.tmpdir()].concat(process.platform==='win32'?[]:['/tmp']).map(r).some(u)||(w!==h&&u(w))){",
+    "const m='banker hooks skipped: the hook script is in a temp folder or the session folder ('+s+')';",
+    `${say};process.exit(0)}`,
+    "import(require('url').pathToFileURL(s).href)",
+  ].join('');
+}
+
+const hookCommand = (p, id, node, win = process.platform === 'win32') => formatCommand(node, scriptOf(p, id), HOOKS[id].args, win, hookGuard(HOOKS[id].event === 'SessionStart'));
+
 // 임시 폴더의 node 는 거부한다. Codex 안에서 돌 때는 작업 폴더 안의 node 도(샌드박스 안 세션이 고칠 수 있다).
-export function safeNode(node, { win = process.platform === 'win32', cwd = process.cwd(), codex = Boolean(process.env.CODEX_THREAD_ID) } = {}) {
+export function safeNode(node, { win = process.platform === 'win32', cwd = process.cwd(), codex = Boolean(process.env.CODEX_THREAD_ID), home = os.homedir() } = {}) {
   const P = win ? path.win32 : path.posix;
   const under = (f, dir) => {
     const r = P.relative(dir, f);
@@ -85,14 +115,25 @@ export function safeNode(node, { win = process.platform === 'win32', cwd = proce
   };
   // A link elsewhere is judged where it leads too, so a link in a safe place cannot pin a node from the temp folder.
   const places = [node, real(node)];
-  return !places.some((f) => under(f, os.tmpdir()) || (codex && under(f, cwd)));
+  // A session in the home folder is no workspace to judge by (as homeInWorkspace): nvm keeps node under ~/.nvm. Only an
+  // absolute home names one (HOME=. would make every folder the home); path.relative compares as the OS does (case on Windows).
+  const isHome = P.isAbsolute(home) && P.relative(real(home), real(cwd)) === '';
+  const inWork = codex && !isHome;
+  return !places.some((f) => under(f, os.tmpdir()) || (inWork && under(f, cwd)));
 }
 
+// 실제 경로. 아직 없는 절대 경로는 있는 조상까지만 풀고 나머지를 붙인다(macOS 의 /var 는 /private/var 로 가는 링크라,
+// 풀지 않으면 링크 아래의 없는 Codex 홈이 풀린 작업 폴더 밖으로 보인다). native 먼저: Windows 의 8.3 짧은 이름을 푼다.
 function real(file) {
   try {
-    return fs.realpathSync(file);
+    return fs.realpathSync.native(file);
   } catch {
-    return file;
+    try {
+      return fs.realpathSync(file);
+    } catch {
+      const up = path.dirname(file);
+      return path.isAbsolute(file) && up !== file ? path.join(real(up), path.basename(file)) : file;
+    }
   }
 }
 
@@ -141,6 +182,49 @@ function saveHooks(p, doc) {
   writeAtomic(p.hooks, `${JSON.stringify(doc, null, 2)}\n`);
 }
 
+const pause = (ms) => Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+
+// hooks.json 을 고치는 쪽(banker 와 Codex 전용 스킬 teamwork 의 엔진)이 함께 쓰는 잠금: hooks.json 옆의 폴더
+// hooks.json.lock. 10초 넘은 잠금은 죽은 쓰기로 보고 치우고, 5초 안에 못 얻으면 바꾸지 않는다(까닭을 돌려줌).
+// 치우지 못한 낡은 잠금(일반 파일, 비지 않은 폴더, 권한)도 기다림과 횟수에 들어, 끝없이 돌지 않고 그 까닭으로 끝난다.
+export function withHooksLock(file, fn, onBusy) {
+  const lock = `${file}.lock`;
+  let stuck = '';
+  for (let i = 0; ; i++) {
+    try {
+      fs.mkdirSync(lock);
+      break;
+    } catch (e) {
+      // Codex 홈이 아직 없으면 다툴 파일도 없다. 그 밖에 잠금을 만들 수 없으면 바꾸지 않는다.
+      if (e.code === 'ENOENT') return fn();
+      if (e.code !== 'EEXIST') return onBusy(`잠금 ${lock} 을 확인하지 못함(${e.code})`);
+      if (i > 200) return onBusy(stuck ? `${file} 의 낡은 잠금 ${lock} 을 지우지 못함(${stuck}). 다른 banker 나 teamwork 가 돌고 있지 않으면 직접 지우십시오` : `${file} 의 잠금(${lock})을 얻지 못함`);
+      stuck = clearStale(lock);
+      if (stuck !== '') pause(25);
+    }
+  }
+  try {
+    return fn();
+  } finally {
+    fs.rmSync(lock, { recursive: true, force: true });
+  }
+}
+
+// 낡은 잠금 치우기: 치웠거나 그사이 풀렸으면 ''(바로 다시 잡음), 10초가 안 된 잠금이면 null(기다림), 10초 넘었는데
+// 지우지 못했으면 그 오류 코드(기다림, 마지막에 까닭으로 알림).
+function clearStale(lock) {
+  try {
+    if (Date.now() - fs.statSync(lock).mtimeMs <= 10000) return null;
+    fs.rmdirSync(lock);
+    return '';
+  } catch (e) {
+    // Windows 의 rmdir 은 파일인 잠금에 ENOENT 를 내므로, 정말 없어졌는지는 다시 보고 정한다.
+    let st;
+    try { st = fs.lstatSync(lock); } catch { return ''; }
+    return st.isDirectory() ? String((e && e.code) || e) : 'ENOTDIR';
+  }
+}
+
 // 사본 폴더. 링크인 폴더는 거부하고, 파일은 내용이 다를 때만 새로 쓴다.
 export function installPayload(p, pkgRoot) {
   fs.mkdirSync(p.dir, { recursive: true });
@@ -167,33 +251,52 @@ function place(doc, id, command) {
   return true;
 }
 
-// Codex 홈이 지금 폴더나 그 저장소 안이면(예: 저장소의 .envrc 가 CODEX_HOME=./.codex) 훅 사본도 작업 폴더 안에 놓여,
-// 샌드박스 안의 세션이 샌드박스 밖에서 도는 훅을 고칠 수 있다. 홈 폴더와 파일 시스템 루트는 작업 폴더로 보지 않는다.
+// Codex 홈이 지금 폴더 안이면(예: 폴더의 .envrc 가 CODEX_HOME=./.codex) 훅 사본도 작업 폴더 안에 놓여, 샌드박스 안의
+// 세션이 샌드박스 밖에서 도는 훅을 고칠 수 있다. 홈 폴더와 파일 시스템 루트는 작업 폴더로 보지 않는다.
 export function homeInWorkspace(home, cwd = process.cwd()) {
-  const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { cwd, encoding: 'utf8', windowsHide: true });
-  const roots = [cwd, top.status === 0 ? top.stdout.trim() : ''].filter(Boolean).map(real);
-  const skip = new Set([real(os.homedir()), path.parse(real(cwd)).root]);
+  const r = real(cwd);
+  if (r === real(os.homedir()) || r === path.parse(r).root) return false;
   const h = real(home);
-  return roots.some((r) => !skip.has(r) && (h === r || h.startsWith(r.endsWith(path.sep) ? r : r + path.sep)));
+  return h === r || h.startsWith(r.endsWith(path.sep) ? r : r + path.sep);
 }
 
-// ids 를 켠다. { code, changed:[id], msg }. code 1 이면 아무것도 바꾸지 않았다.
+// Codex 홈에서 위로 올라가며 .git(폴더나 파일)이 있는 첫 폴더, 없으면 ''. git 을 실행하지 않는다. 사용자 홈 폴더 자체의
+// .git(dotfiles 저장소)은 보지 않는다.
+export function repoAbove(home, userHome = os.homedir()) {
+  const skip = real(userHome);
+  for (let d = real(home); ; d = path.dirname(d)) {
+    if (d !== skip && fs.existsSync(path.join(d, '.git'))) return d;
+    if (path.dirname(d) === d) return '';
+  }
+}
+
+// ids 를 켠다. { code, changed:[id], msg, note }. code 1 이면 아무것도 바꾸지 않았다. note 는 알릴 것(Codex 홈 위의 저장소).
 export function enableHooks(p, ids, pkgRoot, node = process.execPath, cwd = process.cwd()) {
+  return withHooksLock(p.hooks, () => enableLocked(p, ids, pkgRoot, node, cwd), (msg) => ({ code: 1, changed: [], msg }));
+}
+
+function enableLocked(p, ids, pkgRoot, node, cwd) {
   if (!safeNode(node)) return { code: 1, changed: [], msg: `node 가 안전하지 않은 곳에 있음(${node})` };
   if (homeInWorkspace(p.home, cwd)) return { code: 1, changed: [], msg: `Codex 홈(${p.home})이 작업 폴더 안이라 훅을 설치하지 않음. 샌드박스가 고칠 수 있는 곳임` };
   const { doc, why } = loadHooks(p.hooks, ids.map((id) => HOOKS[id].event));
   if (why) return { code: 1, changed: [], msg: why };
-  const cmds = ids.map((id) => [id, formatCommand(node, scriptOf(p, id), HOOKS[id].args)]);
+  const cmds = ids.map((id) => [id, hookCommand(p, id, node)]);
   if (cmds.some(([, c]) => !c)) return { code: 1, changed: [], msg: '경로에 셸이 읽는 글자가 있음' };
   const bad = installPayload(p, pkgRoot);
   if (bad) return { code: 1, changed: [], msg: bad };
   const changed = cmds.filter(([id, c]) => place(doc, id, c)).map(([id]) => id);
   if (changed.length) saveHooks(p, doc);
-  return { code: 0, changed, msg: '' };
+  const repo = repoAbove(p.home);
+  const note = repo ? `Codex 홈(${p.home})이 git 저장소(${repo}) 안에 있음. Codex 홈을 품은 폴더에서 Codex 를 열면 banker 훅은 돌지 않고 세션 시작 때 까닭을 알림` : '';
+  return { code: 0, changed, msg: '', note };
 }
 
 // ids 를 끈다: 우리 항목만 빼고, 비는 묶음과 이벤트를 지운다. 뒤 묶음의 번호가 밀리면 shifted 에 이벤트를 적는다.
 export function disableHooks(p, ids) {
+  return withHooksLock(p.hooks, () => disableLocked(p, ids), (msg) => ({ code: 1, changed: [], shifted: [], msg }));
+}
+
+function disableLocked(p, ids) {
   const { doc, why } = loadHooks(p.hooks, ids.map((id) => HOOKS[id].event));
   if (why) return { code: 1, changed: [], shifted: [], msg: why };
   const changed = [];
@@ -226,7 +329,7 @@ export function hookStatus(p, ids, pkgRoot, node = process.execPath) {
     const groups = doc.hooks[HOOKS[id].event] || [];
     const at = findOurs(groups, id);
     if (!at) out[id] = 'off';
-    else out[id] = groups[at[0]].hooks[at[1]].command === formatCommand(node, scriptOf(p, id), HOOKS[id].args) && copyCurrent(p, pkgRoot) ? 'on' : 'stale';
+    else out[id] = groups[at[0]].hooks[at[1]].command === hookCommand(p, id, node) && copyCurrent(p, pkgRoot) ? 'on' : 'stale';
   }
   return { status: out };
 }

package/bin/lib/codex-names.mjs

@@ -0,0 +1,4 @@
+// Written by scripts/sync-codex-plugin.js from codex/manifest.json (codexName). Do not edit.
+// CODEX_NAMES: Claude name to Codex name; CLAUDE_NAMES: the other way.
+export const CODEX_NAMES = Object.freeze({"omc-reference":"omx-reference","setup-omc":"setup-omx","setup-omc-hud":"setup-omx-hud"});
+export const CLAUDE_NAMES = Object.freeze(Object.fromEntries(Object.entries(CODEX_NAMES).map(([a, b]) => [b, a])));