elanous 0.2.29 → 0.2.32

package/src/pr-tool/inflight-registry.ts

@@ -0,0 +1,143 @@
+/**
+ * INFLIGHT-REGISTRY — 비행 중 등록부(대표 10-17 «출발 때 맥락 남기고 머지 때 참조 · 착지하면 지움 · 폭증 막기»).
+ *
+ * 발사하는 런이 runId·칸·한 줄 의도·대상 파일을 한 줄 등록하고, 머지 순간(스마트 머지 LLM)에 같은 파일을
+ * 만지는 줄들의 의도를 읽는다. 착지하면 지운다. 정본은 PR 본문이고 이것은 «색인»이다 — 못 읽으면 빈 목록
+ * (머지는 종전 그대로 간다), 못 쓰면 발사·착지를 막지 않는다(호출부가 fail-soft).
+ *
+ * 폭증 막기: 런당 1줄(같은 칸 재발사는 덮어씀) · 의도 ≤300자 · 파일 ≤20 · 48h 지난 줄은 읽을 때 거르고 쓸 때 걷는다.
+ */
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { withFileLockSync } from '../storage/file-lock.js';
+
+export const INFLIGHT_INTENT_MAX_CHARS = 300;
+export const INFLIGHT_FILES_MAX = 20;
+export const INFLIGHT_TTL_MS = 48 * 60 * 60 * 1000;
+export const INFLIGHT_REGISTRY_FILE = 'inflight-registry.json';
+
+export interface InflightEntry {
+  runId: string;
+  /** 칸 id(없으면 카드 id) — 같은 칸 재발사는 이 키로 덮어쓴다. */
+  cell: string;
+  intent: string;
+  files: string[];
+  registeredAt: string;
+  cardId?: string;
+}
+
+export interface InflightOptions {
+  path?: string;
+  now?: () => Date;
+}
+
+/** 기본 자리 — 과제 카드 상태(`task-agent-actions.json`)와 같은 우주 뿌리. */
+export function inflightRegistryPath(): string {
+  return join(effectiveInstanceRoot(), INFLIGHT_REGISTRY_FILE);
+}
+
+function readEntries(path: string): InflightEntry[] {
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, 'utf8')) as { entries?: unknown };
+    return Array.isArray(parsed.entries) ? parsed.entries.filter(isEntry) : [];
+  } catch { return []; }
+}
+
+function isEntry(value: unknown): value is InflightEntry {
+  const entry = value as Partial<InflightEntry> | null;
+  return !!entry && typeof entry.runId === 'string' && typeof entry.cell === 'string' && typeof entry.intent === 'string'
+    && Array.isArray(entry.files) && typeof entry.registeredAt === 'string';
+}
+
+function isExpired(entry: InflightEntry, now: Date): boolean {
+  const at = Date.parse(entry.registeredAt);
+  return !Number.isFinite(at) || now.getTime() - at > INFLIGHT_TTL_MS;
+}
+
+/** 잠금 안에서 읽고 고쳐 쓴다 — 48h 지난 줄은 쓸 때 걷는다(`expire` 관측). */
+function mutate(opts: InflightOptions, update: (entries: InflightEntry[]) => InflightEntry[]): void {
+  const path = opts.path ?? inflightRegistryPath();
+  const now = (opts.now ?? (() => new Date()))();
+  withFileLockSync(`${path}.lock`, () => {
+    const all = readEntries(path);
+    const live = all.filter((entry) => !isExpired(entry, now));
+    if (live.length < all.length) {
+      try { debug.log('pr-tool.inflight', 'expire', { phase: 'write', runIds: all.filter((entry) => isExpired(entry, now)).map((entry) => entry.runId) }); } catch { /* fail-soft */ }
+    }
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ entries: update(live) }));
+  });
+}
+
+/** 한 줄 등록 — 같은 runId 또는 같은 칸의 옛 줄을 덮어쓴다. 의도·파일은 상한에서 자른다. */
+export function registerInflight(input: { runId: string; cell: string; intent: string; files: readonly string[]; cardId?: string }, opts: InflightOptions = {}): InflightEntry {
+  const now = (opts.now ?? (() => new Date()))();
+  const files = [...new Set(input.files.map((file) => file.trim()).filter(Boolean))];
+  // 한 줄 칸만 — 줄바꿈·제어 문자는 공백으로(머지 프롬프트 인용 블록을 깨지 못하게 · 프롬프트 쪽도 따로 무력화한다).
+  const oneLine = (value: string) => value.replace(/[\p{Cc}\s]+/gu, ' ').trim();
+  const entry: InflightEntry = {
+    runId: oneLine(input.runId),
+    cell: oneLine(input.cell),
+    intent: oneLine(input.intent).slice(0, INFLIGHT_INTENT_MAX_CHARS),
+    files: files.slice(0, INFLIGHT_FILES_MAX),
+    registeredAt: now.toISOString(),
+    ...(input.cardId ? { cardId: input.cardId } : {}),
+  };
+  let replaced: string[] = [];
+  mutate(opts, (entries) => {
+    replaced = entries.filter((old) => old.runId === entry.runId || old.cell === entry.cell).map((old) => old.runId);
+    return [...entries.filter((old) => old.runId !== entry.runId && old.cell !== entry.cell), entry];
+  });
+  try { debug.log('pr-tool.inflight', 'register', { runId: entry.runId, cell: entry.cell, files: entry.files.length, filesDropped: files.length - entry.files.length, intentChars: entry.intent.length, replaced }); } catch { /* fail-soft */ }
+  return entry;
+}
+
+/** 줄을 지운다 — runId 또는 카드 id 로. 지운 수를 돌려준다(0 = 그런 줄 없음). */
+export function removeInflight(key: { runId: string } | { cardId: string }, reason: string, opts: InflightOptions = {}): number {
+  let removed: string[] = [];
+  const matches = (entry: InflightEntry): boolean => 'runId' in key ? entry.runId === key.runId : entry.cardId === key.cardId;
+  mutate(opts, (entries) => {
+    removed = entries.filter(matches).map((entry) => entry.runId);
+    return entries.filter((entry) => !matches(entry));
+  });
+  try { debug.log('pr-tool.inflight', 'remove', { ...key, reason, removed }); } catch { /* fail-soft */ }
+  return removed.length;
+}
+
+/** 살아 있는 줄 — `files` 를 주면 그중 하나라도 만지는 줄만. 48h 지난 줄은 거른다(읽기는 쓰지 않는다). */
+export function listInflight(filter: { files?: readonly string[] } = {}, opts: InflightOptions = {}): InflightEntry[] {
+  const now = (opts.now ?? (() => new Date()))();
+  const all = readEntries(opts.path ?? inflightRegistryPath());
+  const live = all.filter((entry) => !isExpired(entry, now));
+  if (live.length < all.length) {
+    try { debug.log('pr-tool.inflight', 'expire', { phase: 'read', count: all.length - live.length }); } catch { /* fail-soft */ }
+  }
+  if (!filter.files) return live;
+  const wanted = new Set(filter.files);
+  return live.filter((entry) => entry.files.some((file) => wanted.has(file)));
+}
+
+/**
+ * 착지한 PR 의 줄을 지운다 — 그 PR 을 연 과제 카드(`card.pr`)의 카드 id·runId 로 찾는다.
+ * 카드가 없으면 디스크를 건드리지 않는다(사람 PR · 다른 우주 카드 = 지울 줄 없음).
+ */
+export function removeInflightForPr(
+  pr: number,
+  cards: Iterable<{ id: string; runId?: string; pr?: number | { number: number } }>,
+  opts: InflightOptions = {},
+): number {
+  const owners = [...cards].filter((card) => (typeof card.pr === 'number' ? card.pr : card.pr?.number) === pr);
+  if (owners.length === 0) {
+    try { debug.log('pr-tool.inflight', 'remove', { pr, reason: 'pr-landed', removed: [], cards: 0 }); } catch { /* fail-soft */ }
+    return 0;
+  }
+  let removed = 0;
+  for (const card of owners) {
+    removed += removeInflight({ cardId: card.id }, `pr-landed:${pr}`, opts);
+    if (card.runId) removed += removeInflight({ runId: card.runId }, `pr-landed:${pr}`, opts);
+  }
+  return removed;
+}

