elanous 0.2.8 → 0.2.10

package/src/self-implement/execution-clarification.ts

@@ -0,0 +1,115 @@
+import { randomUUID } from 'node:crypto';
+
+import { createPendingQuestion, writePendingQuestion } from '../ask-user-question/pending-questions.js';
+import { createFileAskUserQuestionResolver } from '../ask-user-question/tool.js';
+import { debug } from '../debug/log.js';
+import {
+  decideAndObserveClarification,
+  defaultClarificationBudget,
+  toAskUserQuestionRequest,
+  type ClarificationCandidate,
+  type ClarificationContext,
+} from '../hitl/clarification-policy.js';
+import { getUserConfig } from '../user-config.js';
+import { appendRunLedgerEntry, type RunLedgerWriter } from './run-ledger.js';
+
+export interface ExecutionClarificationContext {
+  runId: string;
+  budget?: ClarificationContext['budget'];
+  pendingQuestionCount?: number;
+  config?: { hitl?: { executionDeadlineMinutes?: number } };
+}
+
+export type ExecutionClarificationResult =
+  | { choice: string; by: 'assumed' | 'owner' | 'auto-recommended' }
+  | { deferred: true }
+  | { parked: true; reason: 'critical-unanswered'; questionId: string };
+
+export interface ExecutionClarificationDeps {
+  now?: () => number;
+  createId?: () => string;
+  resolver?: typeof createFileAskUserQuestionResolver;
+  resolverDeps?: Parameters<typeof createFileAskUserQuestionResolver>[1];
+  writeRunLedger?: RunLedgerWriter;
+}
+
+/** A single execution-phase decision; the file resolver owns the pending/answer lifecycle. */
+export async function askAtExecution(
+  candidate: ClarificationCandidate,
+  ctx: ExecutionClarificationContext,
+  deps: ExecutionClarificationDeps = {},
+): Promise<ExecutionClarificationResult> {
+  const recommended = candidate.options.filter(option => option.recommended);
+  if (candidate.options.length < 2 || candidate.options.length > 4 || recommended.length !== 1
+    || new Set(candidate.options.map(option => option.label)).size !== candidate.options.length) {
+    throw new Error('Execution clarification requires 2–4 distinct options and exactly one recommendation.');
+  }
+  const observe = (event: 'assumed' | 'asked' | 'answered' | 'auto-recommended' | 'parked', questionId?: string): void => {
+    try {
+      debug.log('hitl.execution', event, { runId: ctx.runId, questionId, impact: candidate.impact });
+    } catch { /* Logging must not decide the user's choice. */ }
+  };
+  const record = (event: 'assumed' | 'auto-recommended' | 'parked', data: Record<string, unknown>): void => {
+    (deps.writeRunLedger ?? appendRunLedgerEntry)({
+      timestamp: new Date((deps.now ?? Date.now)()).toISOString(),
+      runId: ctx.runId,
+      event,
+      data: { impact: candidate.impact, ...data },
+    });
+  };
+  const decision = decideAndObserveClarification(candidate, {
+    phase: 'execution',
+    budget: ctx.budget ?? defaultClarificationBudget('execution'),
+    pendingQuestionCount: ctx.pendingQuestionCount,
+  }, { consumer: 'self-implement-execution' });
+  if (decision.action === 'defer') return { deferred: true };
+  if (decision.action === 'assume') {
+    record('assumed', { choice: recommended[0]!.label, assumption: decision.assumption });
+    observe('assumed');
+    return { choice: recommended[0]!.label, by: 'assumed' };
+  }
+
+  const request = toAskUserQuestionRequest(decision);
+  if (!request) throw new Error('Execution clarification policy approved a question without a valid wire request.');
+  const configured = ctx.config === undefined
+    ? getUserConfig().hitl?.executionDeadlineMinutes
+    : ctx.config.hitl?.executionDeadlineMinutes;
+  const minutes = configured === undefined ? 30 : configured;
+  if (!Number.isSafeInteger(minutes) || minutes < 1 || minutes > 35_791) {
+    throw new Error('hitl.executionDeadlineMinutes must be a positive integer within the resolver timer limit.');
+  }
+  const questionId = (deps.createId ?? (() => `execution:${ctx.runId}:${randomUUID()}`))();
+  let expired = false;
+  let written = false;
+  const resolver = (deps.resolver ?? createFileAskUserQuestionResolver)(minutes * 60_000, {
+    ...deps.resolverDeps,
+    observe: (state, data) => {
+      if (state === 'answer-missing') expired = true;
+      deps.resolverDeps?.observe?.(state, data);
+    },
+    createId: () => questionId,
+    write: (pending) => {
+      const question = createPendingQuestion(questionId, { ...request, runId: ctx.runId }, undefined,
+        { now: () => new Date((deps.now ?? Date.now)()) },
+        { surface: 'file', delivery: 'file', expiresAt: pending.expiresAt });
+      (deps.resolverDeps?.write ?? writePendingQuestion)(question);
+      written = true;
+      observe('asked', questionId);
+    },
+  });
+  const answer = await resolver({ ...request, runId: ctx.runId });
+  const chosen = answer.answers[candidate.id];
+  if (written && !expired && !answer.cancelled && typeof chosen === 'string' && candidate.options.some(option => option.label === chosen)) {
+    observe('answered', questionId);
+    return { choice: chosen, by: 'owner' };
+  }
+  if (!written || !expired) throw new Error('Execution clarification was cancelled or could not read its answer before expiry.');
+  if (candidate.impact === 'critical') {
+    record('parked', { questionId, reason: 'critical-unanswered' });
+    observe('parked', questionId);
+    return { parked: true, reason: 'critical-unanswered', questionId };
+  }
+  record('auto-recommended', { questionId, choice: recommended[0]!.label, by: 'auto-recommended' });
+  observe('auto-recommended', questionId);
+  return { choice: recommended[0]!.label, by: 'auto-recommended' };
+}

