elanous 0.2.35 → 0.2.36

package/src/harness/control-inbox.ts

@@ -448,6 +448,18 @@ function consumeRecord(
     return;
   }
   messages.push(message);
+  // A Pod sender asks for this exact record's acknowledgement before publishing
+  // it. Missing ack is safe: delivery has happened, but the sender must report
+  // read state as unobserved rather than infer it from file disappearance.
+  if (existsSync(`${recordPath}.ack-request`)) {
+    // Rename consumes the request atomically. If the sender already removed it,
+    // this cannot leave a late ack file after the sender's cleanup.
+    try { renameSync(`${recordPath}.ack-request`, `${recordPath}.ack`); }
+    catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
+        logger(opts)('control-inbox', 'memo-ack-failed', { spaceId, path: recordPath, reason: String(error) });
+    }
+  }
 }
 
 /** Inspect existing ready records without claiming, deleting, or creating any inbox entry. */
@@ -541,7 +553,43 @@ export function cleanupStaleControlInbox(spaceId: string, maxAgeMs: number, opts
       restoreClaim(claimPath, recordPath, spaceId, opts);
     }
   }
-  logger(opts)('control-inbox', 'cleanup', { spaceId, path, maxAgeMs, count });
+  // A sender killed without an EXIT trap can leave receipt markers behind.
+  // Its wait is capped at 60s; keep at least two minutes before sweeping only
+  // markers whose exact record no longer exists. Never infer a read from cleanup.
+  let markerCount = 0;
+  let tempCount = 0;
+  let markerNames: string[] = [];
+  try { markerNames = readdirSync(ready); } catch { /* absent ready directory */ }
+  const markerCutoff = Date.now() - Math.max(maxAgeMs, 120_000);
+  for (const name of markerNames) {
+    // Only the Pod publisher's mktemp shape; local enqueue has a different name.
+    if (/^\.write-[A-Za-z0-9]{8}$/.test(name)) {
+      const tempPath = join(ready, name);
+      try {
+        if (statSync(tempPath).mtimeMs > markerCutoff) continue;
+        rmSync(tempPath);
+        tempCount += 1;
+      } catch (error) {
+        if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
+          logger(opts)('control-inbox', 'cleanup-temp-failed', { spaceId, path: tempPath, reason: String(error) });
+      }
+      continue;
+    }
+    const suffix = name.endsWith('.ack-request') ? '.ack-request' : name.endsWith('.ack') ? '.ack' : null;
+    if (!suffix) continue;
+    const recordName = name.slice(0, -suffix.length);
+    if (!isReadyRecord(recordName) || existsSync(join(ready, recordName))) continue;
+    const markerPath = join(ready, name);
+    try {
+      if (statSync(markerPath).mtimeMs > markerCutoff) continue;
+      rmSync(markerPath);
+      markerCount += 1;
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== 'ENOENT')
+        logger(opts)('control-inbox', 'cleanup-marker-failed', { spaceId, path: markerPath, reason: String(error) });
+    }
+  }
+  logger(opts)('control-inbox', 'cleanup', { spaceId, path, maxAgeMs, count, markerCount, tempCount });
   return count;
 }
 

package/src/harness/harness-cli-command.ts

@@ -20,7 +20,7 @@ import { runGitCommand } from '../git-fs/runner.js';
 import { GOAL_TYPES, lintGoalFile, parseGoalId, parseGoalType, resolveGoalAuthorGrade, tracedPathReferences, type GoalAuthorGrade, type GoalAuthorGradeSelection, type GoalType } from '../self-implement/goal-author.js';
 import { templateForGoalType } from '../self-implement/graph-templates.js';
 import { appendRunLedgerEntry, listRunLedgers, loadFederatedRunLedger, loadRunLedger, queryRunScreenKey, runLedgerDir, type RunLedgerEntry, type RunLedgerMatch, type RunLedgerWriter } from '../self-implement/run-ledger.js';
