elanous 0.2.0 → 0.2.4

package/scripts/cli-json-exit-scan.ts

@@ -0,0 +1,126 @@
+#!/usr/bin/env bun
+/** Report CLI JSON handlers that can exit after an unawaited stdout write. */
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import ts from 'typescript';
+
+export interface JsonExitFinding { file: string; line: number; exitLine: number }
+
+function namedCall(node: ts.Node, object: string, method: string): node is ts.CallExpression {
+  return ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)
+    && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === object
+    && node.expression.name.text === method;
+}
+
+function isOutput(node: ts.Node): boolean {
+  return namedCall(node, 'console', 'log') || (ts.isCallExpression(node)
+    && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === 'write'
+    && ts.isPropertyAccessExpression(node.expression.expression)
+    && node.expression.expression.name.text === 'stdout'
+    && ts.isIdentifier(node.expression.expression.expression)
+    && node.expression.expression.expression.text === 'process');
+}
+
+function isExit(node: ts.Node): boolean { return namedCall(node, 'process', 'exit'); }
+function isJsonRead(node: ts.Node): boolean {
+  return ts.isPropertyAccessExpression(node) && node.name.text === 'json'
+    && ts.isIdentifier(node.expression) && (node.expression.text === 'opts' || node.expression.text === 'options');
+}
+function isFunction(node: ts.Node): node is ts.FunctionLikeDeclaration {
+  return ts.isArrowFunction(node) || ts.isFunctionExpression(node) || ts.isFunctionDeclaration(node)
+    || ts.isMethodDeclaration(node) || ts.isGetAccessorDeclaration(node) || ts.isSetAccessorDeclaration(node);
+}
+
+/** Positions are lines of the raw write; exits are recorded separately for auditing. */
+export function scanJsonExitSource(source: string, file: string): JsonExitFinding[] {
+  const tree = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true);
+  const findings: JsonExitFinding[] = [];
+  const line = (node: ts.Node) => tree.getLineAndCharacterOfPosition(node.getStart(tree)).line + 1;
+  const visit = (node: ts.Node): void => {
+    if (isFunction(node)) {
+      const outputs: ts.Node[] = [];
+      const exits: ts.Node[] = [];
+      const body = node.body;
+      const collect = (child: ts.Node): void => {
+        if (child !== node && isFunction(child)) return;
+        if (isOutput(child)) outputs.push(child);
+        if (isExit(child)) exits.push(child);
+        ts.forEachChild(child, collect);
+      };
+      if (body) collect(body);
+      const readsJson = (expression: ts.Node): boolean => {
+        let found = false;
+        const inspect = (child: ts.Node): void => {
+          if (child !== expression && isFunction(child)) return;
+          if (isJsonRead(child)) found = true;
+          ts.forEachChild(child, inspect);
+        };
+        inspect(expression);
+        return found;
+      };
+      if (!body || !readsJson(body)) { ts.forEachChild(node, visit); return; }
+      // Exclude human-only arms even when the handler also has a JSON path.
+      const jsonArm = (output: ts.Node): ts.Statement | undefined => {
+        for (let parent = output.parent; parent && parent !== node; parent = parent.parent) {
+          if (ts.isIfStatement(parent) && output.getStart(tree) >= parent.thenStatement.getStart(tree)
+            && output.getEnd() <= parent.thenStatement.getEnd() && readsJson(parent.expression)
+            && !parent.expression.getText(tree).trimStart().startsWith('!')) return parent.thenStatement;
+        }
+        return undefined;
+      };
+      for (const output of outputs) {
+        const arm = jsonArm(output);
+        let jsonConditionalOutput = false;
+        if (ts.isCallExpression(output)) {
+          const inspect = (child: ts.Node): void => {
+            if (ts.isConditionalExpression(child) && readsJson(child.condition)) jsonConditionalOutput = true;
+            ts.forEachChild(child, inspect);
+          };
+          for (const arg of output.arguments) inspect(arg);
+        }
+        if (!arm && !jsonConditionalOutput) continue;
+        const armReturns = arm && (() => {
+          let returns = false;
+          const inspect = (child: ts.Node): void => {
+            if (isFunction(child)) return;
+            if (ts.isReturnStatement(child)) returns = true;
+            ts.forEachChild(child, inspect);
+          };
+          inspect(arm);
+          return returns;
+        })();
+        const exit = exits.find(candidate => candidate.getStart(tree) > output.getStart(tree)
+          && (!arm || candidate.getStart(tree) <= arm.getEnd() || !armReturns));
+        if (exit) findings.push({ file, line: line(output), exitLine: line(exit) });
+      }
+    }
+    ts.forEachChild(node, visit);
+  };
+  visit(tree);
+  return findings;
+}
+
+function cliFiles(root: string): string[] {
+  const files = [join(root, 'src/index.ts')];
+  const walk = (dir: string): void => {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+      if (entry.isDirectory()) walk(join(dir, entry.name));
+      else if (entry.isFile() && entry.name.endsWith('.ts') && !entry.name.endsWith('.test.ts')) files.push(join(dir, entry.name));
+    }
+  };
+  walk(join(root, 'src/cli'));
+  return files.sort();
+}
+
+export function scanCliJsonExits(root = join(import.meta.dir, '..')): JsonExitFinding[] {
+  return cliFiles(root).flatMap(path => scanJsonExitSource(readFileSync(path, 'utf8'), relative(root, path)));
+}
+
+if (import.meta.main) {
+  const findings = scanCliJsonExits();
+  if (process.argv.includes('--json')) console.log(JSON.stringify(findings, null, 2));
+  else {
+    console.log(`JSON 출력 → process.exit 후보 ${findings.length}곳 (file:writeLine → exitLine)`);
+    for (const finding of findings) console.log(`${finding.file}:${finding.line} → ${finding.exitLine}`);
+  }
+}