package/src/self-implement/gate-cli.ts

@@ -7,6 +7,7 @@ import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
 import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
 import { runAndroidUnitTestGate } from '../../scripts/ci-android-unit-tests.js';
 import { runIosUnitTestGate } from '../../scripts/ci-ios-unit-tests.js';
+import { runPwaBuildGate } from '../../scripts/ci-pwa-build-gate.js';
 import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-gate.js';
 import { parseReviewDepthFromFilesJson } from '../agent-mission/review-depth.js';
 import { buildGateBaselineReport, calculateGateTestCountChange, formatGateBaselineNote, formatGateTestCountNote, isGateTestFile, runGateBaseline, type BaselineProcessResult, type BaselineProcessStatus, type GateTestFailure } from './gate-baseline.js';
@@ -83,6 +84,7 @@ interface SelfGateCliDeps {
   runAndroidGate?: (out: GateOutput) => number;
   /** iOS 순수-로직 시험 게이트 심(시험 주입용). */
   runIosGate?: (out: GateOutput) => number;
+  runPwaGate?: (out: GateOutput) => number;
   listPrWorktrees?: (cwd: string) => PrWorktreeListEntry[] | { lookupFailed: string };
   inspectWorktreeDirtiness?: (path: string) => { dirty: boolean } | { lookupFailed: string };
 }
@@ -619,11 +621,12 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   const androidPassed = runAdditionalGate('android-gate', deps.runAndroidGate ?? runAndroidUnitTestGate, selection.files, cwd, lines);
   // 🍎 iOS 축 — 안드로이드와 «같은 자리»에 둔다(skipTestStep 앞). Swift 만 바뀐 PR 도 여기서 조기 리턴한다.
   const iosPassed = runAdditionalGate('ios-gate', deps.runIosGate ?? runIosUnitTestGate, selection.files, cwd, lines);
