elanous 0.2.25 → 0.2.28

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/prompt-enhance/enhance.ts

@@ -393,6 +393,8 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
   let complication: string | undefined;
   let decisionSignal: EnhanceResult['decisionSignal'];
   let enhancedBy: 'llm' | 'fallback' = 'llm';
+  let fallbackReason: 'llm-error' | 'empty-reply' | 'unparsed' | 'none' = 'none';
+  let replyChars = 0;
   const groundedFacts = opts.groundedFacts ?? [];
   const wantsScqa = groundedFacts.length > 0;
 
@@ -439,6 +441,10 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
         try { opts.onUsage?.(usage); } catch { /* usage observation must not change enhancement */ }
       },
     });
+    replyChars = rawOut.length;
+    if (rawOut.trim().length === 0) {
+      fallbackReason = 'empty-reply';
+    }
     const parsed = parseEnhanceJson(rawOut);
     if (parsed) {
       goal = parsed.goal;
@@ -449,9 +455,11 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
       complication = parsed.complication;
       decisionSignal = parsed.decisionSignal;
     } else {
+      fallbackReason = fallbackReason === 'empty-reply' ? 'empty-reply' : 'unparsed';
       enhancedBy = 'fallback';
     }
   } catch (e) {
+    fallbackReason = 'llm-error';
     debug.log('prompt-enhance', 'llm-error', { error: String((e as { message?: string })?.message ?? e).slice(0, 160) }, { level: 'error' });
     enhancedBy = 'fallback';
   }
@@ -461,6 +469,7 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
     checklist = extractChecklistFallback(original);
     checklistProvenance = checklist.map(() => 'unknown');
     enhancedBy = 'fallback';