package/scripts/codex-quota-alert-format.ts

@@ -0,0 +1,52 @@
+export interface CreditsRow {
+  name: string;
+  balance?: number;
+  perHour?: number;
+  resetInHours?: number;
+}
+
+export interface CreditsSummary {
+  totalBalance: number;
+  totalPerHour: number | null;
+  etaHours: number | null;
+  earliestResetHours: number | null;
+  beforeReset: boolean | null;
+  unknownSpeedCount: number;
+  unknownBalanceCount: number;
+}
+
+export function creditsSummary(rows: CreditsRow[]): CreditsSummary {
+  const balances = rows.map(row => row.balance).filter((balance): balance is number =>
+    typeof balance === 'number' && Number.isFinite(balance));
+  const unknownBalanceCount = rows.length - balances.length;
+  const totalBalance = balances.reduce((sum, balance) => sum + balance, 0);
+  const measuredSpeeds = rows.map(row => row.perHour).filter((speed): speed is number =>
+    typeof speed === 'number' && Number.isFinite(speed));
+  const totalPerHour = measuredSpeeds.length
+    ? measuredSpeeds.reduce((sum, speed) => sum + speed, 0) : null;
+  const unknownSpeedCount = rows.length - measuredSpeeds.length;
+  const resets = rows.map(row => row.resetInHours).filter((hours): hours is number =>
+    typeof hours === 'number' && Number.isFinite(hours) && hours > 0);
+  const earliestResetHours = rows.length > 0 && resets.length === rows.length ? Math.min(...resets) : null;
+  const etaHours = unknownBalanceCount === 0 && totalPerHour !== null && totalPerHour < 0
+    ? Math.max(0, totalBalance / -totalPerHour) : null;
+  const beforeReset = etaHours === null || earliestResetHours === null
+    ? null : etaHours < earliestResetHours;
+  return { totalBalance, totalPerHour, etaHours, earliestResetHours, beforeReset, unknownSpeedCount, unknownBalanceCount };
+}
+
+export function formatCreditsSummary(summary: CreditsSummary): string {
+  const balance = Math.round(summary.totalBalance).toLocaleString('en-US');
+  const rate = summary.totalPerHour === null ? '미상'
+    : `${summary.totalPerHour < 0 ? '−' : summary.totalPerHour > 0 ? '+' : ''}${Math.abs(summary.totalPerHour).toLocaleString('en-US', { maximumFractionDigits: 1 })}`;
+  const speed = summary.unknownSpeedCount ? ` · 속도 모름 ${summary.unknownSpeedCount}개` : '';
+  const eta = summary.etaHours === null ? ' · 고갈 시각 미상' : ` · 약 ${Math.round(summary.etaHours)}시간 뒤 0`;
+  const reset = summary.earliestResetHours === null
+    ? ' — 가장 이른 리셋 시각 미상'
+    : summary.beforeReset === null ? ` — 가장 이른 리셋(${summary.earliestResetHours}시간)과 비교 불가`
+      : summary.beforeReset
+        ? ` — 가장 이른 리셋(${summary.earliestResetHours}시간)«보다 먼저»`
+        : ` — 가장 이른 리셋(${summary.earliestResetHours}시간)이 먼저 옵니다`;
+  const balanceLabel = summary.unknownBalanceCount ? `확인된 계정 합계 ${balance} · 잔액 모름 ${summary.unknownBalanceCount}개` : `크레딧 합계 ${balance}`;
+  return `💳 ${balanceLabel} · 시간당 ${rate}${speed}${eta}${reset}`;
+}

