elanous 0.2.4 → 0.2.5

package/src/self-dev/dev-pipeline.ts

@@ -15,8 +15,12 @@
 //   self 는 backend 리스트 항목이 아니라 transport 축을 붕괴시키는 특수 갈래. 감독 축도 self=turn 레벨.
 
 import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
 import { readFileSync } from 'node:fs';
-import { appendEvidenceLocationRequirement, extractVerbatimOriginalAsk, formatGoalFileLintFinding, inspectAskDecisionSignalMarker, leadingGoalMetadata, lintGoalFile, parseGoalId, parseGoalType, SUPERSEDED_BY_LINE, type GoalFileLintFinding, type GoalFileLintResult } from '../self-implement/goal-author.js';
+import { dispatchTask, type DispatchTaskDeps } from '../execution-loop/dispatch-task.js';
+import { getNestDepth } from '../agent/nest-depth.js';
+import { appendRunLedgerEntry } from '../self-implement/run-ledger.js';
+import { appendEvidenceLocationRequirement, extractVerbatimOriginalAsk, formatGoalFileLintFinding, inspectAskDecisionSignalMarker, leadingGoalMetadata, lintGoalFile, parseGoalId, parseGoalType, tracedPathReferences, SUPERSEDED_BY_LINE, type GoalFileLintFinding, type GoalFileLintResult } from '../self-implement/goal-author.js';
 import { createRepositoryReferencedFileReader, type ReferencedFileReader } from '../self-implement/goal-file-reader.js';
 import { parseGoalDocumentClarifications } from '../self-implement/goal-author-clarification.js';
 import { requiredEvidenceFromGoal } from '../self-implement/off-diff-evidence.js';