package/src/prompt-library/chat-conciseness.ts

@@ -39,6 +39,19 @@ useful answers instead of narrated progress.
 - Group related actions into one short preamble instead of emitting
   a new status line before every command.
 
+## Initiative
+
+- Act first: when looking (repo, logs, tools) can answer or advance the
+  request, do that before asking, and answer with what you found or did.
+- Ambiguous request: take the most plausible reading, proceed, and state
+  the assumption in one line. Ask first only when a wrong guess would be
+  costly or hard to undo.
+- Finish forward: end with up to 3 concrete next steps. When one is
+  obvious, cheap and inside the request, continue and do it instead of
+  offering it.
+- A stop always comes with a path: when you decline or cannot finish, say
+  what you will do instead or what would unblock it.
+
 ## Terminal formatting
 
 - Use monospace CommonMark for commands, paths, env vars, and code ids.

package/src/prompt-library/universal-preamble.ts

@@ -104,10 +104,13 @@ execute the next stage; your tool calls are the audit trail.
 
 ## Analysis (분석) — find → read → organize
 When a user's analysis question identifies a concrete, user-fixable code or
-configuration defect, end the organized answer with a clear next-action CTA:
-ask whether they want the discovered fix implemented (for example,
-\`수정할까요?\`). Do not ask this when no actionable defect was found, and do
-not claim a change was made before it is implemented and verified.
+configuration defect: if the fix is small, low-risk and inside what the user
+asked about, make it — switch to the Implementation pipeline, verify it, then
+report what changed. Otherwise end the organized answer with 1-3 concrete
+next actions and ask only the one decision that is really the user's (for
+example, \`이 세 곳을 고칠까요?\` / \`수정할까요?\`). Do not ask when no actionable
+defect was found, and do not claim a change was made before it is implemented
+and verified.
 1. **find**: ONE batch of search tools (Grep / Glob / ListDir / AstGrep
    in parallel) to locate candidate files. Do not run a second \`find\`
    batch unless the first returned ZERO useful candidates — if it
@@ -144,7 +147,9 @@ not claim a change was made before it is implemented and verified.
   produces candidate paths. Do not issue a second \`find\` batch
   searching the SAME paths/globs with different keywords — the
   candidates are already on the table; advance to \`read\`.
-- For Analysis: stop at \`organize\`. Don't drift into edit/exec.
+- For Analysis: end at \`organize\` unless a small, low-risk fix inside the
+  request is ready — then switch to Implementation (edit → verify). Larger or
+  out-of-scope changes stay a proposal.
 - For Implementation/Debugging: \`verify\` is mandatory. "I made the
   change" without verification is incomplete output.
 - Pick a pipeline ONLY when you actually need to use it. Pure conversational

package/src/pty-shell/pty-manifest.ts

@@ -277,6 +277,9 @@ export function upsertPtyManifest(row: {
   };
 }): void {
   try {
+    // 행을 (다시) 세우면 snapshot·frame 칸이 비워진다 — 같은 프로세스의 쓰기 스로틀도 비워 다음 쓰기가 바로 닿게 한다.
+    _lastSnapshotAt.delete(row.id);
+    _lastFrameAt.delete(row.id);
     const d = db(); if (!d) return;
     const runId = getHarnessRunId(process.env);
     const runIdSource = getHarnessRunIdSource();
@@ -800,12 +803,18 @@ export function listPtyManifestByRun(runId: string): PtyManifestRow[] {
   }
 }
 
-export function getPtyManifest(id: string): PtyManifestRow | null {
+/** `strict` — 조회 실패(db 못 엶·질의 오류)를 «행 없음»(null)과 가르도록 던진다. 기본은 둘 다 null(fail-soft). */
+export function getPtyManifest(id: string, opts: { readonly strict?: boolean } = {}): PtyManifestRow | null {
   try {
-    const d = db(); if (!d) return null;
+    const d = db();
+    if (!d) {
+      if (opts.strict) throw new Error('pty-manifest-db-unavailable');
+      return null;
+    }
     const row = d.query('SELECT * FROM pty_manifest WHERE id=?').get(id) as Record<string, unknown> | null;
     return row ? mapRow(row) : null;
-  } catch {
+  } catch (error) {
+    if (opts.strict) throw error;
     return null;
   }
 }

package/src/pty-shell/tui-run-state.ts

@@ -176,10 +176,9 @@ export function describePtyRunState(
     ...(checkoutHead ? { checkoutHead } : {}),
     ...(row && row.kind === 'tui' ? { startedAt: row.startedAt } : {}),
   });
-  const turn: PtyTurnView = row?.alive && row.turnState ? row.turnState : 'unknown';
+  const turnView = ptyTurnViewOfRow(row);
   return {
-    turn,
-    ...(turn !== 'unknown' && row?.turnAt ? { turnAt: row.turnAt } : {}),
+    ...turnView,
     build: build ?? null,
     installed: installed.sha ?? null,
     stale: staleness.stale,
@@ -191,6 +190,38 @@ export function shortSha(sha: string | null | undefined): string {
   return sha ? sha.slice(0, 7) : '-';
 }
 
+/** 행의 자기보고 턴만 — 설치본·git 판독과 «무관»하다(판독이 실패해도 기록된 턴은 그대로 읽힌다). 죽은 행·기록 없음 = unknown. */
+export function ptyTurnViewOfRow(row: Pick<PtyManifestRow, 'alive' | 'turnState' | 'turnAt'> | null | undefined): Pick<PtyRunStateView, 'turn' | 'turnAt'> {
+  const turn: PtyTurnView = row?.alive && row.turnState ? row.turnState : 'unknown';
+  return { turn, ...(turn !== 'unknown' && row?.turnAt ? { turnAt: row.turnAt } : {}) };
+}
+
+// ── 턴 칸(H10 · `pty list` 가 화면 긁기 없이 «지금 턴 중인가·얼마나 됐나»를 낸다) ──
+
+export interface PtyTurnCell {
+  readonly state: PtyTurnView;
+  /** 지금 턴 상태로 바뀐 시각(epoch ms) — 모르면 null. */
+  readonly at: number | null;
+  /** 지금 턴 상태에 머문 초(busy 면 «이 턴 경과»). ⛔ 모르면 null — 「0초」와 「못 잼」은 다른 값이다. */
+  readonly sinceSec: number | null;
+}
+
+export const UNKNOWN_TURN_CELL: PtyTurnCell = { state: 'unknown', at: null, sinceSec: null };
+
+/** `turnAt` 은 턴 값이 «바뀔 때만» 적힌다(`reportTuiTurn` 이 같은 값을 거른다) ⇒ now−turnAt = 그 상태의 경과. */
+export function describeTurnCell(view: Pick<PtyRunStateView, 'turn' | 'turnAt'>, now: number): PtyTurnCell {
+  if (view.turn === 'unknown' || view.turnAt === undefined || !Number.isFinite(view.turnAt) || view.turnAt <= 0) {
+    return { state: view.turn, at: null, sinceSec: null };
+  }
+  return { state: view.turn, at: view.turnAt, sinceSec: Math.max(0, Math.floor((now - view.turnAt) / 1000)) };
+}
+
+/** 표 한 칸 값: `busy,42s` · `idle,300s` · 시각 모름 `busy,?s` · 턴 모름 `?`. */
+export function formatTurnCell(cell: PtyTurnCell): string {
+  if (cell.state === 'unknown') return '?';
+  return `${cell.state},${cell.sinceSec === null ? '?' : cell.sinceSec}s`;
+}
+
 // ── 기록(TUI) ──
 
 export interface TuiRunStateRecorderDeps {

package/src/release-loop/gate-host-reservation.ts

@@ -0,0 +1,97 @@
+import { randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { psProcessStartMs } from '../harness/harness-stop.js';
+import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+
+interface GateHostClaim {
+  token: string;
+  runId: string;
+  hosts: string[];
+  pid: number;
+  pidStartedAt: number | null;
+}
+
+export type GateHostReservation =
+  | { status: 'free' }
+  | { status: 'reserved' | 'unknown'; reason: string; runId?: string };
+
+const hostName = /^[A-Za-z0-9][A-Za-z0-9._-]*$/;
+const claimsDir = (root: string) => join(root, 'release', 'gate-host-reservations');
+
+/** The release graph's pinned child state and the self gate CLI's selected universe resolve through this same entry. */
+export function gateHostReservationRoot(): string { return effectiveInstanceRoot(); }
+
+function claimAlive(claim: GateHostClaim): 'alive' | 'dead' | 'unknown' {
+  try { process.kill(claim.pid, 0); }
+  catch (error) {
+    return (error as NodeJS.ErrnoException).code === 'ESRCH' ? 'dead' : 'unknown';
+  }
+  if (claim.pidStartedAt === null) return 'unknown';
+  const current = psProcessStartMs(claim.pid);
+  if (current === null) return 'unknown';
+  return Math.abs(current - claim.pidStartedAt) <= 2_000 ? 'alive' : 'dead';
+}
+
+/** A gate owns its host until its node exits. A crashed owner's claim is removed on the next read. */
+export function reserveReleaseGateHosts(root: string, runId: string, hosts: readonly string[]): () => void {
+  const unique = [...new Set(hosts)];
+  if (!runId || unique.some(host => host !== '*' && !hostName.test(host))) throw new Error('invalid release gate reservation');
+  if (!unique.length) return () => undefined;
+  const dir = claimsDir(root);
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const token = randomUUID();
+  const pidStartedAt = psProcessStartMs(process.pid);
+  if (pidStartedAt === null) throw new Error('release gate owner start time unmeasured');
+  const claim: GateHostClaim = { token, runId, hosts: unique, pid: process.pid, pidStartedAt };
+  const path = join(dir, `${token}.json`);
+  const temp = join(dir, `.${token}.tmp`);
+  try {
+    writeFileSync(temp, JSON.stringify(claim) + '\n', { mode: 0o600, flag: 'wx' });
+    renameSync(temp, path);
+  } finally { if (existsSync(temp)) rmSync(temp); }
+  debug.log('release-loop.gate', 'host-reserved', { runId, hosts: unique, pid: process.pid, path });
+  return () => {
+    try {
+      const current = JSON.parse(readFileSync(path, 'utf8')) as Partial<GateHostClaim>;
+      if (current.token === token) rmSync(path);
+      debug.log('release-loop.gate', 'host-released', { runId, hosts: unique, path });
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
+        debug.log('release-loop.gate', 'host-release-unmeasured', { runId, path, error: String(error) });
+    }
+  };
+}
+
+/** An unreadable claim is a reservation, never permission to enter a gate host. */
+export function inspectReleaseGateHost(root: string, host: string): GateHostReservation {
+  const dir = claimsDir(root);
+  let names: string[];
+  try { names = readdirSync(dir).filter(name => name.endsWith('.json')); }
+  catch (error) {
+    return { status: 'unknown', reason: `reservation directory unreadable: ${String(error)}` };
+  }
+  for (const name of names) {
+    const path = join(dir, name);
+    let claim: GateHostClaim;
+    try {
+      claim = JSON.parse(readFileSync(path, 'utf8')) as GateHostClaim;
+      if (!claim || !Array.isArray(claim.hosts) || claim.hosts.length === 0
+        || !claim.hosts.every(item => typeof item === 'string' && (item === '*' || hostName.test(item)))
+        || !Number.isSafeInteger(claim.pid) || claim.pid <= 0 || typeof claim.token !== 'string'
+        || typeof claim.runId !== 'string' || !claim.runId
+        || (claim.pidStartedAt !== null && (!Number.isSafeInteger(claim.pidStartedAt)
+          || claim.pidStartedAt <= 0 || claim.pidStartedAt > Date.now()))) throw new Error('invalid claim');
+    } catch (error) { return { status: 'unknown', reason: `reservation unreadable: ${name}: ${String(error)}` }; }
+    const live = claimAlive(claim);
+    if (live === 'dead') {
+      try { rmSync(path); } catch { /* a confirmed dead process cannot still own the host */ }
+      debug.log('release-loop.gate', 'host-claim-reclaimed', { runId: claim.runId, hosts: claim.hosts, path });
+      continue;
+    }
+    if (!claim.hosts.includes(host) && !claim.hosts.includes('*')) continue;
+    return { status: live === 'unknown' ? 'unknown' : 'reserved', reason: `release gate ${claim.runId} holds ${host}`, runId: claim.runId };
+  }
+  return { status: 'free' };
+}

package/src/release-loop/landing-freeze.ts

@@ -36,6 +36,11 @@ export function readLandingFreeze(root = effectiveInstanceRoot(), now = new Date
   return { ...freeze, holdLaunches: freeze.holdLaunches ?? false } as LandingFreeze;
 }
 
+/** Interpret a validated, expiry-aware read without reading the freeze file twice. */
+export function landingFreezeState(freeze: LandingFreeze | null): 'on' | 'off' {
+  return freeze === null ? 'off' : 'on';
+}
+
 export function enableLandingFreeze(opts: { reason?: string; until?: string; by?: string; holdLaunches?: boolean }, root = effectiveInstanceRoot(), now = new Date()): LandingFreeze {
   const until = opts.until === undefined ? null : opts.until;
   if (until !== null && (!/^\d{4}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d+)?)?(?:Z|[+-]\d\d:\d\d)$/.test(until) || !Number.isFinite(Date.parse(until)) || Date.parse(until) <= now.getTime())) {

package/src/release-loop/light-rc.ts

@@ -29,6 +29,9 @@ export interface LightRcOptions {
   /** Run on this machine (the remote child is re-invoked with it). */
   local?: boolean;
   shards?: number;
+  /** OP FU — pass `--fixed-shard-distribution` to self gate (sorted round-robin into `shards`, no RSS pre-measurement).
+   *  Opt-in; absent = the measured planner, unchanged. Also carried to the remote child. */
+  fixedShardDistribution?: boolean;
   /** Release ledger root for the previous-version lookup (release run's deps.ledgerRoot). */
   ledgerRoot?: string;
   log?: (line: string) => void;
@@ -192,7 +195,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
     try {
       const dir = checkout?.dir ?? cwd;
       if (checkout) alwaysInclude = readList(dir);
-      local = (deps.runGate ?? runSelfGateCli)(dir, { base, shards, alwaysInclude, includeImporterTests: true });
+      local = (deps.runGate ?? runSelfGateCli)(dir, { base, shards, ...(opts.fixedShardDistribution ? { fixedShardDistribution: true } : {}), alwaysInclude, includeImporterTests: true });
       if (opts.rehearsalTui) {
         const command = async (cmd: string, args: string[], tree: string, limitMs?: number) => {
           const run = spawnSync(cmd, args, { cwd: tree, encoding: 'utf8', timeout: limitMs });
@@ -208,7 +211,7 @@ export async function runLightRc(version: string, opts: LightRcOptions = {}, dep
   const rc = await (deps.dispatch ?? dispatchHeavyCheck)({
     tool: 'self-gate', repo: cwd, installPwa: true, refs: [base], json: true, commit: measuredCommit,
     // The host re-runs this command with --local (and ELANOUS_GATE_REMOTE_CHILD=1), so it never recurses.
-    remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), '--local', '--json', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],
+    remoteArgv: (sha) => ['bun', 'bin/elanous.mjs', 'release', 'light-rc', '--version', version, '--base', sha(base), '--head', measuredCommit, '--shards', String(shards), ...(opts.fixedShardDistribution ? ['--fixed-shard-distribution'] : []), '--local', '--json', ...(opts.rehearsalTui ? ['--rehearsal-tui'] : [])],
     flags: { remote: opts.local ? undefined : opts.remote ?? true, local: !!opts.local },
     runLocal,
   }, {

package/src/release-loop/placement.ts

@@ -6,7 +6,7 @@ import { resolveRepositoryName } from '../harness/repository-name.js';
 import { getElanousConfigDirOverride } from '../elanous-config-dir.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { userConfigPath } from '../user-config.js';
-import { addItem, checklistHistory, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
+import { addItem, checklistHistory, inspectChecklistTargetPaths, listChecklist, ownerMatches, parseOwner, setItem, validateCeoLoad, type ChecklistItem } from './checklist.js';
 import { assignedVersions, move, releasedVersion } from './feature-store.js';
 import { debug } from '../debug/log.js';
 import { kstDay, listSchedules, type ReleaseSchedule } from './release-schedule.js';
@@ -110,6 +110,12 @@ function validCeoCap(cap: number): number {
 
 export function placementCeoDailyCap(): number { return validCeoCap(placementConfig().ceoDailyCap ?? 30); }
 
+/** One configuration snapshot for the read-only pull-forward caller. */
+export function pullForwardPlacementConfig(): { seatCap: Record<string, number>; ceoDailyCap: number; ceoCalendar: CeoCalendar } {
+  const config = placementConfig();
+  return { seatCap: config.seatCap ?? {}, ceoDailyCap: validCeoCap(config.ceoDailyCap ?? 30), ceoCalendar: config.ceoCalendar ?? {} };
+}
+
 function validDay(day: string): boolean {
   return typeof day === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(day) && Number.isFinite(Date.parse(`${day}T00:00:00Z`))
     && new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) === day;
@@ -406,6 +412,91 @@ export function rebalance(version: string, deps: PlacementDeps = {}): RebalanceR
   return result;
 }
 
+export interface PullForwardDeps {
+  now: Date;
+  schedules: readonly ReleaseSchedule[];
+  checklists: ReadonlyMap<string, readonly ChecklistItem[]>;
+  released: string;
+  merged24h: number;
+  seatCap: Record<string, number>;
+  ceoDailyCap: number;
+  ceoCalendar: CeoCalendar;
+  signal: { order?: readonly string[]; hold?: readonly string[] };
+  targetPathExists: (path: string) => boolean;
+  backlog?: readonly string[];
+}
+
+/** Read-only plan: every operational input is supplied by the caller. */
+export function planPullForward(deps: PullForwardDeps): RebalanceResult {
+  if (typeof deps.targetPathExists !== 'function') throw new CliUserError('대상 저장소 경로 판정기가 필요하다');
+  const rows = [...deps.schedules].sort((a, b) => versionOrder(a.version, b.version));
+  const now = deps.now.getTime();
+  const backlog = deps.backlog ?? BACKLOG_VERSIONS;
+  const released = deps.released;
+  const open = rows.filter((row) => (!released || versionOrder(row.version, released) > 0) && available(row, now, backlog));
+  const target = open[0];
+  if (!target) throw new CliUserError('당겨올 판이 없다 — 착지 마감이 안 지난 판이 필요하다');
+  const result: RebalanceResult = { decisions: [], blocked: [] };
+  const source = rows.find((row) => versionOrder(row.version, target.version) > 0 && !backlog.includes(row.version));
+  if (!source || !available(source, now, backlog)) return result;
+  const sources = [...new Set([...rows.map((row) => row.version), ...deps.checklists.keys(), ...backlog])];
+  const snapshots = new Map(sources.map((version) => [version, [...(deps.checklists.get(version) ?? [])]]));
+  const remainingP0 = snapshots.get(target.version)!.filter((item) => item.priority === 'P0' && item.status !== 'green' && item.status !== 'done').length;
+  const hold = new Set(deps.signal?.hold ?? []);
+  const rank = new Map<string, number>();
+  for (const [index, id] of (deps.signal?.order ?? []).entries()) if (!rank.has(id)) rank.set(id, index);
+  // Untyped legacy cells are fail-closed on human-action words in either language. These
+  // conservative markers may exclude code about approvals, but must never move a manual gate.
+  const human = /\uD83D\uDC51|실기기|실기 |사람|대표|손|라이브 1회|녹화|세미나|수동|승인|검토|결정|HITL|manual|human|approval|sign.off|review|operator|ceo/i;
+  const complete = new Set<string>();
+  const incomplete = new Set<string>();
+  for (const items of snapshots.values()) for (const item of items) {
+    if (item.status === 'green' || item.status === 'done') complete.add(item.id);
+    else incomplete.add(item.id);
+  }
+  const targetPathsReady = (title: string): boolean => {
+    const check = inspectChecklistTargetPaths({ title }, { existsAtMain: deps.targetPathExists });
+    return check.targets.length > 0 && check.warnings.length === 0;
+  };
+  const candidates = snapshots.get(source.version)!.filter((item) =>
+    (item.priority === 'P0' || item.priority === 'P1') && item.status !== 'green' && item.status !== 'done'
+    && !hold.has(item.id) && !human.test(item.title) && (!item.dispatchKind || item.dispatchKind === 'code')
+    && (item.ceoMinutes === undefined || item.ceoMinutes === 0)
+    && targetPathsReady(item.title)
+    && (item.predecessors ?? []).every((id) => complete.has(id) && !incomplete.has(id)))
+    .map((item, index) => ({ item, index }))
+    .sort((a, b) => (rank.get(a.item.id) ?? Infinity) - (rank.get(b.item.id) ?? Infinity)
+      || (a.item.priority === 'P0' ? 0 : 1) - (b.item.priority === 'P0' ? 0 : 1) || a.index - b.index);
+  if (!candidates.length) return result;
+  if (Date.parse(target.landBy ?? target.cutAt) - now < 4 * 60 * 60 * 1000) {
+    for (const { item } of candidates)
+      result.blocked.push({ id: item.id, from: source.version, to: target.version, reason: `지금 판 ${target.version} 착지 마감까지 4시간 미만 — 당겨오기 보류` });
+    return result;
+  }
+  if (remainingP0 > 3) {
+    for (const { item } of candidates)
+      result.blocked.push({ id: item.id, from: source.version, to: target.version, reason: `지금 판 ${target.version} 남은 P0 ${remainingP0} > 3 — 당겨오기 보류` });
+    return result;
+  }
+  const rate = deps.merged24h;
+  if (!Number.isInteger(rate) || rate < 0) throw new CliUserError('24시간 병합 PR 수가 잘못됐다');
+  const caps = deps.seatCap;
+  const ceoCap = validCeoCap(deps.ceoDailyCap);
+  const calendar = deps.ceoCalendar;
+  for (const { item } of candidates) {
+    if (result.decisions.length >= 5) break;
+    const from = source.version;
+    // The pull-forward contract uses the schedule's cutAt only when landBy is absent.
+    const destination = { ...target, landBy: target.landBy ?? target.cutAt };
+    const violation = moveConstraint(item, destination, backlog, snapshots, now, rate, caps, rows, ceoCap, calendar, released);
+    if (violation) { result.blocked.push({ id: item.id, from, to: target.version, reason: violation }); continue; }
+    result.decisions.push({ id: item.id, from, version: target.version, reason: `다음 판 ${from} → 지금 판 ${target.version} 당겨오기 · 남은 P0 ${remainingP0} ≤ 3 · 착지 마감 ≥ 4h`, displaced: [] });
+    snapshots.set(from, snapshots.get(from)!.filter((cell) => cell.id !== item.id));
+    snapshots.get(target.version)!.push(item);
+  }
+  return result;
+}
+
 /** Reasons that justify a second forward rollover of the same cell (대표 10-10 «계속 이월되지 않게»). */
 const SECOND_ROLLOVER_REASON_PREFIXES: readonly string[] = ['쪼개기:', '닫기:', '\u{1F451}:'];