package/scripts/codex-quota-alert.ts

@@ -29,12 +29,21 @@ import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { ensureCronNodePath } from '../src/domains/cron-path.js';
 import { registerStandaloneLogSink } from '../src/domains/standalone-log-sink.js';
+import { getUserConfig } from '../src/user-config.js';
+import { creditsSummary, formatCreditsSummary } from './codex-quota-alert-format.js';
+import {
+  CODEX_QUOTA_POLICY_LABEL, codexPolicyAllowsCredits, codexPolicyAllowsFallback, resolveCodexQuotaPolicy,
+} from '../src/oauth/codex-quota-policy.js';
 
 const STATE = join(homedir(), '.elanous/conatus/codex_quota_alert_state.json');
 /** 잔여가 이 % 이하로 내려간 계정을 «임박»으로 본다. */
 const LOW_REMAINING_PERCENT = 10;
 /** 리셋권 만료가 이 일수 안이면 알린다. */
 const RESET_CREDIT_EXPIRY_DAYS = 7;
+/** 정책 `credits`(크레딧 사용이 «허가된» 상태)에서 잔액 보고의 발송 단위 — 이만큼 줄 때마다 한 번.
+ *  ⛔ 허가된 지출을 매시 경보로 보내면 진짜 경보(리셋 전 고갈 · 정책 위반)가 묻힌다(대표 2026-09-28 «정책과 안 맞는다»).
+ *  허가 «밖»(within-quota·fallback)에서는 종전대로 줄 때마다 보낸다 — 그때는 줄어드는 것 자체가 사고다. */
+const CREDITS_REPORT_STEP = 5000;
 
 interface AccountRow {
   provider: string; accountName: string;
@@ -105,6 +114,12 @@ if ('error' in usage) {
   process.exit(0);
 }
 
+// 대표 2026-09-28 한도 정책(`llm.codexQuotaPolicy`) — 알림 문구·발송 기준이 «설정된 정책»을 따른다.
+let quota = resolveCodexQuotaPolicy(undefined);
+try { quota = resolveCodexQuotaPolicy(getUserConfig().llm); } catch { /* 못 읽으면 기본(fallback) */ }
+const creditsAllowed = codexPolicyAllowsCredits(quota.policy);
+const fallbackAllowed = codexPolicyAllowsFallback(quota.policy);
+
 const codex = usage.rows.filter((r) => r.provider === 'codex');
 const others = usage.rows.filter((r) => r.provider !== 'codex');
 
@@ -178,7 +193,20 @@ function drainOf(r: AccountRow): { state: 'draining' | 'flat' | 'unknown'; delta
     ...(hours > 0 ? { perHour: delta / hours, windowMin: Math.round(hours * 60) } : {}),
   };
 }