-import { classifyPodExit, type PodExitClass } from '../task-orchestrator/surfaces/pod-failure-reason.js';
+import { classifyPodExit, parsePodTermination, type PodExitClass, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 import type { PodChildEvidence } from '../task-orchestrator/surfaces/self-implement.js';
 import { classifyPodExitStop, readRunStopRecord, recordRunStop, runStopRecorded, RUN_STOP_EVENT } from '../self-implement/run-stop.js';
 import { captureStopKnowhowCandidate } from '../self-implement/stop-autoheal.js';
@@ -419,7 +419,7 @@ function resolveLaunchSubstrate(opts: HarnessSubstrateOpts): ResolvedHarnessSubs
 }
 type PodExit = { status: number | null; signal?: string | null };
 type PodExitReason = 'signal' | 'human-stop' | 'supervisor' | 'no-launch' | 'unknown' | 'preflight-refused'
-  | 'pod-error' | 'launch-gate-blocked' | 'ENOBUFS' | 'OOMKilled';
+  | 'pod-error' | 'launch-gate-blocked' | 'dep-blocked' | 'ENOBUFS' | 'OOMKilled';
 
 function unknownPodExitTailReason(output: string): PodExitReason | undefined {
   const tail = output.slice(-16_000);
@@ -427,6 +427,7 @@ function unknownPodExitTailReason(output: string): PodExitReason | undefined {
   if (/\bENOBUFS\b/i.test(tail)) return 'ENOBUFS';
   if (/launch gate[^\r\n]*blocked|blocked[^\r\n]*launch gate/i.test(tail)) return 'launch-gate-blocked';
   if (/\bpod-error\b/i.test(tail)) return 'pod-error';
+  if (/\b(?:DEP_FAILED|DEPENDENCY_NEEDS_HUMAN|DEP_BLOCKED_REBASE_READY)\b/.test(tail)) return 'dep-blocked';
   return undefined;
 }
 /** GitHub lists at most this many files for one pull request; a list that reaches it is not provably complete. */
@@ -575,7 +576,9 @@ export function recordClassifiedHarnessPodExit(runId: string | undefined, reason
   context: { entrance?: string; seat?: string; output?: string } = {}): void {
   if (!runId) return;
   try {
-    const childEvidence = reason === 'preflight-refused' ? undefined : latestPodChildEvidence(loadRunLedger(runId));
+    const ledger = reason === 'preflight-refused' ? undefined : loadRunLedger(runId);
+    const childEvidence = latestPodChildEvidence(ledger);
+    const podTermination = latestPodTermination(ledger);
     const signal = status > 128
       ? Object.entries(osConstants.signals).find(([, number]) => number === status - 128)?.[0] ?? null : null;
     const cwd = process.cwd();
@@ -586,17 +589,42 @@ export function recordClassifiedHarnessPodExit(runId: string | undefined, reason
       cwd: `${basename(dirname(cwd))}/${basename(cwd)}`, hostname: hostname().split('.')[0]!, pid: process.pid,
       ...(context.output ? { lastLines: incidentLastLines(context.output) } : {}),
       ...(childEvidence ? { childEvidence } : {}),
+      ...(podTermination ? { podTermination } : {}),
     }, effectiveInstanceRoot());
   } catch { /* incident writes cannot change Pod output or exit */ }
 }
 
