elanous 0.2.36 → 0.2.37

package/src/task-agent/task-hand.ts

@@ -32,10 +32,11 @@ import { parseWorkOrder, renderWorkOrderGoal, WORK_ORDER_FILE_PATTERN, type Work
 import { inspectPrelaunchAlreadyDone, type AlreadyDoneDecision, type AlreadyDoneCandidate,
   type PrelaunchGitRunnerForTest } from './prelaunch-already-done.js';
 import { draftClaimComment, draftClaimRecordLive, draftClaimState, draftReleaseComment } from '../self-dev/draft-triage-rules.js';
-import { parseAskTargetPathHints, parseAskTargetPathHintsResult } from '../self-dev/launch-preflight-text.js';
+import { parseAskTargetPathHints, parseAskTargetPathHintsResult, type AskTargetPathHintsParseResult } from '../self-dev/launch-preflight-text.js';
 import { inspectGoalDoneBoundary, linesOutsideFencedCode } from '../self-implement/goal-author.js';
+import { selectKnowhowPack } from '../self-implement/knowhow-pack.js';
 import { INFLIGHT_REGISTRY_FILE, registerInflight } from '../pr-tool/inflight-registry.js';
-import { taskParentRoleEnv } from './task-parent-role-llm.js';
+import { taskParentRoleEnv, taskParentRolePinsForChild } from './task-parent-role-llm.js';
 import { runHarvestUnit, type ReviewInvocation } from './harvest-unit.js';
 import { TASK_CARD_PREFIX } from './task-card-prefix.js';
 
@@ -124,6 +125,43 @@ export function taskCardLabelContext(card: Pick<TaskCard, 'id'>): TaskCardLabelC
 export const COMPLETION_KINDS = ['code-pr', 'artifact', 'research-report', 'ops-action', 'content', 'watch-brief', 'decision-support', 'deliverable'] as const;
 export type CompletionKind = typeof COMPLETION_KINDS[number];
 
+/** «실행·조사» 손의 조합 — 종결 종류별 조합이 아직 없을 때 그 손이 기본으로 쓰는 판(조사 make-doc ⊕ 확인 verify). */
+export const RUN_RESEARCH_COMPOSITION = 'graphs/work/run-research.yaml';
+
+/** 기본 손 묶음 — «개발»(자식 구현 런·PR 착지 = 코드 하니스) 또는 «실행·조사»(비코드 종결 다섯 ⊕ 콘텐츠·전달). */
+export type DefaultHand = 'develop' | 'run-research';
+
+/**
+ * DEFAULT-HANDS — 종결 종류마다 과제 담당이 기본으로 쥐는 손과 그 «확인 증거»(RFC-loop-agent-map §A4c).
+ * 기본은 «개발»이 아니라 «실행·조사»다: 마케터·산업 현장·선생님·C 레벨이 자기 일을 그대로 맡긴다.
+ * 코드 하니스(`harness-say` 자식 구현 런 · PR 착지)는 개발자 팩(`code-pr`)만 쓴다.
+ */
+export interface DefaultHandSpec {
+  hand: DefaultHand;
+  /** 확인 증거 — 종류별 판정 규칙의 이름(정본 = `completion-evidence.ts` `checkCompletionEvidence`). */
+  evidence: string;
+  /** 종류별 조합 파일이 없을 때 그 손이 기본으로 쓰는 조합. */
+  composition: string;
+  /** 코드 하니스(자식 구현 런·PR 병합)를 쓰나 — 개발자 팩 전용. */
+  codeHarness: boolean;
+}
+
+export const DEFAULT_HANDS: Record<CompletionKind, DefaultHandSpec> = {
+  'code-pr': { hand: 'develop', evidence: '구현 — PR 병합', composition: 'graphs/work/code-pr.yaml', codeHarness: true },
+  'research-report': { hand: 'run-research', evidence: '조사 — 출처 인용 보고(출처 ⊕ 반대 근거)', composition: 'graphs/work/research-report.yaml', codeHarness: false },
+  artifact: { hand: 'run-research', evidence: '산출물 — 파일 ⊕ 미리보기', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  content: { hand: 'run-research', evidence: '콘텐츠 — 파일 ⊕ 미리보기', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  'ops-action': { hand: 'run-research', evidence: '실행 — 실행 기록 ⊕ 되읽기', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  'watch-brief': { hand: 'run-research', evidence: '감시·브리핑 — 일정 ⊕ 도착', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  'decision-support': { hand: 'run-research', evidence: '결정 지원 — 카드 ⊕ 기록', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+  deliverable: { hand: 'run-research', evidence: '전달 — 산출물 ⊕ 수신 확인', composition: RUN_RESEARCH_COMPOSITION, codeHarness: false },
+};
+
+/** 카드의 종결 종류가 기본으로 받는 손 — 비면 code-pr(=개발)다. */
+export function defaultHandOf(completion: CompletionKind | undefined): DefaultHand {
+  return DEFAULT_HANDS[completion ?? 'code-pr'].hand;
+}
+
 export interface TaskComposition {
   file: string;
   /** null = 파일은 있으나 파싱 실패로 판을 확인하지 못했다. */
@@ -143,13 +181,27 @@ export const COMPOSITION_ROOT = join(dirname(fileURLToPath(import.meta.url)), '.
 
 /** 1판은 조합을 고르고 단위 해석 결과를 기록한다. 단위 실행은 2판의 몫이다. */
 export function selectTaskComposition(completion: CompletionKind, root = COMPOSITION_ROOT): CompositionSelection {
-  const file = `graphs/work/${completion}.yaml`;
-  const path = join(root, file);
+  const requested = `graphs/work/${completion}.yaml`;
+  // DEFAULT-HANDS — 종류별 조합이 없으면 그 손의 기본 조합(«실행·조사»)으로 내려간다.
+  // 비개발 종결이 «조합 없음»으로 막히면 사람별 표본이 과제 담당에 닿지도 못한다.
+  let file = requested;
+  let path = join(root, file);
   let source: string;
   try { source = readFileSync(path, 'utf8'); } catch (error) {
-    if ((error as NodeJS.ErrnoException)?.code === 'ENOENT') return { unitsResolved: false, missingUnits: [] };
-    return { composition: { file, version: null }, unitsResolved: false, missingUnits: [],
-      error: `조합 읽기 오류: ${file}: ${error instanceof Error ? error.message : String(error)}` };
+    const missing = (error as NodeJS.ErrnoException)?.code === 'ENOENT';
+    if (!missing) {
+      return { composition: { file, version: null }, unitsResolved: false, missingUnits: [],
+        error: `조합 읽기 오류: ${file}: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    const fallback = DEFAULT_HANDS[completion].composition;
+    if (fallback === requested) return { unitsResolved: false, missingUnits: [] };
+    file = fallback;
+    path = join(root, file);
+    try { source = readFileSync(path, 'utf8'); } catch (fallbackError) {
+      if ((fallbackError as NodeJS.ErrnoException)?.code === 'ENOENT') return { unitsResolved: false, missingUnits: [] };
+      return { composition: { file, version: null }, unitsResolved: false, missingUnits: [],
+        error: `조합 읽기 오류: ${file}: ${fallbackError instanceof Error ? fallbackError.message : String(fallbackError)}` };
+    }
   }
   const parsed = parseGraphTemplateYaml(source, path);
   if (!parsed.template || parsed.errors.length) {
@@ -763,6 +815,46 @@ export function readTaskCard(id: string, path = taskAgentStatePath()): TaskCard
   return readState(path).tasks?.[id];
 }
 
+/** TA-REVIEW-PASS — runId 기준 단일 카드 멱등 생성 결과. `ok: false` 는 임의 생성 없이 사유만 남긴 보류(fail-closed)다. */
+export type IdempotentRunCardCreate =
+  | { ok: true; card: TaskCard; created: boolean }
+  | { ok: false; reason: string };
+
+/**
+ * TA-REVIEW-PASS — runId 기준 단일 카드 결속(멱등 생성). 단일 파일 잠금 안에서 원장을 읽어
+ * (a) 같은 runId 카드가 정확히 1건이면 그대로 재사용, (b) 0건이면 runId 해시로 재진입에 안정적인 id 를 만들어
+ * `card.runId` 를 검증된 부모 런 ID 와 정확히 일치시켜 원장에 추가한다(종전 칸·다른 카드·원장 기타 필드 보존),
+ * (c) 복수 카드·원격 Pod 자식 런·불명 runId·읽기 실패는 임의 생성하지 않고 사유를 남겨 보류한다.
+ */
+export function idempotentCreateCardForRun(path: string, input: { runId: string; text: string; now?: () => Date; env?: NodeJS.ProcessEnv }): IdempotentRunCardCreate {
+  const runId = input.runId.trim();
+  if (!runId) return { ok: false, reason: 'runId 불명 — 고유한 런 소유를 검증할 수 없어 카드를 만들지 않는다' };
+  const env = input.env ?? process.env;
+  if (env.ELANOUS_POD_NAME) return { ok: false, reason: `원격 Pod 자식 런(${env.ELANOUS_POD_NAME}) — HQ 결속만 허용한다` };
+  const at = (input.now ?? (() => new Date()))().toISOString();
+  return withFileLockSync(`${path}.lock`, (): IdempotentRunCardCreate => {
+    let disk: TaskAgentStateFile;
+    try {
+      disk = readState(path);
+    } catch (error) {
+      return { ok: false, reason: `원장 읽기 실패 — 임의 생성하지 않는다: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    const tasks = { ...(disk.tasks ?? {}) };
+    const bound = Object.values(tasks).filter((candidate) => candidate.runId === runId);
+    if (bound.length === 1) return { ok: true, card: bound[0]!, created: false };
+    if (bound.length > 1) return { ok: false, reason: `runId ${runId} 카드 ${bound.length}건(모호) — 고유한 런 소유가 아니므로 결속하지 않는다` };
+    const id = `${TASK_CARD_PREFIX}run-${createHash('sha256').update(runId).digest('hex').slice(0, 12)}`;
+    if (tasks[id]) return { ok: false, reason: `카드 id ${id} 충돌 — 종전 카드를 덮어쓰지 않는다` };
+    const card: TaskCard = {
+      id, text: input.text, createdAt: at, status: 'launched', runId,
+      history: [{ at, event: 'card-created-for-run', detail: `카드 없는 runId(${runId})의 리뷰 필요 판정 — 단일 카드 멱등 결속`, runId }],
+    };
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, JSON.stringify({ ...disk, tasks: { ...tasks, [id]: card } }));
+    return { ok: true, card, created: true };
+  });
+}
+
 function canonicalTargetPaths(paths: readonly string[]): string[] {
   return [...new Set(paths.filter((path): path is string => typeof path === 'string').map((path) => posix.normalize(path))
     .filter((path) => path !== '.' && path !== '..' && !posix.isAbsolute(path)
@@ -864,6 +956,7 @@ export function launchArgs(card: Pick<TaskCard, 'text' | 'seat' | 'childLlm' | '
     ? ['--child-llm-provider', card.childLlm.provider, '--child-llm-model', card.childLlm.model, ...(card.childLlm.effort ? ['--child-llm-effort', card.childLlm.effort] : [])]
     : [];
   const runPriority = runIdentityQueuePriority(card.identity);
+  // Exact role model pins travel in ELANOUS_ROLE_LLM_*: harness say's argv parser only accepts provider[/tier].
   return ['harness', 'say', ...(card.seat ? ['--seat', card.seat] : []), '--substrate', 'pod', '--merge-by-host', ...(runPriority !== undefined ? ['--run-priority', String(runPriority)] : []), ...child, card.text];
 }
 
@@ -1040,6 +1133,37 @@ function goalEvidenceCommandFormViolations(document: string): string[] {
   return violations;
 }
 
+/**
+ * FIRST-LINE-PATH-LIST-ONLY — 골 «첫 줄»의 형태 판정: `대상 경로:` 뒤의 «경로 조각» 에는 괄호·줄번호·덧말이 붙지 않는다.
+ * 첫 줄만 보는 판정은 `parseAskTargetPathHintsResult` 가 이미 하므로 새 파서를 만들지 않고 그 결과에 얹는다:
+ * 파서가 통과시킨 경로(`paths`)와 버린 조각(`rejected`)을 한 줄씩 보고, «경로 조각»(디렉터리 구분자·확장자가 있는 것)에
+ * 장식이 붙었을 때만 이유를 붙여 거부한다. `· 동작: a 고침` 같은 «산문 조각» 은 경로 조각이 아니다 —
+ * 조각 분해가 합성하는 손 문면(`handTaskWithTierSplit` 경로)이 그 모양으로 첫 줄을 만든다.
+ * 라벨이 없는 문면(첫 줄이 대상 경로 목록이 아닌 손)은 이 축의 몫이 아니다 — 그 모양은 지금과 같다.
+ */
+const FIRST_LINE_PATH_DECORATIONS: readonly { readonly label: string; readonly pattern: RegExp }[] = [
+  { label: '괄호 장식', pattern: /[()[\]{}（）【】]/ },
+  { label: '줄번호', pattern: /:\d/ },
+  { label: '덧말', pattern: /->|→|—|–/ },
+];
+
+function firstLinePathListViolations(hints: AskTargetPathHintsParseResult): string[] {
+  if (hints.labelMissing) return [];
+  const violations: string[] = [];
+  for (const piece of [...hints.paths, ...hints.rejected.map((rejection) => rejection.fragment.trim())]) {
+    if (!/[/.]/.test(piece)) continue;
+    const decoration = FIRST_LINE_PATH_DECORATIONS.find((entry) => entry.pattern.test(piece));
+    if (decoration) violations.push(`${decoration.label}: ${piece}`);
+    // 공백만으로 거부하지 않는다 — «경로 자체에 공백»(`docs/foo bar.md`)은 지금처럼 통과한다.
+    // 덧말은 공백 뒤에 «경로가 아닌 말»이 붙은 경우만이다(마지막 조각에 구분자·확장자가 없다).
+    else {
+      const trailing = piece.split(/\s+/).slice(1).join(' ').trim();
+      if (trailing !== '' && !/[/.]/.test(trailing)) violations.push(`덧말(공백 섞임): ${piece}`);
+    }
+  }
+  return violations;
+}
+
 export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
   const text = opts.text.trim();
   if (!text) throw new Error('과제 한 줄이 비어 있다');
@@ -1072,7 +1196,8 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
       launcher: 'hand',
     }, birthTags);
   const childLlm = opts.childLlm !== undefined ? parseChildLlm(opts.childLlm, opts.childLlmEffort) : undefined;
-  const parentRoleEnv = taskParentRoleEnv(opts.parentRoleLlm ?? []); // validate before writing the card
+  const parentRolePins = taskParentRolePinsForChild(opts.parentRoleLlm ?? [], childLlm);
+  const parentRoleEnv = taskParentRoleEnv(parentRolePins); // validate before writing the card
   const completion = opts.completion ?? 'code-pr';
   const selected = selectTaskComposition(completion, opts.compositionRoot);
   // 2판 — launcher 'graph-run' 조합(단위 해석까지 완료)은 실제 graph run 으로 발사한다. 더 이상 거부하지 않는다.
@@ -1083,8 +1208,11 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     : !selected.composition ? `조합 없음: graphs/work/${completion}.yaml`
     : selected.error ?? (selected.launcher === 'graph-run' && !selected.unitsResolved
       ? `조합 단위 미해석: ${selected.composition.file} — 대상 unit: ${selected.missingUnits.length ? selected.missingUnits.join(', ') : '해석 실패'} (graph-run 발사는 단위 해석이 필요하다)`
-      : completion !== 'code-pr' || selected.launcher !== 'harness-say'
-        ? `조합 실행기 없음: ${selected.composition.file} (발사 가능한 launcher: code-pr harness-say · graph-run)` : undefined);
+      // DEFAULT-HANDS — 코드 하니스(harness-say 자식 구현 런)는 개발자 팩(code-pr)만 쓴다.
+      : !DEFAULT_HANDS[completion].codeHarness && selected.launcher === 'harness-say'
+        ? `조합 실행기 없음: ${selected.composition.file} — ${completion} 은 «실행·조사» 손이라 코드 하니스(harness-say)를 쓰지 않는다(개발자 팩 전용)`
+        : selected.launcher === undefined
+          ? `조합 실행기 없음: ${selected.composition.file} (발사 가능한 launcher: harness-say · graph-run)` : undefined);
   let project: TaskCard['project'];
   let targetIsGit: boolean | null = null;
   if (opts.project) {
@@ -1126,7 +1254,7 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     ...(opts.milestone ? { milestone: opts.milestone } : {}),
     ...(opts.taLand === true ? { taLand: true as const } : {}),
     ...(childLlm ? { childLlm } : {}),
-    ...(opts.parentRoleLlm?.length ? { parentRoleLlm: [...opts.parentRoleLlm] } : {}),
+    ...(parentRolePins.length ? { parentRoleLlm: parentRolePins } : {}),
     ...(opts.tier ? { tier: opts.tier } : {}),
     ...(opts.tierSplit ? { tierSplit: opts.tierSplit } : {}),
     ...(identity ? { identity } : {}),
@@ -1202,11 +1330,20 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     if (formViolations.length > 0) {
       throw new Error(`goal-revision-required: 완료 경계 증거 명령은 명령 원문이어야 한다 ${formViolations.join(' · ')} — 증거 명령 줄에 설명 접미(예: → 0 fail)나 백틱 장식을 붙이지 말고 명령만 적은 뒤 다시 넘기세요`);
     }
+    // FIRST-LINE-PATH-LIST-ONLY — 첫 줄 형태 판정(발사 전 거부): 괄호·줄번호·덧말이 붙은 골은 자식을 띄우지 않는다.
+    // 카드 기록(writeCard)과 launcher 호출 뒤로 밀리면 «발사 전 거부·카드 0» 이 깨지므로 이 자리에서 던진다.
+    const firstLineViolations = firstLinePathListViolations(targetPathHints);
+    if (firstLineViolations.length > 0) {
+      try { debug.log('task-agent.hand', 'first-line-path-list-rejected', { card: id, violations: firstLineViolations }); } catch { /* fail-soft */ }
+      throw new Error(`goal-revision-required: 골 첫 줄은 «대상 경로:» 뒤에 경로 목록만 적어야 한다 ${firstLineViolations.join(' · ')} — 괄호·줄번호·덧말을 떼고 경로만 적은 뒤 다시 넘기세요`);
+    }
   }
   writeCard(path, card);
   try { debug.log('task-agent.hand', 'target-paths', { card: id, count: targetPaths.length, labelMissing: targetPathHints.labelMissing }); } catch { /* fail-soft */ }
   try { debug.log('task-agent.graph-select', !selected.composition ? 'composition-missing' : selected.error ? 'composition-invalid' : 'composition-selected', {
     completion, file: selected.composition?.file ?? `graphs/work/${completion}.yaml`,
+    // DEFAULT-HANDS — 어느 손으로 나가는지(«개발»/«실행·조사»)와 코드 하니스 여부를 선택 관측에 싣는다.
+    hand: DEFAULT_HANDS[completion].hand, codeHarness: DEFAULT_HANDS[completion].codeHarness,
     unitsResolved: selected.unitsResolved, missingUnits: selected.missingUnits,
     ...(selected.error ? { error: selected.error } : {}),
   }); } catch { /* fail-soft */ }
@@ -1282,6 +1419,14 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     writeCard(path, candidate);
     return { card: candidate, move: nextMoveFor(candidate), mode, launched: false, ...(project ? { cwd: project.target } : {}) };
   }
+  // Only the code-PR harness Pod consumes podGoal. Keep the card and other launchers unchanged.
+  const podLaunch = completion === 'code-pr' && selected.launcher === 'harness-say';
+  let childGoal = card.text;
+  if (podLaunch) {
+    const knowhow = selectKnowhowPack(project?.target ?? resolve(import.meta.dir, '../..'), card.text, targetPaths);
+    if (knowhow.text) childGoal = `${knowhow.text}\n\n${card.text}`;
+    try { debug.log('task-agent', 'knowhow-pack', { taskId: id, ids: knowhow.ids, bytes: knowhow.bytes, injected: knowhow.bytes > 0 }); } catch { /* fail-soft */ }
+  }
   const runId = mintRunId();
   const launchId = newLaunchUtteranceId();
   recordLaunchUtterance({ source: 'hand', utterance: opts.text, launchId });
@@ -1294,10 +1439,10 @@ export async function handTask(opts: HandTaskOptions): Promise<HandTaskResult> {
     // An omitted card provider uses the established Pod default. Carry the effective value explicitly so
     // remote-parent code never has to infer a provider from the serialized CLI argv.
     effectiveChildProvider: card.childLlm?.provider ?? 'openai-codex',
-    ...(completion === 'code-pr' && selected.launcher === 'harness-say' ? { substrate: 'pod' as const, podGoal: card.text } : {}) };
+    ...(podLaunch ? { substrate: 'pod' as const, podGoal: childGoal } : {}) };
   let receipt: void | TaskLaunchReceipt;
   try {
-    receipt = await opts.launcher(move.command!, project?.target, context);
+    receipt = await opts.launcher(podLaunch ? [...move.command!.slice(0, -1), childGoal] : move.command!, project?.target, context);
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     const failed: TaskCard = { ...card, status: 'launch-failed', history: [{ at: (opts.now ?? (() => new Date()))().toISOString(), event: 'launch-failed', detail: reason }] };

package/src/task-agent/task-parent-role-llm.ts

@@ -34,3 +34,12 @@ export function taskParentRoleEnv(values: readonly string[]): Record<string, str
   }
   return env;
 }
+
+/** A child model also powers planning unless the caller pinned planning explicitly. */
+export function taskParentRolePinsForChild(
+  values: readonly string[], child?: { provider: string; model: string },
+): string[] {
+  const env = taskParentRoleEnv(values);
+  if (!child || env[roleLlmEnvName('planning')] !== undefined) return [...values];
+  return [...values, `planning=${JSON.stringify({ provider: child.provider, model: child.model })}`];
+}

package/src/task-agent/tier-split.ts

@@ -43,10 +43,11 @@ export function composeSliceHandText(sliceGoal: string, parentText: string, mark
     const label = INHERITED_PARENT_LABELS.exec(line)?.[1];
     return label !== undefined && !sliceHas.has(label);
   });
-  // The slice marker also carries review scope. Device slices now own their
-  // completion boundary, so inherited can be empty while the marker is needed.
+  // 표지는 리뷰 범위를 나르므로 장치 우선 조각(총 2 이상)은 상속 줄이 없어도 남는다 —
+  // 다만 «물려받았다» 는 물려받은 줄에 대한 주장이므로 그 줄이 있을 때만 붙인다.
   if (inherited.length === 0 && (marker.total < 2 || !sliceGoal.includes(`동작: ${DEVICE_FIRST_STEP}`))) return sliceGoal;
-  const tag = `조각 ${marker.index}/${marker.total} — 부모 ${marker.cid ?? '(칸 없음)'}(${marker.fromTier}) 를 중 이하로 나눈 몫. 아래 계약·완료 경계는 부모 칸에서 물려받았다 — 이 조각 범위만 채운다.`;
+  const inheritanceClaim = inherited.length > 0 ? ' 아래 계약·완료 경계는 부모 칸에서 물려받았다 — 이 조각 범위만 채운다.' : '';
+  const tag = `조각 ${marker.index}/${marker.total} — 부모 ${marker.cid ?? '(칸 없음)'}(${marker.fromTier}) 를 중 이하로 나눈 몫.${inheritanceClaim}`;
   return [...sliceLines, tag, ...inherited].join('\n');
 }
 

package/src/task-agent/work-order.ts

@@ -11,7 +11,8 @@
  *   4. 판정 신호(`verdictSignal` — 조건·관측·기대) ⊕ 현재 계약 한 줄(`contract`)
  *   5. 경계(`boundary` — 대상 경로 · 건드리지 말 곳)
  *   6. 예산(`budget` — 시간 · 모델 티어 · Pod 자리 · 재작업 상한)
- *   7. 선행·짝 칸(`peers`)
+ *   7. 선행·짝 칸(`peers`) — 항목마다 조회된 상태(`state`)와 조회 시각(`observedAt`)을 보존한다
+ *      (칸 이름만으로는 발사 시점의 상태를 알 수 없다 · 조회하지 않은 항목은 «모름»).
  *   8. 선례 묶음(`precedents` — 같은 칸 앞 생애 결말·must-fix 서명)
  *   9. 올림 규칙(`escalation` — 무엇이면 누구에게 · 돈·보안은 대표)
  *
@@ -50,6 +51,21 @@ export interface WorkOrder {
   escalation: string;
   /** 입력에 없어 «모름»으로 채운 키. */
   unknownFields: string[];
+  /**
+   * 선행 항목별 관측 — 지시서가 선행을 배열로 적었을 때만 있다(문자열 한 줄이면 종전 그대로 없다).
+   * 항목마다 조회된 상태와 그 상태를 조회한 시각을 보존하고, 조회하지 않은 값은 «모름»이다.
+   */
+  dependencies?: WorkOrderDependency[];
+}
+
+/** 선행 칸 하나의 관측 — 칸 이름 ⊕ 조회된 상태 ⊕ 그 상태를 본 시각. */
+export interface WorkOrderDependency {
+  /** 선행 칸 id(또는 칸 이름). */
+  cell: string;
+  /** 조회된 상태(yellow·green·red …) — 조회하지 않았으면 «모름». */
+  state: string;
+  /** 상태를 조회한 시각(ISO 8601) — 조회하지 않았으면 «모름». */
+  observedAt: string;
 }
 
 export type ParseWorkOrderResult = { ok: true; order: WorkOrder } | { ok: false; reason: string };
@@ -63,6 +79,26 @@ function cellText(value: unknown): string {
   catch { return WORK_ORDER_UNKNOWN; }
 }
 
+/**
+ * 선행 칸을 항목별 관측으로 읽는다 — 배열 원소가 객체면 `state`·`observedAt` 을 보존하고,
+ * 이름만 적힌 항목(문자열 등)은 조회하지 않은 것이므로 상태·시각 모두 «모름»으로 둔다.
+ * 선행 칸이 배열이 아니면(문자열 한 줄·없음) 항목 목록은 비어 있다 — 종전 문면 그대로다.
+ */
+function parseDependencies(value: unknown): WorkOrderDependency[] {
+  if (!Array.isArray(value)) return [];
+  return value.map((item) => {
+    if (item && typeof item === 'object' && !Array.isArray(item)) {
+      const record = item as Record<string, unknown>;
+      return {
+        cell: cellText(record['cell'] ?? record['cellId']),
+        state: cellText(record['state']),
+        observedAt: cellText(record['observedAt']),
+      };
+    }
+    return { cell: cellText(item), state: WORK_ORDER_UNKNOWN, observedAt: WORK_ORDER_UNKNOWN };
+  });
+}
+
 /**
  * 지시서 JSON 원문을 검증한다. 깨진 JSON 은 `JSON 이 깨졌다: …`, 칸 id(문자열)가 없으면 `칸 id 가 없다`
  * 하나로 거부하고, 그 밖의 빠진 칸은 «모름»으로 채운다(거부 아님).
@@ -84,7 +120,21 @@ export function parseWorkOrder(source: string): ParseWorkOrderResult {
     if (value == null || (typeof value === 'string' && !value.trim())) unknownFields.push(field);
     cells[field] = text;
   }
-  return { ok: true, order: { cellId: rawCellId.trim(), ...cells, unknownFields } };
+  const dependencies = parseDependencies(record['peers']);
+  return {
+    ok: true,
+    order: {
+      cellId: rawCellId.trim(), ...cells,
+      ...(dependencies.length ? { dependencies } : {}),
+      unknownFields,
+    },
+  };
+}
+
+/** 선행 항목별 «상태 ⊕ 조회 시각» 한 줄 — 이름만 있는 항목은 «모름 (관측 모름)»으로 드러난다. */
+function renderDependencies(dependencies: WorkOrderDependency[]): string {
+  const items = dependencies.map((dep) => `${dep.cell}=${dep.state} (관측 ${dep.observedAt})`);
+  return `선행 상태: ${items.join(' · ')}`;
 }
 
 /** 검증된 지시서를 사람이 읽는 골 문면으로 펼친다 — 첫 줄 «대상 경로:»(경계), 둘째 줄 «현재 계약:». */
@@ -99,6 +149,7 @@ export function renderWorkOrderGoal(order: WorkOrder): string {
     `판정 신호: ${order.verdictSignal}`,
     `예산: ${order.budget}`,
     `선행·짝 칸: ${order.peers}`,
+    ...(order.dependencies?.length ? [renderDependencies(order.dependencies)] : []),
     `선례: ${order.precedents}`,
     `올림 규칙: ${order.escalation}`,
   ].join('\n');

package/src/task-orchestrator/dispatcher.ts

@@ -32,6 +32,7 @@ import {
   type AcceptanceReport,
 } from './acceptance.js';
 import { recordOpsEventSafe, type OpsEventInput } from '../domains/ops-log.js';
+import { defaultAnomalyCluster, extractContainerExit, type AnomalyCluster } from '../loops/orchestrator/anomaly-cluster.js';
 
 // ───────────────────────── Concurrency caps ────────────────────────
 
@@ -82,6 +83,9 @@ export interface DispatcherOptions {
    *  acceptance.checks reference fs or subprocess (file-exists /
    *  file-contains / shell-zero). */
   acceptanceIo?: AcceptanceIo;
+  /** ANOMALY-CLUSTER — grouping state written at the failure record point; while a signature has 3+ runs
+   *  and no cause verdict, relaunches of that goal·host are deferred instead of spawned. */
+  anomalyCluster?: AnomalyCluster;
 }
 
 export interface DispatchTickResult {
@@ -95,7 +99,7 @@ export interface DispatchTickResult {
   }>;
   /** Ready tasks we skipped this tick due to caps. Caller may `tick()`
    *  again after any adapter completes. */
-  deferred: Array<{ taskId: string; reason: 'cap' | 'no-adapter' | 'intake-sequential' }>;
+  deferred: Array<{ taskId: string; reason: 'cap' | 'no-adapter' | 'intake-sequential' | 'anomaly-hold' }>;
 }
 
 export class TaskDispatcher {
@@ -103,10 +107,13 @@ export class TaskDispatcher {
   private readonly activeByKind = new Map<TaskSurfaceKind, number>();
   private readonly abortByTask = new Map<string, AbortController>();
   private readonly now: () => number;
+  /** Production default is the process-wide cluster so tick-recorded failures gate relaunch here. */
+  private readonly anomaly: AnomalyCluster;
 
   constructor(private readonly opts: DispatcherOptions) {
     this.caps = { ...DEFAULT_CONCURRENCY_CAPS, ...(opts.concurrencyCaps ?? {}) };
     this.now = opts.now ?? Date.now;
+    this.anomaly = opts.anomalyCluster ?? defaultAnomalyCluster();
   }
 
   /**
@@ -147,6 +154,12 @@ export class TaskDispatcher {
         deferred.push({ taskId: task.id, reason: 'cap' });
         continue;
       }
+      // ANOMALY-CLUSTER relaunch gate: the task's goal·host relaunch is deferred while its signature has
+      // 3+ runs and no cause verdict has cleared it. Goal = task id, host = surface kind.
+      if (this.anomaly.hold(task.id, kind).hold) {
+        deferred.push({ taskId: task.id, reason: 'anomaly-hold' });
+        continue;
+      }
       const result = this.spawn(task, adapter);
       dispatched.push({
         taskId: task.id,
@@ -220,6 +233,24 @@ export class TaskDispatcher {
     }
   }
 
+  /** Records one failed attempt into the anomaly cluster (goal·host key, host excluded from signature). */
+  private recordAnomalyFailure(task: Task, observation: { runId: string; kind: string; stage: string; lastLines: string[] }): void {
+    try {
+      this.anomaly.record({
+        goal: task.id,
+        host: task.surface.kind,
+        runId: observation.runId,
+        kind: observation.kind,
+        containerExit: extractContainerExit(observation.lastLines.join('\n')),
+        stage: observation.stage,
+        lastLines: observation.lastLines,
+        at: new Date(this.now()).toISOString(),
+      });
+    } catch {
+      // Observability must not alter dispatch admission or completion.
+    }
+  }
+
   private recordOpsEvent(input: OpsEventInput): void {
     try {
       (this.opts.recordOpsEvent ?? recordOpsEventSafe)(input);
@@ -322,6 +353,8 @@ export class TaskDispatcher {
         this.recordOps(task, 'cycle_end', nextStatus, { execStatus: exec.status, durationMs: exec.durationMs });
 
         if (nextStatus === 'done') {
+          // Cause verdict — the same goal·host produced a clean run, so the relaunch hold is cleared.
+          this.anomaly.release(task.id, kind, '원인 판정: 실행이 정상 완료됨');
           this.opts.bus?.emit({
             kind: 'task-completed',
             taskId: task.id,
@@ -337,6 +370,12 @@ export class TaskDispatcher {
             reason: 'user',
           });
         } else {
+          this.recordAnomalyFailure(task, {
+            runId: exec.id,
+            kind: exec.status === 'timeout' ? 'timeout' : 'exit',
+            stage: 'monitor',
+            lastLines: [exec.error?.message ?? '', `Reason: ${exec.error?.code ?? 'UNKNOWN'}`],
+          });
           this.opts.bus?.emit({
             kind: 'task-failed',
             taskId: task.id,
@@ -368,6 +407,12 @@ export class TaskDispatcher {
         this.opts.store?.saveTask(this.opts.graph.getTask(task.id)!);
       } catch { /* ignore illegal transition */ }
       this.recordOps(task, 'cycle_end', 'failed', { errorCode: 'ADAPTER_ERROR', error: err instanceof Error ? err.message.slice(0, 120) : String(err) });
+      this.recordAnomalyFailure(task, {
+        runId: res.executionId,
+        kind: 'adapter-error',
+        stage: 'monitor',
+        lastLines: [err instanceof Error ? err.message : String(err)],
+      });
       this.opts.bus?.emit({
         kind: 'task-failed',
         taskId: task.id,

package/src/task-orchestrator/generator-prompt.ts

@@ -82,6 +82,8 @@ export function buildDecomposePrompt(
 
   const lines: string[] = [];
   const isGoalAuthorCoarse = opts.profile === 'goal-author-coarse';
+  const measuredDeviceInventory = input.context?.activeSummary?.match(/^Device inventory \(measured at goal-author repository root\): .*$/mu)?.[0];
+  const measuredDevice = measuredDeviceInventory?.match(/^Device inventory \(measured at goal-author repository root\): (missing|existing): (src\/ux-sim\/[^\s,]+)$/u);
   lines.push(
     'You are the monad-agent Task Orchestrator decomposition planner.',
     isGoalAuthorCoarse
@@ -205,6 +207,10 @@ export function buildDecomposePrompt(
       '## Device-first decomposition (DEVICE-FIRST-AUTHORING — follow strictly)',
       '### Existing device inventory (read from this checkout; use these names before proposing a new device)',
       ...deviceInventory(),
+      ...(measuredDeviceInventory
+        ? ['### Goal-author device check (measured at the target root; takes precedence over checkout inventory)',
+          measuredDeviceInventory,
+          ...(measuredDevice ? [`- Use the measured ${measuredDevice[1]} status for ${measuredDevice[2]} instead of this checkout's inventory when choosing the device branch.`] : [])] : []),
       '- The objective\'s verification plan (검증 계획/TDD) section picks a stage and ladder tier (무대·층) — e.g. a `src/ux-sim/*` stage at L2 (fake-llm·fake-bin·fake-clock). BEFORE writing slices, CHECK whether the mock device or injected event definition that this verification plan needs ALREADY EXISTS: look in `src/ux-sim/*`, the §1 device table of `docs/manual/MANUAL-ux-simulation-devices-2026-08-23.md`, and the event-monkey event kinds.',
       '- Two branches — exactly one applies per needed device:',
       '  - Device EXISTS: its name MUST go into the verification plan wording — the slice that tests the feature carries the device\'s exact name (device file / §1 table row / event kind) in its acceptance criteria and reuses the device; never re-create it.',

package/src/task-orchestrator/surfaces/pod-artifact-return.ts

@@ -7,6 +7,8 @@ import { fromJsonl, type LogRecord } from '../../mss/logging/record.js';
 
 const FILE_LIMIT = 5 * 1024 * 1024;
 const TOTAL_LIMIT = 20 * 1024 * 1024;
+export const POD_SALVAGE_BUNDLE_FILE_LIMIT = 160 * 1024 * 1024;
+export const POD_SALVAGE_BUNDLE_TOTAL_LIMIT = 180 * 1024 * 1024;
 
 type Artifact = { path: string; bytes: Buffer };
 type Incomplete = { path: string; reason: string };
@@ -50,13 +52,16 @@ export function parsePodArtifactChunks(logs: string): ParseResult {
   }
   const artifacts: Artifact[] = [];
   const error: Incomplete[] = [];
-  let bytesSoFar = 0;
+  let artifactBytes = 0;
+  let salvageBundleBytes = 0;
   for (const [token, group] of groups) {
     let path = token;
     let reason = group.reason;
     try {
       path = decodePath(token);
       if (!safeRelativePath(path)) throw new Error('unsafe relative path');
+      const salvageBundle = /^pod-salvage\/[a-zA-Z0-9._-]+\.bundle$/.test(path);
+      const fileLimit = salvageBundle ? POD_SALVAGE_BUNDLE_FILE_LIMIT : FILE_LIMIT;
       if (!reason && group.chunks.size !== group.total) reason = 'missing chunk';
       if (!reason) {
         let encoded = '';
@@ -64,15 +69,20 @@ export function parsePodArtifactChunks(logs: string): ParseResult {
           const chunk = group.chunks.get(i);
           if (!chunk) { reason = 'missing chunk'; break; }
           encoded += chunk;
-          if (encoded.length > 8 * 1024 * 1024) { reason = 'file too large'; break; }
+          if (encoded.length > Math.ceil(fileLimit * 4 / 3) + 1024 * 1024) { reason = 'file too large'; break; }
         }
         if (!reason) {
           const compressed = Buffer.from(encoded, 'base64');
           if (compressed.toString('base64') !== encoded) throw new Error('invalid base64');
-          const bytes = gunzipSync(compressed, { maxOutputLength: FILE_LIMIT + 1 });
-          if (bytes.length > FILE_LIMIT) reason = 'file too large';
-          else if (bytesSoFar + bytes.length > TOTAL_LIMIT) reason = 'total too large';
-          else { artifacts.push({ path, bytes }); bytesSoFar += bytes.length; }
+          const bytes = gunzipSync(compressed, { maxOutputLength: fileLimit + 1 });
+          if (bytes.length > fileLimit) reason = 'file too large';
+          else if ((salvageBundle ? salvageBundleBytes : artifactBytes) + bytes.length >
+            (salvageBundle ? POD_SALVAGE_BUNDLE_TOTAL_LIMIT : TOTAL_LIMIT)) reason = 'total too large';
+          else {
+            artifacts.push({ path, bytes });
+            if (salvageBundle) salvageBundleBytes += bytes.length;
+            else artifactBytes += bytes.length;
+          }
         }
       }
     } catch (e) { reason = e instanceof Error ? e.message : String(e); }

package/src/task-orchestrator/surfaces/pod-ledger-collect.ts

@@ -14,6 +14,7 @@ type ParseResult = Ledger[] | { error: Incomplete[]; ledgers: Ledger[] };
 const NON_PROGRESS_EVENTS = new Set(['progress-delivery-outcome']);
 const REEMIT_EXCLUDED_PREFIX = 'progress-delivery';
 type Emit = (category: string, event: string, data: Record<string, unknown>) => void;
+export interface PodLedgerMeasurement { ledgerRead: boolean; activityMeasured: boolean }
 /** Heal-loop starter seam — defaults to the real `startHealLoop` inside `recordFailureEvent`. */
 type StartHealLoop = Parameters<typeof recordFailureEvent>[2];
 
@@ -174,7 +175,7 @@ export function createPodLedgerFollower(opts: {
   stallMinutes?: number;
   now?: () => number;
   onStall?: (message: string) => void;
-}): { poll(): void; readonly owned: boolean } {
+}): { poll(): PodLedgerMeasurement; readonly owned: boolean } {
   const dir = opts.dir ?? runLedgerDir();
   const log = opts.log ?? defaultPodReemit();
   const emit: Emit = opts.emit ?? defaultPodReemit();
@@ -208,17 +209,17 @@ export function createPodLedgerFollower(opts: {
   return {
     get owned() { return owned; },
     poll() {
-      if (disabled) return;
+      if (disabled) return { ledgerRead: true, activityMeasured: false };
       if (!owned && existsSync(path)) {
         disabled = true;
         log('self-implement.pod', 'ledger-live-skipped', { runId: opts.runId, reason: 'host-ledger-exists' });
-        return;
+        return { ledgerRead: true, activityMeasured: false };
       }
       const since = `${Math.floor(lastActivityMeasuredAt / 1000)}.${String(lastActivityMeasuredAt % 1000).padStart(3, '0')}`;
       const measurementStartedAt = now();
       const until = `${Math.floor(measurementStartedAt / 1000)}.${String(measurementStartedAt % 1000).padStart(3, '0')}`;
       const r = opts.exec(`s="\${ELANOUS_STATE_DIR:-$HOME/.elanous}"; f="$s/run-ledger/${opts.runId}.jsonl"; w="$s/worktrees"; if [ -f "$f" ]; then tail -c +${offset + 1} "$f" || exit 1; fi; target=''; matches=0; for tree in "$w"/*/*.worktrees/*; do [ -e "$tree/.git" ] || continue; owner=$(git -C "$tree" config --worktree --get elanous.harness.owner 2>/dev/null) || continue; [ "$owner" = 'dev:${opts.runId}' ] || continue; target="$tree"; matches=$((matches + 1)); done; if [ "$matches" -eq 1 ]; then activity=$(find "$target" -type d \\( -name .git -o -name node_modules \\) -prune -o -type f -newermt '@${since}' ! -newermt '@${until}' -printf . 2>/dev/null) && printf '\\nELANOUS_ACTIVITY %s\\n' "\${#activity}" || printf '\\nELANOUS_ACTIVITY_ERROR\\n'; else printf '\\nELANOUS_ACTIVITY_ERROR\\n'; fi`);
-      if (r.status !== 0) { log('self-implement.pod', 'ledger-live-unavailable', { runId: opts.runId, status: r.status, stderr: r.stderr.trim().slice(0, 200) }); checkStall(false, false); return; }
+      if (r.status !== 0) { log('self-implement.pod', 'ledger-live-unavailable', { runId: opts.runId, status: r.status, stderr: r.stderr.trim().slice(0, 200) }); checkStall(false, false); return { ledgerRead: false, activityMeasured: false }; }
       const marker = r.stdout.lastIndexOf('\nELANOUS_ACTIVITY');
       const activityLine = marker < 0 ? '' : r.stdout.slice(marker + 1);
       const activityMatch = /^ELANOUS_ACTIVITY (0|[1-9]\d*)\n$/.exec(activityLine);
@@ -241,11 +242,11 @@ export function createPodLedgerFollower(opts: {
           }
         }
       }
-      if (!ledgerBytes) { checkStall(true, activityMeasured); return; }
+      if (!ledgerBytes) { checkStall(true, activityMeasured); return { ledgerRead: true, activityMeasured }; }
       offset += Buffer.byteLength(ledgerBytes);
       const text = pending + ledgerBytes;
       const cut = text.lastIndexOf('\n');
-      if (cut < 0) { pending = text; checkStall(true, activityMeasured); return; }
+      if (cut < 0) { pending = text; checkStall(true, activityMeasured); return { ledgerRead: true, activityMeasured }; }
       const complete = text.slice(0, cut + 1);
       pending = text.slice(cut + 1);
       mkdirSync(dir, { recursive: true });
@@ -278,6 +279,7 @@ export function createPodLedgerFollower(opts: {
         nextStallMinute = stallMinutes;
       }
       checkStall(true, activityMeasured);
+      return { ledgerRead: true, activityMeasured };
     },
   };
 }