elanous 0.2.27 → 0.2.28

package/src/patents/ledger.ts

@@ -0,0 +1,128 @@
+import { Database } from 'bun:sqlite';
+import { chmodSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { debug } from '../debug/log.js';
+
+/** 특허 후보의 갈래 — 구체 후보와 기전은 비공개 원장에만 둔다. */
+const PATENT_TRACKS = ['비공개', '출원', '신규'] as const;
+/** 특허 후보의 상태 — 조사/명세/출원/공개 허용 중 공개 허용 상태만 공개 읽기 통로에 나온다. */
+const PATENT_STATUSES = ['조사', '명세', '출원', '공개 허용'] as const;
+
+export type PatentTrack = (typeof PATENT_TRACKS)[number];
+export type PatentStatus = (typeof PATENT_STATUSES)[number];
+
+export class PatentsInputError extends Error {
+  override name = 'PatentsInputError';
+}
+
+export interface PatentCandidate {
+  id: string;
+  title: string;
+  track: PatentTrack;
+  status: PatentStatus;
+  deadline: string | null;
+  created_at: string;
+  updated_at: string;
+}
+export interface PatentLedgerOptions { stateDir?: string; now?: () => Date }
+
+function required(value: string, field: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new PatentsInputError(`${field} is required`);
+  return value.trim();
+}
+
+function trackOf(value: PatentTrack): PatentTrack {
+  if (!PATENT_TRACKS.includes(value)) throw new PatentsInputError(`invalid track: ${value}`);
+  return value;
+}
+
+function statusOf(value: PatentStatus): PatentStatus {
+  if (!PATENT_STATUSES.includes(value)) throw new PatentsInputError(`invalid status: ${value}`);
+  return value;
+}
+
+function isoDate(value: string, field: string): string {
+  if (typeof value !== 'string' || !/^\d{4}-\d\d-\d\d$/.test(value)) throw new PatentsInputError(`invalid ${field}: ${value}`);
+  const date = new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value) throw new PatentsInputError(`invalid ${field}: ${value}`);
+  return value;
+}
+
+/** 후보 식별자·갈래·상태·마감일의 비공개 원장 — 공개 허용 상태 후보만 읽기 통로로 노출한다. */
+export class PatentLedger {
+  readonly path: string;
+  private readonly now: () => Date;
+
+  constructor(options: PatentLedgerOptions = {}) {
+    this.path = join(options.stateDir ?? elanousStateRoot(), 'patents', 'patents.sqlite');
+    this.now = options.now ?? (() => new Date());
+  }
+
+  private open(): Database {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const db = new Database(this.path, { create: true, strict: true });
+    try {
+      chmodSync(this.path, 0o600);
+      db.exec('PRAGMA busy_timeout = 10000');
+      db.exec('PRAGMA journal_mode = WAL');
+      db.exec(`CREATE TABLE IF NOT EXISTS patent_candidates (
+        id TEXT PRIMARY KEY, title TEXT NOT NULL,
+        track TEXT NOT NULL CHECK(track IN ('비공개','출원','신규')),
+        status TEXT NOT NULL CHECK(status IN ('조사','명세','출원','공개 허용')),
+        deadline TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);`);
+      return db;
+    } catch (error) { db.close(); throw error; }
+  }
+
+  private using<T>(work: (db: Database) => T): T {
+    const db = this.open();
+    try { return work(db); } finally { db.close(); }
+  }
+
+  private transaction<T>(db: Database, work: () => T): T {
+    db.exec('BEGIN IMMEDIATE');
+    try { const result = work(); db.exec('COMMIT'); return result; }
+    catch (error) { db.exec('ROLLBACK'); throw error; }
+  }
+
+  private row(db: Database, id: string): PatentCandidate {
+    const row = db.query('SELECT id, title, track, status, deadline, created_at, updated_at FROM patent_candidates WHERE id = ?').get(id) as PatentCandidate | null;
+    if (!row) throw new PatentsInputError(`patent candidate not found: ${id}`);
+    return row;
+  }
+
+  add(input: { id: string; title: string; track: PatentTrack; status?: PatentStatus; deadline?: string }): PatentCandidate {
+    const id = required(input.id, 'id');
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(id)) throw new PatentsInputError('invalid patent candidate id');
+    const title = required(input.title, 'title');
+    const track = trackOf(input.track);
+    const status = statusOf(input.status ?? '조사');
+    const deadline = input.deadline === undefined ? null : isoDate(input.deadline, 'deadline');
+    return this.using(db => this.transaction(db, () => {
+      if (db.query('SELECT 1 FROM patent_candidates WHERE id = ?').get(id)) throw new PatentsInputError(`patent candidate already exists: ${id}`);
+      const at = this.now().toISOString();
+      db.query('INSERT INTO patent_candidates (id, title, track, status, deadline, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+        .run(id, title, track, status, deadline, at, at);
+      debug.log('patents.ledger', 'add', { id, status });
+      return this.row(db, id);
+    }));
+  }
+
+  setStatus(id: string, status: PatentStatus): PatentCandidate {
+    const next = statusOf(status);
+    return this.using(db => this.transaction(db, () => {
+      this.row(db, id);
+      const at = this.now().toISOString();
+      db.query('UPDATE patent_candidates SET status = ?, updated_at = ? WHERE id = ?').run(next, at, id);
+      debug.log('patents.ledger', 'status', { id, status: next });
+      return this.row(db, id);
+    }));
+  }
+
+  /** 이 원장의 유일한 공개 읽기 통로 — 공개 허용 상태 후보만 나온다(조사·명세·출원 상태 후보는 나오지 않는다). */
+  listPublicCandidates(): PatentCandidate[] {
+    return this.using(db =>
+      db.query(`SELECT id, title, track, status, deadline, created_at, updated_at FROM patent_candidates WHERE status = '공개 허용' ORDER BY created_at, id`).all() as PatentCandidate[]);
+  }
+}