-function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | undefined): PodChildEvidence | undefined {
+/**
+ * The current attempt's `pod-child-evidence` rows (same job · childRunId as the last `pod-child-run`), oldest first.
+ * Also fenced by position: only rows written after that start count, so a reused job/childRunId pair cannot
+ * hand an earlier attempt's row (childEvidence or podTermination) to a later one.
+ */
+function currentPodChildEvidenceRows(entries: readonly RunLedgerEntry[] | null | undefined): { job: string; rows: Record<string, unknown>[] } | undefined {
   // The current attempt's start is the fence. An earlier Pod's terminal facts cannot
   // classify a later attempt when that attempt has no JSON or its ledger write failed.
-  const current = entries?.filter((entry) => entry.event === 'pod-child-run').at(-1)?.data;
+  let startIndex = -1;
+  entries?.forEach((entry, index) => { if (entry.event === 'pod-child-run') startIndex = index; });
+  const current = startIndex >= 0 ? entries![startIndex]!.data : undefined;
   if (typeof current?.job !== 'string' || typeof current.childRunId !== 'string') return undefined;
-  const data = entries?.filter((entry) => entry.event === 'pod-child-evidence'
-    && entry.data?.job === current.job && entry.data?.childRunId === current.childRunId).at(-1)?.data;
+  const rows = (entries ?? []).filter((entry, index) => index > startIndex && entry.event === 'pod-child-evidence'
+    && entry.data?.job === current.job && entry.data?.childRunId === current.childRunId).map((entry) => entry.data);
+  return { job: current.job, rows };
+}
+
+/** JOB-FAILURE-TERMINATION-CAPTURE — the current attempt's latest well-formed capture of its own Job (a later
+ *  evidence row of the same attempt without one does not drop it); another Job's or round's never crosses over. */
+function latestPodTermination(entries: readonly RunLedgerEntry[] | null | undefined): PodTermination | undefined {
+  const current = currentPodChildEvidenceRows(entries);
+  if (!current) return undefined;
+  for (const row of current.rows.slice().reverse()) {
+    const parsed = parsePodTermination(row.podTermination, current.job);
+    if (parsed) return parsed;
+  }
+  return undefined;
+}
+
+function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | undefined): PodChildEvidence | undefined {
+  const data = currentPodChildEvidenceRows(entries)?.rows.at(-1);
   const evidence = data?.childEvidence;
   if (!evidence || typeof evidence !== 'object' || Array.isArray(evidence)) return undefined;
   const row = evidence as Record<string, unknown>;
@@ -604,6 +632,8 @@ function latestPodChildEvidence(entries: readonly RunLedgerEntry[] | null | unde
   if (('scopeEscape' in row && row.scopeEscape !== true)
     || ('goalCauseObserved' in row && row.goalCauseObserved !== true)
     || ('classification' in row && typeof row.classification !== 'string')
+    || ('newScope' in row && !Array.isArray(row.newScope))
+    || ('scopeStopReasons' in row && !Array.isArray(row.scopeStopReasons))
     || ('abandonedClassification' in row && !object(row.abandonedClassification))
     || ('accountAvailability' in row && !object(row.accountAvailability))) return undefined;
   return row as PodChildEvidence;
@@ -783,6 +813,14 @@ export function recordHarnessPodStop(
     if (ledger?.some((entry) => entry.event === RUN_STOP_EVENT)) return false;
     const childEvidence = latestPodChildEvidence(ledger);
     const scopeEscape = childEvidence?.scopeEscape === true;
+    // SCOPE-ESCAPE-AS-REFINE — out-of-scope edits without a stop reason are «new scope», not a scope-escape stop.
+    if (childEvidence?.newScope?.length || childEvidence?.scopeStopReasons?.length) {
+      try {
+        debug.log('harness.pod', scopeEscape ? 'scope-escape-stop' : 'scope-new-scope', { runId, scopeEscape,
+          ...(childEvidence.newScope ? { newScope: childEvidence.newScope } : {}),
+          ...(childEvidence.scopeStopReasons ? { scopeStopReasons: childEvidence.scopeStopReasons } : {}) });
+      } catch { /* observation cannot change the stop record */ }
+    }
     if (classified.reason === 'preflight-refused') {
       (deps.record ?? recordRunStop)({
         runId, site: 'preflight', class: 'launch-failed',
@@ -3538,7 +3576,13 @@ export function installHarnessCliCommand(program: Command, deps: HarnessCliComma
   if (say) {
     registerHarnessAskSayOptions(harnessCmd.command('say <sentence...>').description('문장을 받아 구동한다'))
       .addOption(new Option('--author-grade <grade>', 'say 저작 등급 (full|lite)').choices(['full', 'lite']))
+      .option('--move-id <id>', 'NEXTMOVE-GENERAL-RELAUNCH-MOVEID — 이 발사를 고른 TA next-move 결정의 수 id(관측 조인 칸 · 발사 동작은 바꾸지 않는다)')
       .action(async (sentence: string[], opts: HarnessAskSayChildLlmOptions & HarnessDryRunOpts) => {
+        const moveId = (opts as { moveId?: unknown }).moveId;
+        // 발사 쪽 영수증 — TA 일반 재발사가 실은 수 id 를 받았다는 한 줄(관측만 · fail-soft · 옵션은 아래로 내려가지 않는다).
+        if (typeof moveId === 'string' && moveId) {
+          try { debug.log('harness', 'move-id-received', { entrance: 'cli-harness-say', moveId }); } catch { /* fail-soft */ }
+        }
         const repair = opts as HarnessSubstrateOpts;
         if (repair.repairCommitOnly !== undefined && (repair.substrate !== 'pod' || !/^pr:[1-9]\d*$/.test(repair.source ?? '')
           || !/^[0-9a-f]{40}$/.test(repair.repairCommitOnly) || repair.autoMerge !== false || repair.target !== undefined)) {

package/src/harness/harness-incidents.ts

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { redactSecretText } from '../debug/log.js';
 import { refuseProductionLedgerWriteInTest } from './ledger-write-guard.js';
 import type { PodChildEvidence } from '../task-orchestrator/surfaces/self-implement.js';
+import { parsePodTermination, type PodTermination } from '../task-orchestrator/surfaces/pod-failure-reason.js';
 
 export interface RunExit {
   runId: string;
@@ -18,6 +19,14 @@ export interface RunExit {
   pid?: number;
   lastLines?: string[];
   childEvidence?: PodChildEvidence;
+  /** JOB-FAILURE-TERMINATION-CAPTURE — the current attempt's Job/Pod termination facts, captured before GC. */
+  podTermination?: PodTermination;
+  /** INCIDENT-REASON-FROM-LASTLINES — 기록된 reason 이 unknown 이라 lastLines 로 다시 분류했으면 원래 값. */
+  recordedReason?: string;
+  /** reason 을 어디서 얻었나 — 'lastLines' 면 위 분류 규칙으로 정했다(기록 원문은 recordedReason). */
+  reasonSource?: 'lastLines';
+  /** lastLines 에 ux-sim 장치 조각 경로가 보였다 — 장치 먼저 조각의 실패를 따로 셀 수 있게. */
+  slice?: 'device';
 }
 
 export interface IncidentBurst {
@@ -44,6 +53,40 @@ function kstDate(at: number): string {
   return new Date(at + KST_OFFSET_MS).toISOString().slice(0, 10);
 }
 
+// ── INCIDENT-REASON-FROM-LASTLINES (0.2.36 · 10-22 · OP 대응 피처) ───────────────────────────────
+// 기록된 reason 이 «unknown» 인데 마지막 출력 줄에 사유가 그대로 있는 사고가 다수(10-22 경보) — 읽는 쪽에서
+// 결정론으로 다시 분류한다. 우선순위 = 더 구체적인 종료 사유 먼저. 아무것도 안 맞으면 unknown 그대로(추측 0).
+const LAST_LINE_REASONS: ReadonlyArray<[RegExp, string]> = [
+  // 근본 원인 먼저 — 뒤 조각의 DEPENDENCY_NEEDS_HUMAN 은 앞 조각 실패의 «증상»이라 맨 뒤 쪽.
+  [/goal-elaboration needs-human:\s*goal-elaboration-ungrounded-path\b/, 'goal-elaboration-ungrounded-path'],
+  [/goal-elaboration needs-human:\s*goal-elaboration-protected-path\b/, 'goal-elaboration-protected-path'],
+  [/goal-elaboration needs-human:\s*goal-elaboration-scope-conflict\b/, 'goal-elaboration-scope-conflict'],
+  [/goal-elaboration needs-human:\s*goal-elaboration-fixed-layer-conflict\b/, 'goal-elaboration-fixed-layer-conflict'],
+  [/pod-deadline-exceeded|DeadlineExceeded/, 'pod-deadline-exceeded'],
+  [/GOAL_DONE_BOUNDARY_MISSING/, 'goal-done-boundary-missing'],
+  [/BackoffLimitExceeded/, 'pod-backoff-limit'],
+  [/childError=no-resul/, 'pod-child-no-result'],
+  [/pod-job-failed/, 'pod-job-failed'],
+  [/DEPENDENCY_NEEDS_HUMAN/, 'dependency-needs-human'],
+  [/\[needs-human\]|needs-human/, 'needs-human'],
+];
+const DEVICE_SLICE_PATH = /src\/ux-sim\/[\w.-]*-device(?:\.test)?\.ts|DEVICE-FIRST/;
+
+/** lastLines 에서 종료 사유를 꺼낸다 — 안 맞으면 null(unknown 유지). */
+export function classifyIncidentReasonFromLastLines(lines: readonly string[] | undefined): string | null {
+  if (!lines?.length) return null;
+  const text = lines.join('\n');
+  for (const [pattern, reason] of LAST_LINE_REASONS) if (pattern.test(text)) return reason;
+  return null;
+}
+
+function refinedReasonFields(reason: string, lines: readonly string[] | undefined): Pick<RunExit, 'reason' | 'recordedReason' | 'reasonSource' | 'slice'> {
+  const slice = lines?.some((line) => DEVICE_SLICE_PATH.test(line)) ? { slice: 'device' as const } : {};
+  if (reason !== 'unknown') return { reason, ...slice };
+  const refined = classifyIncidentReasonFromLastLines(lines);
+  return refined ? { reason: refined, recordedReason: reason, reasonSource: 'lastLines', ...slice } : { reason, ...slice };
+}
+
 /** Read only recorded exits. Missing ledgers are not evidence that no runs failed. */
 export function readRunExits(root: string): RunExit[] {
   const dir = join(root, 'incidents');
@@ -71,7 +114,8 @@ export function readRunExits(root: string): RunExit[] {
         || !(row.status === null || typeof row.status === 'number')
         || !(row.signal === null || typeof row.signal === 'string')) continue;
       seen.add(row.runId);
-      rows.push({ runId: row.runId, reason: row.reason, status: row.status, signal: row.signal, at: row.at,
+      const lines = Array.isArray(row.lastLines) && row.lastLines.every((line) => typeof line === 'string') ? row.lastLines : undefined;
+      rows.push({ runId: row.runId, ...refinedReasonFields(row.reason, lines), status: row.status, signal: row.signal, at: row.at,
         ...(typeof row.entrance === 'string' ? { entrance: row.entrance } : {}),
         ...(typeof row.seat === 'string' ? { seat: row.seat } : {}),
         ...(typeof row.cwd === 'string' ? { cwd: row.cwd } : {}),
@@ -81,12 +125,19 @@ export function readRunExits(root: string): RunExit[] {
           ? { lastLines: row.lastLines } : {}),
         ...(row.childEvidence && typeof row.childEvidence === 'object' && !Array.isArray(row.childEvidence)
           ? { childEvidence: row.childEvidence } : {}),
+        ...podTerminationField(row.podTermination),
       });
     }
   }
   return rows.sort((a, b) => Date.parse(a.at) - Date.parse(b.at) || a.runId.localeCompare(b.runId));
 }
 
+function podTerminationField(value: unknown): { podTermination?: PodTermination } {
+  const job = value && typeof value === 'object' && !Array.isArray(value) ? (value as Record<string, unknown>).job : undefined;
+  const parsed = typeof job === 'string' ? parsePodTermination(value, job) : undefined;
+  return parsed ? { podTermination: parsed } : {};
+}
+
 /** SQLite's process-owned write lock serializes ledger checks and appends across processes. */
 export function recordRunExit(row: RunExit, root: string): void {
   if (refuseProductionLedgerWriteInTest(root, 'incidents')) return;

package/src/harness/pod-control-send.ts

@@ -2,6 +2,14 @@ import { encodeControlMemoFrame, type ControlMemoPayload } from './control-inbox
 import type { PodFragmentRecord } from './self-send-target.js';
 import { defaultKubectl, type Kubectl } from '../task-orchestrator/surfaces/self-implement-pod.js';
 
+const POD_CONTROL_KUBECTL_TIMEOUT_MS = 120_000;
+
+export function parsePodReadWait(value: string | number): number {
+  const parsed = typeof value === 'string' && !value.trim() ? Number.NaN : Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 60) throw new Error('self send --read-wait는 0~60초의 유한한 값이어야 합니다');
+  return Math.floor(parsed);
+}
+
 const PUBLISH = `set -eu
 inbox="$1"
 kind="$2"
@@ -9,9 +17,24 @@ IFS= read -r line
 mkdir -p "\${inbox}.ready"
 if [ "$kind" = memo ]; then
   temp=$(mktemp "\${inbox}.ready/.write-XXXXXXXX")
-  trap 'rm -f "$temp"' EXIT
+  record=''
+  cleanup_memo() {
+    rm -f "$temp"
+    if [ -n "$record" ]; then rm -f "$record.ack-request" "$record.ack"; fi
+  }
+  trap 'cleanup_memo' EXIT
+  trap 'exit 129' HUP
+  trap 'exit 130' INT
+  trap 'exit 143' TERM
   printf 'memo:%s\\n' "$line" > "$temp"
-  mv "$temp" "\${inbox}.ready/record-$(printf '%016x' "$(date +%s%3N)")-$(cat /proc/sys/kernel/random/uuid)"
+  record="\${inbox}.ready/record-$(printf '%016x' "$(date +%s%3N)")-$(cat /proc/sys/kernel/random/uuid)"
+  : > "$record.ack-request"
+  mv "$temp" "$record"
+  printf 'ELANOUS_POD_MEMO_PUBLISHED %s\\n' "\${record##*/}"
+  count=0
+  while [ ! -e "$record.ack" ] && [ "$count" -lt "$3" ]; do sleep 1; count=$((count + 1)); done
+  if [ -e "$record.ack" ]; then printf 'ELANOUS_POD_MEMO_READ %s\\n' "\${record##*/}"
+  else printf 'ELANOUS_POD_MEMO_UNVERIFIED %s\\n' "\${record##*/}"; fi
 else
   temp=$(mktemp "\${inbox}.ready/.write-XXXXXXXX")
   trap 'rm -f "$temp"' EXIT
@@ -25,13 +48,18 @@ else
 fi`;
 
 /** Publish a control-inbox record inside the child container, not on the host. */
-export function sendPodControl(record: PodFragmentRecord, message: { stop: true } | { memo: ControlMemoPayload }, kubectl: Kubectl = defaultKubectl): void {
+export function sendPodControl(record: PodFragmentRecord, message: { stop: true } | { memo: ControlMemoPayload }, kubectl: Kubectl = defaultKubectl,
+  readWaitSeconds = 0): { memoRecord?: string; read?: boolean } {
   const stop = 'stop' in message;
   const input = stop ? 'stop\n' : `${encodeControlMemoFrame(message.memo)}\n`;
   const result = kubectl([
     ...(record.context ? ['--context', record.context] : []), '-n', record.namespace,
     'exec', '-i', `job/${record.job}`, '-c', 'child', '--',
-    'sh', '-c', PUBLISH, 'pod-control', record.inboxDir, stop ? 'stop' : 'memo',
-  ], input);
+    'sh', '-c', PUBLISH, 'pod-control', record.inboxDir, stop ? 'stop' : 'memo', String(parsePodReadWait(readWaitSeconds)),
+  ], input, POD_CONTROL_KUBECTL_TIMEOUT_MS);
   if (result.status !== 0) throw new Error(`Pod ${record.job} control send 실패: ${result.stderr.trim() || 'kubectl exec failed'}`);
+  if (stop) return {};
+  const published = /^ELANOUS_POD_MEMO_PUBLISHED (record-[0-9a-f-]+)$/m.exec(result.stdout)?.[1];
+  if (!published) return {};
+  return { memoRecord: published, read: result.stdout.includes(`ELANOUS_POD_MEMO_READ ${published}`) };
 }

package/src/harness/self-send-remote.ts

@@ -0,0 +1,69 @@
+import { readTaskAgentState, shellQuote, taskAgentStatePath, type TaskCard } from '../task-agent/task-hand.js';
+import { defaultSshRunner, remoteLedgerMirrorDir, type SshRunner } from '../task-agent/parent-host.js';
+import { loadRunLedger } from '../self-implement/run-ledger.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { normalizeRunId } from './harness-space.js';
+import { parsePodReadWait } from './pod-control-send.js';
+import { SELF_SEND_LOCAL_ONLY_ENV } from './self-send-routing-guard.js';
+
+export interface RemotePodRunCard extends Pick<TaskCard, 'id' | 'runId' | 'runChildId' | 'parentHost'>, Partial<Pick<TaskCard, 'status'>> {}
+
+export class RemotePodOwnershipAmbiguousError extends Error {
+  override name = 'RemotePodOwnershipAmbiguousError';
+}
+
+export function remotePodControlForOptions(opts: { stop?: boolean; memo?: string; readWait?: string }): { stop: true } | { memo: string; readWait: string } {
+  if (Boolean(opts.stop) === (opts.memo !== undefined)) throw new Error('self send에는 --stop 또는 --memo 한 가지만 필요합니다');
+  if (opts.stop) return { stop: true };
+  if (!opts.memo || /[\r\n]/.test(opts.memo)) throw new Error('control inbox memo must be a non-empty single line');
+  return { memo: opts.memo, readWait: String(parsePodReadWait(opts.readWait ?? '10')) };
+}
+
+/** Resolve only an exact card parent or a child recorded under that parent. */
+export function remotePodCardForRun(runId: string, cards: readonly RemotePodRunCard[],
+  children: (card: RemotePodRunCard) => readonly string[]): RemotePodRunCard | null {
+  if (runId !== normalizeRunId(runId)) return null;
+  const active = cards.filter((card) => card.parentHost?.host && card.runId
+    && (card.status === undefined || card.status === 'launched'));
+  const direct = active.filter((card) => card.parentHost?.host && card.runId
+    && (card.runId === runId || card.runChildId === runId));
+  const mirrored = active.filter((card) => children(card).includes(runId));
+  const matches = [...new Map([...direct, ...mirrored].map((card) => [card.id, card])).values()];
+  if (matches.length > 1) throw new RemotePodOwnershipAmbiguousError(`self send 원격 런 소유 카드가 여러 개입니다: ${runId} (${matches.map((card) => card.id).join(', ')})`);
+  return matches[0] ?? null;
+}
+
+/** A missing child mirror is a possible explanation, never proof of ownership. */
+export function remoteChildOwnershipUnconfirmed(card: RemotePodRunCard | null, cards: readonly RemotePodRunCard[]): boolean {
+  return !card && cards.filter((candidate) => candidate.parentHost?.host && candidate.runId && !candidate.runChildId
+    && (candidate.status === undefined || candidate.status === 'launched')).length === 1;
+}
+
+export function findRemotePodCardForRun(runId: string): { card: RemotePodRunCard | null; remoteChildUnconfirmed: boolean } {
+  const cards = Object.values(readTaskAgentState<{ tasks?: Record<string, TaskCard> }>(taskAgentStatePath()).tasks ?? {});
+  const card = remotePodCardForRun(runId, cards, (card) => {
+    if (!card.runId || !card.parentHost?.host) return [];
+    const ledger = loadRunLedger(card.runId, remoteLedgerMirrorDir(effectiveInstanceRoot(), card.parentHost.host)) ?? [];
+    return ledger.filter((entry) => entry.event === 'pod-child-run')
+      .map((entry) => entry.data.childRunId).filter((value): value is string => typeof value === 'string');
+  });
+  return { card, remoteChildUnconfirmed: remoteChildOwnershipUnconfirmed(card, cards) };
+}
+
+export function sendRemotePodRun(card: RemotePodRunCard, runId: string, control: { memo: string; readWait: string } | { stop: true },
+  ssh: SshRunner = defaultSshRunner): { stdout: string; stderr: string } {
+  const host = card.parentHost?.host;
+  if (!host || !/^[A-Za-z0-9][A-Za-z0-9._@-]{0,127}$/.test(host) || runId !== normalizeRunId(runId))
+    throw new Error(`self send 원격 런 대상이 유효하지 않습니다: ${runId}`);
+  const binary = '$HOME/.local/share/elanous/bin/elanous';
+  const configDir = card.parentHost?.configDir ? shellQuote(card.parentHost.configDir) : '$HOME/.elanous';
+  const args = control.stop ? '--stop' : `--memo ${shellQuote(control.memo)} --read-wait ${shellQuote(control.readWait)}`;
+  const script = `${SELF_SEND_LOCAL_ONLY_ENV}=1 ${binary} --config-dir ${configDir} self send --run ${shellQuote(runId)} ${args}`;
+  const wait = 'memo' in control ? Number(control.readWait) : 0;
+  // The remote kubectl call has a 120s ceiling; SSH must outlive it and CLI startup.
+  const result = ssh(host, script, Math.max(150_000, (Number.isFinite(wait) ? Math.max(0, wait) : 0) * 1_000 + 90_000));
+  if (result.status !== 0) throw new Error(`self send 원격 Pod 전달 실패 (${host}, ${runId}, rc=${result.status ?? 'unknown'}): ${result.stderr.trim() || result.stdout.trim() || '원격 응답 없음'}`);
+  const podReceipt = control.stop ? 'Pod 조각에 soft stop 기록:' : 'Pod 조각에 감독 메모 기록:';
+  if (!result.stdout.includes(podReceipt)) throw new Error(`self send 원격 Pod 전달 미확인 (${host}, ${runId}): ${result.stdout.trim() || '원격 Pod 영수증 없음'}`);
+  return { stdout: result.stdout, stderr: result.stderr };
+}

package/src/harness/self-send-routing-guard.ts

@@ -0,0 +1,6 @@
+export const SELF_SEND_LOCAL_ONLY_ENV = 'ELANOUS_SELF_SEND_LOCAL_ONLY';
+
+/** A remote child must resolve its own Pod fragment without starting another SSH hop. */
+export function mayLookupRemotePodRun(env: NodeJS.ProcessEnv): boolean {
+  return env[SELF_SEND_LOCAL_ONLY_ENV] !== '1';
+}

package/src/harness/self-send-target.ts

@@ -69,14 +69,15 @@ export function finishPodFragment(spaceId: string, env?: NodeJS.ProcessEnv): voi
   }
 }
 
-export function dispatchPodSelfSend(spaceId: string, message: { stop: true } | { memo: ControlMemoPayload }, kubectl?: Kubectl, env?: NodeJS.ProcessEnv): { job: string } | null {
+export function dispatchPodSelfSend(spaceId: string, message: { stop: true } | { memo: ControlMemoPayload }, kubectl?: Kubectl, env?: NodeJS.ProcessEnv,
+  readWaitSeconds = 0): { job: string; memoRecord?: string; read?: boolean } | null {
   const record = readPodFragment(spaceId, env);
   if (!record) {
     if (podFragmentFinished(spaceId, env)) throw new Error(`self send 대상 조각이 이미 끝났다: ${spaceId}`);
     return null;
   }
-  sendPodControl(record, message, kubectl);
-  return { job: record.job };
+  const receipt = sendPodControl(record, message, kubectl, readWaitSeconds);
+  return { job: record.job, ...receipt };
 }
 
 export type SelfSendTargetResolution =