elanous 0.2.25 → 0.2.27

package/src/self-implement/self-implement-runtime.ts

@@ -456,11 +456,36 @@ function parseGoals(req: SelfImplementRuntimeRequest): string[] | undefined {
   return goals;
 }
 
-function formatOrchestrationResults(results: readonly SelfDevJobResult[]): string {
+interface SelfImplementGoalResult {
+  goal: string;
+  status: SelfDevJobResult['status'];
+  runId?: string;
+  stage?: string;
+  reason?: string;
+  parentPrNumber?: number;
+}
+
+function observedGoalResults(results: readonly SelfDevJobResult[]): SelfImplementGoalResult[] {
+  return results.map((result, index) => ({
+    goal: result.feature || `골 ${index + 1}`,
+    status: result.status,
+    ...(result.runId ? { runId: result.runId } : {}),
+    ...(result.stage ? { stage: result.stage } : {}),
+    ...(result.error?.message || result.stopReason || result.blockReason
+      ? { reason: result.error?.message || result.stopReason || (result.blockReason === 'parent-unlanded'
+        ? result.parentPrNumber ? `선행 PR #${result.parentPrNumber} 미착지` : '선행 골 미착지'
+        : result.blockReason) }
+      : {}),
+    ...(result.parentPrNumber ? { parentPrNumber: result.parentPrNumber } : {}),
+  }));
+}
+
+function formatOrchestrationResults(results: readonly SelfDevJobResult[], goals: readonly SelfImplementGoalResult[]): string {
   const done = results.filter(result => result.status === 'done').length;
   const merged = results.filter(result => result.merged).length;
   const failed = results.filter(result => result.status === 'failed').length;
-  return `[self-implement] parallel ${results.length} goal · done ${done}${merged ? ` (병합 ${merged})` : ''}${failed ? ` · 실패 ${failed}` : ''}`;
+  const summary = `[self-implement] parallel ${results.length} goal · done ${done}${merged ? ` (병합 ${merged})` : ''}${failed ? ` · 실패 ${failed}` : ''}`;
+  return [summary, ...goals.map(goal => `- ${goal.goal}: ${goal.status} · 런 ${goal.runId ?? '미관측'}${goal.stage ? ` · 단계 ${goal.stage}` : ''}${goal.reason ? ` · 이유 ${goal.reason}` : ''}`)].join('\n');
 }
 
 export function resolveDocumentReferences(paths: readonly string[], repositoryRoot = process.cwd()): DocumentReferenceStatus[] {
@@ -476,7 +501,15 @@ function documentReferenceStatusLines(references: readonly DocumentReferenceStat
 
 function formatResult(feature: string, r: SelfImplementResult, references: readonly DocumentReferenceStatus[] = []): string {
   const head = `[self-implement] ${r.stage}`;
-  const lines: string[] = [head, ...documentReferenceStatusLines(references)];
+  const next = r.runId ? `eln self run ${r.runId}` : r.ok ? 'eln self running-runs' : '실패 이유를 확인한 뒤 다시 요청';
+  const lines: string[] = [
+    r.ok
+      ? r.runId
+        ? `하니스가 맡았습니다 · 런 ${r.runId} · 노드 ${r.node || '미관측'} · 다음 조회: ${next} · 이 턴에서 파일을 직접 편집하지 마세요`
+        : `하니스 응답을 받았지만 런 식별자는 아직 미관측입니다 · 진행 중 런 조회: ${next} · 일치하는 런이 없으면 요청을 다시 보내세요 · 이 턴에서 파일을 직접 편집하지 마세요`
+      : `하니스가 발사되지 않았거나 실패했습니다: ${r.detail ?? r.stage} · 다음: ${next} · 이 턴에서 파일을 직접 편집하지 마세요`,
+    head, ...documentReferenceStatusLines(references),
+  ];
   if (r.branch) lines.push(`branch: ${r.branch}`);
   if (r.worktreePath) lines.push(`worktree: ${r.worktreePath}`);
   if (r.stage === 'pr-opened' && r.prUrl) {
@@ -494,6 +527,12 @@ function formatResult(feature: string, r: SelfImplementResult, references: reado
 export interface SelfImplementRunResult {
   output: string;
   ok: boolean;
+  kind: 'launched' | 'observed-only' | 'failed' | 'pending';
+  next?: string;
+  reason?: string;
+  missing?: string[];
+  /** 병렬 골마다 실제로 관측된 종료 상태·식별자·이유. */
+  goalResults?: SelfImplementGoalResult[];
   // ⛔ 관측 전용 반환에는 **단계가 없다** — 아무 노드도 돌지 않았다. 없는 것을 있는 값으로 적으면
   //   «안 돌았다» 와 «어느 단계에서 끝났다» 가 같은 값이 된다(부재와 미지를 같은 값으로 적지 않는다).
   stage?: SelfImplementResult['stage'];
@@ -506,8 +545,10 @@ export interface SelfImplementRunResult {
   observed?: true;
   /** 명시적 Fabric 분해의 상태·기존 3결말·미산출 사유. */
   fabricDecomposition?: FabricDecompositionOutcome;
-  /** 즉시 반환 모드에서 할당한 런 식별자. 블로킹 기본 경로에는 없어 기존 반환 모양을 보존한다. */
+  /** 실제 런 결과에서 확인한 식별자. 선할당된 비동기 ID는 반환하지 않는다. */
   runId?: string;
+  /** 비동기 요청 조회용 상관 ID. 발사된 런의 증거가 아니다. */
+  requestId?: string;
   /** 호출이 블로킹인지 비블로킹인지. 기본 경로에는 없어 기존 반환 모양을 보존한다. */
   invocationMode?: 'blocking' | 'non-blocking';
 }
@@ -516,6 +557,7 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
   id: 'self_implement',
   spec: buildSelfImplementSpec(),
   async run(req, ctx: ToolRuntimeContext): Promise<SelfImplementRunResult> {
+    try {
     const hasFeature = req.feature !== undefined;
     const hasGoals = req.goals !== undefined;
     if (hasFeature === hasGoals) {
@@ -604,7 +646,7 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
     if (observeOnly.enabled) {
       const requestSummary = feature ?? goals!.join(' · ');
       debug.log('self-implement', 'runtime.observed', { surface: ctx.surface, ...(feature ? { feature: feature.slice(0, 120) } : { goals: goals!.length }), observeOnly: observeOnly.enabled, observeOnlySource: observeOnly.source });
-      return { output: `SelfImplement 관측 전용 측정 모드 — 호출이 접수되어 기록되었습니다. 이 세션에서는 구현을 진행하지 않습니다. 같은 요청을 이 턴에서 직접 구현하지 말고 응답을 마무리하세요: ${requestSummary.slice(0, 120)}${documentReferenceStatusLines(documentReferences).length ? `\n${documentReferenceStatusLines(documentReferences).join('\n')}` : ''}`, ok: true, observed: true };
+      return { output: `관측 전용이라 런을 발사하지 않았습니다 · 코드도 안 바꿨습니다 · 이 결과를 구현 실패로 읽고 직접 Write/Edit 하지 마세요. 실제 발사를 원하면 관측 전용 모드를 끈 뒤 다시 요청하세요: ${requestSummary.slice(0, 120)}${documentReferenceStatusLines(documentReferences).length ? `\n${documentReferenceStatusLines(documentReferences).join('\n')}` : ''}`, ok: true, kind: 'observed-only', observed: true, missing: ['runId', 'node'], next: '관측 전용 모드를 끈 뒤 다시 요청' };
     }
 
     const allocatedRunId = nonBlocking ? mintRunId() : undefined;
@@ -637,9 +679,14 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
           fabricDecomposition = fabricDecompositionOutcome(fabricResult);
           observeFabricDecomposition(fabricDecomposition, ctx.surface, fabricResult.status === 'decomposed' ? fabricResult.goals.length : undefined);
           if (fabricResult.status !== 'decomposed') {
+            const observedOnly = fabricDecomposition.outcome !== 'llm-failed';
             return {
-              output: formatFabricDecompositionOutcome(fabricDecomposition),
-              ok: fabricDecomposition.outcome !== 'llm-failed',
+              output: `${formatFabricDecompositionOutcome(fabricDecomposition)}${observedOnly ? '\n관측 전용이라 런을 발사하지 않았습니다 · 코드도 안 바꿨습니다 · 이 결과를 구현 실패로 읽고 직접 Write/Edit 하지 마세요.' : '\n이 턴에서 파일을 직접 편집하지 마세요.'}`,
+              ok: observedOnly,
+              kind: observedOnly ? 'observed-only' : 'failed',
+              next: observedOnly ? '분해 결과를 확인하고 구현 골을 다시 요청' : '분해 실패 이유를 확인한 뒤 다시 요청',
+              missing: ['runId', 'node'],
+              ...(observedOnly ? { observed: true as const } : { reason: formatFabricDecompositionOutcome(fabricDecomposition) }),
               fabricDecomposition,
             };
           }
@@ -674,10 +721,40 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
         ...(forwardedSupervise === undefined ? {} : { supervise: forwardedSupervise }),
         ...(deliverable === undefined ? {} : { deliverable }),
       });
-      const failed = results.filter(result => result.status === 'failed').length;
+      const goalResults = observedGoalResults(results);
+      const failedGoals = goalResults.filter(result => result.status === 'failed' || result.status === 'cancelled');
+      const blockedGoals = goalResults.filter(result => result.status === 'blocked');
+      const allRunsIdentified = goalResults.length > 0 && goalResults.every(result => result.runId);
+      const kind = goalResults.length === 0 || failedGoals.length > 0 || blockedGoals.length > 0 ? 'failed' : allRunsIdentified ? 'launched' : 'pending';
+      const parentBlockedPrNumbers = [...new Set(results.flatMap(result => result.status === 'blocked' && result.blockReason === 'parent-unlanded' && result.parentPrNumber ? [result.parentPrNumber] : []))];
+      const parentBlockedWithoutPr = results.some(result => result.status === 'blocked' && result.blockReason === 'parent-unlanded' && !result.parentPrNumber && !result.runId);
+      const otherFailureWithoutId = results.some(result => !result.runId && ['failed', 'cancelled', 'blocked'].includes(result.status) && result.blockReason !== 'parent-unlanded');
+      const runQueries = [...new Set(goalResults.flatMap(result => result.runId ? [`eln self run ${result.runId}`] : []))];
+      const availableQueries = [
+        ...parentBlockedPrNumbers.map(pr => `eln gh pr view ${pr}`),
+        ...runQueries,
+      ];
+      const pendingWithoutId = goalResults.some(result => !result.runId && !['failed', 'cancelled', 'blocked'].includes(result.status));
+      const next = [
+        ...availableQueries,
+        ...(pendingWithoutId ? ['eln self running-runs', '일치하는 런이 없으면 ID 미확정 골을 다시 요청'] : []),
+        ...(parentBlockedPrNumbers.length ? ['선행 PR 착지 뒤 차단된 골을 재실행하세요'] : []),
+        ...(parentBlockedWithoutPr ? ['선행 골 상태를 확인한 뒤 해당 골을 재실행하세요'] : []),
+        ...(otherFailureWithoutId ? ['실패·차단 이유를 확인한 뒤 해당 골을 다시 요청'] : []),
+      ].join('\n') || '골 결과가 0건이라 상태를 확인한 뒤 다시 요청';
+      const reason = goalResults.length === 0
+        ? '골 결과가 0건이라 상태 미관측'
+        : [...failedGoals, ...blockedGoals].map(result => `${result.goal}: ${result.reason ?? '이유 미관측'}`).join('; ');
       return {
-        output: formatOrchestrationResults(results),
-        ok: failed === 0,
+        output: formatOrchestrationResults(results, goalResults)
+          + (kind === 'failed' ? `\n실패/차단: ${reason} · 다음: ${next}` : `\n다음 조회: ${next}`)
+          + '\n이 턴에서 파일을 직접 편집하지 마세요',
+        ok: kind !== 'failed',
+        kind,
+        next,
+        missing: [ ...(goalResults.length === 0 || goalResults.some(result => !result.runId) ? ['runId'] : []), 'node' ],
+        goalResults,
+        ...(kind === 'failed' ? { reason } : {}),
         ...(fabricDecomposition ? { fabricDecomposition } : {}),
       };
     }
@@ -751,12 +828,12 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
       ...(runId ? { runId } : {}),
     }, { pipelineDeps });
     if (!outcome.ok) {
-      return { output: withGoalAuthorFailure(`[self-implement] failed: ${outcome.message}`), ok: false };
+      return { output: withGoalAuthorFailure(`하니스가 발사되지 않았거나 실패했습니다: ${outcome.message} · 다음: 실패 이유를 확인한 뒤 다시 요청하세요 · 이 턴에서 파일을 직접 편집하지 마세요`), ok: false, kind: 'failed', reason: outcome.message, next: '실패 이유를 확인한 뒤 다시 요청', missing: ['runId', 'node'] };
     }
     if (outcome.kind !== 'self') {
       return {
-        output: withGoalAuthorFailure('[self-implement] observed by central CLI'),
-        ok: true,
+        output: withGoalAuthorFailure('관측 전용이라 런을 발사하지 않았습니다 · 코드도 안 바꿨습니다 · 이 결과를 구현 실패로 읽고 직접 Write/Edit 하지 마세요'),
+        ok: true, kind: 'observed-only', observed: true, missing: ['runId', 'node'], next: '관측 전용 모드를 끈 뒤 다시 요청',
       };
     }
 
@@ -764,6 +841,11 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
     return {
       output: withGoalAuthorFailure(formatResult(feature, result, documentReferences)),
       ok: result.ok,
+      kind: result.ok ? (result.runId ? 'launched' : 'pending') : 'failed',
+      next: result.runId ? `eln self run ${result.runId}` : result.ok ? 'eln self running-runs' : '실패 이유를 확인한 뒤 다시 요청',
+      missing: [...(result.runId ? [] : ['runId']), ...(result.node ? [] : ['node'])],
+      ...(!result.ok ? { reason: result.detail ?? result.stage } : {}),
+      runId: result.runId,
       stage: result.stage,
       node: result.node,
       ...(result.prUrl ? { prUrl: result.prUrl } : {}),
@@ -775,28 +857,51 @@ export const selfImplementRuntime: ToolRuntime<SelfImplementRuntimeRequest, Self
 
     if (nonBlocking) {
       const runId = allocatedRunId ?? mintRunId();
+      const requestId = runId;
+      const lookup = `eln logs --category self-implement --event runtime.non-blocking-completed,runtime.non-blocking-failed --grep ${requestId} --since 3h --all --include-test`;
       void drive(runId).then(
         (result) => {
-          debug.log('self-implement', 'runtime.non-blocking-completed', {
-            runId,
+          debug.log('self-implement', result.kind === 'failed' ? 'runtime.non-blocking-failed' : 'runtime.non-blocking-completed', {
+            requestId,
+            kind: result.kind,
+            ...(result.runId ? { runId: result.runId } : {}),
+            ...(result.reason ? { reason: result.reason } : {}),
+            next: result.next ?? '요청 결과를 확인한 뒤 다시 요청',
             ok: result.ok,
             ...(result.stage === undefined ? {} : { stage: result.stage }),
-          });
+          }, result.kind === 'failed' ? { level: 'warn' } : undefined);
         },
         (error) => {
+          const reason = error instanceof Error ? error.message : String(error);
           debug.log('self-implement', 'runtime.non-blocking-failed', {
-            runId,
-            error: error instanceof Error ? error.message : String(error),
+            requestId,
+            kind: 'failed',
+            reason,
+            next: '요청과 실패 이유를 확인한 뒤 다시 요청',
           }, { level: 'warn' });
         },
       );
       return {
         ok: true,
-        runId,
+        kind: 'pending',
         invocationMode: 'non-blocking',
-        output: `[self-implement] non-blocking accepted\nrunId: ${runId}`,
+        requestId,
+        next: lookup,
+        missing: ['runId', 'node'],
+        output: `하니스 요청을 접수했습니다 · 런과 노드는 아직 미관측 · 요청 ID ${requestId}(발사 증거 아님) · 다음 조회: ${lookup} · 이 턴에서 파일을 직접 편집하지 마세요\n[self-implement] non-blocking pending`,
+      };
+    }
+    return await drive();
+    } catch (error) {
+      const reason = error instanceof Error ? error.message : String(error);
+      return {
+        ok: false,
+        kind: 'failed',
+        reason,
+        next: '요청과 실패 이유를 확인한 뒤 다시 요청',
+        missing: ['runId', 'node'],
+        output: `SelfImplement 실패: ${reason} · 다음: 요청과 실패 이유를 확인한 뒤 다시 요청 · 이 턴에서 파일을 직접 편집하지 마세요`,
       };
     }
-    return drive();
   },
 };

package/src/session/index.ts

@@ -142,10 +142,20 @@ function migrateLegacySessions(): void {
 }
 
 function stateRoot(): string {
-  const base = process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.trim()
-    ? process.env.XDG_STATE_HOME
-    : join(homedir(), '.local', 'state');
-  return join(base, 'elanous');
+  const universe = process.env.ELANOUS_STATE_DIR?.trim();
+  const root = universe
+    ? join(universe, 'elanous')
+    : join(
+      process.env.XDG_STATE_HOME && process.env.XDG_STATE_HOME.trim()
+        ? process.env.XDG_STATE_HOME
+        : join(homedir(), '.local', 'state'),
+      'elanous',
+    );
+  try {
+    const { debug } = require('../debug/log.js') as typeof import('../debug/log.js');
+    debug.log('session.active', 'pointer-root', { root, universe });
+  } catch { /* 관측 실패가 포인터 경로 결정을 막지 않는다 */ }
+  return root;
 }
 
 function indexPath(root: string = sessionRoot()): string { return join(root, 'index.json'); }

package/src/session-runtime/index.ts

@@ -4,6 +4,7 @@ import { getUserConfig } from '../user-config.js';
 import { resolve } from 'node:path';
 import type { ModelFamily } from '../models/prompts.js';
 import type { InputSourceKind, InputSourceRef } from '../input/input-source-kind.js';
+import type { ControlTurnIntent, SubmitTurnIntent } from '../input/input-intent.js';
 import { getSessionCwd } from '../session/working-dir.js';
 import {
   armQuickControlOnce,
@@ -22,6 +23,7 @@ import {
 import type { LLMMessage, LLMToolSpec } from '../llm.js';
 import type { LLMToolDef } from '../plugins/core/types.js';
 import type { ToolRunResult, ToolRuntime } from '../tool-runtime/types.js';
+import { blockWriteToolSearchHydration, type ToolSearchRunResult } from '../tool-runtime/tool-search-runtime.js';
 import { findNativeTool, isNativeToolModelExposed } from '../native-tool-catalog.js';
 import { hasAstGrep } from '../skills/tools/ast-grep.js';
 import { buildOmniSearchTool, omniSearchAvailable } from '../skills/tools/omni-search.js';
@@ -1731,6 +1733,8 @@ const ESSENTIAL_NATIVE_RULE_IDS = [
   'agent', 'agent-output', 'agent-reply', 'agent-stop', 'agent-list', 'self-implement', 'self-orchestrate', 'dev-harness',
 ] as const;
 const ESSENTIAL_HOST_FAMILY_IDS = ['self-ops', 'release-read'] as const;
+// Keep this TUI essential addition out of the shared control/agent self-ops family.
+const ESSENTIAL_HOST_EXTRA_NAMES = ['logs_query'] as const;
 const ESSENTIAL_RUNTIME_FAMILY_IDS = ['bash', 'run-shell', 'pty-shell', 'run-tests', 'elanous_skills_list', 'skill_exec', 'code-grounding'] as const;
 const ESSENTIAL_OPTIONAL_TOOL_NAMES = [
   'GetDashboardState',
@@ -1764,7 +1768,11 @@ function buildEssentialSessionRuntimeToolSpecs(opts: {
         .filter((tool): tool is LLMToolDef => !!tool)
         .map(toSpec)
       : [];
-  });
+  }).concat(ESSENTIAL_HOST_EXTRA_NAMES
+    .filter(name => isToolAvailable(name, opts.toolAvailability))
+    .map(name => hostByName.get(name))
+    .filter((tool): tool is LLMToolDef => !!tool)
+    .map(toSpec));
   const runtimeById = new Map(opts.runtimeTools.map(tool => [tool.id, tool] as const));
   const runtimeSpecs = ESSENTIAL_RUNTIME_FAMILY_IDS.flatMap(id => {
     const rule = RUNTIME_TOOL_FAMILY_RULE_MAP.get(id);
@@ -1833,12 +1841,23 @@ export function buildSessionRuntimeToolSpecs(opts: {
   // toolset (incident 2026-05-04 — Opus replied "no file tools in this
   // session" while Bash was actually exposed at position 7+).
   const finalSpecs: LLMToolSpec[] = opts.rich === false
-    ? buildEssentialSessionRuntimeToolSpecs({
-        hostTools: opts.hostTools,
-        runtimeTools: opts.runtimeTools ?? [],
-        optionalTools: opts.optionalTools ?? [],
-        toolAvailability: opts.toolAvailability,
-      })
+    ? (() => {
+        const essentialSpecs = buildEssentialSessionRuntimeToolSpecs({
+          hostTools: opts.hostTools,
+          runtimeTools: opts.runtimeTools ?? [],
+          optionalTools: opts.optionalTools ?? [],
+          toolAvailability: opts.toolAvailability,
+        });
+        if (!hasDevHarnessIntent(opts.userText)) return essentialSpecs;
+        const droppedNames = new Set(['Edit', 'Write']);
+        const filteredSpecs = essentialSpecs.filter(spec => !droppedNames.has(spec.name));
+        if (filteredSpecs.length !== essentialSpecs.length) {
+          debug.log('session-runtime.tools', 'harness-phrase-write-tools-dropped', {
+            dropped: ['Edit', 'Write'],
+          });
+        }
+        return filteredSpecs;
+      })()
     : [
         ...dynamicNativeTools,
         ...hostSpecs,
@@ -2084,6 +2103,10 @@ export async function dispatchSessionRuntimeTool(
   args: Record<string, unknown>,
   deps: SessionRuntimeDispatchDeps,
 ): Promise<unknown> {
+  const finishRuntimeResult = (result: unknown): unknown =>
+    name === 'ToolSearch' && isDevHarnessIntent(deps.userText ?? '')
+      ? blockWriteToolSearchHydration(result as ToolSearchRunResult)
+      : result;
   // Fix W-bis (2026-04-25): codex family always enables scoped-analysis
   // mode regardless of userText vocabulary. Rationale (see docs/RESEARCH-
   // codex-reread-pathology-2refs-2026-04-25.md): codex's search-heavy
@@ -2178,8 +2201,9 @@ export async function dispatchSessionRuntimeTool(
   const nativeRuntime = nativeRule?.preferRuntime ? deps.getToolRuntime(name) : undefined;
   if (nativeRuntime) {
     const result = await deps.dispatchToolRuntime(name, normalizedArgs, deps.toolCallId);
-    rememberCandidateListingResult(name, normalizedArgs, result, scopedAnalysis, deps.searchPlannerState);
-    return result;
+    const safeResult = finishRuntimeResult(result);
+    rememberCandidateListingResult(name, normalizedArgs, safeResult, scopedAnalysis, deps.searchPlannerState);
+    return safeResult;
   }
   if (nativeRule?.dispatch) {
     let result: unknown;
@@ -2213,8 +2237,9 @@ export async function dispatchSessionRuntimeTool(
     const isPtyTool = name.startsWith('PtyShell') || name.startsWith('pty_shell');
     if (!isPtyTool || deps.ptyDashboardOn) {
       const result = await deps.dispatchToolRuntime(name, normalizedArgs, deps.toolCallId);
-      rememberCandidateListingResult(name, normalizedArgs, result, scopedAnalysis, deps.searchPlannerState);
-      return result;
+      const safeResult = finishRuntimeResult(result);
+      rememberCandidateListingResult(name, normalizedArgs, safeResult, scopedAnalysis, deps.searchPlannerState);
+      return safeResult;
     }
   }
 
@@ -2699,6 +2724,25 @@ function hasDevHarnessIntent(text: string): boolean {
   return hasAny(text, DEV_HARNESS_INTENT_TERMS);
 }
 
+export function isDevHarnessIntent(text: string): boolean {
+  return hasDevHarnessIntent(text);
+}
+
+/** The dashboard calls this immediately after submitIntent resolution. A
+ * fixed plain turn becomes the same control turn used by `/harness ask`, so
+ * the model dispatch branch is never reached for that turn. */
+export function routeDevHarnessSubmitIntent(
+  intent: SubmitTurnIntent | ControlTurnIntent,
+): SubmitTurnIntent | ControlTurnIntent {
+  if (intent.kind !== 'submit-turn' || intent.route !== 'plain' || !isDevHarnessIntent(intent.text)) return intent;
+  return {
+    kind: 'control-turn',
+    source: intent.source,
+    command: 'slash-command',
+    commandText: `/harness ask ${intent.text}`,
+  };
+}
+
 export function shouldExposeDevHarnessSessionTool(text: string): boolean {
   return isDevHarnessModelSurfaceEnabled() && hasDevHarnessIntent(text);
 }

package/src/task-agent/cover.ts

@@ -32,7 +32,10 @@ export interface TaskAgentCoverInput {
   /** null means the pending-landing age source could not be read; [] means no pending landings. */
   pendingLandingAgeSeconds?: readonly number[] | null;
   /** A source reached the query safety limit; its aggregate is not known to be complete. */
-  truncated?: { taskAgentActions: boolean; allLands: boolean };
+  truncated?: { taskAgentActions: boolean; allLands: boolean; goalAsks?: boolean; goalRuns?: boolean };
+  /** Completed authoring provenance and terminal goal records. undefined = not wired; null = unreadable. */
+  goalAsks?: readonly { authorRunId: string; goalId: string }[] | null;
+  goalRuns?: readonly { goalId: string; outcome: string; stage?: string }[] | null;
 }
 
 export type LandingFailureReason = 'load' | 'oom' | 'time-limit' | 'conflict' | 'review' | 'other';
@@ -161,22 +164,22 @@ export function formatTaskAgentCover(row: CoverRow): string {
 /** 7동사의 이름 — 리뷰·착지·수리·검증·저작·구현·정리 (decision·deliver 는 7동사 밖이라 세지 않는다). */
 export type SevenVerbName = '리뷰' | '착지' | '수리' | '검증' | '저작' | '구현' | '정리';
 
-/** no-source 는 출처 배선이 아직 없는 동사 · unreadable 은 TASK-AGENT 행동 원장을 못 읽은 것이다. */
+/** no-source 는 출처 배선이 없는 동사 · unreadable 은 해당 동사의 원천을 완전히 못 읽은 것이다. */
 export type SevenVerbState = 'live' | 'shadow-only' | 'none' | 'no-source' | 'unreadable';
 
 /** 7동사 출처 표의 한 칸 — source 는 그 동사를 관측하는 TASK-AGENT action kind, null 이면 출처가 아직 없다. */
 export interface SevenVerbSource {
   verb: SevenVerbName;
-  source: Exclude<NextActionKind, 'decision' | 'deliver'> | null;
+  source: Exclude<NextActionKind, 'decision' | 'deliver'> | 'goal-ask+goal-run' | null;
 }
 
-/** TA-THEME-VERBS-LIVE — 7동사와 출처 표(코드로 고정). 저작·구현·정리의 출처 배선은 다음 조각. */
+/** TA-THEME-VERBS-LIVE — 저작은 완료 골 조인; 구현·정리는 아직 출처가 없다. */
 export const SEVEN_VERB_SOURCES: readonly SevenVerbSource[] = [
   { verb: '리뷰', source: 'review' },
   { verb: '착지', source: 'land' },
   { verb: '수리', source: 'retry' },
   { verb: '검증', source: 'green' },
-  { verb: '저작', source: null },
+  { verb: '저작', source: 'goal-ask+goal-run' },
   { verb: '구현', source: null },
   { verb: '정리', source: null },
 ];
@@ -197,12 +200,21 @@ export interface SevenVerbLive {
   measuredVerbs: number;
 }
 
-/** live = 창 안에 result done 인 non-shadow 사건 ≥1. 원장이 null 이거나 절단되었으면 전부 unreadable. */
+/** 행동 동사는 창 안의 done, 저작은 완료한 저작 원장과 착지 골의 조인. 각 출처의 null·절단은 해당 동사만 unreadable. */
 export function measureSevenVerbLive(input: TaskAgentCoverInput): SevenVerbLive {
   const unreadable = input.taskAgentActions === null || input.truncated?.taskAgentActions === true;
   const verbs = SEVEN_VERB_SOURCES.map(({ verb, source }): SevenVerbLiveRow => {
-    if (unreadable) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
     if (source === null) return { verb, source: null, liveDone: null, shadow: null, state: 'no-source' };
+    if (source !== 'goal-ask+goal-run' && unreadable) return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+    if (source === 'goal-ask+goal-run') {
+      if (input.goalAsks == null || input.goalRuns == null || input.truncated?.goalAsks || input.truncated?.goalRuns) {
+        return { verb, source, liveDone: null, shadow: null, state: 'unreadable' };
+      }
+      const landed = new Set(input.goalRuns.filter((run) =>
+        run.stage === 'merged' && (run.outcome === 'completed' || run.outcome === 'merged')).map((run) => run.goalId));
+      const liveDone = new Set(input.goalAsks.filter((ask) => ask.authorRunId && landed.has(ask.goalId)).map((ask) => ask.goalId)).size;
+      return { verb, source, liveDone, shadow: 0, state: liveDone > 0 ? 'live' : 'none' };
+    }
     const actions = input.taskAgentActions!.filter((action) => action.kind === source);
     const liveDone = actions.filter((action) => action.result === 'done').length;
     const shadow = actions.filter((action) => action.result === 'shadow').length;
@@ -210,7 +222,7 @@ export function measureSevenVerbLive(input: TaskAgentCoverInput): SevenVerbLive
   });
   return {
     verbs,
-    liveVerbs: unreadable ? null : verbs.filter((row) => row.state === 'live').length,
+    liveVerbs: verbs.some((row) => row.state === 'unreadable' && row.source !== null) ? null : verbs.filter((row) => row.state === 'live').length,
     measuredVerbs: SEVEN_VERB_SOURCES.filter((row) => row.source !== null).length,
   };
 }
@@ -218,7 +230,14 @@ export function measureSevenVerbLive(input: TaskAgentCoverInput): SevenVerbLive
 /** 한 줄 요약 — 못 읽었으면 n 자리를 `-` 로 적는다(0 으로 읽히지 않게). */
 export function formatSevenVerbLive(measurement: SevenVerbLive): string {
   const total = SEVEN_VERB_SOURCES.length;
-  if (measurement.liveVerbs === null) return `${total}동사 live -/${total} · 못 잼(행동 원장 null·절단)`;
+  if (measurement.liveVerbs === null) {
+    const actionUnreadable = measurement.verbs.some((row) => row.source === 'review' && row.state === 'unreadable');
+    const authorUnreadable = measurement.verbs.some((row) => row.source === 'goal-ask+goal-run' && row.state === 'unreadable');
+    const reason = actionUnreadable && authorUnreadable ? '행동·저작·골 원장 null·절단'
+      : actionUnreadable ? '행동 원장 null·절단' : '저작·골 원장 null·절단';
+    const noSource = measurement.verbs.filter((row) => row.state === 'no-source').map((row) => row.verb).join('·');
+    return `${total}동사 live -/${total} · 못 잼(${reason})${noSource ? ` · 출처 없음 ${noSource}` : ''}`;
+  }
   const noSource = measurement.verbs.filter((row) => row.state === 'no-source').map((row) => row.verb).join('·');
   return `${total}동사 live ${measurement.liveVerbs}/${total}${noSource ? ` · 출처 없음 ${noSource}` : ''}`;
 }

package/src/task-agent/live-moves.ts

@@ -3,7 +3,7 @@
  *
  * - `review`: 수확 가능 런의 PR 에 elanous 리뷰를 «한 번» 요청한다 — PR 머리(sha)마다 한 번(카드 `reviewRequests` 이력).
  *   요청만 한다: 결과로 착지·재발사로 잇지 않는다(실행부 `executeNextAction` 의 review→land 사슬을 타지 않는다).
- *   TA-REVIEW-RESULT-CAPTURE — 자식 stdout(`--json`)은 결과 파일로 받고, 회수(`review-result-capture.ts`)는 «다음» 판단 틱이 한다 —
+ *   TA-REVIEW-RESULT-CAPTURE — 자식 stdout(`--json`)은 결과 파일로 받고, 자식 완료 뒤 해당 카드만 회수·재판정한다.
  *   회수한 pass 는 그 틱의 판단부·land 관문 입력(`selfReview`)이 될 뿐 land 판정 로직은 그대로다.
  * - `propose-green`: 카드에 green «제안»(`greenProposal`)만 적는다 — 체크리스트는 손대지 않는다.
  * - `propose-land`: 카드·현재 머리의 self review 통과(pass «또는» warn ⊕ must-fix 0 · TA-LAND-WARN-MUSTFIX0)·non-draft 를 확인하고 기존 `pr land` 를 머리 고정으로 한 번 부른다.
@@ -25,7 +25,7 @@ import type { DetachedSpawn } from '../cli/tasks-cli.js';
 import { LIVE_MOVE_HISTORY_EVENT, taskAgentStatePath, updateTaskCard, type TaskCard } from './task-hand.js';
 import { LIVE_RETRY_MOVES } from './judge.js';
 import { decisionCardGrounds, decisionRaiseArgs, type DecisionCardEvidence, type NextAction } from './actions.js';
-import { reviewResultPath } from './review-result-capture.js';
+import { reviewResultPath, TA_REVIEW_COMPLETION_CARD_ENV, TA_REVIEW_COMPLETION_RESULT_ENV, TA_REVIEW_COMPLETION_STATE_ENV } from './review-result-capture.js';
 import { buildPriorFixContext, PRIOR_FIX_SCOPE_LINE, priorFixBlock, priorFixObservation, type PriorDiffReader, type PriorFixContext } from './review-prior-fix.js';
 import { createLandWorktree, localHead, observeLandWorktree, type LandWorktree, type LandWorktreeFailure, type LandWorktreeInput, type LandWorktreeRemoval } from './land-worktree.js';
 
@@ -208,13 +208,18 @@ export function liveReviewArgs(entry: string, configDir: string, pr: number, int
  * 파이프가 아니라 파일 — 부모가 먼저 끝나도 자식이 EPIPE 로 죽지 않는다). 없으면 종전과 같다(stdio ignore).
  * `opts` 는 시험 몫(spawn·진입점·우주) — 기본은 실물.
  */
-export async function defaultRequestReview(pr: number, intent: string, cwd?: string, opts: { spawn?: DetachedSpawn; entry?: string; configDir?: string; resultPath?: string } = {}): Promise<void> {
+export async function defaultRequestReview(pr: number, intent: string, cwd?: string, opts: { spawn?: DetachedSpawn; entry?: string; configDir?: string; resultPath?: string; cardId?: string; statePath?: string } = {}): Promise<void> {
   const { spawnDetachedConfirmed, ELANOUS_CLI_ENTRY } = await import('../cli/tasks-cli.js');
   const { getElanousConfigDirOverride } = await import('../elanous-config-dir.js');
   const { effectiveInstanceRoot } = await import('../instance/resolve.js');
   const configDir = opts.configDir ?? getElanousConfigDirOverride() ?? effectiveInstanceRoot();
   const base = opts.spawn ?? (spawn as unknown as DetachedSpawn);
   const args = liveReviewArgs(opts.entry ?? ELANOUS_CLI_ENTRY, configDir, pr, intent);
+  const completionEnv = opts.resultPath && opts.cardId && opts.statePath ? {
+    [TA_REVIEW_COMPLETION_CARD_ENV]: opts.cardId,
+    [TA_REVIEW_COMPLETION_STATE_ENV]: opts.statePath,
+    [TA_REVIEW_COMPLETION_RESULT_ENV]: opts.resultPath,
+  } : undefined;
   if (!opts.resultPath) { await spawnDetachedConfirmed(base, process.execPath, args, undefined, cwd); return; }
   let fd: number;
   try {
@@ -229,7 +234,7 @@ export async function defaultRequestReview(pr: number, intent: string, cwd?: str
   const toFile: DetachedSpawn = (command, spawnArgs, options) =>
     (base as unknown as (c: string, a: string[], o: unknown) => ReturnType<DetachedSpawn>)(command, spawnArgs, { ...options, stdio: ['ignore', fd, 'ignore'] });
   try {
-    await spawnDetachedConfirmed(toFile, process.execPath, args, undefined, cwd);
+    await spawnDetachedConfirmed(toFile, process.execPath, args, undefined, cwd, completionEnv);
   } finally {
     try { closeSync(fd); } catch { /* the child keeps its own copy */ }
   }
@@ -360,7 +365,7 @@ export async function executeLiveReview(
       try { (deps.log ?? ((c, e, d) => debug.log(c, e, d)))('task-agent', 'review-prior-fix-filled', priorFixObservation(card.id, pr, prior)); } catch { /* fail-soft */ }
     }
     const intent = liveReviewIntent(card, ctx.runId, ctx.stopReason, prior);
-    await (deps.requestReview ? deps.requestReview(pr, intent, cwd, { resultPath }) : defaultRequestReview(pr, intent, cwd, { resultPath }));
+    await (deps.requestReview ? deps.requestReview(pr, intent, cwd, { resultPath }) : defaultRequestReview(pr, intent, cwd, { resultPath, cardId: card.id, statePath: path }));
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     updateTaskCard(path, card.id, (current) => current?.reviewRequests?.some((entry) => entry.pr === pr && entry.head === head!.head && entry.at === at)
@@ -560,11 +565,14 @@ export async function executeLiveLand(
   const path = deps.statePath ?? taskAgentStatePath();
   const at = (deps.now ?? (() => new Date()))().toISOString();
   const local = (deps.landWorktree?.localHead ?? localHead)(cwd);
+  const landKey = `land:${card.id}:${view.head.slice(0, 12)}`;
   const needsLandWorktree = !!local && local.toLowerCase() !== view.head.toLowerCase();
   const createCap = landWorktreeCreateCap();
   let claimed = false;
   let missing = false;
   let cappedReason: string | undefined;
+  // This state-file lock is the cross-process card/head land claim. Both completion workers
+  // must pass it; an unfinished or successful attempt makes the second worker skip.
   // TA-LAND-RETRY-ON-INFRA — 같은 머리의 앞 시도들(잠금 안에서 읽은 «지금» 카드) · 재시도면 그 근거.
   let prior: LandAttempt[] = [];
   try {
@@ -590,7 +598,7 @@ export async function executeLiveLand(
   if (!claimed) {
     const last = prior.at(-1);
     const why = last ? ` (attempts ${prior.length} · last ${last.ok === false ? `class ${last.class ?? 'unclassified'}${last.reason ? ` ${last.reason}` : ''}` : last.ok === true ? 'ok' : 'unfinished'})` : '';
-    return observe(deps, withRepo({ kind, card: card.id, ok: true, executed: false, detail: `already attempted land for #${pr} head ${view.head.slice(0, 12)}${why}` }));
+    return observe(deps, withRepo({ kind, card: card.id, ok: true, executed: false, detail: `already attempted land for #${pr} head ${view.head.slice(0, 12)} · ${landKey} claimed — skip${why}` }));
   }
   const attempt = prior.length + 1;
   if (attempt > 1) {