package/src/plugins/install/market-fetch.ts

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto';
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { withFileLockSync } from '../../storage/file-lock.js';
-import { dirname, join, resolve } from 'node:path';
+import { loadPluginManifestFromDir } from '../core/manifest.js';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { elanousStateRoot } from '../../autopilot/state-paths.js';
 import { userConfigPath } from '../../user-config.js';
 import { OFFICIAL_INDEX_KEYS } from '../../market/official-keys.js';
@@ -37,6 +38,36 @@ export interface MarketIndex {
   signature: 'ok';
   keyId: string;
 }
+/** Resolve only an installed, available Codex plugin package to the local-path input
+ *  already accepted by `plugin add`. Codex marketplace records are not Elanous signed indices. */
+export function codexPluginPackagePath(response: unknown, name: string, marketplace: string): string {
+  if (!NAME.test(name) || !NAME.test(marketplace)) throw new MarketFetchError('io', 'invalid Codex plugin or marketplace name');
+  const inventory = response as { marketplaces?: unknown } | null;
+  if (!inventory || !Array.isArray(inventory.marketplaces)) throw new MarketFetchError('io', 'invalid Codex plugin/list response');
+  const matches: string[] = [];
+  for (const rawMarket of inventory.marketplaces) {
+    if (!rawMarket || typeof rawMarket !== 'object') throw new MarketFetchError('io', 'invalid Codex marketplace');
+    const market = rawMarket as { name?: unknown; plugins?: unknown };
+    if (market.name !== marketplace) continue;
+    if (!Array.isArray(market.plugins)) throw new MarketFetchError('io', 'invalid Codex marketplace plugins');
+    for (const rawPlugin of market.plugins) {
+      if (!rawPlugin || typeof rawPlugin !== 'object') continue;
+      const plugin = rawPlugin as Record<string, unknown>;
+      if (plugin.name !== name || plugin.installed !== true) continue;
+      if (typeof plugin.availability === 'string' && plugin.availability.toUpperCase() !== 'AVAILABLE') continue;
+      const path = plugin.installPath ?? plugin.path;
+      if (typeof path !== 'string' || !isAbsolute(path) || !existsSync(path) || !statSync(path).isDirectory()) {
+        throw new MarketFetchError('io', 'Codex installed plugin package directory unavailable');
+      }
+      const manifest = loadPluginManifestFromDir(path, { id: name }).manifest;
+      if (manifest.id !== name) throw new MarketFetchError('io', 'Codex package name differs from inventory');
+      matches.push(path);
+    }
+  }
+  if (matches.length !== 1) throw new MarketFetchError('io', `Codex plugin not installed or ambiguous: ${name}@${marketplace}`);
+  return matches[0]!;
+}
+
 export class MarketFetchError extends Error {
   constructor(public readonly reason: 'io' | 'signature', message: string) {
     super(message);

package/src/pod-lease/admission.ts

@@ -15,21 +15,27 @@ export interface PodLeaseAdmissionOptions {
   dependencyMerged?: (after: PodLeasePredecessor, signal?: AbortSignal) => PredecessorState | boolean | Promise<PredecessorState | boolean>;
   /** Recheck even when there are no local releases (another launcher may free a slot). */
   pollMs?: number;
+  /** Maximum time spent waiting for a free slot; defaults to 30 minutes (predecessor waits do not count). */
+  maxWaitMs?: number;
 }
 
 /** FIFO admission across launches sharing this instance. Unknown status never grants a slot. */
 export class PodLeaseAdmission {
-  private readonly queue: Array<{ resolve: (release: PodLeaseRelease) => void; reject: (error: Error) => void; signal?: AbortSignal; after?: PodLeasePredecessor; onAbort?: () => void; cancelCheck?: () => void; waitReason?: string }> = [];
+  private readonly queue: Array<{ resolve: (release: PodLeaseRelease) => void; reject: (error: Error) => void; signal?: AbortSignal; after?: PodLeasePredecessor; onAbort?: () => void; cancelCheck?: () => void; checkingDependency?: boolean; predecessorMerged?: boolean; waitReason?: string; waitStartedAt?: number }> = [];
   private active = 0;
   private limit = 0;
   private checking: Promise<void> | undefined;
   private recheckRequested = false;
   private timer: ReturnType<typeof setTimeout> | undefined;
+  private expiryTimer: ReturnType<typeof setTimeout> | undefined;
   private readonly pollMs: number;
+  private readonly maxWaitMs: number;
 
   constructor(private readonly options: PodLeaseAdmissionOptions) {
     this.pollMs = options.pollMs ?? 15_000;
+    this.maxWaitMs = options.maxWaitMs ?? 30 * 60_000;
     if (!Number.isFinite(this.pollMs) || this.pollMs <= 0) throw new Error('pod lease pollMs must be positive');
+    if (!Number.isFinite(this.maxWaitMs) || this.maxWaitMs <= 0) throw new Error('pod lease maxWaitMs must be positive');
   }
 
   /** Queue view: each waiting item says why it waits (predecessor not merged yet, or no free slot). */
@@ -42,19 +48,18 @@ export class PodLeaseAdmission {
   acquire(signal?: AbortSignal, after?: PodLeasePredecessor): Promise<PodLeaseRelease> {
     if (signal?.aborted) return Promise.reject(new Error('pod lease admission aborted'));
     return new Promise((resolve, reject) => {
-      const waiter: (typeof this.queue)[number] = { resolve, reject, signal, after };
+      const waiter: (typeof this.queue)[number] = { resolve, reject, signal, after,
+        ...(after === undefined ? { waitStartedAt: Date.now(), waitReason: 'no-free-slot' }
+          : { waitReason: `predecessor-unmerged:${String(after)}` }) };
       if (signal) {
         waiter.onAbort = () => {
-          const index = this.queue.indexOf(waiter);
-          if (index < 0) return;
-          this.queue.splice(index, 1);
-          waiter.cancelCheck?.();
+          if (!this.removeWaiter(waiter)) return;
           reject(new Error('pod lease admission aborted'));
-          this.schedule();
         };
         signal.addEventListener('abort', waiter.onAbort, { once: true });
       }
       this.queue.push(waiter);
+      this.scheduleExpiry();
       void this.refresh();
     });
   }
@@ -83,41 +88,29 @@ export class PodLeaseAdmission {
         } catch {
           this.limit = 0;
         }
-        // No head-of-line blocking: a waiter whose predecessor is not merged yet is skipped and later waiters may admit.
+        // Start independent predecessor checks before admitting eligible waiters in queue order.
+        // A slow predecessor cannot reserve a slot or delay a follower's admission decision.
+        this.expireWaiters();
+        const checks = this.queue.filter((waiter) => waiter.after !== undefined && !waiter.checkingDependency && !waiter.predecessorMerged)
+          .map((waiter) => this.checkPredecessor(waiter));
+        if (checks.length) {
+          // Let ready states settle, but do not hold a free slot for an unanswered dependency check.
+          await Promise.race([Promise.all(checks), new Promise<void>((resolve) => { setTimeout(resolve, 0); })]);
+        }
+        this.expireWaiters();
         let index = 0;
-        while (this.active < this.limit && index < this.queue.length) {
+        while (index < this.queue.length) {
           const waiter = this.queue[index]!;
-          if (waiter.after !== undefined) {
-            let state: PredecessorState = 'waiting';
-            const controller = new AbortController();
-            try {
-              const check = this.options.dependencyMerged?.(waiter.after, controller.signal);
-              const result = await Promise.race([
-                Promise.resolve(check),
-                new Promise<PredecessorState>((resolve) => { waiter.cancelCheck = () => { controller.abort(); resolve('waiting'); }; }),
-              ]);
-              state = result === true ? 'merged' : result === false || result === undefined ? 'waiting' : result;
-            } catch {
-              // An unavailable dependency state cannot grant admission.
-            } finally {
-              waiter.cancelCheck = undefined;
-            }
-            if (!this.queue.includes(waiter)) continue; // aborted while checking
-            if (state === 'blocked') {
-              this.queue.splice(this.queue.indexOf(waiter), 1);
-              if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort);
-              debug.log('pod-lease', 'predecessor-blocked', { after: waiter.after });
-              waiter.reject(new Error(`pod lease predecessor blocked: ${String(waiter.after)} was closed without merging`));
-              continue;
-            }
-            if (state !== 'merged') {
-              waiter.waitReason = `predecessor-unmerged:${String(waiter.after)}`;
-              index++;
-              continue;
-            }
+          if (waiter.after !== undefined && !waiter.predecessorMerged) {
+            index++;
+            continue;
+          }
+          if (this.active >= this.limit) {
+            waiter.waitReason = 'no-free-slot';
+            index++;
+            continue;
           }
-          this.queue.splice(this.queue.indexOf(waiter), 1);
-          if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort);
+          this.removeWaiter(waiter);
           this.active++;
           let released = false;
           waiter.resolve(() => {
@@ -127,21 +120,103 @@ export class PodLeaseAdmission {
             void this.refresh();
           });
         }
-        for (const waiter of this.queue.slice(index)) if (!waiter.waitReason?.startsWith('predecessor-')) waiter.waitReason = 'no-free-slot';
       } while (this.recheckRequested && this.queue.length > 0);
     } finally {
       this.checking = undefined;
+      this.scheduleExpiry();
       this.schedule();
     }
   }
 
+  private async checkPredecessor(waiter: (typeof this.queue)[number]): Promise<void> {
+    waiter.checkingDependency = true;
+    const controller = new AbortController();
+    let state: PredecessorState = 'waiting';
+    try {
+      const check = this.options.dependencyMerged?.(waiter.after!, controller.signal);
+      const result = await Promise.race([
+        Promise.resolve(check),
+        new Promise<PredecessorState>((resolve) => { waiter.cancelCheck = () => { controller.abort(); resolve('waiting'); }; }),
+      ]);
+      state = result === true ? 'merged' : result === false || result === undefined ? 'waiting' : result;
+    } catch {
+      // An unavailable dependency state cannot grant admission.
+    } finally {
+      waiter.cancelCheck = undefined;
+      waiter.checkingDependency = false;
+    }
+    if (!this.queue.includes(waiter)) return;
+    if (state === 'blocked') {
+      this.removeWaiter(waiter);
+      debug.log('pod-lease', 'predecessor-blocked', { after: waiter.after });
+      waiter.reject(new Error(`pod lease predecessor blocked: ${String(waiter.after)} was closed without merging`));
+    } else if (state === 'merged') {
+      waiter.predecessorMerged = true;
+      waiter.waitStartedAt = Date.now();
+      waiter.waitReason = 'no-free-slot';
+      this.scheduleExpiry();
+      void this.refresh();
+    } else {
+      waiter.waitReason = `predecessor-unmerged:${String(waiter.after)}`;
+      waiter.waitStartedAt = undefined;
+    }
+  }
+
+  private expireWaiters(): void {
+    const now = Date.now();
+    for (let index = 0; index < this.queue.length;) {
+      const waiter = this.queue[index]!;
+      if (waiter.waitReason !== 'no-free-slot' || waiter.waitStartedAt === undefined ||
+          now - waiter.waitStartedAt <= this.maxWaitMs) {
+        index++;
+        continue;
+      }
+      this.removeWaiter(waiter);
+      const waitedMs = now - waiter.waitStartedAt;
+      const reason = waiter.waitReason;
+      debug.log('pod-lease', 'admit-starved', { waitedMs, reason, after: waiter.after });
+      waiter.reject(new Error(`pod lease admit-starved: waited ${Math.round(waitedMs / 60_000)}m · reason ${reason}`));
+    }
+    this.scheduleExpiry();
+  }
+
+  /** Every queue exit also updates both timers; an empty queue must retain no timer. */
+  private removeWaiter(waiter: (typeof this.queue)[number]): boolean {
+    const index = this.queue.indexOf(waiter);
+    if (index < 0) return false;
+    this.queue.splice(index, 1);
+    if (waiter.signal && waiter.onAbort) waiter.signal.removeEventListener('abort', waiter.onAbort);
+    waiter.cancelCheck?.();
+    this.scheduleExpiry();
+    if (!this.checking || this.queue.length === 0) this.schedule();
+    return true;
+  }
+
+  private scheduleExpiry(): void {
+    if (this.expiryTimer) clearTimeout(this.expiryTimer);
+    this.expiryTimer = undefined;
+    const now = Date.now();
+    let delay = Infinity;
+    for (const waiter of this.queue) {
+      if (waiter.waitReason === 'no-free-slot' && waiter.waitStartedAt !== undefined) {
+        delay = Math.min(delay, Math.max(1, waiter.waitStartedAt + this.maxWaitMs - now + 1));
+      }
+    }
+    if (Number.isFinite(delay)) {
+      this.expiryTimer = setTimeout(() => {
+        this.expiryTimer = undefined;
+        this.expireWaiters();
+      }, delay);
+    }
+  }
+
   private schedule(): void {
     if (!this.queue.length) {
       if (this.timer) clearTimeout(this.timer);
       this.timer = undefined;
       return;
     }
-    if (this.timer) return;
+    if (this.timer) clearTimeout(this.timer);
     this.timer = setTimeout(() => {
       this.timer = undefined;
       void this.refresh();

package/src/release-loop/checklist.ts

@@ -299,9 +299,20 @@ export function addItem(v: string, input: { id: string; title: string; refs?: st
 }
 
 export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; refs?: string[]; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind; dispatchKind?: ChecklistDispatchKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean | null }, by: string): Checklist {
+  return setItemGuarded(v, id, patch, by);
+}
+
+/** Apply a measured verdict only while the release cell is still the snapshot that was judged. */
+export function setItemIfSnapshot(v: string, id: string, patch: Parameters<typeof setItem>[2], by: string, expected: Pick<ChecklistItem, 'title' | 'status' | 'evidence'>): Checklist {
+  return setItemGuarded(v, id, patch, by, expected);
+}
+
+function setItemGuarded(v: string, id: string, patch: Parameters<typeof setItem>[2], by: string, expected?: Pick<ChecklistItem, 'title' | 'status' | 'evidence'>): Checklist {
   return mutate(v, (data, otherItems) => {
     const item = data.items.find((i) => i.id === id);
     if (!item) throw new CliUserError(`없는 칸: ${id}`, 'list 로 칸 목록을 본다');
+    if (expected && (item.title !== expected.title || item.status !== expected.status || item.evidence !== expected.evidence))
+      throw new CliUserError(`판정 중 칸 변경: ${id}`, '현재 칸으로 다시 측정한다');
     if (patch.status !== undefined && !['green', 'yellow', 'red', 'done'].includes(patch.status)) throw new CliUserError(`잘못된 상태: ${patch.status}`);
     if (patch.disposition !== undefined && !['move', 'known-issue', 'block'].includes(patch.disposition)) throw new CliUserError(`잘못된 처분: ${patch.disposition}`);
     if (patch.kind !== undefined && !CHECKLIST_KINDS.includes(patch.kind)) throw new CliUserError(`잘못된 종류: ${patch.kind}`, 'screen|postpub');

package/src/release-loop/merged-pr-checklist.ts

@@ -7,21 +7,25 @@ import { listChecklist, setItem } from './checklist.js';
 import { judgeLandedCell } from './landed-to-green.js';
 import { evidencePlan, landedButYellow, type MergedChecklistPr } from './landed-but-yellow.js';
 import { assignedVersions, evidenceAdd } from './feature-store.js';
+import { boundMergedTaskCells, candidateMergedTaskCells, closeMergedTaskCard } from '../task-agent/postland-card.js';
 
 export interface MergedPrChecklistDeps {
-  readPr?: (number: number, cwd: string) => { state: string; baseRefName: string; title: string; body: string | null; mergedAt: string };
+  readPr?: (number: number, cwd: string) => { state: string; baseRefName: string; title: string; body: string | null; mergedAt: string; url?: string; headRefOid?: string; files?: Array<{ path: string }> };
   versions?: () => string[];
   checklist?: typeof listChecklist;
   addEvidence?: typeof evidenceAdd;
   setStatus?: typeof setItem;
   judgeLanded?: typeof judgeLandedCell;
+  closeTaskCard?: typeof closeMergedTaskCard;
+  boundTaskCells?: typeof boundMergedTaskCells;
+  candidateTaskCells?: typeof candidateMergedTaskCells;
   log?: typeof debug.log;
 }
 
 /** A confirmed main merge is the only entry. The existing checklist matcher owns PR-to-cell decisions. */
 export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: string, deps: MergedPrChecklistDeps = {}): void {
   const log = deps.log ?? debug.log.bind(debug);
-  const pr = (deps.readPr ?? ((n, dir) => JSON.parse(execFileSync('gh', ['pr', 'view', String(n), '--json', 'state,baseRefName,title,body,mergedAt'], { cwd: dir, encoding: 'utf8', timeout: 30_000 })) as ReturnType<NonNullable<MergedPrChecklistDeps['readPr']>>))(number, cwd);
+  const pr = (deps.readPr ?? ((n, dir) => JSON.parse(execFileSync('gh', ['pr', 'view', String(n), '--json', 'state,baseRefName,title,body,mergedAt,url,headRefOid,files'], { cwd: dir, encoding: 'utf8', timeout: 30_000 })) as ReturnType<NonNullable<MergedPrChecklistDeps['readPr']>>))(number, cwd);
   if (pr.state !== 'MERGED' || pr.baseRefName !== 'main') return;
   const merged: MergedChecklistPr = { number, title: pr.title, body: pr.body, mergedAt: pr.mergedAt };
   const versions = deps.versions?.() ?? (() => {
@@ -43,6 +47,21 @@ export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: st
   const fromTitle = titleCells(pr.title);
   const fromGoal = goal ? goalFileCells(goal) : new Set<string>();
   const designated = [...new Set([...fromBody, ...fromTitle, ...fromGoal])];
+  // A TA card's bound checklist criterion owns its postland verdict. A prose completion
+  // declaration cannot turn that cell green before the measured TA judgment runs.
+  let taClosedId: string | null = null;
+  let taBoundIds = new Set<string>();
+  let taBindingUnreadable = false;
+  try {
+    taBoundIds = new Set((deps.candidateTaskCells ?? candidateMergedTaskCells)(number));
+    if (pr.url && pr.headRefOid) for (const id of (deps.boundTaskCells ?? boundMergedTaskCells)({ number, url: pr.url })) taBoundIds.add(id);
+  } catch (error) { taBindingUnreadable = true; log('release.checklist', 'postland-binding-unreadable', { pr: number, error: String(error) }); }
+  if (pr.url && pr.headRefOid && !taBindingUnreadable) {
+    try {
+      taClosedId = (deps.closeTaskCard ?? closeMergedTaskCard)({ ...pr, number, url: pr.url, headRefOid: pr.headRefOid }, cwd, { versions: [...new Set(versions)] });
+      if (taClosedId) taBoundIds.add(taClosedId);
+    } catch (error) { log('release.checklist', 'postland-card-error', { pr: number, ids: [...taBoundIds], error: String(error) }); }
+  }
   for (const id of designated) {
     log('release.checklist', 'merged-pr-cell-source', {
       pr: number,
@@ -67,19 +86,19 @@ export function syncMergedPrChecklist(number: number, cwd: string, goalFile?: st
   }
   for (const { version, snapshot, row } of matches) {
     if (counts.get(row.id) !== 1) continue;
-    for (const { id, ref } of evidencePlan([row])) {
+    for (const { id, ref } of taClosedId === row.id ? [] : evidencePlan([row])) {
       (deps.addEvidence ?? evidenceAdd)(id, version, ref, 'harness', snapshot.released, snapshot.dev);
       log('release.checklist', 'merged-pr-evidence-added', { version, id, pr: number, ref });
     }
     const cell = snapshot.items.find((item) => item.id === row.id)!;
-    if (cell.status !== 'green' && cell.status !== 'done') {
+    if (!taBindingUnreadable && !taBoundIds.has(row.id) && cell.status !== 'green' && cell.status !== 'done') {
       try {
         (deps.judgeLanded ?? judgeLandedCell)({ version, id: row.id, title: cell.title, pr: number }, { cwd });
       } catch (error) {
         try { log('release.checklist', 'landed-green-error', { version, id: row.id, pr: number, error: String(error) }); } catch { /* Judgment remains fail-soft. */ }
       }
     }
-    if (goal && declaresCompletion(goal)) {
+    if (!taBindingUnreadable && !taBoundIds.has(row.id) && goal && declaresCompletion(goal)) {
       if (!goalCells(goal).has(row.id)) {
         log('release.checklist', 'merged-pr-status-skipped', { version, id: row.id, pr: number, reason: 'goal-does-not-name-cell' });
         continue;

package/src/release-loop/rubric.ts

@@ -99,6 +99,76 @@ export function rubricPriority(text: string): ReturnType<typeof rubricGrade> {
   return rubric ? rubricGrade(rubricScore(rubric)) : 'P2';
 }
 
+// Rubric v2 — first slice: the formula only (line parsing and v1/v2 output are later slots).
+
+/** v2 value axes (L U F O R T M, each 0..3); Z divides the total, X subtracts from it. */
+export const RUBRIC_V2_VALUE_AXES = ['L', 'U', 'F', 'O', 'R', 'T', 'M'] as const;
+export const RUBRIC_V2_Z_CHOICES: readonly number[] = [1, 2, 4, 8];
+const V2_AXIS_KEYS = new Set<string>([...RUBRIC_V2_VALUE_AXES, 'Z', 'X']);
+
+/** Rubric v2 values: L U F O R T M each 0..3, Z ∈ {1,2,4,8}, X 0..3. */
+export interface RubricV2 {
+  L: number;
+  U: number;
+  F: number;
+  O: number;
+  R: number;
+  T: number;
+  M: number;
+  Z: number;
+  X: number;
+}
+
+/** The F weight is 2 through 2026-10-28 and 1 from 2026-10-29 on; asOf must retain its original date text. */
+export const RUBRIC_V2_F_CUTOVER_DAY = '2026-10-29';
+
+export function rubricV2FWeight(asOf: string): 2 | 1 {
+  const invalid = () => new Error(`루브릭 v2 기준 날짜가 잘못되었다: ${String(asOf)}`);
+  // A Date may already have normalized an impossible calendar day before this call.
+  if (typeof asOf !== 'string') throw invalid();
+  const parts = /^(\d{4}|[1-9]\d{4,5}|[+-]\d{6})-(\d{2})-(\d{2})(?:$|T)/.exec(asOf);
+  if (!parts) throw invalid();
+  const year = Number(parts[1]);
+  const month = Number(parts[2]);
+  const day = Number(parts[3]);
+  const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+  const daysInMonth = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1];
+  if (!daysInMonth || day < 1 || day > daysInMonth) throw invalid();
+  const date = new Date(asOf);
+  if (Number.isNaN(date.getTime())) throw invalid();
+  return date.getTime() >= Date.parse(`${RUBRIC_V2_F_CUTOVER_DAY}T00:00:00.000Z`) ? 1 : 2;
+}
+
+/** V = 2L + 2U + wF + 1.5O + 1.5R + 1.5T + M (w = rubricV2FWeight), 점수 = V / Z − 0.5X. */
+export function rubricScoreV2(values: RubricV2, asOf: string): number {
+  if (values === null || typeof values !== 'object' || Array.isArray(values)) throw new Error('루브릭 v2 값이 축 객체가 아니다');
+  const given = values as unknown as Record<string, unknown>;
+  for (const key of Object.keys(given)) {
+    if (!V2_AXIS_KEYS.has(key)) throw new Error(`루브릭 v2 알 수 없는 축: ${key}`);
+  }
+  const readAxis = (axis: (typeof RUBRIC_V2_VALUE_AXES)[number]): number => {
+    const value = given[axis];
+    if (typeof value !== 'number' || !Number.isFinite(value)) throw new Error(`루브릭 v2 축 ${axis} 값이 없다`);
+    if (value < 0 || value > 3) throw new Error(`루브릭 v2 축 ${axis} 값이 0~3 밖이다: ${value}`);
+    return value;
+  };
+  const L = readAxis('L');
+  const U = readAxis('U');
+  const F = readAxis('F');
+  const O = readAxis('O');
+  const R = readAxis('R');
+  const T = readAxis('T');
+  const M = readAxis('M');
+  const Z = given.Z;
+  if (typeof Z !== 'number' || !Number.isFinite(Z)) throw new Error('루브릭 v2 크기 Z 값이 없다');
+  if (!RUBRIC_V2_Z_CHOICES.includes(Z)) throw new Error(`루브릭 v2 크기 Z 값이 1·2·4·8 밖이다: ${Z}`);
+  const X = given.X;
+  if (typeof X !== 'number' || !Number.isFinite(X)) throw new Error('루브릭 v2 위험 X 값이 없다');
+  if (X < 0 || X > 3) throw new Error(`루브릭 v2 위험 X 값이 0~3 밖이다: ${X}`);
+  const w = rubricV2FWeight(asOf);
+  return (2 * L + 2 * U + w * F + 1.5 * O + 1.5 * R + 1.5 * T + M) / Z - 0.5 * X;
+}
+
 /** Inspect an existing checklist without initializing, importing, or migrating its ledger. */
 export function readRubricItems(version: string, ledgerRoot: string): Pick<ChecklistItem, 'id' | 'title' | 'evidence' | 'priority'>[] {
   const dbPath = join(ledgerRoot, 'release', 'features.sqlite');

package/src/rfc-registry/registry.ts

@@ -0,0 +1,88 @@
+import { chmodSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { Database } from 'bun:sqlite';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { assertNotTestWritingOps } from '../instance/test-write-guard.js';
+
+/** The RFC ledger is independent of the release checklist ledger. Callers own and close the handle. */
+export function openRfcRegistry(root = releaseLedgerRoot()): Database {
+  const path = join(root, 'rfc', 'registry.sqlite');
+  assertNotTestWritingOps(path, 'open the RFC registry');
+  mkdirSync(dirname(path), { recursive: true });
+  const db = new Database(path, { create: true, strict: true });
+  try {
+    chmodSync(path, 0o600);
+    db.exec('PRAGMA busy_timeout = 10000; PRAGMA foreign_keys = ON');
+    db.exec(`CREATE TABLE IF NOT EXISTS rfc (
+      id TEXT PRIMARY KEY CHECK(length(id) = 8 AND id GLOB 'RFC-[0-9][0-9][0-9][0-9]'),
+      title TEXT NOT NULL CHECK(length(trim(title)) > 0),
+      status TEXT NOT NULL,
+      doc_path TEXT,
+      created_at TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS rfc_item (
+      id TEXT PRIMARY KEY CHECK(length(id) = 12 AND id GLOB 'RFC-[0-9][0-9][0-9][0-9].I[0-9][0-9]'),
+      rfc_id TEXT NOT NULL REFERENCES rfc(id),
+      title TEXT NOT NULL CHECK(length(trim(title)) > 0),
+      status TEXT NOT NULL,
+      created_at TEXT NOT NULL,
+      CHECK(substr(id, 1, 8) = rfc_id)
+    );
+    CREATE TABLE IF NOT EXISTS rfc_item_link (
+      item_id TEXT NOT NULL REFERENCES rfc_item(id),
+      target_item_id TEXT NOT NULL REFERENCES rfc_item(id),
+      PRIMARY KEY(item_id, target_item_id),
+      CHECK(item_id <> target_item_id)
+    );
+    CREATE TABLE IF NOT EXISTS rfc_event (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT,
+      rfc_id TEXT NOT NULL REFERENCES rfc(id),
+      item_id TEXT REFERENCES rfc_item(id),
+      at TEXT NOT NULL,
+      actor TEXT NOT NULL,
+      event TEXT NOT NULL,
+      payload TEXT
+    );
+    CREATE TRIGGER IF NOT EXISTS rfc_id_immutable BEFORE UPDATE OF id ON rfc
+      BEGIN SELECT RAISE(ABORT, 'RFC identifier is immutable'); END;
+    CREATE TRIGGER IF NOT EXISTS rfc_no_delete BEFORE DELETE ON rfc
+      BEGIN SELECT RAISE(ABORT, 'RFC identifier is immutable'); END;
+    CREATE TRIGGER IF NOT EXISTS rfc_item_id_immutable BEFORE UPDATE OF id, rfc_id ON rfc_item
+      BEGIN SELECT RAISE(ABORT, 'RFC item identifier is immutable'); END;
+    CREATE TRIGGER IF NOT EXISTS rfc_item_no_delete BEFORE DELETE ON rfc_item
+      BEGIN SELECT RAISE(ABORT, 'RFC item identifier is immutable'); END;
+    CREATE TRIGGER IF NOT EXISTS rfc_event_item_parent BEFORE INSERT ON rfc_event
+      WHEN NEW.item_id IS NOT NULL AND NOT EXISTS
+        (SELECT 1 FROM rfc_item WHERE id = NEW.item_id AND rfc_id = NEW.rfc_id)
+      BEGIN SELECT RAISE(ABORT, 'RFC event item belongs to another RFC'); END;
+    CREATE TRIGGER IF NOT EXISTS rfc_event_no_update BEFORE UPDATE ON rfc_event
+      BEGIN SELECT RAISE(ABORT, 'RFC event history is append-only'); END;
+    CREATE TRIGGER IF NOT EXISTS rfc_event_no_delete BEFORE DELETE ON rfc_event
+      BEGIN SELECT RAISE(ABORT, 'RFC event history is append-only'); END;`);
+    return db;
+  } catch (error) { db.close(); throw error; }
+}
+
+export interface RfcRow { id: string; title: string; status: string; doc_path: string | null; created_at: string }
+export interface RfcItemRow { id: string; rfc_id: string; title: string; status: string; created_at: string }
+export interface RfcItemLinkRow { item_id: string; target_item_id: string }
+export interface RfcDetail extends RfcRow { items: Array<RfcItemRow & { links: RfcItemLinkRow[] }> }
+
+export function listRfcs(root?: string): RfcRow[] {
+  const db = openRfcRegistry(root);
+  try { return db.query('SELECT id, title, status, doc_path, created_at FROM rfc ORDER BY id').all() as RfcRow[]; }
+  finally { db.close(); }
+}
+
+export function showRfc(id: string, root?: string): RfcDetail | null {
+  const db = openRfcRegistry(root);
+  try {
+    const read = db.transaction(() => {
+      const row = db.query('SELECT id, title, status, doc_path, created_at FROM rfc WHERE id = ?').get(id) as RfcRow | null;
+      if (!row) return null;
+      const items = db.query('SELECT id, rfc_id, title, status, created_at FROM rfc_item WHERE rfc_id = ? ORDER BY id').all(id) as RfcItemRow[];
+      return { ...row, items: items.map((item) => ({ ...item, links: db.query('SELECT item_id, target_item_id FROM rfc_item_link WHERE item_id = ? ORDER BY target_item_id').all(item.id) as RfcItemLinkRow[] })) };
+    });
+    return read();
+  } finally { db.close(); }
+}