elanous 0.2.28 → 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, 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,8 +15,15 @@ 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 { 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 { runCoordinatorInbox } from './inbox.js';
+import { runCoordinatorAgentInbox, runCoordinatorInbox, type CoordinatorInboxResult } from './inbox.js';
+import { loadAgentRolePack, type AgentReplyInput } from '../agent-reply.js';
+import type { LLMProvider } from '../../llm.js';
 
 export type Window = '08' | '12' | '18';
 export type Node = 'intake' | 'split' | 'place' | 'delegate' | 'launch' | 'reconcile' | 'report';
@@ -61,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>;
@@ -73,7 +82,10 @@ export interface TickDeps {
   handTask?: (opts: HandTaskOptions) => Promise<HandTaskResult>;
   taskLauncher?: TaskLauncher;
   /** Coordinator inbox seam; the real intake reads and replies on the durable message bus. */
-  coordinatorInbox?: () => { replied: number; acknowledged: number };
+  coordinatorInbox?: () => CoordinatorInboxResult | Promise<CoordinatorInboxResult>;
+  /** Production still uses the restricted turn; tests can supply a deterministic turn. */
+  coordinatorAgentRun?: AgentReplyInput['runAgent'];
+  coordinatorAgentProvider?: LLMProvider;
 }
 
 /** ORCH-TA-HAND ledger — one row per handed `orch:<card>:<cell>` key so a cell is handed once across ticks and processes. */
@@ -475,7 +487,15 @@ export async function runOrchestratorNode(node: Node, deps: TickDeps = {}): Prom
   // A graph node may be replayed with the same runId, and 12/18 skip intake.
   // Drain the bus on every tick command; the message transaction prevents duplicate answers.
   if (mode !== 'off') {
-    const inbox = (deps.coordinatorInbox ?? (() => runCoordinatorInbox(undefined, 100, join(root, 'msg', 'messages.db'))))();
+    const inboxPath = join(root, 'msg', 'messages.db');
+    const inbox = await (deps.coordinatorInbox ?? (() => {
+      const role = resolveConfiguredAgentRoleLlm('coordinator');
+      return role
+        ? runCoordinatorAgentInbox({ role, pack: loadAgentRolePack('coordinator'), path: inboxPath, root,
+            ...(deps.coordinatorAgentRun ? { runAgent: deps.coordinatorAgentRun } : {}),
+            ...(deps.coordinatorAgentProvider ? { provider: deps.coordinatorAgentProvider } : {}) })
+        : runCoordinatorInbox(undefined, 100, inboxPath);
+    }))();
     if (inbox.replied || inbox.acknowledged) {
       observe('exchange', 'coordinator-inbox-replied', inbox.replied);
       observe('exchange', 'coordinator-inbox-acknowledged', inbox.acknowledged);
@@ -730,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 };
@@ -754,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}`));
@@ -767,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

@@ -14,6 +14,9 @@ import { getUserConfig, type UserConfig } from '../user-config.js';
 import { runGraph, type GraphRunState } from '../graph-runner/runner.js';
 import { FENCE_ROLES } from '../hq/hq.js';
 import { dueBefore, type CheckEntry } from './checker.js';
+import { readUnreadCount } from '../msg/msg-store.js';
+import { loopMessageRoute, SEAT_MESSAGE_ROUTES, type LoopReplyBody, type MessageWake } from './msg-address.js';
+import { resolveWake, type WakeDeps, type WakeResolution } from './msg-wake.js';
 
 export interface LoopRun {
   at: string;
@@ -23,8 +26,22 @@ 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;
+  /** Where `wake` came from — `unresolved` is «모름», not a measured absence. */
+  wakeSource?: WakeResolution['source'];
+  unreadCount?: number | null;
   title: string;
   description: string | null;
   owner?: string | null;
@@ -48,6 +65,20 @@ export interface LoopRegistryOptions {
   scheduleAction?: (action: 'create' | 'enable' | 'disable', args: Record<string, unknown>) => Promise<unknown>;
   /** Home used to expand `~`/`$HOME` in cron redirects; tests inject a temp dir instead of writing the real HOME. */
   home?: string;
+  /** Seat wake resolution (pty manifest ⊕ seat folders); tests inject fixed rows. */
+  wakeDeps?: WakeDeps;
+}
+
+function messageFields(id: string, stateRoot: string): { msgAddress: string | null; replyBody: LoopReplyBody; wake: MessageWake; wakeSource?: WakeResolution['source']; unreadCount: number | null } {
+  const route = loopMessageRoute(id);
+  return { ...route, ...(route.msgAddress ? { wakeSource: 'loop-table' as const } : {}), unreadCount: route.msgAddress ? readUnreadCount(route.msgAddress, join(stateRoot, 'msg', 'messages.db')) : null };
+}
+
+/** A seat row is addressed by its seat; its wake path is resolved on this host (pty name → herdr pane → 모름). */
+function seatMessageFields(seat: string, stateRoot: string, wakeDeps?: WakeDeps): { msgAddress: string; replyBody: LoopReplyBody; wake: MessageWake; wakeSource: WakeResolution['source']; unreadCount: number | null } {
+  const wake = resolveWake(seat, wakeDeps);
+  return { msgAddress: seat, replyBody: 'agent', wake: wake.wake, wakeSource: wake.source,
+    unreadCount: readUnreadCount(seat, join(stateRoot, 'msg', 'messages.db')) };
 }
 
 function graphFiles(dir: string): string[] {
@@ -186,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();
@@ -211,13 +244,25 @@ 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);
     const next = active.map(row => nextLoopFire(row.cron!, opts.now ?? new Date())).filter((v): v is string => v !== null).sort()[0] ?? null;
     const title = typeof header?.title === 'string' ? header.title : doc.graph_id;
-    const entry: LoopEntry = { id: doc.graph_id, title,
+    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),
@@ -229,6 +274,16 @@ 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;
+  /** Where `wake` came from — `unresolved` is «모름», not a measured absence. */
+  wakeSource?: WakeResolution['source'];
+  unreadCount?: number | null;
   kind: 'graph' | 'seat' | 'cron-shell' | 'orchestrator' | 'unregistered';
   title: string;
   cron?: string;
@@ -589,6 +644,9 @@ 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',
       ...(fenceRole ? { fenceRole } : {}),
@@ -599,6 +657,7 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
       recentStatuses: runs.map(run => run.status) };
   });
   const namedIds = namedCronIds(rows, claimed);
+  const seatOf = new Map<AllLoopEntry, string>();
   for (const row of rows) {
     if (claimed.has(row.id)) continue;
     const command = row.command ?? '';
@@ -622,7 +681,7 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
     const picked = logMtime && (!recorded || Date.parse(logMtime) >= Date.parse(recorded)) ? 'log-mtime'
       : recorded ? 'registry' : 'none';
     debug.log('loops.registry', 'cron-last-run', { id, targets, picked });
-    all.push({ kind, id, title,
+    const pushed: AllLoopEntry = { kind, id, title,
       ...resolveOwner(id, title, config, undefined, seatArg ?? seat, seatArg ? 'seat-arg' : 'seat'), ...(fenceRole ? { fenceRole } : {}),
       host: hostname(), observationCategory: row.category,
       enabled: !!row.enabled, registered: true,
@@ -632,7 +691,11 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
       ...(picked === 'log-mtime' ? { lastRunAt: logMtime, evidence: picked }
         : picked === 'registry' ? { lastRunAt: recorded, evidence: picked } : {}),
       ...(row.last_status ? { lastStatus: row.last_status } : {}),
-      recentStatuses: row.last_status ? [row.last_status] : [] });
+      recentStatuses: row.last_status ? [row.last_status] : [] };
+    all.push(pushed);
+    const seatName = (seatArg ?? seat)?.toUpperCase();
+    // 선언된 자리 줄만 자리 주소로 공개한다 — 모르는 `--seat FOO` 는 종전처럼 주소 없음.
+    if (kind === 'seat' && seatName && Object.hasOwn(SEAT_MESSAGE_ROUTES, seatName)) seatOf.set(pushed, seatName);
   }
   const warnings = unregisteredCronLoops(all, graphOpts);
   for (const row of warnings) {
@@ -647,7 +710,10 @@ export function listAllLoops(opts: LoopRegistryOptions = {}): AllLoopEntry[] {
   for (const loop of all) bySource[loop.ownerSource!]++;
   debug.log('loop.check', 'ownership', { total: all.length, bySource });
   debug.log('loops.registry', 'list-all', { count: all.length });
-  return all;
+  const stateRoot = opts.stateRoot ?? effectiveInstanceRoot();
+  return all.map(entry => entry.kind === 'graph' ? entry
+    : seatOf.has(entry) ? { ...entry, ...seatMessageFields(seatOf.get(entry)!, stateRoot, opts.wakeDeps) }
+      : { ...entry, ...messageFields(entry.id, stateRoot) });
 }
 
 /** An unclaimed cron line with any elanous marker must surface as an unregistered warning. */
@@ -711,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/memory.ts

@@ -444,7 +444,12 @@ const INDEX_MAX_LINES = 200;
  */
 export function rebuildIndex(root: string = memoryRoot()): void {
   ensureRoot(root);
-  const entries = listMemories({}, root);
+  writeFileDurable(memoryIndexPath(root), renderMemoryIndex(listMemories({}, root)));
+}
+
+/** The MEMORY.md text for a set of entries — rebuildIndex writes it for the whole store,
+ *  a scoped injection renders it for the entries its filter keeps. */
+export function renderMemoryIndex(entries: readonly MemoryEntry[]): string {
   const byType: Record<MemoryType, MemoryEntry[]> = {
     user: [], feedback: [], project: [], reference: [],
   };
@@ -468,7 +473,7 @@ export function rebuildIndex(root: string = memoryRoot()): void {
     }
     lines.push('');
   }
-  writeFileDurable(memoryIndexPath(root), lines.join('\n'));
+  return lines.join('\n');
 }
 
 /** Read the MEMORY.md index verbatim. Returns '' when missing (e.g.
@@ -512,6 +517,11 @@ export interface InjectOpts {
   minScore?: number;
   /** Always include the MEMORY.md index even if no keyword hits. */
   alwaysIncludeIndex?: boolean;
+  /** Scope filter. When set, only kept entries are injected and the index is rendered from
+   *  them instead of read from MEMORY.md (which lists every entry, other seats' cards included). */
+  filter?: (entry: MemoryEntry) => boolean;
+  /** Inject these bodies like pinned ones (e.g. the current seat's context cards). */
+  alwaysInject?: (entry: MemoryEntry) => boolean;
 }
 
 /** Build the memory-injection block for a user turn. Always prepends
@@ -531,7 +541,9 @@ export function buildMemoryInjection(
   const minScore = opts.minScore ?? 2;
   const alwaysIdx = opts.alwaysIncludeIndex !== false;
 
-  const index = readIndex(root);
+  const filter = opts.filter;
+  const scoped = filter ? listMemories({}, root).filter(m => m.contextCard?.status !== 'retired' && filter(m)) : null;
+  const index = scoped ? (scoped.length > 0 ? renderMemoryIndex(scoped) : '') : readIndex(root);
   if (!index) return { block: '', tokens: 0, injectedIds: [] };
 
   const parts: string[] = [];
@@ -548,7 +560,10 @@ export function buildMemoryInjection(
 
   // 📌 pinned 기억 — 키워드 무관 항상 주입(relevance gate bypass · Letta pinned block /
   //    claude-code MEMORY.md tier 동형). priority 높은 순. core/safety/ref-location 사실용.
-  const pinnedMems = listMemories({}, root).filter(m => m.pinned && m.contextCard?.status !== 'retired').sort((a, b) => b.priority - a.priority);
+  const alwaysInject = opts.alwaysInject;
+  const pinnedMems = (scoped ?? listMemories({}, root))
+    .filter(m => (m.pinned || alwaysInject?.(m) === true) && m.contextCard?.status !== 'retired')
+    .sort((a, b) => b.priority - a.priority);
   const pinnedParts: string[] = [];
   for (const e of pinnedMems) {
     const chunk = pinnedChunk(e);
@@ -566,7 +581,7 @@ export function buildMemoryInjection(
   const hits = lowContext
     ? []
     : searchMemories(userText, { limit: maxHits + pinnedParts.length }, root)
-        .filter(h => h.score >= minScore && !injected.includes(h.entry.id))
+        .filter(h => h.score >= minScore && !injected.includes(h.entry.id) && (!filter || filter(h.entry)))
         .slice(0, maxHits);
   const bodyParts: string[] = [];
   for (const hit of hits) {

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