+  const pwaPassed = runAdditionalGate('pwa-gate', deps.runPwaGate ?? runPwaBuildGate, selection.files, cwd, lines);
 
   if (scope.skipTestStep) {
     const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
-    return { exitCode: androidPassed && iosPassed && policyPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
+    return { exitCode: androidPassed && iosPassed && pwaPassed && policyPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles: [], unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
   }
 
   const test = (deps.runTests ?? ((dir, files) => (deps.runCommand ?? defaultRunCommand)('bun', ['test', ...files], dir)))(cwd, testFiles);
@@ -632,7 +635,7 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
     lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, `tests: pass (${testFiles.length} files)`));
     const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
     logGateCliBaseline(cwd, { ...ZERO_GATE_BASELINE, unrunImporterTotal, lookupFailed: importerLookupFailed });
-    return { exitCode: policyPassed && androidPassed && iosPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
+    return { exitCode: policyPassed && androidPassed && iosPassed && pwaPassed ? 0 : 1, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
   }
 
   if (worktreeLog.includes('deterministic environment setup failed')) lines.push(worktreeLog);
@@ -653,6 +656,6 @@ export function runSelfGateCli(cwd: string, options: SelfGateCliOptions = {}, de
   });
   lines.push(formatPartialObservationNote(unrunImporterTotal ?? 0, formatGateBaselineNote(report, unrunImporterTotal ?? 0)));
   const policyPassed = runPolicyGates(selection.files, cwd, lines, deps);
-  const exitCode = !androidPassed || !iosPassed || !policyPassed || report.introduced > 0 || report.unknown > 0 || report.preconditionUnmet > 0 ? 1 : 0;
+  const exitCode = !androidPassed || !iosPassed || !pwaPassed || !policyPassed || report.introduced > 0 || report.unknown > 0 || report.preconditionUnmet > 0 ? 1 : 0;
   return { exitCode, lines, changedFiles: selection.files, testFiles, unverified: scope.unverified, documentPaths: scope.documentPaths, documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests };
 }

package/src/self-implement/orchestrator.ts

@@ -79,6 +79,7 @@ import { classifyReviewProviderFailure } from '../self-dev/review-provider-fallb
 import { classifyError } from '../session-runtime/retry-policy.js';
 import { decomposeSelfDevGoal, inferHotPaths, type SelfDevDecomposeOptions } from '../self-dev/decompose.js';
 import { boundaryGlobs, boundaryViolations } from './goal-boundary.js';
+import { askAtExecution, type ExecutionClarificationResult } from './execution-clarification.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
 import type { SelfDevGoalType } from '../self-dev/orchestrate.js';
 import { DEFAULT_BRANCH_WORKTREE_BASE, gateGitResidue, observeGitResidue } from '../git-fs/worktree.js';
