elanous 0.2.16 → 0.2.18

package/src/domains/outbound-alert.ts

@@ -5,8 +5,8 @@
 // send.py 와 동일 동작을 TS 로 포팅(완전 elanous 소유). sync(curl) 계약.
 
 import * as childProcess from 'node:child_process';
-import { existsSync, readFileSync, appendFileSync, mkdirSync, unlinkSync } from 'node:fs';
-import { dirname, join, relative } from 'node:path';
+import { existsSync, readFileSync, appendFileSync, mkdirSync, unlinkSync, readdirSync, renameSync, openSync, closeSync, statSync, writeFileSync } from 'node:fs';
+import { basename, dirname, join, relative } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { getElanousConfigDir } from '../elanous-config-dir.js';
 import { conatusEnv } from './conatus-env.js';
@@ -138,11 +138,11 @@ export function userRecentlyActive(now: Date = new Date()): boolean {
 
 /** 야간 보류 적재 (jsonl append — 크론 동시 실행에 안전). origin 있으면 함께 적재 —
  *  아침 flush 가 그 origin(발신 채널)으로 되돌려 발송(없으면 report 묶음). */
-function deferOutbound(text: string, kind: string, origin?: MissionOrigin | null, path = DEFERRED_PATH): boolean {
+export function deferOutbound(text: string, kind: string, origin?: MissionOrigin | null, path = DEFERRED_PATH): boolean {
   try {
     mkdirSync(dirname(path), { recursive: true });
     const rec = { ts: new Date().toISOString(), kind, text, ...(origin ? { origin } : {}) };
-    appendFileSync(path, JSON.stringify(rec) + '\n');
+    withQueueLock(path, () => appendFileSync(path, JSON.stringify(rec) + '\n'));
     console.error(`[outbound] 야간 무음(00:00~06:30 KST) — 보류 적재 (${kind})`);
     return true;
   } catch (e) {
@@ -198,32 +198,195 @@ function deliverToOrigin(origin: MissionOrigin, text: string, onBot?: (bot: stri
   try { return sendTelegramRaw(token, origin.chatId, text, origin.threadId); } catch { return false; }
 }
 
-/** 보류분 일괄 발송 — 묶음 1건(아침 폭주 방지). 발송 건수 반환.
- *  무음 창 밖 첫 sendOutbound 가 자동 호출 + 06:31 플러시 크론이 보장. */
-export function flushDeferred(path = DEFERRED_PATH): number {
+/** 보류 큐 재시도 상한 env — config `outbound.deferredMaxAttempts` 가 없을 때만 읽는다. */
+export const DEFERRED_MAX_ATTEMPTS_ENV = 'ELANOUS_OUTBOUND_DEFERRED_MAX_ATTEMPTS';
+
+/** 보류 항목이 격리되기 전까지 허용하는 실패 flush 수 — config > env > 5. */
+export function deferredMaxAttempts(config?: Pick<UserConfig, 'outbound'>): number {
+  try {
+    const v = (config ?? getUserConfig()).outbound?.deferredMaxAttempts;
+    if (typeof v === 'number' && Number.isSafeInteger(v) && v > 0) return v;
+  } catch { /* unreadable config: env, then default */ }
+  const raw = Number(process.env[DEFERRED_MAX_ATTEMPTS_ENV]?.trim() || NaN);
+  if (Number.isSafeInteger(raw) && raw > 0) return raw;
+  return 5;
+}
+
+/** 격리 파일 — 보류 큐 옆 `<name>.failed.jsonl`. */
+export function deferredQuarantinePath(path: string): string {
+  return path.endsWith('.jsonl') ? `${path.slice(0, -'.jsonl'.length)}.failed.jsonl` : `${path}.failed`;
+}
+
+function pidAlive(pid: number): boolean {
+  try { process.kill(pid, 0); return true; } catch (e) { return (e as NodeJS.ErrnoException).code === 'EPERM'; }
+}
+
+/** 큐 적재·claim 이 서로를 가로지르지 않게 하는 짧은 배타 잠금(`<queue>.lock`, O_EXCL).
+ *  적재는 open→write→close 를 잠금 안에서 하므로 claim 의 rename 이 «열린 채 쓰기 전»인 적재를 가져가지 않는다.
+ *  잠금을 못 얻으면(2초 · 30초 넘은 잔여 잠금은 걷는다) 그대로 진행한다 — 알림을 잃는 것보다 낫다. */
+function withQueueLock<T>(path: string, fn: () => T): T {
+  const lock = `${path}.lock`;
+  const deadline = Date.now() + 2_000;
+  let fd: number | null = null;
+  while (fd === null && Date.now() <= deadline) {
+    try { fd = openSync(lock, 'wx'); break; } catch (e) {
+      const code = (e as NodeJS.ErrnoException).code;
+      if (code === 'ENOENT') { try { mkdirSync(dirname(path), { recursive: true }); } catch { break; } continue; }
+      if (code !== 'EEXIST') break;
+      try { if (Date.now() - statSync(lock).mtimeMs > 30_000) { unlinkSync(lock); continue; } } catch { continue; }
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 10);
+    }
+  }
+  if (fd === null) { try { debug.log('outbound.send', 'deferred-lock-unavailable', { lock: basename(lock) }); } catch { /* */ } }
+  try { return fn(); } finally {
+    if (fd !== null) { try { closeSync(fd); } catch { /* */ } try { unlinkSync(lock); } catch { /* */ } }
+  }
+}
+
+/** 이보다 오래된 claim 은 소유 pid 가 살아 있어도 회수한다(pid 재사용 대비 · 정상 flush 는 이보다 훨씬 짧다). */
+const STALE_CLAIM_MS = 15 * 60_000;
+
+let claimSeq = 0;
+/** 큐를 «가져간다» — 원자적 rename 으로 이 flush 만의 파일로 옮긴다. flush 도중 적재되는 항목은 새 큐 파일에
+ *  쌓이므로 잃지 않는다. 죽은 flusher(또는 이 프로세스의 앞 호출)가 남긴 claim 도 같이 회수한다. */
+function claimDeferred(path: string): string[] {
+  const claims: string[] = [];
+  const next = (): string => `${path}.flushing-${process.pid}-${Date.now()}-${claimSeq++}`;
+  const dir = dirname(path);
+  const prefix = `${basename(path)}.flushing-`;
+  try {
+    for (const name of readdirSync(dir)) {
+      if (!name.startsWith(prefix)) continue;
+      const m = /^(\d+)-(\d+)-/.exec(name.slice(prefix.length));
+      const pid = Number(m?.[1]);
+      const at = Number(m?.[2]);
+      if (!Number.isSafeInteger(pid)) continue;
+      // flushDeferred 는 동기라 같은 pid 의 claim 은 «지난 호출의 잔여»다. 남의 것은 죽었거나 오래됐을 때만.
+      const stale = Number.isFinite(at) && Date.now() - at > STALE_CLAIM_MS;
+      if (pid !== process.pid && !stale && pidAlive(pid)) continue;
+      const own = next();
+      try { renameSync(join(dir, name), own); claims.push(own); } catch { /* another flusher took it */ }
+    }
+  } catch { /* no directory yet */ }
+  withQueueLock(path, () => {
+    if (!existsSync(path)) return;
+    const own = next();
+    try { renameSync(path, own); claims.push(own); } catch { /* another flusher took it */ }
+  });
+  return claims;
+}
+
+/** flushDeferred 주입점 — 시험은 실제 발송 대신 sendBatch 를 준다. */
+export type FlushDeferredDeps = {
+  sendBatch?: (text: string, kind: string, origin?: MissionOrigin) => boolean;
+  maxAttempts?: number;
+};
+
+/** 보류분 일괄 발송 — 묶음 단위. 배달 건수 반환.
+ *  무음 창 밖 첫 sendOutbound 가 자동 호출 + 06:31 플러시 크론이 보장.
+ *  ⭐ 실패한 묶음의 항목만 큐에 남긴다(성공 묶음은 다시 보내지 않는다 · 10-07 야간 11회 재발송 사고).
+ *  실패가 `maxAttempts` 번 쌓인 항목은 `<name>.failed.jsonl` 로 격리한다. */
+export function flushDeferred(path = DEFERRED_PATH, deps: FlushDeferredDeps = {}): number {
   ensureOutboundLogSink();
-  const observeFlush = (count: number, lagMin: number, kinds: string[]): void => {
+  const observeFlush = (
+    count: number, lagMin: number, kinds: string[],
+    outcome: { sent: number; kept: number; quarantined: number },
+  ): void => {
     const lagWarnMin = flushLagWarnMin();
     const over = count > 0 && lagMin > lagWarnMin;
     logSend(
       'flush',
       'deferred-batch',
-      { count, lagMin, kinds: kinds.map(safeObservationLabel), path, lagWarnMin },
+      { count, lagMin, kinds: kinds.map(safeObservationLabel), path, lagWarnMin, ...outcome },
       over ? { level: 'warn' } : undefined,
     );
   };
-  if (!existsSync(path)) {
-    observeFlush(0, 0, []);
+  const none = { sent: 0, kept: 0, quarantined: 0 };
+  const claims = claimDeferred(path);
+  if (claims.length === 0) {
+    observeFlush(0, 0, [], none);
     return 0;
   }
-  type Item = { ts: string; kind: string; text: string; origin?: MissionOrigin };
-  let items: Item[] = [];
-  try {
-    items = readFileSync(path, 'utf-8').split('\n').filter(Boolean).map(l => JSON.parse(l));
-  } catch { /* 손상 라인 무시 */ }
+  type Item = { ts: string; kind: string; text: string; origin?: MissionOrigin; attempts?: number };
+  const items: Item[] = [];
+  const corrupt: string[] = [];
+  const readClaims: string[] = [];
+  for (const claim of claims) {
+    let body = '';
+    try { body = readFileSync(claim, 'utf-8'); } catch (e) {
+      // 못 읽은 claim 은 지우지 않는다 — 다음 flush 가 다시 회수한다.
+      try { debug.log('outbound.send', 'deferred-claim-unreadable', { error: e instanceof Error ? e.message : String(e) }, { level: 'warn' }); } catch { /* */ }
+      continue;
+    }
+    readClaims.push(claim);
+    for (const line of body.split('\n')) {
+      if (!line.trim()) continue;
+      try {
+        const rec = JSON.parse(line) as Item;
+        if (rec && typeof rec === 'object' && typeof rec.text === 'string') items.push(rec);
+        else corrupt.push(line);
+      } catch { corrupt.push(line); }
+    }
+  }
+  const qPath = deferredQuarantinePath(path);
+  const settleFailed = (stage: string, e: unknown): void => {
+    try { debug.log('outbound.send', 'deferred-settle-failed', { stage, error: e instanceof Error ? e.message : String(e) }, { level: 'warn' }); } catch { /* */ }
+  };
+  /** 읽은 claim 을 정산한다. 격리 기록이 실패하면 그 줄은 큐로 돌린다(다음에 다시 격리).
+   *  큐 기록이 실패하면 claim 하나를 «남길 줄만»으로 바꿔 두어 다음 flush 가 배달분을 다시 보내지 않게 한다. */
+  /** 정산된 claim 을 걷는다. 삭제가 실패하면 비워 둔다 — 남은 claim 이 다음 flush 에 배달분을 다시 내지 않게. */
+  const retireClaim = (claim: string): void => {
+    try { unlinkSync(claim); return; } catch (e) { settleFailed('claim-unlink', e); }
+    try { writeFileSync(claim, ''); } catch (e) { settleFailed('claim-truncate', e); }
+  };
+  type Quarantine = { line: string; kind?: string; attempts?: number };
+  /** 반환 = 실제 정산 결과(관측은 이것으로 센다). */
+  const settle = (keep: string[], quarantine: Quarantine[]): { kept: number; quarantined: number } => {
+    let back = keep;
+    let quarantined = 0;
+    if (quarantine.length) {
+      try {
+        appendFileSync(qPath, quarantine.map(q => q.line).join('\n') + '\n');
+        quarantined = quarantine.length;
+        for (const q of quarantine) {
+          if (q.kind === undefined) continue;
+          try { debug.log('outbound.send', 'deferred-quarantined', { kind: safeObservationLabel(q.kind), attempts: q.attempts }); } catch { /* */ }
+        }
+      } catch (e) { settleFailed('quarantine', e); back = [...keep, ...quarantine.map(q => q.line)]; }
+    }
+    const result = { kept: back.length, quarantined };
+    if (readClaims.length === 0) return result;
+    let wrote = back.length === 0;
+    if (!wrote) {
+      try { withQueueLock(path, () => appendFileSync(path, back.join('\n') + '\n')); wrote = true; } catch (e) { settleFailed('queue', e); }
+    }
+    if (!wrote) {
+      const first = readClaims[0]!;
+      const tmp = join(dirname(first), `.${basename(first)}.tmp`);
+      try {
+        writeFileSync(tmp, back.join('\n') + '\n');
+        renameSync(tmp, first);
+        for (const claim of readClaims.slice(1)) retireClaim(claim);
+      } catch (e) { settleFailed('claim-rewrite', e); }
+      return result;
+    }
+    for (const claim of readClaims) retireClaim(claim);
+    return result;
+  };
+  const maxAttempts = deps.maxAttempts ?? deferredMaxAttempts();
+  const priorAttempts = (it: Item): number =>
+    typeof it.attempts === 'number' && Number.isSafeInteger(it.attempts) && it.attempts > 0 ? it.attempts : 0;
+  const quarantine: Quarantine[] = corrupt.map(line => ({ line }));
+  // 이미 상한에 닿은 줄(앞 flush 의 격리 기록이 실패해 큐로 돌아온 것)은 보내지 않고 다시 격리만 시도한다.
+  for (let i = items.length - 1; i >= 0; i--) {
+    const it = items[i]!;
+    if (priorAttempts(it) < maxAttempts) continue;
+    quarantine.push({ line: JSON.stringify(it), kind: it.kind, attempts: priorAttempts(it) });
+    items.splice(i, 1);
+  }
   if (items.length === 0) {
-    try { unlinkSync(path); } catch { /* */ }
-    observeFlush(0, 0, []);
+    const settled = settle([], quarantine);
+    observeFlush(0, 0, [], { ...none, ...settled });
     return 0;
   }
   const kst = (iso: string) => {
@@ -236,8 +399,7 @@ export function flushDeferred(path = DEFERRED_PATH): number {
     `🌙 야간 보류 알림 ${list.length}건 (00:00~06:30 KST 무음 · ⏳ 최대 ${lagMin}분 지연 — 일괄 전달)`,
     ...list.map(i => `\n── [${kst(i.ts)} · ${i.kind}] ──\n${i.text}`),
   ].join('\n');
-  observeFlush(items.length, lagMin, [...new Set(items.map(i => i.kind))]);
-  const sendBatch = (text: string, kind: string, origin?: MissionOrigin): boolean => {
+  const sendBatch = deps.sendBatch ?? ((text: string, kind: string, origin?: MissionOrigin): boolean => {
     let bot = 'unknown';
     const path = origin
       ? (deliverToOrigin(origin, text, label => { bot = label; }) ? 'origin' : false)
@@ -250,15 +412,17 @@ export function flushDeferred(path = DEFERRED_PATH): number {
       });
     } catch { /* observation must not change delivery */ }
     return path !== false;
+  });
+  const failed: Item[] = [];
+  const send = (batch: Item[], kind: string, origin?: MissionOrigin): void => {
+    if (!sendBatch(fmt(batch), kind, origin)) failed.push(...batch);
   };
-  let delivered = 0;
   // origin 없는 매매 알림만 report 묶음. 그 외는 kind 별로 운영 봇 경계를 유지한다.
   const noOrigin = items.filter(i => !i.origin);
   const tradingBatch = noOrigin.filter(i => !isOperationalKind(i.kind));
-  if (tradingBatch.length && sendBatch(fmt(tradingBatch), 'report')) delivered += tradingBatch.length;
+  if (tradingBatch.length) send(tradingBatch, 'report');
   for (const kind of new Set(noOrigin.filter(i => isOperationalKind(i.kind)).map(i => i.kind))) {
-    const batch = noOrigin.filter(i => i.kind === kind);
-    if (sendBatch(fmt(batch), kind)) delivered += batch.length;
+    send(noOrigin.filter(i => i.kind === kind), kind);
   }
   // origin 있는 것 = 발신 채널·스레드별로 묶어 서로 다른 수신자에게 섞이지 않게 발송.
   const groups = new Map<string, { origin: MissionOrigin; list: Item[] }>();
@@ -272,10 +436,19 @@ export function flushDeferred(path = DEFERRED_PATH): number {
   }
   for (const g of groups.values()) {
     const kinds = new Set(g.list.map(i => i.kind));
-    if (sendBatch(fmt(g.list), kinds.size === 1 ? g.list[0]!.kind : 'mixed', g.origin)) delivered += g.list.length;
+    send(g.list, kinds.size === 1 ? g.list[0]!.kind : 'mixed', g.origin);
+  }
+  // 실패 묶음의 항목만 되돌린다(시도 수 +1). 상한에 닿은 항목은 격리 — 영원히 재시도하지 않는다.
+  const keep: string[] = [];
+  for (const it of failed) {
+    const attempts = priorAttempts(it) + 1;
+    const line = JSON.stringify({ ...it, attempts });
+    if (attempts >= maxAttempts) quarantine.push({ line, kind: it.kind, attempts });
+    else keep.push(line);
   }
-  // 전량 배달 성공 시에만 파일 제거(부분 실패는 다음 flush 재시도 — 성공분 중복은 드문 엣지 수용).
-  if (delivered >= items.length) { try { unlinkSync(path); } catch { /* */ } }
+  const settled = settle(keep, quarantine);
+  const delivered = items.length - failed.length;
+  observeFlush(items.length, lagMin, [...new Set(items.map(i => i.kind))], { sent: delivered, ...settled });
   return delivered;
 }
 

package/src/domains/outbound-log-probe.ts

@@ -1,8 +1,23 @@
-import { sendOutbound, setInProcessOutbound } from './outbound-alert.js';
+import { inQuietHours, kstMinutes, sendOutbound, setInProcessOutbound } from './outbound-alert.js';
 import { setUserConfigOverlay } from '../user-config.js';
 
 // Focused subprocess fixture: isolated state/config roots and a fake curl on PATH.
 setUserConfigOverlay(cfg => ({ ...cfg, telegram: { ...cfg.telegram, botToken: '123456:private-secret', homeChannel: 98765 } }));
 process.env.SEND_VIA_ELANOUS = '0';
+// Quiet hours (00:00~06:30 KST) defer instead of sending, so a gate run at night saw no `sent` row.
+// Shift this fixture's clock back to 23:59 KST of the previous day; the shift stays inside this process.
+const quietShiftMs = inQuietHours() ? (kstMinutes() + 1) * 60_000 : 0;
+if (quietShiftMs > 0) {
+  const RealDate = Date;
+  const shifted = () => RealDate.now() - quietShiftMs;
+  class ShiftedDate extends RealDate {
+    constructor(...args: unknown[]) {
+      if (args.length === 0) super(shifted());
+      else super(...(args as [string | number | Date]));
+    }
+    static override now(): number { return shifted(); }
+  }
+  globalThis.Date = ShiftedDate as DateConstructor;
+}
 setInProcessOutbound(null);
 if (!sendOutbound('SECRET-BODY-DO-NOT-LOG', 'ops-alert', { channel: 'cli', surface: process.env.OUTBOUND_PROBE_SOURCE ?? 'outbound-log-probe' })) process.exitCode = 1;

package/src/domains/release-tool.ts

@@ -2,7 +2,7 @@ import type { LLMToolSpec } from '../llm.js';
 import type { ToolRuntimeContext } from '../tool-runtime/types.js';
 import { debug } from '../debug/log.js';
 import { requestConfirmation, type ConfirmOpts, type ConfirmResult } from '../hitl/confirm.js';
-import { devVersion, listChecklist, summarizeChecklist, type Checklist } from '../release-loop/checklist.js';
+import { devVersion, checklistDevVersion, listChecklist, summarizeChecklist, type Checklist } from '../release-loop/checklist.js';
 import { add, move, validateVersion } from '../release-loop/feature-store.js';
 import { formatKst, getSchedule, setSchedule, type ReleaseSchedule } from '../release-loop/release-schedule.js';
 import { latestGraphRun, type GraphRunState } from '../graph-runner/runner.js';
@@ -64,7 +64,7 @@ function dDay(days: number): string {
 export function dispatchReleaseStatus(args: Record<string, unknown>, deps: ReleaseToolDeps = {}): { text: string; structured: Record<string, unknown> } {
   const requested = args.version;
   if (requested !== undefined && (typeof requested !== 'string' || !requested.trim())) throw new Error('판 이름이 필요합니다');
-  const version = requested ? null : (deps.devVersion?.() ?? devVersion());
+  const version = requested ? null : checklistDevVersion(deps.devVersion?.() ?? devVersion());
   const versions = requested ? [requested as string] : [version!, nextVersion(version!)];
   const now = deps.now ?? new Date();
   const run = (deps.latestRun ?? latestGraphRun)('release-loop');

package/src/execution-loop/gates.ts

@@ -3,6 +3,7 @@ import { decideBudget, readBudgetInputsLive, type BudgetDecision, type BudgetInp
 import { resolveHarnessSubstrate, type ResolvedHarnessSubstrate } from '../harness/harness-substrate-default.js';
 import { podMemoryLimitFor } from '../task-orchestrator/surfaces/self-implement-pod.js';
 import { recallMemoryContext } from '../agent-substrate/execution/memory-context.js';
+import { CONTEXT_CARD_SCREEN_CHARS } from '../context-card/index.js';
 
 export interface GateResult<T> {
   decision: T;
@@ -169,6 +170,7 @@ export async function relationGate(
 export interface MemoryGateDeps {
   recall: (query: string) => Promise<string>;
   priorAbandonment: (goalId: string) => Promise<string | undefined> | string | undefined;
+  priorMustFix?: (goalId: string) => readonly string[];
 }
 
 export interface MemoryDecision {
@@ -183,15 +185,22 @@ export async function memoryGate(
   card: Pick<TaskCard, 'goalId' | 'title'>,
   deps: MemoryGateDeps = { recall: recallMemoryContext, priorAbandonment: () => undefined },
 ): Promise<GateResult<MemoryDecision>> {
-  const [context, priorAbandonment] = await Promise.all([
+  const [recall, priorAbandonment] = await Promise.all([
     deps.recall(card.title), deps.priorAbandonment(card.goalId),
   ]);
+  // must-fix 와 recall 은 서로 독립이다 — recall 이 비어도 앞선 must-fix 는 맥락에 남는다.
+  const mustFix = deps.priorMustFix?.(card.goalId) ?? [];
+  const mustFixBlock = mustFix.length ? `앞선 must-fix:\n${mustFix.map((item) => `- ${item}`).join('\n')}` : '';
+  const combined = [mustFixBlock, recall].filter(Boolean).join('\n');
+  const codePoints = [...combined];
+  const truncated = codePoints.length > CONTEXT_CARD_SCREEN_CHARS;
+  const context = truncated ? codePoints.slice(0, CONTEXT_CARD_SCREEN_CHARS).join('') : combined;
   const decision: MemoryDecision = {
     action: 'record', context, fragmentIds: [],
     ...(priorAbandonment === undefined ? {} : { priorAbandonment }),
   };
   return {
     decision,
-    explanation: `memory=${context ? 'recalled' : 'none or unavailable'}; prior abandonment=${priorAbandonment ?? 'unknown'}; fragment IDs unavailable from recall API`,
+    explanation: `memory=${recall ? 'recalled' : 'none or unavailable'}; prior abandonment=${priorAbandonment ?? 'unknown'}; fragment IDs unavailable from recall API${truncated ? `; truncated; chars=${[...context].length}/${CONTEXT_CARD_SCREEN_CHARS}` : ''}`,
   };
 }

package/src/flow-loop/split.ts

@@ -1,23 +1,27 @@
 import type { TaskCard } from '../task-cards/card-store.js';
 
-export interface SplitCell { id: string; title: string; seat?: string; host?: string }
+export interface SplitCell { id: string; title: string; kind?: string; seat?: string; host?: string }
 
 /** FLOW1: only explicitly assigned work may enter a seat's queue. The same proposal is used in shadow and live. */
 export function splitCard(card: TaskCard, _opts: { shadow?: boolean } = {}): SplitCell[] {
   const intake = [...card.sections].reverse().find(section => section.key.startsWith('intake:wish:'));
   let text = card.title;
+  let kind: string | undefined;
   if (intake) {
     let body: unknown;
     try { body = JSON.parse(intake.content); } catch { body = intake.content; }
     if (typeof body === 'string') text = body;
-    else if (body && typeof body === 'object' && typeof (body as { text?: unknown }).text === 'string') text = (body as { text: string }).text;
+    else if (body && typeof body === 'object') {
+      if (typeof (body as { text?: unknown }).text === 'string') text = (body as { text: string }).text;
+      if (typeof (body as { kind?: unknown }).kind === 'string') kind = (body as { kind: string }).kind;
+    }
   }
   const lines = text.split(/\r?\n/).map(line => line.trim()).filter(Boolean);
   const cells: SplitCell[] = lines.map((line, index) => {
     const match = /^(?:[-*]|\d+[.)])?\s*\[(OP|MK|TC|UX)\]\s*(.+)$/u.exec(line);
-    if (match) return { id: `${card.id}-${index + 1}`, title: match[2]!.trim(), seat: match[1]! };
+    if (match) return { id: `${card.id}-${index + 1}`, title: match[2]!.trim(), seat: match[1]!, ...(kind !== undefined ? { kind } : {}) };
     // 담당 없는 행도 칸으로 남긴다 — seat 가 없으니 대기열엔 못 들어가고 tick 이 unplaced-no-owner 로 센다.
-    return { id: `${card.id}-${index + 1}`, title: line.replace(/^(?:[-*]|\d+[.)])\s*/u, '') };
+    return { id: `${card.id}-${index + 1}`, title: line.replace(/^(?:[-*]|\d+[.)])\s*/u, ''), ...(kind !== undefined ? { kind } : {}) };
   });
   // 의뢰 본문이 있으면 담당이 하나도 없어도 행마다 칸으로 남긴다. 본문 없이 제목뿐일 때만 카드 한 칸.
   return intake || cells.some(cell => cell.seat) ? cells : [{ id: card.id, title: card.title }];

package/src/git-fs/worktree.ts

@@ -20,6 +20,9 @@ import { debug } from '../debug/log.js';
 import { getUserConfig } from '../user-config.js';
 
 const GIT_TIMEOUT_MS = 30_000;
+/** 얕은 클론(Pod `git clone --depth 50` · docker/harness/job.yaml)에서 base 를 가져올 깊이 — 클론과 같은 값.
+ *  ⛔ 깊이 없이 얕은 저장소로 다른 브랜치를 fetch 하면 그 브랜치의 «전 이력»을 받는다(실측 193s vs 4s · 30s 에 SIGTERM). */
+const SHALLOW_BASE_FETCH_DEPTH = 50;
 const WORKTREE_ADD_TIMEOUT_MS = 5 * 60_000;
 
 export interface WorktreeAddDeps {
@@ -439,14 +442,31 @@ export function syncBaseWithRemote(
   // 원격이 "그런 브랜치 없다" 고 답했다 ⇒ 축약 hex 여도 모호하지 않다.
   if (!hasRemote) return asSha(false) ?? { checkout: base, freshness: 'local-only' };
 
+  // ⭐ 얕은 저장소면 깊이를 묶는다 — 아니면 그 브랜치의 전 이력을 받느라 GIT_TIMEOUT_MS 를 넘긴다
+  //    (Pod 클론은 `--depth 50` · 비-main base 런이 전부 여기서 SIGTERM 으로 죽었다). 받은 tip 에서 갈리므로
+  //    이후 merge-base(HEAD ↔ 그 tip)는 tip 자체라 깊이 50 으로 족하다. 얕지 않으면 종전 인자 그대로다.
+  //    probe 를 못 읽으면 종전 경로로 간다(값은 'unknown' 으로 관측에 남긴다).
+  const shallowProbe = git('rev-parse', '--is-shallow-repository');
+  const shallowAnswer = shallowProbe.status === 0 ? (shallowProbe.stdout || '').trim() : '';
+  const shallow: boolean | 'unknown' = shallowAnswer === 'true' ? true : shallowAnswer === 'false' ? false : 'unknown';
+  const depth = shallow === true ? SHALLOW_BASE_FETCH_DEPTH : null;
+  const fetchArgs = depth === null ? ['fetch', 'origin', wanted] : ['fetch', `--depth=${depth}`, 'origin', wanted];
+  const fetchStartedAt = Date.now();
   // Only the no-runner fallback joins the shared retry seam; injected runners remain
   // an exact test/caller seam with their prior command count.
   const fetched = runner
-    ? git('fetch', 'origin', wanted)
-    : runGitCommand(repoRoot, ['fetch', 'origin', wanted], { encoding: 'utf8', timeout: GIT_TIMEOUT_MS });
+    ? git(...fetchArgs)
+    : runGitCommand(repoRoot, fetchArgs, { encoding: 'utf8', timeout: GIT_TIMEOUT_MS });
+  const fetchMs = Date.now() - fetchStartedAt;
+  debug.log('git-fs.worktree', 'base.fetch', { base, shallow, depth, ms: fetchMs, ok: fetched.status === 0, signal: fetched.signal ?? null }, fetched.status === 0 ? undefined : { level: 'warn' });
   if (fetched.status !== 0) {
     // origin 에 있는 것을 확인했는데 못 가져왔다 ⇒ 낡은 로컬로 진행하면 조용히 틀린다.
-    throw new Error(`git worktree base sync failed — origin/${remoteBranch} exists but fetch failed: status=${fetched.status}, signal=${fetched.signal ?? 'none'}, stdout=${JSON.stringify((fetched.stdout || '').trim().slice(0, 200))}, stderr=${JSON.stringify((fetched.stderr || '').trim().slice(0, 200))}`);
+    // spawnSync 의 timeout 은 SIGTERM 으로 끝난다 — 「실패」와 「시간 초과」를 문면에서 가른다.
+    const timedOut = fetched.status === null && fetched.signal === 'SIGTERM';
+    const what = timedOut
+      ? `fetch timed out after ${GIT_TIMEOUT_MS / 1000}s (shallow=${shallow}${depth === null ? '' : `, depth=${depth}`})`
+      : 'fetch failed';
+    throw new Error(`git worktree base sync failed — origin/${remoteBranch} exists but ${what}: status=${fetched.status}, signal=${fetched.signal ?? 'none'}, stdout=${JSON.stringify((fetched.stdout || '').trim().slice(0, 200))}, stderr=${JSON.stringify((fetched.stderr || '').trim().slice(0, 200))}`);
   }
   // ⭐ **가져온 것**에서 갈린다(리뷰 must-fix ②) — ls-remote 로 먼저 읽은 SHA 를 쓰면 그 사이 원격이
   //    전진했을 때 "원격 tip" 계약이 깨진다. FETCH_HEAD 가 방금 받은 tip 이다.