@@ -55,6 +59,8 @@ export type OrchestrateRuntime = Omit<OrchestrateSelfDevOptions, 'goals' | 'conc
 export interface DevMissionOpts {
   chain?: readonly ('codex' | 'claude' | 'elanous')[];
   plugin?: { plugin: string; marketplace: string };
+  resources?: 'on' | 'off';
+  backendExplicit?: string;
   headless?: boolean;
   evidence?: EvidenceMode;
   maxRounds?: number;
@@ -619,6 +625,8 @@ export function toAgentMissionSpec(
     ...(m.headless === true ? { headless: true } : {}),
     ...(m.chain ? { chain: m.chain } : {}),
     ...(m.plugin ? { plugin: m.plugin } : {}),
+    ...(m.resources !== undefined ? { resources: m.resources } : {}),
+    ...(m.backendExplicit !== undefined ? { backendExplicit: m.backendExplicit } : {}),
     ...(plan.base ? { base: plan.base } : {}),
     ...(plan.enhance !== undefined ? { enhance: plan.enhance } : {}),
     ...(m.maxRounds !== undefined ? { maxRounds: m.maxRounds } : {}),
@@ -644,6 +652,8 @@ export function buildAgentMissionDevSpec(o: {
   headless?: boolean;
   chain?: readonly ('codex' | 'claude' | 'elanous')[];
   plugin?: { plugin: string; marketplace: string };
+  resources?: 'on' | 'off';
+  backendExplicit?: string;
   /** --no-enhance 시 false(그 외 미지정 → driver 가 entry 로 구동). */
   enhanceOff?: boolean;
   evidence: EvidenceMode;
@@ -663,6 +673,8 @@ export function buildAgentMissionDevSpec(o: {
       ...(o.headless === true ? { headless: true } : {}),
       ...(o.chain ? { chain: o.chain } : {}),
       ...(o.plugin ? { plugin: o.plugin } : {}),
+      ...(o.resources !== undefined ? { resources: o.resources } : {}),
+      ...(o.backendExplicit !== undefined ? { backendExplicit: o.backendExplicit } : {}),
       maxRounds: o.maxRounds,
       commit: o.commit,
       entry: 'elanous-apparatus',
@@ -918,6 +930,10 @@ export interface DevHarnessDispatchArgs extends Record<string, unknown> {
 }
 
 export interface DevPipelineDeps {
+  dispatchTask?: typeof dispatchTask;
+  dispatchTaskDeps?: DispatchTaskDeps;
+  /** Caller has already recorded this dispatch decision at an outer entrance. */
+  skipDispatchTask?: boolean;
   /** Caller-managed human progress sink (for example SurfaceUx.progress). Absent callers retain byte-for-byte CLI stdout. */
   progress?: SurfaceUx['progress'];
   runSelfImplement?: (o: SelfImplementOptions) => Promise<SelfImplementResult>;
@@ -1777,6 +1793,65 @@ export async function runDevPipeline(spec: DevPipelineSpec, deps: DevPipelineDep
   }
 }
 
+async function observeDevTaskDispatch(spec: DevPipelineSpec, plan: ResolvedDevPlan, deps: DevPipelineDeps): Promise<void> {
+  const skipped = plan.dispatch === 'interactive' && getNestDepth() > 0 ? 'nested-interactive'
+    : plan.relaunch === true ? 'relaunch'
+    : plan.dispatch === 'parallel' ? 'parallel-parent'
+    : deps.skipDispatchTask === true ? 'skipDispatchTask'
+    : process.env.ELANOUS_DISPATCH_RECORDED === '1' ? 'dispatch-recorded'
+    // `bun test` preload sets this so pipeline tests do not run the real gates (usage/recall
+    // lookups) on every launch; tests that inject a dispatcher or gates still observe.
+    : process.env.ELANOUS_EXECUTION_LOOP_DISPATCH === 'off' && !deps.dispatchTask && !deps.dispatchTaskDeps ? 'disabled'
+    : undefined;
+  if (skipped) {
+    try { debug.log('execution-loop.gate', 'dispatch-skipped', { reason: skipped, ...(spec.runId ? { runId: spec.runId } : {}) }); } catch { /* fail-soft */ }
+    return;
+  }
+  try {
+    const goalText = 'text' in plan.input ? plan.input.text : (deps.readFile ?? ((path: string) => readFileSync(path, 'utf8')))(plan.input.file);
+    const goalId = 'file' in plan.input ? parseGoalId(goalText) : null;
+    let recordedCardId: string | undefined;
+    const recordCard = (cardId: string): void => {
+      if (!spec.runId || recordedCardId) return;
+      recordedCardId = cardId;
+      try {
+        appendRunLedgerEntry({ timestamp: new Date().toISOString(), runId: spec.runId,
+          event: 'execution-loop-card', data: { cardId } });
+      } catch (error) {
+        try { debug.log('execution-loop.gate', 'ledger-unavailable', { reason: String(error) }); } catch { /* fail-soft */ }
+      }
+    };
+    const dispatchDeps: DispatchTaskDeps = {
+      ...deps.dispatchTaskDeps,
+      onCardCreated: (cardId) => {
+        recordCard(cardId);
+        deps.dispatchTaskDeps?.onCardCreated?.(cardId);
+      },
+    };
+    const work = Promise.resolve().then(() => (deps.dispatchTask ?? dispatchTask)({
+      goalId: goalId ?? `request-${createHash('sha256').update(goalText).digest('hex').slice(0, 32)}`,
+      title: goalText.split(/\r?\n/, 1)[0]?.trim() || 'Untitled request',
+      goalText,
+      targetPaths: 'file' in plan.input ? tracedPathReferences(goalText).map((reference) => reference.path) : [],
+      spec,
+      ...(spec.runId ? { runKey: spec.runId } : {}),
+    }, dispatchDeps));
+    // The default dispatcher bounds its gates to five seconds. Await its completed
+    // observation so short-lived callers cannot exit before decisions reach the card.
+    // Injected dispatchers retain an outer timeout to protect the original launch.
+    let timeout: ReturnType<typeof setTimeout> | undefined;
+    const result = await (deps.dispatchTask
+      ? Promise.race([
+          work,
+          new Promise<never>((_, reject) => { timeout = setTimeout(() => reject(new Error('dispatch timeout after 5000ms')), 5_000); }),
+        ]).finally(() => { if (timeout) clearTimeout(timeout); })
+      : work);
+    recordCard(result.cardId);
+  } catch (error) {
+    try { debug.log('execution-loop.gate', 'dispatch-unavailable', { reason: String(error) }); } catch { /* fail-soft */ }
+  }
+}
+
 async function runDevPipelineDispatch(
   spec: DevPipelineSpec,
   deps: DevPipelineDeps,
@@ -1785,6 +1860,7 @@ async function runDevPipelineDispatch(
 ): Promise<DevPipelineRunResult> {
   const plan = planDevPipeline(spec);
   seen.plan = plan;
+  await observeDevTaskDispatch(spec, plan, deps);
   if (!plan.wired) {
     throw new DevPipelineError(
       `runDevPipeline: '${plan.dispatch}' 경로는 U4 골격에서 미배선(NotYetUnified). ` +

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

@@ -682,7 +682,9 @@ function runIsolatedBunTest(cwd: string, args: string[], timeout: number): Proce
     return { status: null, stdout: '', stderr: message, error: error instanceof Error ? error : new Error(message) };
   }
   try {
-    return spawnSync('bun', ['test', ...args], { cwd, env: isolated.env, encoding: 'utf8', timeout, maxBuffer: 32 * 1024 * 1024 });
+    // SIGKILL — a test that traps SIGTERM while blocked in a native wait never runs its handler, so spawnSync
+    // waited forever and its drive grandchildren lived on as ppid=1 orphans (09-30 O1: 19 processes, up to 11h).
+    return spawnSync('bun', ['test', ...args], { cwd, env: isolated.env, encoding: 'utf8', timeout, killSignal: 'SIGKILL', maxBuffer: 32 * 1024 * 1024 });
   } finally {
     isolated.cleanup();
   }

package/src/self-implement/goal-author.ts

@@ -32,6 +32,7 @@ import { quoteShellArg } from '../cli/logs-cli.js';
 import type { HarnessGroundingProvenance } from './context-capsule.js';
 import { hasGoalStepCodeName } from './goal-step-code-name.js';
 import { targetScopedGoalText } from './goal-text-path-scope.js';
+import { parseReleaseNoteSection } from '../release-loop/release-note.js';
 
 // ⭐ `situation`/`complication` 은 **선택**이다 — 안 오면 `scqaNarrative` 가 종전 문면을 쓴다.
 //   ⛔ 필수로 만들지 않는다: 그러면 인핸싱이 폴백으로 떨어진 저작(LLM 실패·`disabled`)이 전부 죽는다.
@@ -334,7 +335,7 @@ function endGoalAuthorPhase(phase: GoalAuthorTimedPhase, startedAt: number, auth
 
 export type GoalFileLintLevel = 'ERROR' | 'WARN';
 
-export type GoalFileLintTag = 'canonical-structure' | 'evidence-section' | 'boundary-size' | 'launch-branch' | 'unanswered-clarification' | 'shell-damage' | 'traced-path' | 'grounding-evidence' | 'empty-result-population' | 'decision-signal-numeric-source' | 'decision-signal-numeric-coverage' | 'decision-signal-proxy-expectation' | 'out-of-target-requirement' | 'heading-form-marker' | 'blanket-invariant' | 'self-question-subject' | 'artifact-launch-declaration' | 'all-negative-signals' | 'unreadable-signals' | 'alternative-signals' | 'count-observation' | 'identifier-name-observation' | 'self-reported-observation' | 'default-invocation-observation';
+export type GoalFileLintTag = 'canonical-structure' | 'evidence-section' | 'boundary-size' | 'launch-branch' | 'unanswered-clarification' | 'shell-damage' | 'traced-path' | 'grounding-evidence' | 'empty-result-population' | 'decision-signal-numeric-source' | 'decision-signal-numeric-coverage' | 'decision-signal-proxy-expectation' | 'out-of-target-requirement' | 'heading-form-marker' | 'blanket-invariant' | 'self-question-subject' | 'artifact-launch-declaration' | 'all-negative-signals' | 'unreadable-signals' | 'alternative-signals' | 'count-observation' | 'identifier-name-observation' | 'self-reported-observation' | 'default-invocation-observation' | 'release-note';
 
 type GoalFileLintOrigin =
   | { readonly kind: 'known-incident'; readonly incident: string; readonly reference: string }
@@ -369,6 +370,7 @@ export const GOAL_FILE_LINT_ORIGINS: Record<GoalFileLintTag, GoalFileLintOrigin>
   'identifier-name-observation': { kind: 'known-incident', incident: "an authored observation of 'the list of test names this file registers' produced a test that greps its own source for test-name strings, which passes with every named test body emptied; 59 of 3164 goal documents carried the same wording", reference: 'PR #15791 (closed; superseded by #15802); docs/harness/observability/ISSUES.md OBS-T415' },
   'self-reported-observation': { kind: 'known-incident', incident: "an authored observation of 'the captureScope field of the emitted JSON' stayed green across two failed implementations: a Chrome CLI flag Chrome silently ignores (capture stayed 1280x900 against a true 4651) and a CDP call that timed out leaving no file at all, both of which still emitted captureScope:'full-page'", reference: 'docs/manual/MANUAL-web-clone-to-reproducible-resource-2026-09-08.md section 6b; PR #16201; measured 2026-09-08: 190 of 2867 goal documents that carry a decision signal match this shape, three times the 63 that match identifier-name-observation' },
   'default-invocation-observation': { kind: 'known-incident', incident: 'a scripts/*.ts checker landed green from fixture tests and, run once with no arguments from the repository root, reported covered 1 and uncovered 22 because its default catalog path never opened the map the goal named', reference: 'PR #19126; measured 2026-09-20 against the same-day controls #19123 and #19127' },
+  'release-note': { kind: 'unknown-origin', label: 'ORIGIN-UNKNOWN' },
 } as const satisfies Record<GoalFileLintTag, GoalFileLintOrigin>;
 
 /** Machine-countable reason for a finding that retains the canonical-structure tag. */
@@ -1452,6 +1454,21 @@ export function lintGoalFile(document: string, branch: string, deps: GoalFileLin
   for (const finding of askSectionCountLintFindings(document)) findings.push(finding);
   for (const finding of headingFormMarkerLintFindings(document)) findings.push(finding);
   for (const finding of blanketInvariantLintFindings(document)) findings.push(finding);
+  const releaseNote = parseReleaseNoteSection(document);
+  for (const problem of releaseNote.problems) {
+    findings.push({
+      level: 'WARN', tag: 'release-note',
+      message: `## 릴리스 노트 ${problem} invalid or missing; use - 한 줄: English summary, - 종류: feat|fix|security|internal (feature → feat), - 문서: path or 없음(이유), - 대상: next|later`,
+    });
+  }
+  if (releaseNote.fragment || releaseNote.problems.length) {
+    const section = markdownSection(document, '릴리스 노트') ?? '';
+    const kind = releaseNote.fragment?.kind ?? /^[ \t]*- 종류:[ \t]*(.*?)[ \t]*$/m.exec(section)?.[1];
+    const line = releaseNote.fragment?.line ?? /^[ \t]*- 한 줄:[ \t]*(.*?)[ \t]*$/m.exec(section)?.[1];
+    if (kind && ['feat', 'fix', 'security'].includes(kind) && line && /[가-힣ㄱ-ㅎㅏ-ㅣ]/u.test(line)) {
+      findings.push({ level: 'WARN', tag: 'release-note', message: '## 릴리스 노트 한 줄: 공개 노트에 실리는 문장은 영어로(internal 은 한국어 무방)' });
+    }
+  }
   for (const violation of selfQuestionSubjectViolations) {
     findings.push({
       level: 'WARN',

package/src/self-implement/host-regate.ts

@@ -27,9 +27,13 @@ export type HostRegateDeps = {
   log?: (event: 'passed' | 'failed' | 'unmeasured' | 'base-raced', data: Record<string, unknown>) => void;
 };
 
+const SPAWN_MAX_BUFFER = 256 * 1024 * 1024;
+
 const defaultCommand: NonNullable<HostRegateDeps['command']> = (bin, args, cwd, env) => {
-  const r = spawnSync(bin, [...args], { cwd, env: env ?? process.env, encoding: 'utf8', timeout: 600_000 });
-  return { status: r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? `${r.error.message} (command unavailable)` : '') };
+  // bun ≥1.4 applies Node's 1MB default maxBuffer and silently truncates — test output here is often larger.
+  const r = spawnSync(bin, [...args], { cwd, env: env ?? process.env, encoding: 'utf8', timeout: 600_000, maxBuffer: SPAWN_MAX_BUFFER });
+  const overflow = (r.error as NodeJS.ErrnoException | undefined)?.code === 'ENOBUFS';
+  return { status: overflow ? null : r.status, stdout: r.stdout ?? '', stderr: (r.stderr ?? '') + (r.error ? `${r.error.message} (${overflow ? `output exceeded ${SPAWN_MAX_BUFFER} bytes` : 'command unavailable'})` : '') };
 };
 
 /** The informational pr-land gate always returns zero; enforce its measured report and the combined test result instead. */

package/src/self-implement/orchestrator.ts

@@ -3307,9 +3307,14 @@ export async function runSelfImplement(opts: SelfImplementOptions): Promise<Self
   if (opts.childLlm && (typeof opts.childLlm.provider !== 'string' || !opts.childLlm.provider.trim() || typeof opts.childLlm.model !== 'string' || !opts.childLlm.model.trim())) {
     throw new Error('childLlm.provider and childLlm.model must both be non-empty');
   }
-  const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId);
   const identity = resolveRunIdentity({ explicit: opts.runId });
   const { runId } = identity;
+  const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId, runId);
+  try {
+    debug.log('self-implement.branch', 'planned', {
+      runId, goalId: opts.goalId, branch, runSuffix: opts.branchName === undefined ? branch.match(/-r[a-z0-9]{6}$/)?.[0] ?? null : null,
+    });
+  } catch { /* observation must not block the run */ }
   const attemptOrdinal = incrementRunAttemptOrdinal(runId);
   const shardIdentity = parseRunShardIdentity(opts.feature);
   const observeOuter = makeRunObserver(runId, opts.goalId, debug.log.bind(debug), opts.seams.writeRunLedger, shardIdentity);
@@ -4517,8 +4522,8 @@ async function runSelfImplementInner(
     roundClassifications.push(classification);
     onRoundClassification(classification);
   };
-  const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId);
   const { runId, source: runIdSource } = identity ?? resolveRunIdentity({ explicit: opts.runId });
+  const branch = opts.branchName ?? plannedSelfImplBranch(opts.feature, opts.goalId, runId);
   try {
     debug.log('run-identity', 'own', {
       runId, branch, source: runIdSource, nestDepth: nestInfo().depth, ...originObservationFields(),

package/src/self-implement/seams.ts

@@ -60,7 +60,7 @@ import { pwaReachableSrcFiles } from './pwa-import-graph.js';
 import { stageNonGitDir, stageFile, applyShadowToTarget, applyFileToTarget } from './shadow-stage.js';
 import type { TargetKind } from './target-kind.js';
 import { basename } from 'node:path';
-import { makePrManager, type PrManager } from '../autopilot/pr-manager.js';
+import { ghAutomationEnv, makePrManager, type PrManager } from '../autopilot/pr-manager.js';
 import { defaultSpawnGh, lookupOpenDraftPrs } from '../cli/logs-abandoned-draft-prs.js';
 import { loadRunLedger, runLedgerDir } from './run-ledger.js';
 import { readdirSync } from 'node:fs';
@@ -2347,8 +2347,10 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     closePr: (prUrl, comment) => (o.prManager ?? makePrManager()).closePr(prUrl, comment),
 
     postPrComment: async ({ number, body, cwd }) => {
+      // Round comments go out as the GitHub App like the PR itself — a personal `gh` login made the owner a
+      // participant and mailed them on merge (#22089).
       await execFileAsync('gh', ['pr', 'comment', String(number), '--body', body], {
-        cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024,
+        cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env),
       });
     },
 

package/src/skills/tools/dev-harness.ts

@@ -13,7 +13,9 @@
 // ★ 제1원칙: front door 결정 observe(harness.frontdoor) — objective digest·autoDrive·terminal.
 //   autoDrive 'safe'(기본): 저위험 자율·고위험(PR open)만 ux.confirm(막 채널 없으면 fail-closed).
 
+import { createHash } from 'node:crypto';
 import { tierModel } from '../../llm/model-defaults.js';
+import { dispatchTask, type DispatchTaskDeps } from '../../execution-loop/dispatch-task.js';
 import type { LLMToolSpec } from '../../llm.js';
 import type { DaemonToolDispatchCtx } from '../../boot/daemon-tools/types.js';
 import type { SelfImplementSeams } from '../../self-implement/orchestrator.js';
@@ -96,6 +98,9 @@ export function buildRunDevHarnessTool(): LLMToolSpec {
 export interface DevHarnessDeps {
   /** 하니스 구동(기본 runStagedHarnessOnSurface). */
   runHarness?: (opts: RunHarnessOnSurfaceOptions) => Promise<HarnessResult>;
+  /** In-process 실행 직전의 관측 전용 디스패치 seam. */
+  dispatchTask?: typeof dispatchTask;
+  dispatchTaskDeps?: DispatchTaskDeps;
   /** seam 팩토리(기본 defaultSeams). */
   seamsFactory?: (o: DefaultSeamsOptions) => SelfImplementSeams;
   /** 비대화형 HITL relay 팩토리 seam(기본 buildLlmHitlRelay). */
@@ -468,6 +473,43 @@ export async function dispatchRunDevHarness(
   const runHarness = deps?.runHarness ?? runStagedHarnessOnSurface;
   const knobs = resolveHarnessKnobs(rawArgs, ctx?.userText);   // ★ B1 관통 — C1~C4 노브를 surface 파라미터에서 막으로
   const harnessMention = harnessMentionState(ctx?.userText);
+  // Outer pipeline/Pod observations are not repeated; this decision never controls the harness.
+  const dispatchSkipped = rawArgs.plan_staged === true ? 'plan-staged'
+    : rawArgs.dispatch_recorded === true || process.env.ELANOUS_DISPATCH_RECORDED === '1' ? 'dispatch-recorded'
+    : process.env.ELANOUS_EXECUTION_LOOP_DISPATCH === 'off' && !deps?.dispatchTask && !deps?.dispatchTaskDeps ? 'disabled'
+    : undefined;
+  if (dispatchSkipped) {
+    try { debug.log('execution-loop.gate', 'dispatch-skipped', { reason: dispatchSkipped, runId }); } catch { /* fail-soft */ }
+  } else {
+    try {
+      const spec = { input: { text: objective }, executor: { kind: 'self' as const }, plan: true, runId };
+      const observer = new AbortController();
+      const timeoutMs = Math.min(5_000, Math.max(0, deps?.dispatchTaskDeps?.timeoutMs ?? 5_000));
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      try {
+        await Promise.race([
+          Promise.resolve().then(() => (deps?.dispatchTask ?? dispatchTask)({
+            goalId: `request-${createHash('sha256').update(objective).digest('hex').slice(0, 32)}`,
+            title: objective.split(/\r?\n/, 1)[0]?.trim() || 'Untitled request',
+            goalText: objective,
+            targetPaths: [],
+            spec,
+            runKey: runId,
+          }, { ...deps?.dispatchTaskDeps, signal: observer.signal })),
+          new Promise<never>((_, reject) => {
+            timer = setTimeout(() => {
+              observer.abort();
+              reject(new Error(`dispatch observation timed out after ${timeoutMs}ms`));
+            }, timeoutMs);
+          }),
+        ]);
+      } finally {
+        if (timer) clearTimeout(timer);
+      }
+    } catch (error) {
+      try { debug.log('execution-loop.gate', 'dispatch-unavailable', { reason: String(error), runId }); } catch { /* fail-soft */ }
+    }
+  }
   const result = await runHarness({
     // ⛔⭐ `naturalLanguageDispatch` 를 «단정»하지 않는다 — 증거로 정한다.
     //   이 함수는 «둘» 이 지난다: ⑴ 모델이 부른 도구(사용자 턴 문면이 ctx.userText 로 온다)

package/src/steward/steward-cards.ts

@@ -0,0 +1,45 @@
+import { createHash } from 'node:crypto';
+import { CardStore, redactSecrets, type AppendSectionInput, type CreateCardInput, type TaskCard } from '../task-cards/card-store.js';
+import type { ScheduledDecision, TriageIssue } from './triage.js';
+
+export interface StewardCardStore {
+  createCard(input: CreateCardInput): TaskCard;
+  appendSection(id: string, input: AppendSectionInput): TaskCard;
+  close(): void;
+}
+
+export interface StewardCardDeps {
+  store?: StewardCardStore;
+  root?: string;
+  now?: () => Date;
+}
+
+/** Record observe-only intake and the latest scheduled judgment without launching any work. */
+export function recordTriageOnCards(decisions: ScheduledDecision[], issues: TriageIssue[], deps: StewardCardDeps = {}): void {
+  const store = deps.store ?? new CardStore(deps.root);
+  const byIssue = new Map(issues.map(issue => [issue.identifier, issue]));
+  try {
+    for (const decision of decisions) {
+      const issue = byIssue.get(decision.issue);
+      if (!issue) throw new Error(`Missing issue ${decision.issue}`);
+      const card = store.createCard({ goalId: `linear:${issue.identifier}`, title: redactSecrets(issue.title) });
+      const intakeKey = `intake:${issue.identifier}`;
+      if (!card.sections.some(section => section.key === intakeKey)) {
+        const directiveSource = /^출처: (telegram|pwa|tui|cli)$/m.exec(issue.body)?.[1];
+        const directiveTime = /^시각: (\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z)$/m.exec(issue.body)?.[1];
+        store.appendSection(card.id, {
+          key: intakeKey, owner: 'steward',
+          content: JSON.stringify({ summary: redactSecrets(issue.title), source: directiveSource ?? `linear:${issue.identifier}`, at: directiveTime ?? (deps.now ?? (() => new Date()))().toISOString() }),
+        });
+      }
+      const { rung, dependsOn, priority, disposition, hitlReason, why, owner } = decision;
+      const judgment = { rung, dependsOn, priority, disposition: rung === 'hitl' || hitlReason ? 'hitl' : disposition, hitlReason: hitlReason ?? null, why: redactSecrets(why), ...(owner ? { owner } : {}) };
+      const key = `triage:${createHash('sha256').update(JSON.stringify(judgment)).digest('hex')}`;
+      if (!card.sections.some(section => section.key === key)) {
+        store.appendSection(card.id, { key, owner: 'steward', content: JSON.stringify(judgment) });
+      }
+    }
+  } finally {
+    if (!deps.store) store.close();
+  }
+}

package/src/steward/triage.ts

@@ -4,30 +4,39 @@ import { fetchLinearIssues } from '../connectors/linear.js';
 import { getSecretAsync } from '../nexus/config/secrets/index.js';
 import { getUserConfig } from '../user-config.js';
 import { emitDecision } from '../live/detail-switch.js';
+import { debug, redactSecretText } from '../debug/log.js';
 import { effectiveInstanceRoot } from '../instance/resolve.js';
+import { redactSecrets } from '../task-cards/card-store.js';
 import { directiveHash } from './directive.js';
+import { recordTriageOnCards, type StewardCardDeps } from './steward-cards.js';
 
 export type Rung = 0 | 1 | 2 | 3 | 4 | 5 | 'hitl';
-export type HitlReason = 'money' | 'public' | 'security' | 'irreversible';
+/** `other` = the judge chose human review for a reason outside the four named ones (kept as HITL, never downgraded). */
+export type HitlReason = 'money' | 'public' | 'security' | 'irreversible' | 'other';
 export interface TriageIssue { identifier: string; ref: string; title: string; body: string }
 export interface TriageDecision {
   issue: string; rung: Rung; dependsOn: string[]; priority: number; duplicateOf?: string;
   hitlReason?: HitlReason; why: string; role?: string; cost?: number;
+  /** Owner track from `loops.steward.tracks` (absent when no table is configured or the judge picked none of its keys). */
+  owner?: string;
 }
 export interface ScheduledDecision extends TriageDecision { disposition: 'now' | 'wait' | 'hitl' }
 export interface StewardSettings {
   mode?: 'observe' | 'act'; linearTeam?: string;
   roles?: Record<string, { maxConcurrent?: number }>;
   budget?: number;
+  tracks?: Record<string, string>;
 }
 export interface StewardDeps {
   fetch?: typeof fetch;
   getSecret?: (id: string) => Promise<string | undefined>;
-  judge?: (issue: TriageIssue, issues: TriageIssue[]) => Promise<unknown>;
+  judge?: (issue: TriageIssue, issues: TriageIssue[], tracks?: Record<string, string>) => Promise<unknown>;
   decide?: typeof emitDecision;
   sendDigest?: (text: string) => Promise<void>;
   now?: () => Date;
   root?: string;
+  cardStore?: StewardCardDeps['store'];
+  warn?: (message: string) => void;
 }
 
 export function stewardSettings(): StewardSettings {
@@ -41,7 +50,7 @@ const unsafe: Array<[HitlReason, RegExp]> = [
   ['irreversible', /비가역|강제\s*푸시|force.push|영구\s*삭제|리셋권\s*소비|drop\s*table|초기화/i],
 ];
 
-function parseJudgment(issue: TriageIssue, raw: unknown): TriageDecision {
+function parseJudgment(issue: TriageIssue, raw: unknown, tracks?: Record<string, string>): TriageDecision {
   const value = typeof raw === 'string' ? JSON.parse(raw) as unknown : raw;
   if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error(`Invalid triage judgment: ${issue.identifier}`);
   const d = value as Record<string, unknown>;
@@ -51,8 +60,9 @@ function parseJudgment(issue: TriageIssue, raw: unknown): TriageDecision {
     throw new Error(`Invalid triage judgment: ${issue.identifier}`);
   }
   const forced = unsafe.find(([, pattern]) => pattern.test(`${issue.title}\n${issue.body}`))?.[0];
-  const hitlReason = forced ?? (unsafe.some(([reason]) => reason === d.hitlReason) ? d.hitlReason as HitlReason : undefined);
-  if (d.rung === 'hitl' && !hitlReason) throw new Error(`HITL reason required: ${issue.identifier}`);
+  const named = forced ?? (unsafe.some(([reason]) => reason === d.hitlReason) ? d.hitlReason as HitlReason : undefined);
+  // A HITL judgment without one of the four named reasons stays HITL (`other`) — one issue must not stop the stage.
+  const hitlReason = named ?? (d.rung === 'hitl' ? 'other' as const : undefined);
   return {
     issue: issue.identifier, rung: hitlReason ? 'hitl' : d.rung as Rung,
     dependsOn: d.dependsOn as string[], priority: d.priority as number,
@@ -60,24 +70,40 @@ function parseJudgment(issue: TriageIssue, raw: unknown): TriageDecision {
     ...(hitlReason ? { hitlReason } : {}), why: (d.why as string).trim().replace(/\s+/g, ' '),
     ...(typeof d.role === 'string' ? { role: d.role } : {}),
     ...(typeof d.cost === 'number' && Number.isFinite(d.cost) && d.cost >= 0 ? { cost: d.cost } : {}),
+    ...(tracks && typeof d.owner === 'string' && Object.hasOwn(tracks, d.owner) ? { owner: d.owner } : {}),
   };
 }
 
-async function judgeStewardIssue(issue: TriageIssue, issues: TriageIssue[]): Promise<unknown> {
-  const prompt = `스튜어드 트리아지. JSON 객체만 출력: {"rung":0|1|2|3|4|5|"hitl","dependsOn":[],"priority":1,"duplicateOf":null,"hitlReason":null,"why":"한 문장","role":"builder","cost":0}.\n0=이미됨/중복, 1=셸, 2=CLI, 3=조사, 4=하니스 골, 5=외부 에이전트. 돈·공개·보안·비가역은 hitl. 확인되지 않은 완료/중복은 추측하지 마라. 의존은 제공된 이슈 키만 써라.\n이슈 목록: ${JSON.stringify(issues.map(i => ({ key: i.identifier, title: i.title })))}\n판정 대상: ${JSON.stringify(issue)}`;
+/** The role table as prompt lines — read from config so a reorg edits one place. */
+export function trackTablePrompt(tracks?: Record<string, string>): string {
+  if (!tracks || !Object.keys(tracks).length) return '';
+  const keys = Object.keys(tracks);
+  return `\n담당 트랙(owner) — 아래 중 하나(${keys.map(k => JSON.stringify(k)).join('|')}) · 이슈가 어느 트랙 일인지:\n${keys.map(k => `- ${k}: ${tracks[k]}`).join('\n')}`;
+}
+
+async function judgeStewardIssue(issue: TriageIssue, issues: TriageIssue[], tracks?: Record<string, string>): Promise<unknown> {
+  const ownerField = tracks && Object.keys(tracks).length ? `,"owner":${JSON.stringify(Object.keys(tracks)[0])}` : '';
+  const prompt = `스튜어드 트리아지. JSON 객체만 출력: {"rung":0|1|2|3|4|5|"hitl","dependsOn":[],"priority":1,"duplicateOf":null,"hitlReason":null,"why":"한 문장","role":"builder","cost":0${ownerField}}.\n0=이미됨/중복, 1=셸, 2=CLI, 3=조사, 4=하니스 골, 5=외부 에이전트. 돈·공개·보안·비가역은 hitl(hitlReason = "money"|"public"|"security"|"irreversible" · 그 밖의 이유로 사람 확인이 필요하면 "other"). 확인되지 않은 완료/중복은 추측하지 마라. 의존은 제공된 이슈 키만 써라.${trackTablePrompt(tracks)}\n이슈 목록: ${JSON.stringify(issues.map(i => ({ key: i.identifier, title: i.title })))}\n판정 대상: ${JSON.stringify(issue)}`;
   const { streamLLM } = await import('../llm.js');
   const { tierModel } = await import('../llm/model-defaults.js');
   const result = await streamLLM([{ role: 'user', content: prompt }], () => {}, { model: tierModel('best') });
   return JSON.parse(result.replace(/^```(?:json)?\s*|\s*```$/g, '').trim()) as unknown;
 }
 
-export async function triageIssues(issues: TriageIssue[], judge: NonNullable<StewardDeps['judge']> = judgeStewardIssue, decide: typeof emitDecision = emitDecision): Promise<TriageDecision[]> {
+export async function triageIssues(issues: TriageIssue[], judge: NonNullable<StewardDeps['judge']> = judgeStewardIssue, decide: typeof emitDecision = emitDecision, tracks?: Record<string, string>): Promise<TriageDecision[]> {
   const decisions: TriageDecision[] = [];
   for (const issue of issues) {
-    const result = parseJudgment(issue, await judge(issue, issues));
+    let result: TriageDecision;
+    try {
+      result = parseJudgment(issue, await judge(issue, issues, tracks), tracks);
+    } catch (error) {
+      // A malformed or failed judgment for one issue goes to a human; the other issues are still triaged.
+      try { debug.log('steward.stage', 'judgment-invalid', { issue: issue.identifier, reason: redactSecrets(String(error)) }); } catch { /* fail-soft */ }
+      result = { issue: issue.identifier, rung: 'hitl', hitlReason: 'other', dependsOn: [], priority: 0, why: 'triage judgment unavailable — human review' };
+    }
     decisions.push(result);
     decide({ kind: result.rung === 'hitl' ? 'ESCALATE' : 'ROUTE', what: issue.identifier, reason: result.why,
-      purpose: 'steward triage', target: String(result.rung), refs: { issue: issue.identifier } });
+      purpose: 'steward triage', target: result.owner ? `${result.rung} · ${result.owner}` : String(result.rung), refs: { issue: issue.identifier } });
   }
   return decisions;
 }
@@ -99,7 +125,7 @@ export function scheduleTriage(decisions: TriageDecision[], settings: StewardSet
   const slots = { ...running };
   let remaining = settings.budget ?? Infinity;
   return sorted.map(item => {
-    const role = item.role ?? String(item.rung);
+    const role = item.owner ?? item.role ?? String(item.rung);
     const max = settings.roles?.[role]?.maxConcurrent ?? Infinity;
     const blocked = item.dependsOn.some(dep => !completed.has(dep));
     const status: ScheduledDecision['disposition'] = item.rung === 'hitl' || item.hitlReason ? 'hitl' :
@@ -146,7 +172,7 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
   } else if (stage === 'triage') {
     const issues = JSON.parse(readFileSync(snapshot, 'utf8')) as TriageIssue[];
     const judge = deps.judge ?? judgeStewardIssue;
-    writeFileSync(judgments, JSON.stringify(await triageIssues(issues, judge, deps.decide)));
+    writeFileSync(judgments, JSON.stringify(await triageIssues(issues, judge, deps.decide, settings.tracks)));
   } else if (stage === 'schedule') {
     const decisions = JSON.parse(readFileSync(judgments, 'utf8')) as TriageDecision[];
     const pending = new Set(decisions.flatMap(decision => decision.dependsOn));
@@ -163,6 +189,13 @@ export async function runStewardStage(stage: 'sync' | 'triage' | 'schedule' | 'r
     const state = readState(path);
     const at = (deps.now ?? (() => new Date()))().toISOString();
     const issues = JSON.parse(readFileSync(snapshot, 'utf8')) as TriageIssue[];
+    try {
+      recordTriageOnCards(rows, issues, { root, store: deps.cardStore, now: deps.now });
+    } catch (error) {
+      const message = `steward report: card write failed: ${redactSecrets(error instanceof Error ? error.message : String(error))}`;
+      debug.log('steward.cards', 'write-failed', { error: message });
+      (deps.warn ?? console.warn)(message);
+    }
     for (const row of rows) {
       const issue = issues.find(item => item.identifier === row.issue);
       if (!issue) throw new Error(`Missing issue ${row.issue}`);
@@ -195,8 +228,11 @@ if (import.meta.main) {
     console.error('steward: expected sync|triage|schedule|report');
     process.exitCode = 2;
   } else {
-    runStewardStage(stage as 'sync' | 'triage' | 'schedule' | 'report').catch(() => {
-      console.error(`steward ${stage}: stage failed`);
+    runStewardStage(stage as 'sync' | 'triage' | 'schedule' | 'report').catch((error: unknown) => {
+      // Say why (secrets masked) — 09-29 the first resident run failed as a bare «stage failed» on a missing Linear key.
+      const reason = redactSecretText(error instanceof Error ? error.message : String(error)).slice(0, 300);
+      console.error(`steward ${stage}: stage failed — ${reason}`);
+      debug.log('steward.stage', 'failed', { stage, reason });
       process.exitCode = 1;
     });
   }

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

@@ -2,6 +2,8 @@ import { lstatSync, mkdirSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join, relative, resolve, sep } from 'node:path';
 import { gunzipSync } from 'node:zlib';
 import { debug } from '../../debug/log.js';
+import { getDefaultLogStore, type LogStore } from '../../mss/logging/log-store.js';
+import type { LogRecord } from '../../mss/logging/record.js';
 
 const FILE_LIMIT = 5 * 1024 * 1024;
 const TOTAL_LIMIT = 20 * 1024 * 1024;
@@ -79,14 +81,63 @@ export function parsePodArtifactChunks(logs: string): ParseResult {
   return error.length ? { error, artifacts } : artifacts;
 }
 
+const POD_LOGS_PATH = 'pod-logs/logs.jsonl';
+
+function childRunId(data: unknown): string | undefined {
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return undefined;
+  const value = (data as Record<string, unknown>).runId;
+  return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+
+function decisionRecord(line: string): { rec: LogRecord; surface: string } | undefined {
+  let parsed: unknown;
+  try { parsed = JSON.parse(line); } catch { return undefined; }
+  if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return undefined;
+  const row = parsed as Record<string, unknown>;
+  if (row.category !== 'harness.decision') return undefined;
+  if (typeof row.ts !== 'string' || typeof row.event !== 'string') return undefined;
+  const runId = childRunId(row.data);
+  if (!runId) return undefined;
+  const data = { ...(row.data as Record<string, unknown>), podJob: '', importedFrom: 'pod' as const };
+  return {
+    rec: {
+      ts: row.ts,
+      category: 'harness.decision',
+      event: row.event,
+      data,
+      ...(typeof row.level === 'string' ? { level: row.level as LogRecord['level'] } : {}),
+      ...(typeof row.trace_id === 'string' ? { trace_id: row.trace_id } : {}),
+    },
+    surface: typeof row.surface === 'string' && row.surface ? row.surface : 'pod',
+  };
+}
+
+/** Import only harness.decision rows from a returned pod log into the launching host store. */
+export function importPodDecisionLogs(bytes: Buffer, job: string, store: LogStore | null = getDefaultLogStore()): { imported: number; skipped: number } {
+  if (!store) return { imported: 0, skipped: 0 };
+  const text = bytes.toString('utf8');
+  const rows: Array<{ rec: LogRecord; surface: string }> = [];
+  let skipped = 0;
+  for (const line of text.split(/\r?\n/)) {
+    if (!line) continue;
+    const row = decisionRecord(line);
+    if (!row) { skipped += 1; continue; }
+    row.rec.data = { ...(row.rec.data as Record<string, unknown>), podJob: job };
+    rows.push(row);
+  }
+  if (rows.length > 0) store.insertBatch(rows);
+  return { imported: rows.length, skipped };
+}
+
 /** Reject symlink parents as well as lexical traversal; never replace a host file. */
-export function collectPodArtifacts(logs: string, { dir, job, log = (c, e, d) => debug.log(c, e, d) }: {
+export function collectPodArtifacts(logs: string, { dir, job, log = (c, e, d) => debug.log(c, e, d), logStore = getDefaultLogStore() }: {
   dir: string;
   job: string;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  logStore?: LogStore | null;
 }): void {
   const parsed = parsePodArtifactChunks(logs);
-  const podLogsPath = 'pod-logs/logs.jsonl';
+  const podLogsPath = POD_LOGS_PATH;
   let podLogsReturned = false;
   let podLogsMissingReason = logs.split(/\r?\n/).find((line) => line.startsWith(`ELANOUS_POD_ARTIFACT_SKIPPED ${podLogsPath} `))
     ? 'artifact skipped (size limit or encoding failure)'
@@ -123,7 +174,14 @@ export function collectPodArtifacts(logs: string, { dir, job, log = (c, e, d) =>
       log('self-implement.pod', 'artifact-collected', { job, path, bytes: bytes.length });
       if (path === podLogsPath) {
         podLogsReturned = true;
-        log('self-implement.pod', 'pod-logs-returned', { job, path: destination, lines: bytes.length ? bytes.toString('utf8').split('\n').length - (bytes.at(-1) === 10 ? 1 : 0) : 0 });
+        const lines = bytes.length ? bytes.toString('utf8').split('\n').length - (bytes.at(-1) === 10 ? 1 : 0) : 0;
+        log('self-implement.pod', 'pod-logs-returned', { job, path: destination, lines });
+        try {
+          const imported = importPodDecisionLogs(bytes, job, logStore);
+          log('self-implement.pod', 'pod-decisions-imported', { job, imported: imported.imported, skipped: imported.skipped });
+        } catch (error) {
+          log('self-implement.pod', 'pod-logs-import-failed', { job, reason: error instanceof Error ? error.message : String(error) });
+        }
       }
     } catch (e) {
       const reason = (e as NodeJS.ErrnoException).code === 'EEXIST' ? 'exists' : e instanceof Error ? e.message : String(e);