elanous 0.2.42 → 0.2.44

package/src/prompt-enhance/enhance.ts

@@ -120,6 +120,8 @@ export interface EnhanceOpts {
   groundedFacts?: readonly string[];
   /** Relevant prior-failure lessons for goal-authoring prompts only; never part of the original ask. */
   authoringLessons?: string;
+  /** Canonical reusable mock-device and event-injection inventory; reference only, not a completion gate. */
+  mockScenarioCatalog?: string;
   /** Clock seam for the first-token observation (ms epoch); defaults to `Date.now`. */
   now?: () => number;
 }
@@ -439,6 +441,14 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
           ...(opts.authoringLessons?.trim()
             ? ['', '## 지난 실패에서 배운 것', opts.authoringLessons.trim(), '위 교훈은 현재 ask의 대상 경로와 범위에 맞을 때만 적용하고, 맞지 않으면 무시하라.']
             : []),
+          ...(opts.mockScenarioCatalog?.trim()
+            ? [
+              '',
+              '## 재사용 가능한 목장치·사건 주입 카탈로그 (참고 자료 · 완료 조건이 아님)',
+              opts.mockScenarioCatalog.trim(),
+              '골의 완료 경계가 실물 점검만 요구하면 먼저 제약을 의심하라: 그 제약은 저작 문면의 세계와 구현의 세계에서 같은가? 카탈로그의 목장치나 사건 주입으로 같은 동작을 관찰할 수 있는가? 실제 외부 시스템 확인이 사용자의 의도인 경우에만 실물 점검을 유지하고, 목장치가 맞으면 해당 장치·입력·관측 신호를 제안하라.',
+            ]
+            : []),
         ].join('\n'),
       },
     ];

package/src/pty-shell/pty-control-ipc.ts