+    if (fallbackReason === 'none') fallbackReason = 'unparsed';
   }
   if (!constraints.length) {
     constraints = [
@@ -515,6 +524,8 @@ export async function enhancePrompt(raw: string, opts: EnhanceOpts = {}): Promis
     enhancedChars: enhanced.length,
     checklist: checklist.length,
     enhancedBy,
+    fallbackReason,
+    replyChars,
     model,
     verbatimPreserved,
     // ⭐ 관측 — 「요약을 요구했나 / 받았나 / 옮겨 적어 버렸나」를 «다른 값»으로 남긴다.

package/src/release-loop/checklist.ts

@@ -10,6 +10,8 @@ export type ChecklistDisposition = 'move' | 'known-issue' | 'block';
 /** `screen` = a five-surface feature cell — its evidence carries a `짝:` line (MANUAL-five-surface-parity §A). `postpub` = measured after publication, outside the pre-publication gate. */
 export type ChecklistKind = 'screen' | 'postpub';
 const CHECKLIST_KINDS: readonly ChecklistKind[] = ['screen', 'postpub'];
+export type ChecklistDispatchKind = 'code' | 'ops' | 'measure' | 'decision' | 'umbrella';
+const CHECKLIST_DISPATCH_KINDS: readonly ChecklistDispatchKind[] = ['code', 'ops', 'measure', 'decision', 'umbrella'];
 export interface ChecklistItem {
   id: string;
   title: string;
@@ -27,6 +29,8 @@ export interface ChecklistItem {
   evidence?: string;
   disposition?: ChecklistDisposition;
   kind?: ChecklistKind;
+  /** Whether the seat dispatcher should launch a coding task. Missing in old rows means code. */
+  dispatchKind?: ChecklistDispatchKind;
   updatedAt: string;
   updatedBy: string;
 }
@@ -122,6 +126,37 @@ function change(data: Checklist, id: string, field: string, from: unknown, to: u
 
 const REPO_ROOT = join(import.meta.dir, '..', '..');
 
+const PATH_TOKEN = /(?:^|[^A-Za-z0-9_.\/-])((?:(?:[A-Za-z0-9_.-]+\/)+)?[A-Za-z0-9_.-]+\.(?:ts|tsx|js|jsx|mjs|cjs|json|md|yaml|yml|sh|py|css|html|toml|sql|rs|swift))(?![A-Za-z0-9_.\/-])/g;
+function mentionedPaths(text: string): string[] {
+  return [...text.matchAll(PATH_TOKEN)].map((match) => match[1]!).filter((path) => !path.split('/').includes('..'));
+}
+
+/** Shadow check at checklist authorship. Callers supply the origin/main file probe and merged-PR file reader. */
+export function inspectChecklistTargetPaths(input: {
+  title: string; evidence?: string; refs?: readonly string[]; dispatchKind?: ChecklistDispatchKind;
+}, deps: { existsAtMain: (path: string) => boolean; mergedPrFiles?: (number: number) => readonly string[] }): {
+  targets: string[]; warnings: string[]; candidates: string[];
+} {
+  const lines = input.title.split(/\r?\n/);
+  const first = /^대상 경로:\s*(.*)$/.exec(lines[0] ?? '');
+  const targets = first ? [...new Set(mentionedPaths(first[1]!))] : [];
+  const newFileDeclared = /^신설:\s*/.test(lines[1] ?? '');
+  const warnings: string[] = [];
+  if ((input.dispatchKind ?? 'code') === 'code') {
+    if (!first || !first[1]!.trim() || targets.length === 0) warnings.push('첫 줄 대상 경로가 없다');
+    for (const path of targets) if (!deps.existsAtMain(path) && !newFileDeclared) warnings.push(`${path}: origin/main에 없는 파일 · 신설: 둘째 줄 선언 필요`);
+  }
+  if (!warnings.length) return { targets, warnings, candidates: [] };
+  const sources = [input.title, input.evidence ?? '', ...(input.refs ?? [])].join('\n');
+  const candidates = [...new Set(mentionedPaths(sources).filter(deps.existsAtMain))];
+  for (const match of sources.matchAll(/(?:^|[^\d])#(\d{2,8})\b/g)) {
+    for (const path of deps.mergedPrFiles?.(Number(match[1])) ?? []) {
+      if (deps.existsAtMain(path) && !candidates.includes(path)) candidates.push(path);
+    }
+  }
+  return { targets, warnings, candidates };
+}
+
 /** `--ref` 문서를 찾는 뿌리들 — 이 코드의 트리 ⊕ 지금 작업 디렉토리의 git 뿌리.
  *  ⭐ 설치본(`~/.local/share/elanous/current`)에는 `docs/` 가 없다 — 저장소 안에서 부른 설치본도 저장소 문서를 인용할 수 있게. */
 export function refRoots(cwd = process.cwd()): string[] {
@@ -233,10 +268,11 @@ export function validateCeoLoad(input: { ceoMinutes?: number; ceoDate?: string }
   if (input.ceoDate !== undefined && (!/^\d{4}-\d{2}-\d{2}$/.test(input.ceoDate) || !Number.isFinite(Date.parse(`${input.ceoDate}T00:00:00Z`)) || new Date(`${input.ceoDate}T00:00:00Z`).toISOString().slice(0, 10) !== input.ceoDate)) throw new CliUserError('대표 손 날짜는 YYYY-MM-DD 이어야 한다');
 }
 
-export function addItem(v: string, input: { id: string; title: string; refs?: string[]; owner?: string; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean }, options: { allowDuplicateId?: boolean } = {}): Checklist {
+export function addItem(v: string, input: { id: string; title: string; refs?: string[]; owner?: string; kind?: ChecklistKind; dispatchKind?: ChecklistDispatchKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean }, options: { allowDuplicateId?: boolean } = {}): Checklist {
   if (!input.id.trim()) throw new CliUserError('칸 id 가 비었다');
   if (!input.title.trim()) throw new CliUserError('칸 제목이 비었다');
   if (input.kind !== undefined && !CHECKLIST_KINDS.includes(input.kind)) throw new CliUserError(`잘못된 종류: ${input.kind}`, 'screen|postpub');
+  if (input.dispatchKind !== undefined && !CHECKLIST_DISPATCH_KINDS.includes(input.dispatchKind)) throw new CliUserError(`잘못된 발사 종류: ${input.dispatchKind}`, 'code|ops|measure|decision|umbrella');
   if (input.owner !== undefined) parseOwner(input.owner);
   if (input.priority !== undefined && !['P0', 'P1', 'P2'].includes(input.priority)) throw new CliUserError(`잘못된 우선순위: ${input.priority}`);
   if (input.predecessors !== undefined && (!Array.isArray(input.predecessors) || input.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === input.id))) throw new CliUserError('잘못된 선행 칸');
@@ -255,20 +291,32 @@ export function addItem(v: string, input: { id: string; title: string; refs?: st
     assertPredecessorsExist(input.predecessors, data, otherItems);
     const by = process.env.ELANOUS_TRACK || 'cli';
     const at = new Date().toISOString();
-    const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), ...(input.priority !== undefined ? { priority: input.priority } : {}), ...(input.predecessors !== undefined ? { predecessors: input.predecessors } : {}), ...(input.deadlineVersion !== undefined ? { deadlineVersion: input.deadlineVersion } : {}), ...(input.ceoMinutes !== undefined ? { ceoMinutes: input.ceoMinutes } : {}), ...(input.ceoDate !== undefined ? { ceoDate: input.ceoDate } : {}), ...(input.accelerator === true ? { accelerator: true as const } : {}), ...(refs ? { refs } : {}), updatedAt: at, updatedBy: by };
+    const item: ChecklistItem = { id: input.id, title: input.title, status: 'yellow', ...(input.owner !== undefined ? { owner: input.owner } : {}), ...(input.kind !== undefined ? { kind: input.kind } : {}), ...(input.dispatchKind !== undefined ? { dispatchKind: input.dispatchKind } : {}), ...(input.priority !== undefined ? { priority: input.priority } : {}), ...(input.predecessors !== undefined ? { predecessors: input.predecessors } : {}), ...(input.deadlineVersion !== undefined ? { deadlineVersion: input.deadlineVersion } : {}), ...(input.ceoMinutes !== undefined ? { ceoMinutes: input.ceoMinutes } : {}), ...(input.ceoDate !== undefined ? { ceoDate: input.ceoDate } : {}), ...(input.accelerator === true ? { accelerator: true as const } : {}), ...(refs ? { refs } : {}), updatedAt: at, updatedBy: by };
     data.items.push(item);
     change(data, item.id, 'add', null, item, by, at);
     return true;
   });
 }
 
-export function setItem(v: string, id: string, patch: { status?: ChecklistStatus; evidence?: string; refs?: string[]; owner?: string; disposition?: ChecklistDisposition; kind?: ChecklistKind; priority?: ChecklistItem['priority']; predecessors?: string[]; deadlineVersion?: string; ceoMinutes?: number; ceoDate?: string; accelerator?: boolean | null }, by: string): Checklist {
+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');
+    if (patch.dispatchKind !== undefined && !CHECKLIST_DISPATCH_KINDS.includes(patch.dispatchKind)) throw new CliUserError(`잘못된 발사 종류: ${patch.dispatchKind}`, 'code|ops|measure|decision|umbrella');
     if (patch.priority !== undefined && !['P0', 'P1', 'P2'].includes(patch.priority)) throw new CliUserError(`잘못된 우선순위: ${patch.priority}`);
     if (patch.predecessors !== undefined && (!Array.isArray(patch.predecessors) || patch.predecessors.some((p) => typeof p !== 'string' || !p.trim() || p === id))) throw new CliUserError('잘못된 선행 칸');
     assertPredecessorsExist(patch.predecessors, data, otherItems);
@@ -283,7 +331,7 @@ export function setItem(v: string, id: string, patch: { status?: ChecklistStatus
         throw new CliUserError(`지금 주인: ${item.owner} — --force 로만 바꾼다`, 'release checklist claim <id> --by <자리> --force');
       }
     }
-    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const).filter((field) => patch[field] !== undefined && JSON.stringify(patch[field]) !== JSON.stringify(item[field] ?? null));
+    const fields = (['evidence', 'owner', 'status', 'disposition', 'kind', 'dispatchKind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const).filter((field) => patch[field] !== undefined && JSON.stringify(patch[field]) !== JSON.stringify(item[field] ?? null));
     if (fields.length === 0) return false;
     const at = new Date().toISOString();
     for (const field of fields) {

package/src/release-loop/feature-store.ts

@@ -36,7 +36,7 @@ const walWait = new Int32Array(new SharedArrayBuffer(4));
 const SCHEMA_COLUMNS: Record<string, readonly string[]> = {
   imported_versions: ['json_hash', 'imported_at'],
   events: ['reason', 'generation'],
-  assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date', 'accelerator', 'refs'],
+  assignments: ['priority', 'predecessors', 'deadline_version', 'ceo_minutes', 'ceo_date', 'accelerator', 'refs', 'dispatch_kind'],
   release_schedules: ['freeze_from', 'freeze_until', 'publish_at'],
 };
 function schemaCurrent(db: Database): boolean {
@@ -81,7 +81,7 @@ function open(root = releaseLedgerRoot()): Database {
       if (!eventColumns.some((column) => column.name === 'generation')) db.exec('ALTER TABLE events ADD COLUMN generation INTEGER');
       db.exec('CREATE TABLE IF NOT EXISTS release_schedules (version TEXT PRIMARY KEY, cut_at TEXT NOT NULL, land_by TEXT, updated_at TEXT NOT NULL, updated_by TEXT NOT NULL)');
       const assignmentColumns = db.query('PRAGMA table_info(assignments)').all() as Array<{ name: string }>;
-      for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT'], ['ceo_minutes', 'INTEGER'], ['ceo_date', 'TEXT'], ['accelerator', 'INTEGER'], ['refs', 'TEXT']] as const) {
+      for (const [name, sql] of [['priority', 'TEXT'], ['predecessors', 'TEXT'], ['deadline_version', 'TEXT'], ['ceo_minutes', 'INTEGER'], ['ceo_date', 'TEXT'], ['accelerator', 'INTEGER'], ['refs', 'TEXT'], ['dispatch_kind', 'TEXT']] as const) {
         if (!assignmentColumns.some((column) => column.name === name)) db.exec(`ALTER TABLE assignments ADD COLUMN ${name} ${sql}`);
       }
       const scheduleColumns = db.query('PRAGMA table_info(release_schedules)').all() as Array<{ name: string }>;
@@ -178,12 +178,13 @@ function evidenceRefs(db: Database, version: string, id: string): string[] {
   return (db.query('SELECT ref FROM evidence WHERE feature_id = ? AND version = ? ORDER BY rowid').all(id, version) as Array<{ ref: string }>).map((row) => row.ref);
 }
 function items(db: Database, version: string): ChecklistItem[] {
-  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.priority, a.predecessors, a.deadline_version, a.ceo_minutes, a.ceo_date, a.accelerator, a.refs, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
+  const rows = db.query(`SELECT f.id, COALESCE(a.title_override, f.title) AS title, a.owner, a.kind, a.dispatch_kind, a.priority, a.predecessors, a.deadline_version, a.ceo_minutes, a.ceo_date, a.accelerator, a.refs, a.status, a.disposition, a.evidence, a.updated_at, a.updated_by
     FROM assignments a JOIN features f ON f.id = a.feature_id WHERE a.version = ? ORDER BY a.rowid`).all(version) as Array<Record<string, string | number | null>>;
   return rows.map((r) => {
     const evidence = [r.evidence, ...evidenceRefs(db, version, r.id as string)].filter((value) => value !== null).join('\n');
     return { id: r.id as string, title: r.title as string, status: r.status as ChecklistItem['status'],
       ...(r.owner !== null ? { owner: r.owner as string } : {}), ...(r.kind !== null ? { kind: r.kind as ChecklistItem['kind'] } : {}),
+      ...(r.dispatch_kind !== null ? { dispatchKind: r.dispatch_kind as ChecklistItem['dispatchKind'] } : {}),
       ...(r.priority !== null ? { priority: r.priority as ChecklistItem['priority'] } : {}), ...(r.predecessors !== null ? { predecessors: JSON.parse(r.predecessors as string) as string[] } : {}),
       ...(r.deadline_version !== null ? { deadlineVersion: r.deadline_version as string } : {}),
       ...(r.ceo_minutes !== null ? { ceoMinutes: r.ceo_minutes as number } : {}), ...(r.ceo_date !== null ? { ceoDate: r.ceo_date as string } : {}),
@@ -202,9 +203,9 @@ function putItem(db: Database, version: string, item: ChecklistItem): void {
   if (!feature) db.query('INSERT INTO features (id, title, owner, kind, created_at) VALUES (?, ?, ?, ?, ?)').run(item.id, item.title, item.owner ?? null, item.kind ?? null, item.updatedAt);
   // features.owner/kind follow the latest assignment so details() and the checklist never disagree after a set.
   else if (item.owner !== undefined || item.kind !== undefined) db.query('UPDATE features SET owner = COALESCE(?, owner), kind = COALESCE(?, kind) WHERE id = ?').run(item.owner ?? null, item.kind ?? null, item.id);
-  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, ceo_minutes=excluded.ceo_minutes, ceo_date=excluded.ceo_date, accelerator=excluded.accelerator, refs=excluded.refs, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
-    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
+  db.query(`INSERT INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, dispatch_kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(feature_id, version) DO UPDATE SET status=excluded.status, disposition=excluded.disposition, evidence=excluded.evidence, owner=excluded.owner, kind=excluded.kind, dispatch_kind=excluded.dispatch_kind, priority=excluded.priority, predecessors=excluded.predecessors, deadline_version=excluded.deadline_version, ceo_minutes=excluded.ceo_minutes, ceo_date=excluded.ceo_date, accelerator=excluded.accelerator, refs=excluded.refs, updated_at=excluded.updated_at, updated_by=excluded.updated_by`)
+    .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, feature && feature.title !== item.title ? item.title : null, item.owner ?? null, item.kind ?? null, item.dispatchKind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
 }
 function jsonHash(contents: string | Buffer): string { return createHash('sha256').update(contents).digest('hex'); }
 
@@ -245,8 +246,8 @@ function importOnDb(db: Database, version: string): boolean {
       // Keep a legacy per-version title until an explicit retitle unifies the feature identity.
       if (!existing) putItem(db, version, item);
       else {
-        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
-          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
+        db.query('INSERT OR IGNORE INTO assignments (feature_id, version, status, disposition, evidence, title_override, owner, kind, dispatch_kind, priority, predecessors, deadline_version, ceo_minutes, ceo_date, accelerator, refs, updated_at, updated_by) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)')
+          .run(item.id, version, item.status, item.disposition ?? null, item.evidence ?? null, item.title === existing.title ? null : item.title, item.owner ?? null, item.kind ?? null, item.dispatchKind ?? null, item.priority ?? null, item.predecessors ? JSON.stringify(item.predecessors) : null, item.deadlineVersion ?? null, item.ceoMinutes ?? null, item.ceoDate ?? null, item.accelerator === true ? 1 : null, item.refs?.length ? JSON.stringify(item.refs) : null, item.updatedAt, item.updatedBy);
       }
     }
     for (const entry of data.history) record(db, version, entry);
@@ -273,7 +274,7 @@ function importOnDb(db: Database, version: string): boolean {
       record(db, version, { at: new Date().toISOString(), by: item.updatedBy, id: item.id, field: 'reimport', from: null, to: item, released: data.released, dev: data.dev });
       continue;
     }
-    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const;
+    const fields = ['title', 'status', 'evidence', 'owner', 'disposition', 'kind', 'dispatchKind', 'priority', 'predecessors', 'deadlineVersion', 'ceoMinutes', 'ceoDate', 'accelerator', 'refs'] as const;
     const baseEvidence = (db.query('SELECT evidence FROM assignments WHERE feature_id = ? AND version = ?').get(item.id, version) as { evidence: string | null }).evidence ?? undefined;
     const preserveRefs = item.evidence === baseEvidence || item.evidence === current.evidence;
     const differs = fields.some((field) => field === 'evidence'

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');