elanous 0.2.29 → 0.2.31

package/src/loops/orchestrator/tick.ts

@@ -5,7 +5,7 @@ import { CardStore, taskCardsDir, type TaskCard } from '../../task-cards/card-st
 import { Database } from 'bun:sqlite';
 import { type ChecklistItem } from '../../release-loop/checklist.js';
 import { effectiveInstanceRoot } from '../../instance/resolve.js';
-import { getUserConfig, resolveConfiguredAgentRoleLlm, type OrchestratorLoopConfig } from '../../user-config.js';
+import { getUserConfig, ORCHESTRATOR_DEFAULTS, resolveConfiguredAgentRoleLlm, type OrchestratorLoopConfig } from '../../user-config.js';
 import { rubricPriority } from '../../release-loop/rubric.js';
 import { debug } from '../../debug/log.js';
 import { emitLoopHeartbeat } from '../neighbor-runtime.js';
@@ -15,7 +15,11 @@ import { addHarnessQueue, harnessQueueOutcome, setQueuedPoolHint } from '../../h
 import { placeOnGrid, type GridHost } from './grid-place.js';
 import { checkPodPool, parsePodPool, resolvePodPoolSpec } from '../../task-orchestrator/surfaces/pod-pool.js';
 import { leaseKubectl } from '../../task-orchestrator/surfaces/pod-lease.js';
-import type { TrafficSeatRow } from './traffic.js';
+import { isLaunchEligible, isTrafficLaunch, recordDispatchCycle, seatOfTree, type TrafficProcess } from './traffic.js';
+import { defaultListHarnessProcesses } from '../../harness/harness-cli-command.js';
+import * as testGuard from '../../instance/test-write-guard.js';
+import { seatCapDetails } from '../budget.js';
+export { isLaunchEligible } from './traffic.js';
 import { readTaskAgentState, TASK_SEATS, type HandTaskOptions, type TaskCard as TaskAgentCard, type HandTaskResult, type TaskLauncher, type TaskSeat } from '../../task-agent/task-hand.js';
 import { runCoordinatorAgentInbox, runCoordinatorInbox, type CoordinatorInboxResult } from './inbox.js';
 import { loadAgentRolePack, type AgentReplyInput } from '../agent-reply.js';
@@ -26,12 +30,6 @@ export type Node = 'intake' | 'split' | 'place' | 'delegate' | 'launch' | 'recon
 export type Mode = 'off' | 'shadow' | 'live';
 const SEAT_LOOP_IDS: Readonly<Record<string, string>> = { OP: 'op-seat', MK: 'cmo-seat', TC: 'tc-seat', UX: 'ux-seat' };
 export interface Cell { id: string; title: string; kind?: string; seat?: string; host?: string; gridHost?: boolean; version?: string; cardId: string; origin: 'candidate' | 'flow1a'; priority?: 'P0' | 'P1' | 'P2' | 'P3' | 'P4'; predecessors?: string[] }