@@ -967,6 +968,8 @@ export interface SelfImplementSeams {
   /** 변경 파일 목록 — 게이트 «라우터»가 「코드가 바뀌었나」를 판정하는 입력.
    *  ⛔ 미지정이면 실물 `changedFiles(cwd)` 를 쓴다. 못 얻으면 `undefined` 이고, 라우터는 그때 «돌린다»(fail-safe). */
   changedFilesForGateRoute?: (cwd: string) => readonly string[] | undefined;
+  /** An execution choice is made only after a measured change crosses the authored target paths. */
+  askExecutionClarification?: typeof askAtExecution;
   /** ★ ⑤ 내부 리뷰 seam(2026-07-21·review-gated merge) — gate 통과 diff 를 리뷰어(reviewPullRequest·
    *  agent-substrate·staged 하니스와 동일 엔진)가 비평. verdict fail(mustFix) → rework 재주입(A 확장),
    *  clean(pass/warn) → 병합 결정. 미주입 시 리뷰 스킵(gate 통과=바로 결정·종전 동작). */
@@ -1082,7 +1085,7 @@ export const SELF_IMPLEMENT_PROGRESS_STAGES = [
   'gating', 'gated', 'reviewing', 'reviewed', 'awaiting-approval',
   'pr-opening', 'pr-opened', 'merging', 'merged', 'worktree-completed',
   'aborted', 'gate-failed', 'review-blocked', 'merge-conflict', 'pr-declined',
-  'awaiting-clarification',
+  'awaiting-clarification', 'parked',
   // ⭐⭐ 🩸 2026-09-12 — ***「선언한 대상을 «하나도» 안 만들고 끝났다」를 사람 표면에 낸다.***
   //    ⛔ 기존 단계 이름을 «빌려 쓰지 않는다» — `progress()` 는 단계 이름으로 원장 행을 만들므로
   //       빌려 쓰면 그 단계 집계가 오염된다([T] 2026-09-12 · `#17767` 이후 계약).
@@ -6268,6 +6271,39 @@ async function runSelfImplementInner(
       return { ok: false, stage: 'aborted', node: 'implement', ...resolveRunOutcome({ termination: 'abandoned' }), sessionId, worktreePath: wt.path, branch: wt.branch, quotaExhaustionAssessment: quotaExhaustionAssessmentForRun(), ...(impl.completionDisposition ? { completionDisposition: impl.completionDisposition } : {}), ...(pr ? { prUrl: pr.url, prNumber: pr.number } : {}), detail: impl.summary };
     }
 
+    // Measure the existing declared-target boundary after implementation, before gate/PR.
+    // Unknown declaration or changed files cannot justify an invented choice.
+    let gateRouteFiles: readonly string[] | undefined;
+    try { gateRouteFiles = (s.changedFilesForGateRoute ?? changedFiles)(wt.path); } catch { gateRouteFiles = undefined; }
+    if (opts.goalFile) {
+      let goalDocument: string | undefined;
+      try { goalDocument = readFileSync(opts.goalFile, 'utf8'); } catch { /* unknown scope */ }
+      const scope = detectDeclaredScopeDiff({ goalDocument, changedFiles: gateRouteFiles?.filter(file => !harnessSeededPaths.includes(file)), nameCap: gateRouteFiles?.length });
+      if (scope.status === 'known' && scope.outsideCount !== null && scope.outsideCount > 0) {
+        const result: ExecutionClarificationResult = await (s.askExecutionClarification ?? askAtExecution)({
+          id: 'execution_scope', decision: 'Changing files outside the authored target paths',
+          prompt: 'Implementation changed files outside the authored target paths. Keep the original scope or expand it?',
+          whyNow: 'Continuing to gate or publish these edits would expand the requested scope.',
+          impact: scope.outsideNames.some(file => {
+            if (existsSync(join(wt.path, file))) return false;
+            const tracked = runGitCommand(wt.path, ['ls-files', '--error-unmatch', '--', file], { encoding: 'utf8', timeout: 20_000 });
+            return tracked.status === 0;
+          }) ? 'critical' : 'high',
+          options: [
+            { label: 'Stay in scope', description: 'Do not accept out-of-scope changes.', recommended: true },
+            { label: 'Expand scope', description: 'Accept the changed files outside the target paths.' },
+          ],
+        }, { runId }, { writeRunLedger: s.writeRunLedger });
+        if ('parked' in result || 'deferred' in result || result.choice !== 'Expand scope') {
+          finalizeSupervisorDeliveries('execution-scope-not-approved');
+          observe('execution-scope-held', { outsideCount: scope.outsideCount, disposition: 'parked' in result ? 'parked' : 'in-scope-only' });
+          if ('parked' in result) progress('parked', `critical 질문 ${result.questionId} 미응답 — 이 런만 대기`);
+          return { ok: false, stage: 'parked' in result ? 'parked' : 'soft-stopped', node: 'implement', ...resolveRunOutcome({ termination: 'abandoned' }), sessionId, worktreePath: wt.path, branch: wt.branch,
+            detail: 'parked' in result ? `critical-unanswered: ${result.questionId}` : 'Out-of-scope edits held in the worktree; gate and publication skipped.' };
+        }
+      }
+    }
+
     // ⛔⭐ 이 템플릿이 `gate` 노드를 «안 가지면» 그 단계는 돌지 않는다.
     //   📌 research-loop 이 그렇다 — 문서만 바뀐 판에는 «변경 파일 범위» 게이트가 돌 시험이 없다.
     //   ⚠️ 꺼진 상태에서는 언제나 implement-loop 이라 참이다 ⇒ 오늘과 «같은» 걸음이다.
@@ -6275,8 +6311,6 @@ async function runSelfImplementInner(
     //     기본이 꺼짐이라 지금 폭발 반경은 0이고, 기본을 켜기 «전»에 이 구멍을 먼저 막아야 한다.
     // ⛔⭐ 라우터가 판정한다 — 값은 «코드»가 낸다(RFC §4.3 ⑵). 「모른다」는 «돌린다» 쪽이다.
     //   🚨 이 줄이 2026-09-08 승격의 구멍 ⓐ 를 닫는다: research 골이 «코드»를 만지면 시험이 돈다.
-    let gateRouteFiles: readonly string[] | undefined;
-    try { gateRouteFiles = (s.changedFilesForGateRoute ?? changedFiles)(wt.path); } catch { gateRouteFiles = undefined; }
     const gateRoute = routeGate(graphTemplate, gateRouteFiles);
     const runsGate = gateRoute.runsGate;
     progress('gating', !runsGate

package/src/self-implement/pipeline-shape.ts

@@ -13,7 +13,7 @@ export type PipelineNodeId =
 
 /** Each pipeline node's possible terminal stages. Nodes without a terminal exit use an empty array. */
 export const TERMINAL_STAGES_BY_NODE = {
-  implement: ['aborted', 'timed-out', 'soft-stopped'],
+  implement: ['aborted', 'timed-out', 'soft-stopped', 'parked'],
   gate: [],
   review: ['review-blocked'],
   rework: ['gate-failed', 'review-blocked'],

package/src/self-implement/run-status-mapping.ts

@@ -1,4 +1,4 @@
-export type RunStatus = 'completed' | 'failed' | 'cancelled';
+export type RunStatus = 'completed' | 'failed' | 'cancelled' | 'parked';
 /** ⭐ `crashed` — ***잡히지 않은 예외로 죽어 종결을 스스로 못 적은*** 런 (2026-08-11 · 🅣⊕🅢 어휘 합의).
  *  ⛔ `aborted`(스스로 중단을 «판정»했다)와 다른 값이다 — 이쪽은 «판정할 겨를이 없었다».
  *  📏 왜 생겼나: 실측 미완 57 중 ≈38 이 어느 원장에도 종결이 없었고, 멈춘 자리가 전부 「노드 안」이었다. */
@@ -20,7 +20,8 @@ export type SelfImplementStage =
   | 'aborted'
   | 'timed-out'
   | 'pr-declined'
-  | 'soft-stopped';
+  | 'soft-stopped'
+  | 'parked';
 
 const STAGE_OUTCOMES = {
   merged: { runStatus: 'completed' },
@@ -34,9 +35,10 @@ const STAGE_OUTCOMES = {
   'timed-out': { runStatus: 'failed', failureKind: 'timed-out' },
   'pr-declined': { runStatus: 'cancelled' },
   'soft-stopped': { runStatus: 'cancelled' },
+  parked: { runStatus: 'parked' },
 } satisfies Record<SelfImplementStage, MappedRunOutcome>;
 
-const RUN_STATUSES = new Set<RunStatus>(['completed', 'failed', 'cancelled']);
+const RUN_STATUSES = new Set<RunStatus>(['completed', 'failed', 'cancelled', 'parked']);
 
 /** Runtime guard for the run-status payload produced by observeRunOutcome. */
 export function isRunStatus(value: unknown): value is RunStatus {

package/src/session/chat.ts

@@ -109,6 +109,8 @@ export interface RunTurnOpts {
    *  delegated coding agent's approval prompts back to the originating
    *  chat via `delegate_code_agent`. */
   hitlConfirmChannel?: import('../hitl/confirm.js').ConfirmChannel;
+  /** Verified by the hosting bot from the inbound user id against its server-side owner allowlist. */
+  verifiedOwner?: { id: string };
   /** Paired multi-option question channel (Telegram sets this). Surface
    *  runTurnImpls thread it into `delegate_code_agent` so a delegated
    *  agent's structured questions render as option buttons in the

package/src/session/index.ts

@@ -202,6 +202,8 @@ export interface SessionMeta {
    *  아님). ~/.elanous 공유 스토어 세션은 전부 'prod'. append 는 이 값을 보존(생성자 귀속).
    *  구 세션엔 부재(tolerant read) — 미상 = 필터 비매치. */
   originInstance?: string;
+  /** Project association, omitted for sessions without an assigned project (including legacy records). */
+  projectId?: string;
   /** For telegram-sourced sessions; undefined for cli. */
   tgChatId?: number;
   tgThreadId?: number;
@@ -383,6 +385,7 @@ export interface CreateSessionOpts {
   tgBotId?: string;
   /** Stable identity for a persona's resident conversation. */
   personaId?: string;
+  projectId?: string;
   title?: string;
   /** 표면 origin(cli/pwa/tg/dc/harness) — source 유니온 밖의 세밀 라벨(PWA 챗 구분용). */
   origin?: string;
@@ -534,6 +537,7 @@ export function createSession(opts: CreateSessionOpts = {}, root: string = sessi
     tgThreadId: opts.tgThreadId,
     ...(opts.tgBotId ? { tgBotId: opts.tgBotId } : {}),
     ...(opts.personaId ? { personaId: opts.personaId } : {}),
+    ...(opts.projectId !== undefined ? { projectId: opts.projectId } : {}),
     tgSessionKey,
   };
   writeFileSync(sessionFile(id, root), '', 'utf-8');
@@ -575,6 +579,7 @@ export function adoptSession(id: string, opts: CreateSessionOpts = {}, root: str
     sourceKind: opts.sourceKind ?? defaultSessionSourceKind(source),
     ...(opts.forkedFromId ? { forkedFromId: opts.forkedFromId } : {}),
     ...(origin ? { origin } : {}),
+    ...(opts.projectId !== undefined ? { projectId: opts.projectId } : {}),
     originInstance: resolveInstanceName(),
     ...(opts.tgChatId != null ? { tgChatId: opts.tgChatId } : {}),
     ...(opts.tgThreadId != null ? { tgThreadId: opts.tgThreadId } : {}),
@@ -601,6 +606,7 @@ export function forkSessionFromHistory(
     tgThreadId: opts.tgThreadId,
     title: opts.title,
     origin: opts.origin,
+    projectId: opts.projectId,
   }, root);
   for (const msg of opts.messages) {
     const content = typeof msg.content === 'string' ? msg.content : '';
@@ -738,6 +744,8 @@ export interface ListSessionsOpts {
   tgThreadId?: number;
   /** 생성 인스턴스 정확 일치(prod · test:<repo> …). 구 세션(부재)은 비매치. */
   originInstance?: string;
+  /** Project id exact match; sessions without the field do not match. */
+  projectId?: string;
   /** 표면 origin 정확 일치(cli | pwa | tg | dc | harness). */
   origin?: string;
   /** 제외할 origin(들) — 예: ['harness'] 로 하니스 자식 세션을 사용자 대화 목록에서 숨김. */
@@ -774,6 +782,7 @@ export function listSessions(opts: ListSessionsOpts = {}, root: string = session
     idx = idx.filter(m => !m.sourceKind || !opts.excludeSourceKinds!.includes(m.sourceKind));
   }
   if (opts.originInstance) idx = idx.filter(m => m.originInstance === opts.originInstance);
+  if (opts.projectId !== undefined) idx = idx.filter(m => m.projectId === opts.projectId);
   if (opts.origin) idx = idx.filter(m => m.origin === opts.origin);
   if (opts.excludeOrigins && opts.excludeOrigins.length > 0) {
     idx = idx.filter((m) => {

package/src/shell-env-bootstrap.ts

@@ -210,6 +210,23 @@ export function capturedEnvAvailable(): boolean {
   return captured && cached !== null;
 }
 
+/** Append login-shell PATH entries to the target without replacing its existing environment. */
+export function mergeCapturedPath(target: NodeJS.ProcessEnv = process.env, opts: { capture?: boolean } = {}): number {
+  // capture: 아직 캡처 전이면 여기서 한 번 캡처한다(호출부가 getCapturedEnv 를 직접 부르지 않게 — identity-env 래칫).
+  const capturedPath = opts.capture || capturedEnvAvailable() ? getCapturedEnv().PATH : undefined;
+  const seen = new Set((target.PATH ?? '').split(':'));
+  const missing: string[] = [];
+  for (const entry of capturedPath?.split(':') ?? []) {
+    if (!entry || seen.has(entry)) continue;
+    missing.push(entry);
+    seen.add(entry);
+  }
+  if (missing.length) target.PATH = target.PATH ? `${target.PATH}:${missing.join(':')}` : missing.join(':');
+  const added = missing.length;
+  debug.log('shell.envbootstrap.capture', 'path-merged', { added });
+  return added;
+}
+
 /** Reset cache — test seam. */
 export function resetCapturedEnvForTesting(): void {
   cached = null;

package/src/skills/tools/usage-slash.ts

@@ -1,9 +1,7 @@
-// Slash command: /usage
-//
-// Screen does not compute. It prints the same structured report the
-// `elanous usage` command produces.
+// Slash commands: /usage and /remaining — compact TUI view of the unified report.
 
-import { collectUnifiedUsage, formatUnifiedUsage, type UnifiedUsageDeps } from '../../budget/unified-usage.js';
+import { collectUnifiedUsage, formatUsageCompact, type UnifiedUsageDeps } from '../../budget/unified-usage.js';
+import { visibleWidth } from '../../tui.js';
 import type { SlashExecuteRequest, SlashExecuteResult } from './dashboard-slash.js';
 
 export interface UsageSlashResult extends SlashExecuteResult {
@@ -12,15 +10,18 @@ export interface UsageSlashResult extends SlashExecuteResult {
 }
 
 export async function executeUsageSlash(
-  req: SlashExecuteRequest,
+  req: SlashExecuteRequest & { width?: number },
   deps: UnifiedUsageDeps = {},
 ): Promise<UsageSlashResult | null> {
   if (req.name !== 'usage' && req.name !== 'remaining') return null;
   const report = await collectUnifiedUsage(deps);
+  const width = req.width ?? 120;
+  const hint = ['자세히: elanous usage', 'elanous usage', 'elanous…', '…']
+    .find((text) => visibleWidth(text) <= width) ?? '';
   return {
     ok: true,
     name: req.name,
     args: req.args,
-    logLines: formatUnifiedUsage(report).split('\n').filter((line) => line.length > 0),
+    logLines: [...formatUsageCompact(report, { width, nowMs: Date.now() }), hint],
   };
 }

package/src/steward/directive.ts

@@ -1,10 +1,15 @@
-import { createHash } from 'node:crypto';
+import { createHash, randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
 import { getSecretAsync } from '../nexus/config/secrets/index.js';
 import { getUserConfig } from '../user-config.js';
 
 export type DirectiveSource = 'telegram' | 'pwa' | 'tui' | 'cli';
 export interface DirectiveIssue { id: string; identifier: string; title: string; description?: string | null }
+export interface DirectiveOrigin { chatId: number; botId?: string; threadId?: number }
 export interface DirectiveDeps {
+  root?: string;
   fetch?: typeof fetch;
   getSecret?: (id: string) => Promise<string | undefined>;
   team?: string;
@@ -31,8 +36,50 @@ async function graphql<T>(key: string, query: string, variables: Record<string,
   return payload.data;
 }
 
+function originPath(root: string, identifier: string): string {
+  if (!/^[a-zA-Z0-9_-]+$/.test(identifier)) throw new Error('Invalid directive identifier');
+  return join(root, 'steward', 'origins', `${identifier}.json`);
+}
+
+type TelegramOrigin = import('../autopilot/mission-origin.js').MissionOrigin & { channel: 'telegram'; chatId: number };
+
+function validOrigin(value: unknown): value is TelegramOrigin {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const origin = value as Record<string, unknown>;
+  return origin.channel === 'telegram' && Number.isSafeInteger(origin.chatId) &&
+    (origin.botId === undefined || typeof origin.botId === 'string' && /^\d+$/.test(origin.botId)) &&
+    (origin.threadId === undefined || Number.isSafeInteger(origin.threadId));
+}
+
+export function loadDirectiveOrigins(root: string, identifier: string): TelegramOrigin[] {
+  try {
+    const value: unknown = JSON.parse(readFileSync(originPath(root, identifier), 'utf8'));
+    const origins = Array.isArray(value) ? value : [value];
+    return origins.filter(validOrigin);
+  } catch { return []; }
+}
+
+export function saveDirectiveOrigin(root: string, identifier: string, origin: DirectiveOrigin): void {
+  if (!Number.isSafeInteger(origin.chatId) || origin.threadId !== undefined && !Number.isSafeInteger(origin.threadId)) throw new Error('Invalid directive origin');
+  const path = originPath(root, identifier);
+  const next: TelegramOrigin = { channel: 'telegram', chatId: origin.chatId,
+    ...(origin.botId && /^\d+$/.test(origin.botId) ? { botId: origin.botId } : {}),
+    ...(origin.threadId !== undefined ? { threadId: origin.threadId } : {}) };
+  const origins = loadDirectiveOrigins(root, identifier);
+  if (origins.some(item => JSON.stringify(item) === JSON.stringify(next))) return;
+  origins.push(next);
+  mkdirSync(join(root, 'steward', 'origins'), { recursive: true });
+  const temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+  writeFileSync(temp, JSON.stringify(origins.length === 1 ? next : origins));
+  renameSync(temp, path);
+}
+
+export function loadDirectiveOrigin(root: string, identifier: string): TelegramOrigin | null {
+  return loadDirectiveOrigins(root, identifier)[0] ?? null;
+}
+
 /** The same entry point is used by the CLI and conversational surfaces. */
-export async function addDirective(text: string, options: { source?: DirectiveSource; dryRun?: boolean } = {}, deps: DirectiveDeps = {}): Promise<{ status: 'created' | 'repeated' | 'dry-run'; issue?: string; hash: string }> {
+export async function addDirective(text: string, options: { source?: DirectiveSource; dryRun?: boolean; origin?: DirectiveOrigin } = {}, deps: DirectiveDeps = {}): Promise<{ status: 'created' | 'repeated' | 'dry-run'; issue?: string; hash: string }> {
   const original = text.trim();
   if (!original) throw new Error('directive text is required');
   const source = options.source ?? 'cli';
@@ -74,6 +121,7 @@ export async function addDirective(text: string, options: { source?: DirectiveSo
       'mutation($input:CommentCreateInput!){commentCreate(input:$input){success}}',
       { input: { issueId: duplicate.id, body: `다시 말함 · ${source} · ${at}\n\n${original}` } });
     if (!result.commentCreate?.success) throw new Error('Linear comment creation failed');
+    if (source === 'telegram' && options.origin) saveDirectiveOrigin(deps.root ?? effectiveInstanceRoot(), duplicate.identifier, options.origin);
     return { status: 'repeated', issue: duplicate.identifier, hash };
   }
   const labels = await request<{ issueLabels: { nodes: Array<{ id: string; name: string }> } }>(
@@ -90,6 +138,7 @@ export async function addDirective(text: string, options: { source?: DirectiveSo
     'mutation($input:IssueCreateInput!){issueCreate(input:$input){success issue{id identifier title}}}',
     { input: { teamId, title: original.slice(0, 240), description: `${original}\n\n출처: ${source}\n시각: ${at}\n[directive-hash:${hash}]`, labelIds: [labelId], priority: 0 } });
   if (!created.issueCreate?.success || !created.issueCreate.issue?.identifier) throw new Error('Linear issue creation failed');
+  if (source === 'telegram' && options.origin) saveDirectiveOrigin(deps.root ?? effectiveInstanceRoot(), created.issueCreate.issue.identifier, options.origin);
   return { status: 'created', issue: created.issueCreate.issue.identifier, hash };
 }