@@ -48,6 +48,8 @@ export type PtyControlPayload =
 export interface PtyControlRequestOptions {
   /** 요청자가 주장하는 쓰기 주체. `'agent'` 는 run-identity 일치를 요구한다(`resolveRemoteControlActor`). */
   readonly actor?: PtyWriteActor;
+  /** Bound child identity for an agent-originated control message (e.g. mission HandReply). */
+  readonly requesterRunId?: string;
   readonly timeoutMs?: number;
   /** 대상 PTY를 발견한 매니페스트 뿌리. 연합 조회는 이 DB에 제어 요청을 남겨 그 행의 owner가 처리하게 한다. */
   readonly manifestDbPath?: string;
@@ -467,7 +469,8 @@ export async function requestRemotePtyControl(id: string, action: PtyControlActi
     const now = Date.now();
     // ⭐ 요청자의 run anchor 를 요청에 실어 보낸다 — 인가는 **owner 가** 자기 PTY 의 run 과 대조해 내린다
     //    (요청자 자기 신고를 그대로 믿지 않는다는 뜻이 아니라, 판정 지점이 자원 소유자라는 뜻).
-    d.run(`INSERT INTO pty_control_requests (request_id, pty_id, action, payload_json, actor, requester_run_id, owner_pid, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [requestId, targetId, action, payload ? JSON.stringify(payload) : null, actor, getHarnessRunId(process.env), ownerPid, 'pending', now, now]);
+  const requesterRunId = actor === 'agent' ? (options.requesterRunId?.trim() || getHarnessRunId(process.env)) : getHarnessRunId(process.env);
+  d.run(`INSERT INTO pty_control_requests (request_id, pty_id, action, payload_json, actor, requester_run_id, owner_pid, status, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [requestId, targetId, action, payload ? JSON.stringify(payload) : null, actor, requesterRunId, ownerPid, 'pending', now, now]);
     // ⭐ 깊은 유휴 감속 중인 owner 를 즉시 깨운다 — 행을 넣은 «뒤» 표식을 남기므로 그 재읽기가 이 행을 본다.
     //    표식은 그 행의 `ownerPid` «별» 파일이다 — 같은 원장을 공유하는 다른 owner 가 가져가지 못한다.
     signalPtyControlWake(queuePath ?? ptyManifestDbPath(), ownerPid);

package/src/pty-shell/pty-write-provenance.ts

@@ -24,14 +24,32 @@
  *  장수 owner(데몬)는 PTY 를 계속 만든다. 훅만 믿으면 «한 번 새면 영영» 샌다. */
 const MAX_TRACKED_PTYS = 512;
 
-const writes = new Map<string, { count: number; lastAt: number; lastActor: string }>();
+const writes = new Map<string, { count: number; lastAt: number; lastActor: string | null; accessMode?: 'read' | 'write' | 'auto' }>();
+
+export function notePtyAccessMode(ptyId: string, accessMode: 'read' | 'write' | 'auto'): void {
+  const prev = writes.get(ptyId);
+  writes.delete(ptyId);
+  writes.set(ptyId, { count: prev?.count ?? 0, lastAt: prev?.lastAt ?? 0, lastActor: prev?.lastActor ?? null, accessMode });
+  while (writes.size > MAX_TRACKED_PTYS) {
+    const oldest = writes.keys().next();
+    if (oldest.done) break;
+    writes.delete(oldest.value);
+  }
+}
+
+export function ptyWriteControlState(ptyId: string): { accessMode: 'read' | 'write' | 'auto'; lastWriter: 'agent' | 'human' | null } | undefined {
+  const rec = writes.get(ptyId);
+  if (!rec?.accessMode) return undefined;
+  const lastWriter = rec.lastActor === 'agent' || rec.lastActor === 'human' ? rec.lastActor : null;
+  return { accessMode: rec.accessMode, lastWriter };
+}
 
 /** 성공한 쓰기 1건을 기록한다. ⛔ 거부·실패는 세지 않는다(자식이 «본» 것만 세야 수가 뜻을 갖는다). */
 export function noteExternalWrite(ptyId: string, actor: string, now = Date.now()): void {
   const prev = writes.get(ptyId);
   // 재삽입으로 **삽입 순서를 갱신**한다 — 아래 축출이 「가장 오래 안 쓰인 것」을 버리게.
   writes.delete(ptyId);
-  writes.set(ptyId, { count: (prev?.count ?? 0) + 1, lastAt: now, lastActor: actor });
+  writes.set(ptyId, { count: (prev?.count ?? 0) + 1, lastAt: now, lastActor: actor, ...(prev?.accessMode ? { accessMode: prev.accessMode } : {}) });
   while (writes.size > MAX_TRACKED_PTYS) {
     const oldest = writes.keys().next();
     if (oldest.done) break;
@@ -49,7 +67,7 @@ export function noteExternalWrite(ptyId: string, actor: string, now = Date.now()
  */
 export function externalWriteProvenance(ptyId: string, now = Date.now()): { externalWrites: number; externalWriteAgoMs: number; externalWriteActor: string } | undefined {
   const rec = writes.get(ptyId);
-  if (!rec) return undefined;
+  if (!rec || rec.lastActor === null) return undefined;
   return { externalWrites: rec.count, externalWriteAgoMs: Math.max(0, now - rec.lastAt), externalWriteActor: rec.lastActor };
 }
 

package/src/pty-shell/registry.ts

@@ -30,7 +30,7 @@ import { resolveWriteDecision, resolveTakeover, type PtyWriteActor } from './pty
 import { addPtyManifestOutputBytes, upsertPtyManifest, updatePtyManifestSnapshot, updatePtyManifestNickname, markPtyManifestClosed, removePtyManifest, touchLivePtyManifest } from './pty-manifest.js';
 import { processPtyControlRequests } from './pty-control-ipc.js';
 import { tapPtyOutput, autoStopPtyRecording } from './pty-recording.js';
-import { forgetExternalWriteProvenance, noteExternalWrite } from './pty-write-provenance.js';
+import { forgetExternalWriteProvenance, noteExternalWrite, notePtyAccessMode } from './pty-write-provenance.js';
 import { resolveRunIdentity } from '../harness/harness-space.js';
 import { addSelfDevRunParticipant, selfDevRunsDir } from '../self-dev/run-store.js';
 import { debug } from '../debug/log.js';
@@ -192,6 +192,8 @@ export interface PtyControlTarget {
 export interface PtyHandle extends PtyControlTarget {
   /** 고유 id — `<kind>_<hex>`. 같은 PTY 객체를 부르는 캐논 이름. */
   readonly id: string;
+  /** Actor of the last successful PTY write in this process; denied or failed writes do not update it. */
+  readonly lastWriteActor: PtyWriteActor | null;
   /**
    * 접근 모드(관찰 read / 인터랙션 write / 자율 auto). ⭐정책 매트릭스(§ 입력 중재):
    *  - auto+locked = 보호된 자율(brain 소유·사람 write 불가). 위험 미션 무간섭.
@@ -508,10 +510,13 @@ export function startPty(opts: StartOpts): PtyHandle {
   } catch { term = null; }
 
   let nickname = opts.nickname;
+  let lastWriteActor: PtyWriteActor | null = null;
   let accessMode: PtyAccessMode = opts.accessMode ?? 'write';
   let transitionPolicy: PtyTransitionPolicy = opts.transitionPolicy ?? 'open';
+  notePtyAccessMode(id, accessMode);
   const handle: PtyHandle = {
     id,
+    get lastWriteActor() { return lastWriteActor; },
     kind: ptyKindOf(id),
     get nickname() { return nickname; },
     set nickname(v: string | undefined) { nickname = v; },
@@ -520,13 +525,14 @@ export function startPty(opts: StartOpts): PtyHandle {
       if (ptyManifestEnabled()) updatePtyManifestNickname(id, nickname, Date.now());
     },
     get accessMode() { return accessMode; },
-    set accessMode(v: PtyAccessMode) { accessMode = v; },
+    set accessMode(v: PtyAccessMode) { accessMode = v; notePtyAccessMode(id, v); },
     get transitionPolicy() { return transitionPolicy; },
     set transitionPolicy(v: PtyTransitionPolicy) { transitionPolicy = v; },
     setAccessMode(mode: PtyAccessMode): boolean {
       // 정책 SSOT(canTransitionAccessMode): locked 면 다른 모드로 못 감(read+locked→write = write 불가).
       if (!canTransitionAccessMode(accessMode, mode, transitionPolicy)) return false;
       accessMode = mode;
+      notePtyAccessMode(id, mode);
       return true;
     },
     setTransitionPolicy(policy: PtyTransitionPolicy): void { transitionPolicy = policy; },
@@ -598,6 +604,7 @@ export function startPty(opts: StartOpts): PtyHandle {
         return;
       }
       adapter.write(chars);
+      lastWriteActor = actor;
       debug.log('pty.control', 'write', { ptyId: id, actor, mode: accessMode, bytes: chars.length });
       // ⭐⭐ 여기가 진짜 초크포인트다 — 허용 판정 뒤·바이트가 «실제로» 들어간 뒤. 모든 쓰기가
       //   이 자리로 모인다(크로스-프로세스 IPC · 같은 프로세스 감독 autoAssist · PtyShellSend).

package/src/registry/catalog-server.ts

@@ -0,0 +1,232 @@
+import { createPublicKey, sign, verify, type KeyObject } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { debug } from '../debug/log.js';
+import { getElanousConfigDir } from '../elanous-config-dir.js';
+import type { ModelSpec, ProviderRegistration } from './types.js';
+
+export const CATALOG_SERVER_URL = 'https://storage.googleapis.com/elanous-catalog/v1/catalog.json';
+export const CATALOG_REFRESH_INTERVAL_MS = 24 * 60 * 60 * 1000;
+export const CATALOG_STARTUP_TIMEOUT_MS = 2_000;
+
+export interface SignedCatalogPayload {
+  catalogVersion: number;
+  generatedAt: string;
+  providers: ProviderRegistration[];
+  models: ModelSpec[];
+}
+
+export interface SignedCatalogDocument extends SignedCatalogPayload {
+  signature: string;
+}
+
+export interface VerifiedCatalog {
+  payload: SignedCatalogPayload;
+  stale: boolean;
+}
+
+function catalogVersionFromFile(path: string): number | undefined {
+  try {
+    const match = readFileSync(path, 'utf8').match(/^catalogVersion:\s*(\d+)\s*$/m);
+    const version = match ? Number(match[1]) : NaN;
+    return Number.isSafeInteger(version) && version >= 1 ? version : undefined;
+  } catch { return undefined; }
+}
+
+function bundledCatalogVersion(): number | undefined {
+  let current = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidate = join(current, 'catalog', 'meta', 'catalogVersion.yaml');
+    if (existsSync(candidate)) return catalogVersionFromFile(candidate);
+    current = dirname(current);
+  }
+  return undefined;
+}
+
+export function catalogCachePath(): string {
+  const override = process.env.ELANOUS_CATALOG_SERVER_CACHE?.trim();
+  if (override) return override;
+  return join(getElanousConfigDir(), 'catalog', 'cache.json');
+}
+
+function bundledPublicKeyPath(): string {
+  const override = process.env.ELANOUS_CATALOG_PUBLIC_KEY_FILE?.trim();
+  if (override) return override;
+  let current = dirname(fileURLToPath(import.meta.url));
+  for (let depth = 0; depth < 8; depth += 1) {
+    const candidate = join(current, 'catalog', 'signing', 'catalog-signing-public.pem');
+    if (existsSync(candidate)) return candidate;
+    current = dirname(current);
+  }
+  return join(dirname(fileURLToPath(import.meta.url)), '../../catalog/signing/catalog-signing-public.pem');
+}
+
+export function canonicalCatalogPayload(payload: SignedCatalogPayload): string {
+  return JSON.stringify({
+    catalogVersion: payload.catalogVersion,
+    generatedAt: payload.generatedAt,
+    providers: payload.providers,
+    models: payload.models,
+  });
+}
+
+export function signCatalogPayload(payload: SignedCatalogPayload, privateKey: string | Buffer | KeyObject): SignedCatalogDocument {
+  return { ...payload, signature: sign(null, Buffer.from(canonicalCatalogPayload(payload)), privateKey).toString('base64') };
+}
+
+function parsePayload(value: unknown): SignedCatalogPayload | null {
+  if (!value || typeof value !== 'object') return null;
+  const raw = value as Record<string, unknown>;
+  if (!Number.isSafeInteger(raw.catalogVersion) || (raw.catalogVersion as number) < 1) return null;
+  if (typeof raw.generatedAt !== 'string' || !Number.isFinite(Date.parse(raw.generatedAt))) return null;
+  if (!Array.isArray(raw.providers) || !Array.isArray(raw.models)) return null;
+  if (!raw.providers.every((p) => p && typeof p === 'object' && typeof (p as Record<string, unknown>).id === 'string')) return null;
+  if (!raw.models.every((m) => m && typeof m === 'object'
+    && typeof (m as Record<string, unknown>).id === 'string'
+    && typeof (m as Record<string, unknown>).provider === 'string')) return null;
+  return {
+    catalogVersion: raw.catalogVersion as number,
+    generatedAt: raw.generatedAt,
+    providers: raw.providers as ProviderRegistration[],
+    models: raw.models as ModelSpec[],
+  };
+}
+
+export function verifyCatalogDocument(
+  value: unknown,
+  publicKeyPem: string,
+): SignedCatalogPayload | null {
+  if (!value || typeof value !== 'object') return null;
+  const raw = value as Record<string, unknown>;
+  if (typeof raw.signature !== 'string') return null;
+  const payload = parsePayload(raw);
+  if (!payload) return null;
+  try {
+    const signature = Buffer.from(raw.signature, 'base64');
+    return verify(null, Buffer.from(canonicalCatalogPayload(payload)), createPublicKey(publicKeyPem), signature)
+      ? payload
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+export function readVerifiedCatalogCache(opts: {
+  cachePath?: string;
+  publicKeyPem?: string;
+  now?: number;
+} = {}): VerifiedCatalog | null {
+  const path = opts.cachePath ?? catalogCachePath();
+  try {
+    const key = opts.publicKeyPem ?? readFileSync(bundledPublicKeyPath(), 'utf8');
+    const payload = verifyCatalogDocument(JSON.parse(readFileSync(path, 'utf8')), key);
+    if (!payload) return null;
+    const age = Math.max(0, (opts.now ?? Date.now()) - Date.parse(payload.generatedAt));
+    const stale = age > CATALOG_REFRESH_INTERVAL_MS;
+    debug.log('registry.catalog', 'catalog.source', { source: 'server-cache', stale, catalogVersion: payload.catalogVersion });
+    if (stale) debug.log('registry.catalog', 'catalog.stale', { source: 'server-cache', stale: true, ageMs: age, catalogVersion: payload.catalogVersion }, { level: 'warn' });
+    return { payload, stale };
+  } catch {
+    return null;
+  }
+}
+
+export type RefreshCatalogResult =
+  | { ok: true; payload: SignedCatalogPayload }
+  | { ok: false; reason: 'key-unavailable' | 'fetch-failed' | 'http-error' | 'invalid-json' | 'signature-rejected' | 'version-rejected' | 'cache-write-failed' };
+
+export async function refreshServerCatalog(opts: {
+  fetchImpl?: typeof fetch;
+  url?: string;
+  cachePath?: string;
+  publicKeyPem?: string;
+  timeoutMs?: number;
+} = {}): Promise<RefreshCatalogResult> {
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  const cachePath = opts.cachePath ?? catalogCachePath();
+  const timeoutMs = opts.timeoutMs ?? CATALOG_STARTUP_TIMEOUT_MS;
+  let key: string;
+  try {
+    key = opts.publicKeyPem ?? readFileSync(bundledPublicKeyPath(), 'utf8');
+  } catch (error) {
+    debug.log('registry.catalog', 'catalog.refresh-failed', { source: 'server', reason: 'key-unavailable', message: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+    return { ok: false, reason: 'key-unavailable' };
+  }
+  const previous = readVerifiedCatalogCache({ cachePath, publicKeyPem: key });
+  let response: Response;
+  try {
+    response = await fetchImpl(opts.url ?? CATALOG_SERVER_URL, { signal: AbortSignal.timeout(timeoutMs) });
+  } catch (error) {
+    debug.log('registry.catalog', 'catalog.refresh-failed', { source: 'server', reason: 'fetch-failed', message: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+    return { ok: false, reason: 'fetch-failed' };
+  }
+  if (!response.ok) return { ok: false, reason: 'http-error' };
+  let document: unknown;
+  try { document = await response.json(); }
+  catch { return { ok: false, reason: 'invalid-json' }; }
+  const payload = verifyCatalogDocument(document, key);
+  if (!payload) {
+    debug.log('registry.catalog', 'catalog.signature-rejected', { source: 'server', reason: 'invalid-signature-or-schema' }, { level: 'warn' });
+    return { ok: false, reason: 'signature-rejected' };
+  }
+  // A cold install has no signed server receipt yet, so the packaged catalog is its rollback floor.
+  const versionFloor = Math.max(previous?.payload.catalogVersion ?? 0,
+    bundledCatalogVersion() ?? 0);
+  if (payload.catalogVersion < versionFloor) {
+    debug.log('registry.catalog', 'catalog.version-rejected', {
+      source: 'server', reason: 'version-rollback', currentVersion: versionFloor, receivedVersion: payload.catalogVersion,
+    }, { level: 'warn' });
+    return { ok: false, reason: 'version-rejected' };
+  }
+  const signedDocument = document as SignedCatalogDocument;
+  try {
+    mkdirSync(dirname(cachePath), { recursive: true });
+    const temporary = `${cachePath}.${process.pid}.tmp`;
+    writeFileSync(temporary, `${JSON.stringify(signedDocument, null, 2)}\n`, { encoding: 'utf8', mode: 0o600 });
+    renameSync(temporary, cachePath);
+  } catch (error) {
+    debug.log('registry.catalog', 'catalog.refresh-failed', { source: 'server', reason: 'cache-write-failed', message: error instanceof Error ? error.message : String(error) }, { level: 'warn' });
+    return { ok: false, reason: 'cache-write-failed' };
+  }
+  const ageMs = Math.max(0, Date.now() - Date.parse(payload.generatedAt));
+  debug.log('registry.catalog', 'catalog.source', {
+    source: 'server', stale: ageMs > CATALOG_REFRESH_INTERVAL_MS, catalogVersion: payload.catalogVersion,
+  });
+  return { ok: true, payload };
+}
+
+let scheduledRefresh: Promise<void> | null = null;
+let lastRefreshAttempt = 0;
+let refreshTimer: ReturnType<typeof setTimeout> | null = null;
+
+/** Kick remote refresh behind startup; the callback rebuilds the catalog only after a verified cache write. */
+export function scheduleServerCatalogRefresh(onUpdated: () => void): void {
+  if (process.env.NODE_ENV === 'test') return;
+  if (scheduledRefresh || refreshTimer) return;
+  const now = Date.now();
+  const cached = readVerifiedCatalogCache();
+  const cacheAgeMs = cached ? Math.max(0, now - Date.parse(cached.payload.generatedAt)) : Number.POSITIVE_INFINITY;
+  const untilCacheStale = cached && !cached.stale ? Math.max(1_000, CATALOG_REFRESH_INTERVAL_MS - cacheAgeMs) : 0;
+  const untilRetry = Math.max(0, CATALOG_REFRESH_INTERVAL_MS - (now - lastRefreshAttempt));
+  const delay = Math.max(untilCacheStale, untilRetry);
+  if (delay > 0) {
+    refreshTimer = setTimeout(() => {
+      refreshTimer = null;
+      scheduleServerCatalogRefresh(onUpdated);
+    }, delay);
+    refreshTimer.unref?.();
+    return;
+  }
+  lastRefreshAttempt = now;
+  scheduledRefresh = refreshServerCatalog().then((result) => {
+    if (result.ok) onUpdated();
+  }).finally(() => {
+    scheduledRefresh = null;
+    refreshTimer = setTimeout(() => {
+      refreshTimer = null;
+      scheduleServerCatalogRefresh(onUpdated);
+    }, CATALOG_REFRESH_INTERVAL_MS);
+    refreshTimer.unref?.();
+  });
+}

package/src/registry/loader.ts

@@ -31,6 +31,8 @@ import type {
 } from './types.js';
 import { PROVIDER_CAPABILITIES_NONE } from './types.js';
 import { readDiscoveryCache, type DiscoverySnapshot } from './discovery/cache.js';
+import { debug } from '../debug/log.js';
+import { readVerifiedCatalogCache, scheduleServerCatalogRefresh } from './catalog-server.js';
 
 const HERE = dirname(fileURLToPath(import.meta.url));
 
@@ -85,6 +87,15 @@ function listYamlFiles(dir: string): string[] {
     .map((e) => join(dir, e));
 }
 
+function readCatalogVersion(builtinDir: string): number {
+  const path = join(builtinDir, 'meta', 'catalogVersion.yaml');
+  if (!existsSync(path)) return 1;
+  const raw = safeReadYaml(path) as { catalogVersion?: unknown } | null;
+  return Number.isSafeInteger(raw?.catalogVersion) && (raw?.catalogVersion as number) >= 1
+    ? raw?.catalogVersion as number
+    : 1;
+}
+
 // ── Provider parse + validate ─────────────────────────────────────────
 
 function parseProvider(raw: unknown, source: string): ProviderRegistration | null {
@@ -282,11 +293,13 @@ let cachedCatalog: Catalog | null = null;
 
 function buildCatalog(): Catalog {
   const builtinDir = resolveBuiltinCatalogDir();
+  const catalogVersion = readCatalogVersion(builtinDir);
   const globalDir = resolveGlobalCatalogDir();
 
   const providers = new Map<string, ProviderRegistration>();
   const models = new Map<string, ModelSpec>();
   const patterns = new Map<string, ModelPatternFallback>();
+  const sourceLayers = ['package'];
   let fileCount = 0;
 
   // --- builtin tier ---
@@ -326,12 +339,36 @@ function buildCatalog(): Catalog {
     }
   }
 
+  // --- signed server catalog; package YAML remains available if cache is absent/stale-invalid ---
+  // Keep isolated tests hermetic; an explicit cache path opts a test into the signed-server layer.
+  const serverCatalog = isolatedCatalogTestUniverse() && !process.env.ELANOUS_CATALOG_SERVER_CACHE?.trim()
+    ? null
+    : readVerifiedCatalogCache();
+  if (serverCatalog) {
+    sourceLayers.push('server-cache');
+    for (const raw of serverCatalog.payload.providers) {
+      const provider = parseProvider(raw, 'signed-server-catalog');
+      if (!provider) continue;
+      const base = providers.get(provider.id);
+      providers.set(provider.id, base ? mergeProviders(base, provider) : provider);
+      fileCount++;
+    }
+    for (const raw of serverCatalog.payload.models) {
+      const model = parseModel(raw, 'signed-server-catalog');
+      if (!model) continue;
+      models.set(model.id, model);
+      fileCount++;
+    }
+  }
+
   // --- global tier overlay ---
   const globalProviderDir = join(globalDir, 'providers');
+  let hasUserOverlay = false;
   for (const path of listYamlFiles(globalProviderDir)) {
     const raw = safeReadYaml(path);
     const overlay = parseProvider(raw, path);
     if (!overlay) continue;
+    hasUserOverlay = true;
     fileCount++;
     const base = providers.get(overlay.id);
     providers.set(overlay.id, base ? mergeProviders(base, overlay) : overlay);
@@ -359,6 +396,7 @@ function buildCatalog(): Catalog {
         }
         const model = parseModel(raw, path);
         if (model) {
+          hasUserOverlay = true;
           // global wins on dup id (RFC §6.4 — single-value fields replace).
           models.set(model.id, model);
           fileCount++;
@@ -370,9 +408,14 @@ function buildCatalog(): Catalog {
   // --- discovery fold (대표 2026-09-23 «파생한다») ---
   const folded = foldDiscoveredModels(providers, models, loadFoldSnapshot());
   for (const m of folded) models.set(m.id, m);
+  if (hasUserOverlay) sourceLayers.push('user');
+  if (folded.length > 0) sourceLayers.push('live-discovery');
+  debug.log('registry.catalog', 'catalog.source', {
+    source: 'merged', layers: sourceLayers, ...(serverCatalog ? { stale: serverCatalog.stale } : {}),
+  });
 
   return {
-    catalogVersion: 1,
+    catalogVersion,
     providers,
     models,
     patterns,
@@ -435,6 +478,7 @@ export function foldDiscoveredModels(
 export function getCatalog(): Catalog {
   if (cachedCatalog) return cachedCatalog;
   cachedCatalog = buildCatalog();
+  scheduleServerCatalogRefresh(() => { cachedCatalog = buildCatalog(); });
   return cachedCatalog;
 }
 

package/src/registry/types.ts

@@ -196,8 +196,7 @@ export interface ModelPatternFallback {
 // ── Top-level catalog (loader output) ─────────────────────────────────
 
 export interface Catalog {
-  /** Schema version — bumps when ProviderRegistration / ModelSpec
-   *  shape changes in a non-backwards-compat way. */
+  /** Catalog release version from catalog/meta/catalogVersion.yaml. */
   catalogVersion: number;
   /** Indexed by provider id. */
   providers: Map<string, ProviderRegistration>;

package/src/release-loop/proposal-auto-place.ts

@@ -0,0 +1,83 @@
+import { runRequirementFunnel, type FunnelCandidate, type FunnelOptions, type RequirementDecision } from '../intake-plane/requirement-funnel.js';
+import type { ConsensusEngine, ConsensusRepresentative } from '../loops/consensus.js';
+import { placeCell, type PlacementDeps, type PlacementDecision } from './placement.js';
+import { parseRubric, rubricGrade, rubricScore } from './rubric.js';
+
+export interface ProposalPlacementInput {
+  /** The current funnel inputs; ledger capture and adoption hooks are intentionally not accepted here. */
+  funnel: Omit<FunnelOptions, 'ledger' | 'adopt' | 'mode' | 'placement'>;
+  rubricCandidate: FunnelCandidate;
+  consensus: Pick<ConsensusEngine, 'show'>;
+  consensusProposalId: string;
+  placement: PlacementDeps;
+}
+
+export type ProposalPlacementPlan =
+  | { status: 'not-eligible'; reason: string; decision?: RequirementDecision }
+  | { status: 'awaiting-consensus'; consensusProposalId: string; decision: RequirementDecision }
+  | { status: 'planned'; consensus: { id: string; status: 'agreed'; proposedBy: ConsensusRepresentative; agreedBy: ConsensusRepresentative };
+      decision: RequirementDecision; rubric: { score: number; grade: NonNullable<FunnelCandidate['grade']> }; placement: PlacementDecision };
+
+/**
+ * Safe first slice for the proposal→placement path. It accepts a pre-collected rubric candidate and an existing
+ * dual-root card; the requirement funnel and both placement calculations run in shadow/dry-run only. There is no
+ * ledger writer, live adopter, proposal creator, or operational scheduler in this seam.
+ */
+export function planAgreedProposalPlacement(input: ProposalPlacementInput): ProposalPlacementPlan {
+  const rubric = input.rubricCandidate;
+  if (rubric.score === null || rubric.grade === null) return { status: 'not-eligible', reason: 'candidate has no explicit rubric' };
+  const funnel = runRequirementFunnel({
+    ...input.funnel,
+    mode: 'shadow',
+    placement: { ...input.placement, dryRun: true },
+  });
+  const decision = funnel.decisions.find(({ candidate }) => candidate.id === rubric.id);
+  if (!decision) return { status: 'not-eligible', reason: `funnel candidate not found: ${rubric.id}` };
+  if (decision.status !== 'would-adopt') return { status: 'not-eligible', reason: decision.reason ?? `funnel status: ${decision.status}`, decision };
+  const sourceRubric = parseRubric(decision.candidate.text);
+  const sourceTitle = decision.candidate.text.split(/\s+루브릭:/, 1)[0]!.trim().slice(0, 80);
+  if (sourceTitle !== rubric.title) return { status: 'not-eligible', reason: 'rubric candidate title does not match funnel source', decision };
+  if (!sourceRubric || rubric.score !== rubricScore(sourceRubric) || rubric.grade !== rubricGrade(rubricScore(sourceRubric)))
+    return { status: 'not-eligible', reason: 'rubric score or grade does not match funnel source', decision };
+
+  let proposal;
+  try { proposal = input.consensus.show(input.consensusProposalId); }
+  catch (error) {
+    if (error instanceof Error && error.message === `consensus proposal not found: ${input.consensusProposalId}`)
+      return { status: 'awaiting-consensus', consensusProposalId: input.consensusProposalId, decision };
+    throw error;
+  }
+  if (proposal.category !== 'period-budget' || proposal.factId !== decision.candidate.id
+    || proposal.title !== rubric.title || proposal.thresholds.length > 0 || proposal.status !== 'agreed')
+    return { status: 'awaiting-consensus', consensusProposalId: input.consensusProposalId, decision };
+  const agreement = proposal.reviews.find((review) => review.verdict === 'agree' && review.by !== proposal.proposedBy);
+  if (!agreement) return { status: 'awaiting-consensus', consensusProposalId: input.consensusProposalId, decision };
+
+  const candidate = decision.candidate;
+  if (candidate.priority !== 'P1' && candidate.priority !== 'P2')
+    return { status: 'not-eligible', reason: 'funnel candidate priority is missing or unsupported', decision };
+  if (!candidate.owner) return { status: 'not-eligible', reason: 'funnel candidate owner is missing', decision };
+  let placement: PlacementDecision;
+  try {
+    // The funnel checks urgency/capacity eligibility; this second dry run applies the rubric's deferral grade.
+    placement = placeCell({
+      id: candidate.id,
+      title: candidate.text,
+      owner: candidate.owner,
+      priority: candidate.priority,
+      predecessors: [],
+      grade: rubric.grade,
+      ...(candidate.deadlineVersion ? { deadlineVersion: candidate.deadlineVersion } : {}),
+    }, { ...input.placement, dryRun: true });
+  } catch (error) {
+    return { status: 'not-eligible', reason: error instanceof Error ? error.message : String(error), decision };
+  }
+
+  return {
+    status: 'planned',
+    consensus: { id: proposal.id, status: 'agreed', proposedBy: proposal.proposedBy, agreedBy: agreement.by },
+    decision,
+    rubric: { score: rubric.score, grade: rubric.grade },
+    placement,
+  };
+}