-/** Pure launch decision over observed traffic; dispatch-c will wire it into the periodic launch path. */
-export function isLaunchEligible(row: Pick<TrafficSeatRow, 'nextCell' | 'running' | 'launchCap'>,
-  skipReason?: string): boolean {
-  return row.nextCell !== null && row.running < row.launchCap &&
-    skipReason !== 'degraded-skip' && skipReason !== 'cap-deferred';
-}
 export interface TickState {
   runId: string; window: Window; mode: Mode; day: string;
   cards: TaskCard[]; skippedCards: Array<{ id: string; reason: string }>; cells: Cell[]; placed: number; unplaced?: number; delegated: number; wouldDelegate: number; rebalanced?: number; rebalanceBlocked?: Array<{ id: string; reason: string }>;
@@ -70,6 +68,8 @@ export interface TickDeps {
   gridHosts?: readonly GridHost[];
   seatTurn?: (seat: string, root: string, host?: string, options?: Pick<SeatDeps, 'enqueue'>) => Promise<{ status: string; queueId?: string; runId?: string; item?: { source: string; id: string } }>;
   queueOutcome?: (queueId: string, root: string) => 'pending' | 'unknown' | 'retryable' | 'succeeded';
+  /** Snapshot of running harness processes for launch-cap decisions; an unreadable snapshot blocks launches. */
+  launchProcesses?: () => { status: 'ok'; records: readonly TrafficProcess[] } | { status: 'incomplete' };
   /** 발사 전 대기열 항목의 풀 힌트 갱신(주입 안 하면 harness-queue `setQueuedPoolHint`). */
   setPoolHint?: (queueId: string, poolHint: string | undefined, root: string) => Promise<boolean>;
   loadAdapter?: (path: string, name: string) => Promise<unknown>;
@@ -750,8 +750,55 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
         && (orchestratorConfig?.maxDelegatePerTick === undefined || state.delegatedKeys?.includes(`orch:${cell.cardId}:${cell.id}`)
           || (mode === 'live' && latestRequests.has(`orch:${cell.cardId}:${cell.id}`))));
       const seats = [...new Set(eligible.map(cell => cell.seat!))];
+      const supplied = state.cells.filter(cell => cell.origin === 'flow1a' && cell.seat && SEAT_LOOP_IDS[cell.seat]);
+      const eligibleKeys = new Set(eligible.map(cell => `orch:${cell.cardId}:${cell.id}`));
+      const deferredKeys = new Set((state.deferredCells ?? []).map(cell => `orch:${cell.cardId}:${cell.id}`));
+      const skipped: Record<string, number> = {};
+      for (const cell of supplied) {
+        const key = `orch:${cell.cardId}:${cell.id}`;
+        if (eligibleKeys.has(key)) continue;
+        const reason = state.degradation?.level === 2 ? 'degraded-skip'
+          : deferredKeys.has(key) ? 'cap-deferred' : 'not-queued';
+        skipped[reason] = (skipped[reason] ?? 0) + 1;
+      }
+      if (!supplied.length) skipped['no-supply'] = 1;
+      // Use the same process inventory and seat mapping as traffic for production live launches.
+      // A shadow/test tick must not synchronously scan host processes (up to 2.5s per tick).
+      const observed = seats.length ? deps.launchProcesses?.() ?? (() => {
+        if (mode === 'shadow' || testGuard.testProcessSignal()) {
+          observe('launch-inventory-skipped', mode === 'shadow' ? 'shadow' : 'test', 1);
+          return { status: 'ok' as const, records: [] };
+        }
+        const snapshot = defaultListHarnessProcesses({ include: record => isTrafficLaunch(record.command), cwdOnly: true, deadlineMs: 2_500 });
+        // The inventory itself must be complete; an unreadable cwd is handled as one reserved slot below.
+        return snapshot.status === 'ok' ? snapshot : { status: 'incomplete' as const };
+      })() : { status: 'ok' as const, records: [] };
+      const processes = observed.status === 'ok' ? observed.records : null;
+      const identified = (processes ?? []).filter(process => isTrafficLaunch(process.command)).map(process =>
+        'seat' in process ? process.seat : seatOfTree(process.cwd, orchestratorConfig ?? ORCHESTRATOR_DEFAULTS));
+      const unknown = identified.filter(seat => !seat).length;
+      // OP policy: unknown launches together reserve one conservative slot per seat, rather than
+      // closing every seat. An incomplete process inventory still fails closed.
+      identified.forEach((seat, index) => { if (!seat) observe('launch-unknown-seat', `cwd-unknown:${index}`, 1); });
+      const reserve = unknown ? 1 : 0;
+      const running = (seat: string): number => identified.filter(value => value === seat).length;
+      const free = (seat: string): number => Math.max(0, seatCapDetails({ seat: seat as keyof typeof ORCHESTRATOR_DEFAULTS.seatCaps,
+        caps: orchestratorConfig?.seatCaps, gate: orchestratorConfig?.releaseGate }).cap - running(seat) - reserve);
+      const launchSeats = seats.filter(seat => {
+        const cell = eligible.find(row => row.seat === seat)!;
+        const cap = free(seat);
+        if (processes === null || !isLaunchEligible({ nextCell: { id: cell.id, title: cell.title, owner: seat, status: 'yellow' },
+          running: 0, launchCap: cap })) {
+          // Every eligible cell of this seat stays unlaunched, not just one — count them all per reason.
+          skipped['capacity'] = (skipped['capacity'] ?? 0) + eligible.filter(row => row.seat === seat).length;
+          return false;
+        }
+        const leftovers = eligible.filter(row => row.seat === seat).length - 1;
+        if (leftovers > 0) skipped['seat-occupied'] = (skipped['seat-occupied'] ?? 0) + leftovers;
+        return true;
+      });
       state.launched = [];
-      for (const seat of seats) {
+      for (const seat of launchSeats) {
         if (mode === 'shadow') {
           const cell = eligible.find(row => row.seat === seat)!;
           const item: SeatItem = { source: 'request', id: `orch:${cell.cardId}:${cell.id}`, title: cell.title, text: cell.title };
@@ -774,7 +821,7 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
             : undefined;
           const options = enqueue ? { enqueue } : undefined;
           const turn = await (deps.seatTurn ?? ((assigned: string, stateRoot: string, _preferred?: string, overrides?: Pick<SeatDeps, 'enqueue'>) =>
-            runSeatLoopOnce(assigned, { root: stateRoot,
+            runSeatLoopOnce(assigned, { root: stateRoot, needsOwnerGate: true, // autonomous launch: needs-owner hold on
               config: { ...getUserConfig().loops?.seat, mode: 'live-safe', seats: [assigned] }, ...overrides })))(seat, root, host, options);
           // 자리 턴이 «이 틱이 넣은 의뢰»를 처리했을 때만 칸에 잇는다 — 대기열의 다른 의뢰는 이 카드의 발사가 아니다.
           const targets = new Set(eligible.filter(row => row.seat === seat).map(row => `orch:${row.cardId}:${row.id}`));
@@ -787,6 +834,13 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
           observe('exchange', `seat-turn:${seat}:${turn.status}`, 1, SEAT_LOOP_IDS[seat]);
         }
       }
+      // `dispatch` (podTarget · localLane, RFC A3) is record-only at this stage: it is copied from config into the
+      // dispatch ledger and does not change launch or capacity decisions — seatCaps · running · isLaunchEligible decide those.
+      recordDispatchCycle(root, { at: now.toISOString(), source: 'tick', mode, runId,
+        supply: supplied.length, capacity: processes === null ? 0 : seats.reduce((total, seat) => total + free(seat), 0),
+        eligible: launchSeats.length, skipped,
+        dispatch: orchestratorConfig?.dispatch ?? ORCHESTRATOR_DEFAULTS.dispatch,
+      });
     } else if (node === 'reconcile') {
       if (window !== '08') {
         // 새 카드가 있어도 앞 틱의 의뢰·발사를 같이 대조한다 — 지금 틱 것이 같은 키를 이긴다.

package/src/loops/orchestrator/traffic.ts

@@ -17,6 +17,51 @@ export type TrafficProcess = Pick<HarnessProcessRecord, 'command' | 'elapsedSeco
 export type TrafficSeatRow = { seat: OrchestratorSeat; running: number; cap: number; baseShare: number | null; borrowed: number; lent: number; launchCap: number; idleFor: number | null; idle: boolean; nextCell: TrafficCell | null };
 export type TrafficResult = { seats: TrafficSeatRow[]; unassigned: number; now: Date; idleMinutes: number; finish?: { metrics: FinishMetrics; advice: FinishAdvice } };
 
+/** A reason from a previous turn never blocks recovered supply; only active holds do. */
+export function isLaunchEligible(row: Pick<TrafficSeatRow, 'nextCell' | 'running' | 'launchCap'>,
+  skipReason?: string): boolean {
+  return row.nextCell !== null && row.running < row.launchCap &&
+    skipReason !== 'degraded-skip' && skipReason !== 'cap-deferred';
+}
+
+export type DispatchCycle = {
+  at: string; source: 'traffic' | 'tick'; mode: 'shadow' | 'live'; runId: string;
+  supply: number; capacity: number; eligible: number; skipped: Record<string, number>;
+  dispatch: OrchestratorLoopConfig['dispatch'];
+};
+
+/** Separate journal: never extend or reinterpret seat-requests or per-run state rows. */
+export function recordDispatchCycle(root: string, cycle: DispatchCycle,
+  log: (category: string, event: string, data: Record<string, unknown>) => void = debug.log.bind(debug)): void {
+  const path = join(root, 'orchestrator', 'dispatch-ledger.jsonl');
+  try {
+    mkdirSync(dirname(path), { recursive: true });
+    const appended = withFileLockSync(`${path}.lock`, () => {
+      const previous = existsSync(path) ? readFileSync(path, 'utf8') : '';
+      if (previous.split('\n').some(line => {
+        if (!line) return false;
+        let row: Partial<DispatchCycle>;
+        try { row = JSON.parse(line) as Partial<DispatchCycle>; }
+        catch {
+          // A torn append must not permanently stop later cycles. Keep the line for forensic inspection.
+          try { log('loop.orchestrator', 'dispatch-cycle-malformed', { path }); }
+          catch { /* Observation must not stop a valid append. */ }
+          return false;
+        }
+        return row && row.source === cycle.source && row.runId === cycle.runId && row.mode === cycle.mode;
+      })) return false;
+      // A torn final line has no newline; separate it from the next valid JSONL row.
+      appendFileSync(path, `${previous && !previous.endsWith('\n') ? '\n' : ''}${JSON.stringify(cycle)}\n`);
+      return true;
+    });
+    if (appended) try { log('loop.orchestrator', 'dispatch-cycle', cycle); }
+    catch { /* Observation cannot change a recorded decision. */ }
+  } catch (error) {
+    try { debug.log('loop.orchestrator', 'dispatch-cycle-failed', { error: String(error).slice(0, 200) }, { level: 'warn' }); }
+    catch { /* Observation cannot change a recorded decision. */ }
+  }
+}
+
 /** Same bounded walk as the CTX1 hook: a marker at the git root is checked before stopping. */
 export function seatOfTree(cwd: string | undefined, cfg: Pick<OrchestratorLoopConfig, 'seatTrees'>): OrchestratorSeat | null {
   if (!cwd || !isAbsolute(cwd)) return null;
@@ -144,7 +189,24 @@ export function runTrafficTick({ processes, now, caps, openCells, nextRound, tot
   const advice = finishAdvice(metrics, TRAFFIC_SEATS.reduce((sum, seat) => sum + caps[seat], 0));
   const result = { ...trafficTick({ processes, now, caps, openCells, nextRound, totalSlots: totalSlots ?? advice.launchSlots }),
     finish: { metrics, advice } };
-  const queued = applyTraffic(result, { ...applyDeps, mode });
+  const root = applyDeps?.root ?? effectiveInstanceRoot();
+  const queued = applyTraffic(result, { ...applyDeps, root, mode });
+  {
+    const skipped: Record<string, number> = {};
+    const suppliedSeats = new Set(openCells.filter(cell => cell.status !== 'done').map(cell => cell.owner?.split('/')[0]));
+    for (const row of result.seats) {
+      const reason = !suppliedSeats.has(row.seat) ? 'no-supply' : row.running >= row.launchCap ? 'capacity'
+        : !row.idle ? 'not-idle' : undefined;
+      if (reason) skipped[reason] = (skipped[reason] ?? 0) + 1;
+    }
+    recordDispatchCycle(root, {
+      at: now.toISOString(), source: 'traffic', mode, runId: now.toISOString(),
+      supply: result.seats.filter(row => suppliedSeats.has(row.seat)).length,
+      capacity: result.seats.reduce((sum, row) => sum + Math.max(0, row.launchCap - row.running), 0),
+      eligible: result.seats.filter(row => row.idle && isLaunchEligible(row)).length,
+      skipped, dispatch: getUserConfig().loops?.orchestrator?.dispatch ?? ORCHESTRATOR_DEFAULTS.dispatch,
+    });
+  }
   let authorShadow: AuthorShadow | null = null;
   let shadowFailure: Record<string, unknown> | null = null;
   try {
@@ -187,6 +249,7 @@ if (import.meta.main) {
     const { result, queued, authorShadow } = runTrafficTick({
       processes, now, caps: cfg.seatCaps, openCells: listChecklist(version).items,
       ...(nextVersion ? { nextRound: listChecklist(nextVersion).items } : {}), mode: cfg.trafficMode,
+      applyDeps: { root: effectiveInstanceRoot() },
     });
     if (args.includes('--json')) console.log(JSON.stringify({ ...result, mode: cfg.trafficMode, queued, version, authorShadow }));
     else console.log(trafficLine(result, cfg.trafficMode));

package/src/loops/registry.ts

@@ -26,8 +26,16 @@ export interface LoopRun {
   failedNodes: string[];
   durationMs: number | null;
 }
+export type LoopRoot = '조율자' | '수호자';
+export type LoopStage = 'proposed' | 'shadow' | 'live' | 'retiring' | 'retired';
+const LOOP_STAGES: readonly LoopStage[] = ['proposed', 'shadow', 'live', 'retiring', 'retired'];
+
 export interface LoopEntry {
   id: string;
+  parent?: string | null;
+  root?: LoopRoot | null;
+  purpose?: string | null;
+  stage?: LoopStage | null;
   msgAddress?: string | null;
   replyBody?: LoopReplyBody;
   wake?: MessageWake;
@@ -209,6 +217,8 @@ export function defaultLoopRoot(): string {
   return installedCronRoot() ?? repoRoot();
 }
 
+const warnedLegacyRoots = new Set<string>();
+
 export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
   const root = resolve(opts.root ?? defaultLoopRoot());
   const stateRoot = opts.stateRoot ?? effectiveInstanceRoot();
@@ -234,6 +244,14 @@ export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
     if (!declaredCron && !events.length && !matched.length) continue;
     if (!/^[a-zA-Z0-9][\w.-]*$/.test(doc.graph_id)) throw new Error(`unsafe loop graph_id: ${doc.graph_id}`);
     if (loops.some(loop => loop.id === doc.graph_id)) throw new Error(`duplicate loop graph_id: ${doc.graph_id}`);
+    if (header?.root != null && header.root !== '조율자' && header.root !== '수호자')
+      throw new Error(`invalid loop root for ${doc.graph_id}: ${String(header.root)}`);
+    if (header?.stage !== undefined && (typeof header.stage !== 'string' || !LOOP_STAGES.includes(header.stage as LoopStage)))
+      throw new Error(`invalid loop stage for ${doc.graph_id}: ${String(header.stage)}`);
+    if (header?.root == null && !warnedLegacyRoots.has(file)) {
+      warnedLegacyRoots.add(file);
+      debug.log('loops.registry', 'legacy-root-missing', { id: doc.graph_id, file });
+    }
     const jobs = matched.map(row => ({ id: row.id, cron: row.cron, enabled: !!row.enabled,
       ...(entryRows.includes(row) ? { entryScript: true } : {}) }));
     const active = matched.filter(row => !!row.enabled && !!row.cron);
@@ -241,6 +259,10 @@ export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
     const title = typeof header?.title === 'string' ? header.title : doc.graph_id;
     const entry: LoopEntry = { id: doc.graph_id, title, ...messageFields(doc.graph_id, stateRoot),
       description: typeof header?.description === 'string' ? header.description : null,
+      ...(typeof header?.parent === 'string' ? { parent: header.parent } : {}),
+      ...(header?.root === '조율자' || header?.root === '수호자' ? { root: header.root } : {}),
+      ...(typeof header?.purpose === 'string' ? { purpose: header.purpose } : {}),
+      ...(typeof header?.stage === 'string' ? { stage: header.stage as LoopStage } : {}),
       ...resolveOwner(doc.graph_id, title, config, header?.owner),
       mode: typeof header?.mode === 'string' ? header.mode : null, file: relative(root, file),
       trigger: { cron: declaredCron, events }, jobs, enabled: matched.some(row => !!row.enabled),
@@ -252,6 +274,10 @@ export function listLoops(opts: LoopRegistryOptions = {}): LoopEntry[] {
 }
 
 export interface AllLoopEntry extends CheckEntry {
+  parent?: LoopEntry['parent'];
+  root?: LoopEntry['root'];
+  purpose?: LoopEntry['purpose'];
+  stage?: LoopEntry['stage'];
   msgAddress?: string | null;
   replyBody?: LoopReplyBody;
   wake?: MessageWake;
@@ -618,6 +644,8 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
     const declaredHost = typeof header.host === 'string' && header.host ? header.host : undefined;
     const declaredCategory = typeof header.observationCategory === 'string' && header.observationCategory ? header.observationCategory : undefined;
     return { kind: 'graph', id: loop.id, title: loop.title, owner: loop.owner ?? undefined, ownerSource: loop.ownerSource,
+      ...(loop.parent ? { parent: loop.parent } : {}), ...(loop.root ? { root: loop.root } : {}),
+      ...(loop.purpose ? { purpose: loop.purpose } : {}), ...(loop.stage ? { stage: loop.stage } : {}),
       msgAddress: loop.msgAddress, replyBody: loop.replyBody, wake: loop.wake, ...(loop.wakeSource ? { wakeSource: loop.wakeSource } : {}), unreadCount: loop.unreadCount,
       ...(declaredHost || installed.length ? { host: declaredHost ?? hostname() } : {}),
       observationCategory: declaredCategory ?? 'graph.runner',
@@ -749,6 +777,8 @@ export async function setLoopEnabled(id: string, enabled: boolean, yes = false,
   const loop = loopStatus(id, opts);
   const action = enabled ? 'start' : 'stop';
   if (!loop.jobs.length && (!enabled || !loop.trigger.cron)) throw new Error(`loop ${id} has no cron job to ${action}`);
+  // Registration creates a new cron; toggling an already installed legacy cron remains supported.
+  if (enabled && !loop.jobs.length && !loop.root) throw new Error(`loop ${id} requires root (조율자|수호자) for new registration`);
   const pending = loop.jobs.filter(job => job.enabled !== enabled);
   const entryScript = loop.jobs.some(job => job.entryScript);
   const entryLabel = entryScript ? { entryScript: true } : {};

package/src/market/signed-index.ts

@@ -1,5 +1,7 @@
 import { createHash, createPublicKey, generateKeyPairSync, sign, verify } from 'node:crypto';
 
+import { scanPackInternalRefs } from './pack-internal-refs';
+
 export interface MarketplaceArtifact {
   sha256: string;
   bytes: number;
@@ -96,6 +98,18 @@ function invalidIndex(value: unknown): string | null {
       if (!Number.isSafeInteger(entry.artifact.bytes) || (entry.artifact.bytes as number) < 0) return field('artifact.bytes: expected non-negative integer');
       if (!string(entry.artifact.key) || !entry.artifact.key.trim()) return field('artifact.key: expected non-empty string');
       if (collection === 'loopBundles' && entry.graphs !== undefined && !stringArray(entry.graphs)) return field('graphs: expected string array');
+      if (entry.visibility === 'public') {
+        const texts: Array<[string, string | undefined]> = [
+          ['name', string(entry.name) ? entry.name : undefined],
+          ['version', string(entry.version) ? entry.version : undefined],
+          ['description', string(entry.description) ? entry.description : undefined],
+          ['artifact.key', string(entry.artifact.key) ? entry.artifact.key : undefined],
+        ];
+        const graphs = collection === 'loopBundles' && stringArray(entry.graphs) ? entry.graphs : undefined;
+        if (graphs !== undefined) texts.push(['graphs', graphs.join('\n')]);
+        const hit = scanPackInternalRefs(texts.filter((pair): pair is [string, string] => pair[1] !== undefined).map(([path, text]) => ({ path, text })))[0];
+        if (hit) return field(`${hit.file}: expected no internal reference (${hit.marker})`);
+      }
     }
   }
 

package/src/mcp/mcp-oauth.ts

@@ -9,7 +9,9 @@
 // 인가 서버가 RFC 8628 을 광고할 때는 장치 코드로 자격을 얻는다.
 // 경계: 새 CLI 하위 명령은 더하지 않는다.
 
-import { join } from 'node:path';
+import { chmodSync, closeSync, fchmodSync, mkdirSync, openSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
+import { dirname, join } from 'node:path';
 import { generatePkcePair } from '../oauth/pkce.js';
 import {
   authStorePath,
@@ -19,6 +21,7 @@ import {
   saveTokens,
   type OAuthTokens,
   type ProviderAuthState,
+  type WriteTokensOpts,
 } from '../oauth/store.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { debug } from '../debug/log.js';
@@ -175,7 +178,7 @@ function loadIssuerState(
   if (legacy === path) return null;
   const stranded = loadTokens(issuer, legacy);
   if (!stranded || stranded.authMode !== AUTH_MODE) return null;
-  saveTokens(
+  saveMcpTokens(
     issuer,
     stranded.tokens,
     {
@@ -424,6 +427,15 @@ function registrationFromState(state: ProviderAuthState | null): ClientRegistrat
   };
 }
 
+function saveMcpTokens(issuer: string, tokens: OAuthTokens, opts: WriteTokensOpts, path: string): void {
+  // The shared store creates path.tmp with default permissions and chmods only
+  // after rename. Restrict the temporary file before this MCP credential write.
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(`${path}.tmp`, '', { mode: 0o600, flag: 'w' });
+  chmodSync(`${path}.tmp`, 0o600);
+  saveTokens(issuer, tokens, opts, path);
+}
+
 function persistRegistration(
   issuer: string,
   registration: ClientRegistration,
@@ -431,7 +443,7 @@ function persistRegistration(
   tokens?: OAuthTokens,
 ): void {
   const existing = loadTokens(issuer, path);
-  saveTokens(
+  saveMcpTokens(
     issuer,
     tokens ?? existing?.tokens ?? { accessToken: '', refreshToken: '', expiresAt: null },
     {
@@ -685,8 +697,45 @@ function persistTokens(
 ): void {
   const existing = loadTokens(issuer, path);
   const clientId = registration?.clientId ?? existing?.accountUuid;
-  const clientSecret = registration?.clientSecret ?? existing?.organizationUuid;
-  saveTokens(
+  const switchingClient = registration !== null && existing !== null && registration.clientId !== existing.accountUuid;
+  const clientSecret = registration?.clientSecret ?? (switchingClient ? undefined : existing?.organizationUuid);
+  if (switchingClient) {
+    // Build the complete replacement in memory. A failed temporary write or rename
+    // must leave the old client's registration AND refresh token together on disk.
+    const store = JSON.parse(readFileSync(path, 'utf8')) as { providers: Record<string, ProviderAuthState> };
+    const previous = store.providers[issuer];
+    if (!previous || previous.accountUuid !== existing?.accountUuid) {
+      throw new McpOAuthError('token', 'stored client registration changed during token exchange');
+    }
+    const replacement: ProviderAuthState = {
+      ...previous,
+      tokens,
+      lastRefresh: new Date().toISOString(),
+      authMode: AUTH_MODE,
+      accountUuid: registration.clientId,
+    };
+    delete replacement.redirectUri;
+    delete replacement.organizationUuid;
+    if (clientSecret) replacement.organizationUuid = clientSecret;
+    if (registration.redirectUri) replacement.redirectUri = registration.redirectUri;
+    store.providers[issuer] = replacement;
+    // A stale path.tmp may be 0644. Never write new tokens into it, even briefly.
+    // The unique sibling is created exclusively and private before any token bytes are written.
+    const tmp = `${path}.${randomUUID()}.tmp`;
+    const fd = openSync(tmp, 'wx', 0o600);
+    try {
+      fchmodSync(fd, 0o600);
+      writeFileSync(fd, `${JSON.stringify(store, null, 2)}\n`, 'utf8');
+      closeSync(fd);
+      renameSync(tmp, path);
+    } catch (error) {
+      try { closeSync(fd); } catch { /* already closed */ }
+      try { unlinkSync(tmp); } catch { /* already renamed */ }
+      throw error;
+    }
+    return;
+  }
+  saveMcpTokens(
     issuer,
     tokens,
     {

package/src/models/prompts.ts

@@ -70,6 +70,34 @@ export function getModelFamily(modelId: string | undefined): ModelFamily {
   return 'other';
 }
 
+/** gpt-6 세대 모델인가 — 직결 id(`gpt-6-sol` · `gpt-6-luna` · `gpt-6-astra` …)와 OpenRouter 게이트웨이 id
+ *  (`openrouter/openai/gpt-6-*`) 둘 다. 판정은 «모델 이름»만 본다(구동기 무관): 아래 가드는 모델의 도구 호출
+ *  «행동»에 묶인 것이라 같은 모델이면 어느 경로로 오든 같아야 한다. 맨 `openai/...` id 는 getModelFamily 와 같은
+ *  이유(LM Studio 이름 꼴)로 건드리지 않는다. */
+export function isGpt6GenerationModel(modelId: string | undefined): boolean {
+  if (!modelId) return false;
+  let m = modelId.toLowerCase();
+  if (m.startsWith(OPENROUTER_OPENAI_PREFIX)) m = m.slice(OPENROUTER_OPENAI_PREFIX.length);
+  return m.startsWith('gpt-6');
+}
+
+/** TUI-GPT6-GUARD-PARITY (2026-10-16) — codex 계열 «모델 행동» 도구 루프 가드를 켤 모델인가. 단일 원천.
+ *
+ *  🩸 계기(tui-op-issues #61): getModelFamily 는 `gpt-5*`·이름에 `codex` 만 'codex' 로 보내서 운영 기본
+ *  `gpt-6-sol`(·luna)이 'gpt' 로 떨어졌고, llm.ts 의 `modelFamily === 'codex'` 가드가 전부 꺼져 있었다.
+ *  ⛔ getModelFamily 자체를 바꾸지 않는다 — gpt-6 은 'gpt' 칸으로 전용 프롬프트(gpt6-family-addendum ·
+ *  GPT_CHAT_VARIANT · tool-hint 상한)를 받고 있고, 'codex' 로 옮기면 그것을 잃고 codex 프롬프트·도구 모양·
+ *  예산 칸까지 딸려 간다. 그래서 «가드만» 이 술어로 넓힌다.
+ *
+ *  이 술어로 가는 자리(모델 행동 · 넓힘): llm.ts 탐색 리다이렉트 묶음(W4-anchor · W6-A · W4-A · W5-D · W5-A)
+ *  ⊕ 그 Read 계수 ⊕ hard-stop 강제 종합(W5-E) ⊕ 예산 소진 강제 종합(W5-F).
+ *  일부러 안 넓힌 자리(`modelFamily === 'codex'` 유지 · 근거 없음/정책/구동기 축)는 PR 본문 표 참조:
+ *  즉시 hard-stop 셋 · auto-narrow/inspect 예산 · narrowing 문턱 · W5-G 조기 종합 · 최대 턴 예산 칸 ·
+ *  탐색 면제 · 유휴 감시(구동기 축이 이미 덮음) · codex 도구 모양(eval) · 프롬프트 변형. */
+export function usesCodexBehaviorGuards(modelId: string | undefined): boolean {
+  return getModelFamily(modelId) === 'codex' || isGpt6GenerationModel(modelId);
+}
+
 // ── Model tier (session 21) ─────────────────────────────────────────
 //
 // Coarse 3-tier classification used by the skill router to decide if