-const drain = new Map(burning.map((r) => [r.accountName, drainOf(r)] as const));
+const drain = new Map((quota.policy === 'credits' ? codex : burning)
+  .map((r) => [r.accountName, drainOf(r)] as const));
+// 🩸 2026-09-28: 머리줄이 «찬 ⊕ 크레딧 있음» 계정 수(3)를 «나가는 중» 으로 셌다 — 실제로 줄던 것은 default 하나.
+//   ⇒ «줄고 있다»(draining)와 «크레딧은 있지만 안 쓰는 중»을 가른다.
+const draining = burning.filter((r) => drain.get(r.accountName)?.state === 'draining');
+const creditHolders = quota.policy === 'credits'
+  ? codex.filter((r) => r.credits?.hasCredits === true)
+  : [];
+const combinedCredits = creditHolders.length >= 2 ? creditsSummary(creditHolders.map((r) => ({
+  name: r.accountName,
+  balance: r.credits?.balance,
+  perHour: drain.get(r.accountName)?.state === 'flat' ? 0 : drain.get(r.accountName)?.perHour,
+  resetInHours: hoursUntil(r.subscription?.resetsAt) ?? undefined,
+}))) : null;
 
 // ⭐ 상태를 «문자열 하나»로 접어 두고, 바뀔 때만 보낸다(같은 경고 반복 금지).
 const signature = JSON.stringify({
@@ -187,12 +215,20 @@ const signature = JSON.stringify({
   exp: expiring.map((r) => r.accountName).sort(),
   // ⛔ 「못 읽음」이 서명에 없으면, 자가 눈먼 상태가 「상태 동일」로 조용해진다.
   unread: unreadable.map((r) => r.accountName).sort(),
+  policy: quota.policy,
+  ...(combinedCredits ? { beforeReset: combinedCredits.beforeReset } : {}),
   // ⛔ 「줄고 있는 중」은 «매 틱» 서명이 달라야 한다 — 돈이 계속 나가는데 한 번만 알리면
   //   두 번째 시간부터는 「상태 동일」로 조용해진다. 그래서 draining 이면 원값을 넣는다.
   //   ⛔ 반대로 멎었으면(flat) 원값을 넣지 «않는다» — 그래야 반복 발송이 멎는다.
   burn: burning.map((r) => {
     const d = drain.get(r.accountName);
-    return `${r.accountName}:${d?.state === 'draining' ? String(r.credits?.balance) : (d?.state ?? 'unknown')}`;
+    if (d?.state !== 'draining') return `${r.accountName}:${d?.state ?? 'unknown'}`;
+    const b = r.credits?.balance;
+    // 허가된 크레딧 지출은 «단위»로 접는다 — 단 «리셋 전에 바닥난다»로 바뀌면 단위와 무관하게 서명이 바뀐다.
+    const resetH = hoursUntil(r.subscription?.resetsAt);
+    const etaH = d.perHour && d.perHour < 0 && typeof b === 'number' ? b / -d.perHour : null;
+    const risk = !combinedCredits && etaH !== null && (resetH === null || etaH < resetH) ? ':before-reset' : '';
+    return `${r.accountName}:${creditsAllowed ? b === undefined ? 'balance-unknown' : `step${Math.floor(b / CREDITS_REPORT_STEP)}${risk}` : String(b ?? 0)}`;
   }).sort(),
 });
 const prev = prevState;
@@ -214,13 +250,15 @@ if (prev.signature === signature) {
 }
 
 if (exhausted.length === 0 && low.length === 0 && expiring.length === 0 && burning.length === 0
-    && unreadable.length === 0) {
+    && unreadable.length === 0 && !combinedCredits) {
   console.log('[codex-quota-alert] 경고 조건 없음');
   saveState({ ...prev, ...balances, signature });
   process.exit(0);
 }
 
 const lines: string[] = [];
+lines.push(`🧭 정책: **${CODEX_QUOTA_POLICY_LABEL[quota.policy]}** (\`llm.codexQuotaPolicy=${quota.policy}\`${quota.source === 'legacy-credits' ? ' · 옛 codexCreditsAllowed 에서' : quota.source === 'default' ? ' · 기본값' : quota.source === 'invalid' ? ' · ⚠️ 모르는 값이라 기본값' : ''})`);
+lines.push('');
 // ⛔ 「못 읽음」을 맨 위에 둔다 — 아래 판정들이 «그만큼 눈이 먼» 상태임을 먼저 말해야 한다.
 if (unreadable.length > 0) {
   lines.push(`⚠️ **계정 ${unreadable.length}개를 «못 읽었습니다»** — 아래 판정은 그만큼 눈이 멉니다.`);
@@ -229,16 +267,26 @@ if (unreadable.length > 0) {
   lines.push('');
 }
 // 🔥 돈이 나가는 축을 «맨 위»에 둔다 — 소진은 멈춘 것이고 이것은 안 멈춘 것이다.
-if (burning.length > 0) {
-  lines.push(`🔥 **한도를 넘겼는데 요청이 «안 죽고» 있습니다 (${burning.length}개 계정)**`);
-  lines.push('레이트리밋 오류가 안 나므로 ⛔ **회전도 폴백도 안 열립니다** — 잔액에서 그대로 나갑니다.');
+if (burning.length > 0 || combinedCredits) {
+  if (creditsAllowed) {
+    lines.push(burning.length > 0
+      ? `💳 **크레딧으로 진행 중 — 줄고 있는 계정 ${draining.length}개** (크레딧 보유 ${burning.length}개 · 정책상 허가된 지출)`
+      : '💳 **크레딧 보유 계정**');
+    if (combinedCredits) lines.push(formatCreditsSummary(combinedCredits));
+    if (burning.length > 0) lines.push(combinedCredits
+      ? `잔액이 ${CREDITS_REPORT_STEP} 단위로 줄 때마다 한 번 알립니다. 리셋 전 고갈은 합계로 판정합니다.`
+      : `잔액이 ${CREDITS_REPORT_STEP} 단위로 줄 때마다 한 번 알립니다. 🚨 표시가 있으면 리셋 전에 바닥납니다.`);
+  } else {
+    lines.push(`🚨 **정책 밖 지출 — 한도를 넘겼는데 크레딧에서 나가고 있습니다 (줄고 있는 계정 ${draining.length}개 · 크레딧 보유 ${burning.length}개)**`);
+    lines.push(`정책이 «${CODEX_QUOTA_POLICY_LABEL[quota.policy]}» 인데 레이트리밋 오류가 안 나 회전·폴백이 안 열립니다. 크레딧을 허가하려면 \`elanous config set llm.codexQuotaPolicy credits\`.`);
+  }
   for (const r of burning) {
     const now = r.credits?.balance;
     const nowText = typeof now === 'number' ? now.toFixed(2) : '미상';
     const d = drain.get(r.accountName);
     let tail: string;
     if (!d || d.state === 'unknown') tail = ' (직전 관측 없음 — 이번이 첫 표본입니다)';
-    else if (d.state === 'flat') tail = ' · 직전 관측 이후 «안 줄었습니다»';
+    else if (d.state === 'flat') tail = ' · 크레딧 보유 · 직전 관측 이후 «안 썼습니다»';
     else {
       // ⛔ 남은 시간은 «속도를 실제로 쟀을 때만» 말한다 — 지어내면 사람이 그 수로 계획을 세운다.
       const rate = d.perHour;
@@ -249,7 +297,7 @@ if (burning.length > 0) {
       const etaH = rate && rate < 0 && typeof now === 'number' ? now / -rate : null;
       const resetH = hoursUntil(r.subscription?.resetsAt);
       let eta = '';
-      if (etaH !== null) {
+      if (etaH !== null && !combinedCredits) {
         const h = Math.max(0, Math.round(etaH));
         if (resetH !== null && resetH > 0 && resetH < etaH) {
           // 리셋이 먼저 온다 — 이 창에서 탈 양까지 «수»로 말한다.
@@ -271,10 +319,12 @@ if (burning.length > 0) {
   lines.push('');
 }
 if (exhausted.length === codex.length && codex.length > 0) {
-  lines.push(`🚨 **codex 계정이 «전부» 소진됐습니다 (${codex.length}/${codex.length})**`);
-  lines.push('폴백이 grok 으로 갑니다. grok 도 한도가 있으니 같이 보십시오.');
+  lines.push(`${creditsAllowed ? '💳' : '🚨'} **codex 구독 한도가 «전부» 찼습니다 (${codex.length}/${codex.length})**`);
+  if (creditsAllowed) lines.push('정책 «크레딧까지» — codex 를 크레딧으로 계속 씁니다. 크레딧까지 떨어지면 폴백 체인으로 갑니다.');
+  else if (fallbackAllowed) lines.push(`정책 «자동 폴백» — 폴백 체인(\`llm.fallbackChain\`)으로 갑니다. 폴백 대상의 한도도 같이 보십시오.`);
+  else lines.push('정책 «한도 안에서만» — codex 작업은 리셋까지 «멈춥니다»(폴백·크레딧 없음).');
 } else if (exhausted.length > 0) {
-  lines.push(`⚠️ **codex 계정 ${exhausted.length}/${codex.length} 소진**`);
+  lines.push(`⚠️ **codex 계정 ${exhausted.length}/${codex.length} 한도 참** — 남은 계정으로 회전합니다`);
 }
 for (const r of exhausted) {
   const h = hoursUntil(r.subscription?.resetsAt);
@@ -289,9 +339,9 @@ if (expiring.length > 0) {
   lines.push(`💳 **리셋권 만료 임박 (${RESET_CREDIT_EXPIRY_DAYS}일 이내)**`);
   for (const r of expiring) lines.push(`  • \`${r.accountName}\` — ${daysUntil(r.resetCredits?.expiresAt)}일 뒤`);
 }
-if (others.length > 0) {
+if (others.length > 0 && fallbackAllowed) {
   lines.push('');
-  lines.push('폴백 대상:');
+  lines.push(creditsAllowed ? '폴백 대상(크레딧까지 떨어진 뒤):' : '폴백 대상:');
   for (const r of others) {
     const rem = r.subscription?.remainingPercent;
     const used = r.credits?.usedPercent;

package/scripts/continuation-dogfood.ts

@@ -24,13 +24,14 @@ import { ContinuationScheduler } from '../src/dispatch/continuation-scheduler.js
 import type { ContinuationStepResult } from '../src/dispatch/continuation-driver.js';
 import { makeContinuationRunTurn } from '../src/dispatch/continuation-turn-runner.js';
 import { getUserConfig } from '../src/user-config.js';
+import { envLiteral } from '../src/platform/env-literal.js';
 
 const SLUG = 'continuation-demo';
 const MAX_TICKS = 5;
 
 resetAutoModeForTest();
 const home = mkdtempSync(join(tmpdir(), 'cont-dogfood-'));
-const vault = discoverObsidianVault({ env: { ELANOUS_OBSIDIAN_VAULT: join(home, 'vault') }, cwd: home });
+const vault = discoverObsidianVault({ env: envLiteral({ ELANOUS_OBSIDIAN_VAULT: join(home, 'vault') }), cwd: home });
 const paths = resolveGoalPaths(vault, SLUG);
 const summaryPath = join(paths.goalRoot, 'executive-summary.md');
 

package/scripts/coord-channel-watch.sh

@@ -3,7 +3,7 @@
 #
 # ⭐ 채널 번호는 «인자»다 — 기본값은 아래 `PR_NUM`, 정본은 `MANUAL-multi-agent-coordination-channel` 머리말이다.
 #   ⛔ 채널이 바뀌면 이 파일의 기본값 «한 줄»과 그 매뉴얼 머리말 «둘»만 고친다(이름은 안 바꾼다).
-#    (2026-08-12 #5730→#8328 · 08-25 #8328→#12577 · 09-10 #12577→#16815).
+#    (2026-08-12 #5730→#8328 · 08-25 #8328→#12577 · 09-10 #12577→#16815 · 09-27 #16815→#20798).
 #    ⛔ 채널은 «막힐 수 있다» — GitHub 은 코멘트 2500 을 넘기면 댓글을 차단한다. 그때의 절차 =
 #    `내부 문서 `COORDINATION-CHANNEL`` 「채널이 막히면 — 순서」.
 #
@@ -48,11 +48,11 @@
 
 set -u
 
-PR_NUM="${CH_PR:-16815}"  # ⛔ 2026-09-10: #12577 이 2,376/2,500 에 닿아 채널 «4» 로 옮김(벽 «전»에 미리)
-#   📏 이력: #5730(07-28~08-12) → #8328(08-11~08-25) → #12577(08-25~09-10) → #16815.
+PR_NUM="${CH_PR:-20798}"  # ⛔ 2026-09-27: #16815 가 2,500 상한에 닿아 채널 «5» 로 옮김(🅞 · 벽에 «닿은 뒤» — 미리 못 옮겼다)
+#   📏 이력: #5730(07-28~08-12) → #8328(08-11~08-25) → #12577(08-25~09-10) → #16815(09-10~09-27) → #20798.
 #   ***수명이 «2주 안팎»이다 — 세 판이 전부 그랬다.*** 다음 벽은 09-24 언저리.
-#   🩹 발신이 rc=1 이면 먼저 세라: gh api repos/ElanvitalAI/monad/issues/<n> --jq .comments
-REPO="${CH_REPO:-ElanvitalAI/monad}"
+#   🩹 발신이 rc=1 이면 먼저 세라: gh api repos/ElanvitalAI/elanous/issues/<n> --jq .comments
+REPO="${CH_REPO:-ElanvitalAI/elanous}"
 INTERVAL="${CH_INTERVAL:-60}"
 BODY_CHARS="${CH_BODY_CHARS:-1500}"
 # ⛔⭐⭐⭐ PR «본문» 감시 (2026-08-08 [T] 60차) — 종전엔 «대화 코멘트»만 봤다.

package/scripts/coord-tracks.json

@@ -1,9 +1,10 @@
 {
   "_comment": "조율 채널 트랙 신원의 정본. 트랙을 더하려면 여기 한 줄만 더한다 — scripts/coord-post.sh 와 scripts/build-docs-site.ts 가 이 파일을 읽는다.",
   "tracks": [
-    { "id": "S", "mark": "🅢" },
-    { "id": "T", "mark": "🅣" },
-    { "id": "F", "mark": "🅕" },
-    { "id": "O", "mark": "🅞" }
+    { "id": "S", "mark": "🅢", "owns": ["기획", "총괄", "전략", "소구점", "로드맵", "plan", "strategy"] },
+    { "id": "T", "mark": "🅣", "owns": ["영상", "비디오", "티저", "하이퍼프레임", "HyperFrames", "렌더", "video", "teaser", "render", "B-roll"] },
+    { "id": "F", "mark": "🅕", "owns": ["PWA", "웹", "웹사이트", "elanous.ai", "탭", "화면", "UI", "프론트엔드", "frontend", "web", "tab"] },
+    { "id": "O", "mark": "🅞", "owns": ["블로그", "매뉴얼", "문서", "흡수", "Obsidian", "승인", "blog", "manual", "docs"] },
+    { "id": "E", "mark": "🅔", "owns": [] }
   ]
 }

package/scripts/cron-run.ts

@@ -2,7 +2,8 @@
 // ── 크론 관측성 래퍼 (RFC-scheduler-execution-observability-memory·2026-07-15) ────────────────
 //
 // crontab 이 실제 스크립트를 이 래퍼로 감싸 실행하면, 그 파이어를 3계층(logs.db·레지스트리·자기기억)에
-// 기록한다. 사용:  bun scripts/cron-run.ts <target-script> [target-args...]
+// 기록한다. 사용:  bun scripts/cron-run.ts [--schedule-id <id>] <target-script> [target-args...]
+//                 bun scripts/cron-run.ts [--schedule-id <id>] --shell <interpreter> <target> [args...]
 //   예) cd <repo> && bun scripts/cron-run.ts scripts/community-buzz-cycle.ts --collect-only >> /tmp/x.log 2>&1
 //
 // ★ fail-open 불변식: 관측(sink 등록·레지스트리·기억) 무엇이 실패해도 자식은 반드시 실행하고 자식의
@@ -16,9 +17,17 @@ ensureCronNodePath();
 
 async function main(): Promise<void> {
   const argv = process.argv.slice(2);
-  const target = argv[0];
-  if (!target) { process.stderr.write('cron-run: target script 인자 필수\n'); process.exit(2); }
-  const targetArgs = argv.slice(1);
+  const hasScheduleId = argv[0] === '--schedule-id';
+  const scheduleId = hasScheduleId ? argv.splice(0, 2)[1] : undefined;
+  if (hasScheduleId && (!scheduleId?.trim() || scheduleId === '--shell')) {
+    process.stderr.write('cron-run: --schedule-id 인자 필수\n');
+    process.exit(2);
+  }
+  const shell = argv[0] === '--shell';
+  const interpreter = shell ? argv[1] : process.execPath;
+  const target = argv[shell ? 2 : 0];
+  if (!interpreter || !target) { process.stderr.write('cron-run: target script 인자 필수\n'); process.exit(2); }
+  const targetArgs = argv.slice(shell ? 3 : 1);
 
   // 관측 준비(fail-open) — logs.db sink 등록 + 레지스트리 행 해석.
   let name = target;
@@ -40,33 +49,45 @@ async function main(): Promise<void> {
     sMod.setLogInstanceName(lc.instanceName);
     const off = sMod.registerLogStoreSink((s) => dMod.debug.registerSink(s), 'scheduler', lc.retention);
     if (off) process.on('exit', off);
-    name = rMod.scriptName(target);
+    // 셸 대상은 해석기와 함께 넘겨 레지스트리 파생 이름(`bash /x/backup.sh` → backup)과 맞춘다.
+    name = rMod.scriptName(shell ? `${interpreter} ${target}` : target);
     db = rMod.openSchedulesDb();
     // 최신 crontab 인벤토리 반영(래핑된 라인도 unwrap-aware 로 동일 id 승계).
     try { rMod.inventoryCrontab(db); } catch { /* fail-soft */ }
-    const rows = rMod.listSchedules(db).filter((r) => r.name === name);
-    const activeRows = rows.filter((r) => r.enabled);
-    const selectedRow = activeRows[0] ?? rows[0];
-    if (selectedRow) {
-      id = selectedRow.id;
-      prevStatus = selectedRow.last_status ?? null;
-      activeScheduleRowsAmbiguous = activeRows.length > 1;
-    } else scheduleRowMissing = true;
+    if (scheduleId) {
+      // 명시된 id만 조회한다. 해당 행이 없더라도 이름으로 폴백해 다른 잡을 갱신하지 않는다.
+      const row = db.query('SELECT id, last_status FROM schedule_registry WHERE id = ?').get(scheduleId) as
+        | { id: string; last_status: string | null }
+        | undefined;
+      if (row) {
+        id = row.id;
+        prevStatus = row.last_status ?? null;
+      } else scheduleRowMissing = true;
+    } else {
+      const rows = rMod.listSchedules(db).filter((r) => r.name === name);
+      const activeRows = rows.filter((r) => r.enabled);
+      const selectedRow = activeRows[0] ?? rows[0];
+      if (selectedRow) {
+        id = selectedRow.id;
+        prevStatus = selectedRow.last_status ?? null;
+        activeScheduleRowsAmbiguous = activeRows.length > 1;
+      } else scheduleRowMissing = true;
+    }
   } catch (error) {
     prerequisiteFailed = true;
     prerequisiteError = error; // fail-open — 관측 없이도 자식은 실행
   }
 
   const start = Date.now();
-  // 자식은 이 래퍼와 같은 bun 으로 실행(cron PATH 무관·process.execPath). stdout 은 흘리고(2>&1 보존),
-  // stderr 는 tee(흘리며 tail 캡처).
+  // 기본 자식은 이 래퍼와 같은 bun 으로 실행(cron PATH 무관·process.execPath).
+  // --shell 자식은 지정한 interpreter 로 실행한다. stdout 은 흘리고(2>&1 보존), stderr 는 tee(흘리며 tail 캡처).
   // ⛔⭐ env 를 «명시»한다 — bun 은 자식에게 「기동 시 스냅샷」을 주므로 ensureCronNodePath() 가
   //   런타임에 세운 PATH 가 «안 간다»(node 와 갈리고, 실패가 조용하다).
   //   📏 2026-08-31 실측(알려진 양성 /ZZZ_SENTINEL): env 미지정 ⇒ ⛔ 안 흐름 · env 명시 ⇒ ✅ 흐름.
   //   🔑 크론은 PATH= 선언이 «없어» cron 기본 PATH(pyenv·bun «없음»)로 도는데, 그것을 메우려고
   //     ensureCronNodePath() 가 있다 — 그 수리가 자식에게 안 가면 python 스킬 shell-out 이
   //     `exit 1` 로 «조용히» 죽는다(cron-path.ts 주석의 그 사고).
-  const child = spawn(process.execPath, [target, ...targetArgs], {
+  const child = spawn(interpreter, [target, ...targetArgs], {
     stdio: ['ignore', 'inherit', 'pipe'],
     env: { ...process.env },
   });

package/scripts/daemon-port-baseline.txt

@@ -0,0 +1,9 @@
+# Daemon port literal baseline: non-comment lines in non-test src/**/*.ts, per file.
+# New files and increases fail. Migrate callers to the daemon endpoint resolver, then --update.
+# total=13 files=6
+1	src/autopilot/proposal/draft-plan.ts
+6	src/index.ts
+1	src/nexus/api/mcp-oauth-hint.ts
+1	src/nexus/default-port.ts
+2	src/task-orchestrator/surfaces/pod-command-job.ts
+2	src/task-orchestrator/surfaces/self-implement-pod.ts