elanous 0.2.6 → 0.2.7

package/src/self-dev/run-record-mirror.ts

@@ -0,0 +1,44 @@
+import { randomUUID } from 'node:crypto';
+import { mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+import { debug } from '../debug/log.js';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import type { SelfDevRunState } from './run-store.js';
+
+export function mirrorDir(): string {
+  return join(releaseLedgerRoot(), 'self-dev-runs');
+}
+
+function mirrorPath(runId: string, dir: string): string {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(runId)) throw new Error(`invalid self-dev run ID: ${runId}`);
+  return join(dir, `${runId}.json`);
+}
+
+/** Best-effort atomic copy in the machine ledger; never disrupts the primary checkpoint. */
+export function mirrorRunRecord(state: SelfDevRunState, primaryDir: string): void {
+  let temp: string | undefined;
+  try {
+    const dir = mirrorDir();
+    if (resolve(primaryDir) === resolve(dir)) return;
+    const path = mirrorPath(state.runId, dir);
+    mkdirSync(dir, { recursive: true });
+    temp = `${path}.${process.pid}.${randomUUID()}.tmp`;
+    writeFileSync(temp, JSON.stringify(state, null, 2), { mode: 0o600 });
+    renameSync(temp, path);
+  } catch (error) {
+    if (temp) { try { unlinkSync(temp); } catch { /* no temporary file to remove */ } }
+    try { debug.log('self-dev.run-store', 'mirror-failed', { runId: state.runId, reason: String(error) }); } catch { /* keep the primary save fail-soft */ }
+  }
+}
+
+export function loadMirroredRunRecord(runId: string): SelfDevRunState | null {
+  try {
+    const record = JSON.parse(readFileSync(mirrorPath(runId, mirrorDir()), 'utf8')) as SelfDevRunState | null;
+    return record && record.runId === runId
+      && typeof record.createdAt === 'number' && Number.isFinite(record.createdAt)
+      && typeof record.updatedAt === 'number' && Number.isFinite(record.updatedAt)
+      && Array.isArray(record.results) ? record : null;
+  } catch {
+    return null;
+  }
+}

package/src/self-dev/run-store.ts

@@ -27,6 +27,7 @@ import type { RunIdSource } from '../harness/harness-space.js';
 import { withFileLockSync } from '../storage/file-lock.js';
 import type { SelfDevJobResult, SelfDevGoal } from './orchestrate.js';
 import type { SupervisorStopReason } from './run-supervisor.js';
+import { loadMirroredRunRecord, mirrorRunRecord } from './run-record-mirror.js';
 
 export interface SelfDevRunParticipant {
   id: string;
@@ -151,18 +152,26 @@ export function saveSelfDevRun(state: SelfDevRunState, dir = selfDevRunsDir()):
     withFileLockSync(join(dir, `${state.runId}.lock`), () => {
       const current = loadSelfDevRunFromPath(runPath(state.runId, dir));
       const participants = mergeParticipants(current?.participants, state.participants);
-      writeSelfDevRun({
+      const saved = {
         ...state,
         ...(participants === undefined ? {} : { participants }),
         ...(current?.parkedResolution && !state.parkedResolution ? { parkedResolution: current.parkedResolution } : {}),
-      }, dir);
+      };
+      writeSelfDevRun(saved, dir);
+      mirrorRunRecord(saved, dir);
     });
   } catch { /* fail-soft — a lost checkpoint just means no resume, not a crash */ }
 }
 
 /** Load a run checkpoint by id, or null if absent/corrupt. */
 export function loadSelfDevRun(runId: string, dir = selfDevRunsDir()): SelfDevRunState | null {
-  return loadSelfDevRunFromPath(runPath(runId, dir));
+  const primary = loadSelfDevRunFromPath(runPath(runId, dir));
+  if (primary) return primary;
+  const mirrored = loadMirroredRunRecord(runId);
+  if (mirrored) {
+    try { debug.log('self-dev.run-store', 'read-from-mirror', { runId }); } catch { /* preserve fail-soft reads */ }
+  }
+  return mirrored;
 }
 
 /** Add one participant without losing registrations made by another caller for this run. */

package/src/self-implement/harness-policy-gates.ts

@@ -4,8 +4,9 @@ import { runIsolationHardcodeGate } from '../../scripts/ci-isolation-hardcode-ga
 import { runMockModuleRestoreGate } from '../../scripts/ci-mock-module-restore-gate.js';
 import { runModelHardcodeGate } from '../../scripts/ci-model-hardcode-gate.js';
 import { runDaemonPortGate } from '../../scripts/ci-daemon-port-gate.js';
+import { runPublicExportLeakGate } from '../../scripts/ci-public-export-leak-gate.js';
 
-type GateName = 'isolation-gate' | 'mock-module-restore-gate' | 'model-hardcode-gate' | 'daemon-port-gate';
+type GateName = 'isolation-gate' | 'mock-module-restore-gate' | 'model-hardcode-gate' | 'daemon-port-gate' | 'public-export-leak';
 type GateOutput = { args: string[]; cwd: string; log: (line: string) => void; error: (line: string) => void };
 type GateRunner = (out: GateOutput) => number;
 
@@ -27,6 +28,8 @@ export function runHarnessPolicyGates(input: {
     ['mock-module-restore-gate', input.gates?.['mock-module-restore-gate'] ?? runMockModuleRestoreGate],
     ['model-hardcode-gate', input.gates?.['model-hardcode-gate'] ?? runModelHardcodeGate],
     ['daemon-port-gate', input.gates?.['daemon-port-gate'] ?? ((out) => runDaemonPortGate({ log: out.log, error: out.error, cwd: out.cwd, args: [] }))],
+    // LEAK1 — the check release prepare fails on, before the harness lands (0.2.7: a mark in a test title).
+    ['public-export-leak', input.gates?.['public-export-leak'] ?? runPublicExportLeakGate],
   ];
   const failures: Array<{ gate: GateName; lines: string[] }> = [];
   for (const [gate, run] of runners) {

package/src/self-implement/report-origin.ts

@@ -2,12 +2,23 @@ import type { MissionOrigin } from '../autopilot/mission-origin.js';
 
 export const REPORT_ORIGIN_ENV = 'ELANOUS_REPORT_ORIGIN';
 
-const CHANNELS = new Set<MissionOrigin['channel']>(['telegram', 'pwa', 'voice', 'cli', 'api', 'tui']);
+const CHANNELS = new Set<MissionOrigin['channel']>(['telegram', 'pwa', 'voice', 'cli', 'api', 'tui', 'discord']);
+const SNOWFLAKE = /^\d{1,20}$/;
 
 function isReportOrigin(value: unknown): value is MissionOrigin {
   if (value === null || typeof value !== 'object' || Array.isArray(value)) return false;
   const origin = value as Record<string, unknown>;
   if (!CHANNELS.has(origin.channel as MissionOrigin['channel'])) return false;
+  // Discord carries its own reply target (channel ⊕ optional thread snowflakes) — same shape as MissionOrigin.
+  if (origin.channel === 'discord') {
+    for (const key of Object.keys(origin)) {
+      if (!['channel', 'channelId', 'discordThreadId', 'botId', 'hitlMessageId'].includes(key)) return false;
+    }
+    return typeof origin.channelId === 'string' && SNOWFLAKE.test(origin.channelId)
+      && (origin.discordThreadId === undefined || (typeof origin.discordThreadId === 'string' && SNOWFLAKE.test(origin.discordThreadId)))
+      && (origin.botId === undefined || (typeof origin.botId === 'string' && origin.botId.length > 0))
+      && (origin.hitlMessageId === undefined || Number.isSafeInteger(origin.hitlMessageId));
+  }
   if (origin.channel === 'telegram' && (!Number.isSafeInteger(origin.chatId) || origin.chatId === 0)) return false;
   for (const key of Object.keys(origin)) {
     if (!['channel', 'chatId', 'botId', 'threadId', 'hitlMessageId'].includes(key)) return false;

package/src/session/chat.ts

@@ -30,6 +30,7 @@ import {
 import { buildMemoryInjection, buildMemoryInjectionLLM } from '../memory.js';
 import { getUserConfig } from '../user-config.js';
 import { budgetModel } from '../llm/model-defaults.js';
+import { explicitTurnTier } from '../model-tier/turn-tier.js';
 import { recordTurn } from '../status/metrics.js';
 import {
   buildTerminalCapableTurn,
@@ -375,7 +376,18 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     return trimToBudget(wire, opts.maxTokens ?? DEFAULT_TOKEN_BUDGET);
   };
 
-  const provider = opts.provider ?? getProviderForConfig(opts.userConfig, opts.llmOpts?.model);
+  const explicitTier = opts.llmOpts?.model ? undefined : explicitTurnTier(opts.userConfig, opts.sessionId);
+  const llmOpts = explicitTier ? {
+    ...(opts.llmOpts ?? {}), model: explicitTier.model,
+    ...(explicitTier.reasoningEffort && !opts.llmOpts?.reasoningEffort ? { reasoningEffort: explicitTier.reasoningEffort } : {}),
+  } : opts.llmOpts;
+  if (explicitTier) {
+    debug.log('llm.tier', 'turn-tier-applied', {
+      sessionId: opts.sessionId, tier: explicitTier.tier, source: explicitTier.source, model: explicitTier.model,
+      reasoningEffort: llmOpts?.reasoningEffort ?? null,
+    });
+  }
+  const provider = opts.provider ?? getProviderForConfig(opts.userConfig, llmOpts?.model);
   let kept: LLMMessage[] = [];
   let dropped = 0;
   let used = 0;
@@ -394,7 +406,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
       specs: opts.tools,
       dispatch: rawDispatchTool,
       systemPromptParts: effectiveSystemPrompt ? [effectiveSystemPrompt] : [],
-      ...(opts.llmOpts ? { llmOpts: opts.llmOpts } : {}),
+      ...(llmOpts ? { llmOpts } : {}),
     };
     const terminal = hasPtyShellTool
       ? isTerminalCapableTurn(terminalBase)
@@ -409,7 +421,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     if (terminal) {
       effectiveSystemPrompt = terminal.systemPromptParts.join('\n\n');
     }
-    const turnLlmOpts = terminal ? terminal.llmOpts : opts.llmOpts;
+    const turnLlmOpts = terminal ? terminal.llmOpts : llmOpts;
     ({ kept, dropped, used } = assembleTurnMessages(effectiveSystemPrompt));
     // Durable tool telemetry (추적성) — pair each call's args (onToolCall) with its
     // result (onToolResult) and persist a role:'tool' message so later "어떤 도구
@@ -477,7 +489,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
     }
   } else {
     ({ kept, dropped, used } = assembleTurnMessages(effectiveSystemPrompt));
-    const plainOpts = opts.signal ? { ...(opts.llmOpts ?? {}), signal: opts.signal } : (opts.llmOpts ?? {});
+    const plainOpts = opts.signal ? { ...(llmOpts ?? {}), signal: opts.signal } : (llmOpts ?? {});
     const stream = provider.streamChat
       ? provider.streamChat(kept, plainOpts)
       : wrapTextOnly(provider.chat(kept, plainOpts));
@@ -529,7 +541,7 @@ export async function runTurn(opts: RunTurnOpts): Promise<RunTurnResult> {
   // status bar (CTX bar · $ · 🚀) reflects the latest numbers. Uses
   // rough estimates — providers that expose real `usage` fields can
   // override via opts.llmOpts in a later phase.
-  const resolvedModel = opts.llmOpts?.model ?? provider.defaultModel;
+  const resolvedModel = llmOpts?.model ?? provider.defaultModel;
   recordTurn({
     model: resolvedModel,
     estimatedPromptText: [...messages, userMsg].map(m =>

package/src/skills/shared-agent-skill-roots.ts

@@ -0,0 +1,25 @@
+import { statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+
+export interface SharedAgentSkillRootsOptions {
+  home?: string;
+  /** Directory-existence probe; defaults to a read-only filesystem stat. */
+  exists?: (dir: string) => boolean;
+  includeSharedAgentSkills?: boolean;
+}
+
+/** Discover the shared user skill root without creating or modifying it. */
+export function sharedAgentSkillRoots({
+  home = homedir(),
+  exists = (dir: string) => statSync(dir).isDirectory(),
+  includeSharedAgentSkills = true,
+}: SharedAgentSkillRootsOptions): string[] {
+  if (!includeSharedAgentSkills) return [];
+  const root = join(home, '.agents', 'skills');
+  try {
+    return exists(root) ? [root] : [];
+  } catch {
+    return [];
+  }
+}

package/src/steward/failure-streak.ts

@@ -0,0 +1,78 @@
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { redactSecretText } from '../debug/log.js';
+
+export type StewardStage = 'sync' | 'triage' | 'schedule' | 'report';
+export interface FailureStreak {
+  consecutive: number;
+  lastStage: StewardStage;
+  lastReason: string;
+  lastAt: string;
+  alertedAt?: string;
+  open?: { stage: StewardStage; startedAt: string };
+}
+
+const stages: readonly string[] = ['sync', 'triage', 'schedule', 'report'];
+const empty = (): FailureStreak => ({ consecutive: 0, lastStage: 'sync', lastReason: '', lastAt: '' });
+const pathFor = (root: string): string => join(root, 'steward', 'streak.json');
+
+export function readFailureStreak(root: string): FailureStreak {
+  try {
+    const value: unknown = JSON.parse(readFileSync(pathFor(root), 'utf8'));
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return empty();
+    const s = value as Record<string, unknown>;
+    if (!Number.isSafeInteger(s.consecutive) || (s.consecutive as number) < 0 ||
+        !stages.includes(s.lastStage as string) || typeof s.lastReason !== 'string' || typeof s.lastAt !== 'string' ||
+        (s.alertedAt !== undefined && typeof s.alertedAt !== 'string')) return empty();
+    if (s.open !== undefined && (!s.open || typeof s.open !== 'object' || Array.isArray(s.open) ||
+        !stages.includes((s.open as Record<string, unknown>).stage as string) ||
+        typeof (s.open as Record<string, unknown>).startedAt !== 'string')) return empty();
+    return s as unknown as FailureStreak;
+  } catch { return empty(); }
+}
+
+export function writeFailureStreak(root: string, state: FailureStreak): void {
+  const dir = join(root, 'steward');
+  mkdirSync(dir, { recursive: true });
+  const path = pathFor(root);
+  const tmp = `${path}.${process.pid}.tmp`;
+  writeFileSync(tmp, JSON.stringify(state));
+  renameSync(tmp, path);
+}
+
+export function markStageStart(root: string, stage: StewardStage, now: Date = new Date()): FailureStreak {
+  const state = readFailureStreak(root);
+  if (state.open) {
+    state.consecutive += 1;
+    state.lastStage = state.open.stage;
+    state.lastReason = `killed or timed out: ${state.open.stage}`;
+    state.lastAt = now.toISOString();
+  }
+  state.open = { stage, startedAt: now.toISOString() };
+  writeFailureStreak(root, state);
+  return state;
+}
+
+export function markStageEnd(root: string, stage: StewardStage, ok: boolean, reason = '', now: Date = new Date()): FailureStreak {
+  const state = readFailureStreak(root);
+  delete state.open;
+  if (ok) {
+    state.consecutive = 0;
+    delete state.alertedAt;
+  } else {
+    state.consecutive += 1;
+  }
+  state.lastStage = stage;
+  state.lastReason = ok ? '' : redactSecretText(reason);
+  state.lastAt = now.toISOString();
+  writeFailureStreak(root, state);
+  return state;
+}
+
+export function shouldAlert(state: FailureStreak, threshold: number): boolean {
+  return state.consecutive >= threshold && !state.alertedAt;
+}
+
+export function failureAlertText(state: FailureStreak): string {
+  return `스튜어드 연속 실패 ${state.consecutive}회 · 마지막 ${state.lastStage} · ${redactSecretText(state.lastReason).slice(0, 120)} · 로그 /tmp/elanous-loop-steward.log`;
+}

package/src/steward/steward-cards.ts

@@ -43,3 +43,27 @@ export function recordTriageOnCards(decisions: ScheduledDecision[], issues: Tria
     if (!deps.store) store.close();
   }
 }
+
+function recordOnCard(section: 'launch' | 'outcome', issue: Pick<TriageIssue, 'identifier' | 'title'>, value: object, deps: StewardCardDeps): void {
+  const store = deps.store ?? new CardStore(deps.root);
+  try {
+    const content = redactSecrets(JSON.stringify(value));
+    const key = `${section}:${createHash('sha256').update(content).digest('hex')}`;
+    const card = store.createCard({ goalId: `linear:${issue.identifier}`, title: redactSecrets(issue.title) });
+    if (!card.sections.some(item => item.key === key)) {
+      store.appendSection(card.id, { key, owner: 'steward', content });
+    }
+  } finally {
+    if (!deps.store) store.close();
+  }
+}
+
+/** Append a launch revision to the issue card; an identical retry keeps its original section. */
+export function recordLaunchOnCard(issue: Pick<TriageIssue, 'identifier' | 'title'>, launch: object, deps: StewardCardDeps = {}): void {
+  recordOnCard('launch', issue, launch, deps);
+}
+
+/** Append an outcome revision to the issue card without replacing earlier sections. */
+export function recordOutcomeOnCard(issue: Pick<TriageIssue, 'identifier' | 'title'>, outcome: object, deps: StewardCardDeps = {}): void {
+  recordOnCard('outcome', issue, outcome, deps);
+}

package/src/steward/triage-budget.ts

@@ -0,0 +1,127 @@
+import { createHash } from 'node:crypto';
+import { debug } from '../debug/log.js';
+import type { TriageDecision, TriageIssue } from './triage.js';
+
+export interface HashedTriageDecision extends TriageDecision {
+  inputHash: string;
+  /** Other issues whose ref/body the judge read while producing this decision. */
+  contextInputs?: string[];
+  /** Retained from a previous run without a current judgment; never route as a fresh decision. */
+  deferred?: true;
+}
+
+export function triageInputHash(issue: TriageIssue, issues: TriageIssue[] = [], tracks?: Record<string, string>, contextInputs: string[] = []): string {
+  const byId = new Map(issues.map(item => [item.identifier, item]));
+  return createHash('sha256').update(JSON.stringify([
+    'context-inputs-v2', issue.identifier, issue.ref, issue.title, issue.body,
+    issues.map(item => [item.identifier, item.title]), tracks && Object.keys(tracks).length ? tracks : null,
+    contextInputs.map(id => [id, byId.get(id)?.ref ?? null, byId.get(id)?.body ?? null]),
+  ])).digest('hex');
+}
+
+export async function triageWithinBudget({ issues, previous, judge, tracks, concurrency = 8, perIssueMs = 90_000, deadlineMs = 240_000, now = Date.now, onJudged }: {
+  issues: TriageIssue[];
+  previous: Array<TriageDecision & { inputHash?: string }>;
+  judge: (issue: TriageIssue, observedIssues?: TriageIssue[]) => Promise<TriageDecision>;
+  tracks?: Record<string, string>;
+  concurrency?: number;
+  perIssueMs?: number;
+  deadlineMs?: number;
+  now?: () => number;
+  onJudged?: (decision: HashedTriageDecision) => void;
+}): Promise<{ decisions: HashedTriageDecision[]; stats: { reused: number; judged: number; timedOut: number; deferred: number } }> {
+  const end = now() + deadlineMs;
+  const slots = Number.isFinite(concurrency) ? Math.max(1, Math.floor(concurrency)) : 4;
+  const stats = { reused: 0, judged: 0, timedOut: 0, deferred: 0 };
+  const old = new Map(previous.map(decision => [decision.issue, decision]));
+  const isTemporary = (decision: TriageDecision): boolean =>
+    decision.rung === 'hitl' && decision.hitlReason === 'other' &&
+    ['triage deferred — deadline', 'triage judgment timed out — human review',
+      'triage judgment unavailable — human review'].includes(decision.why);
+  const decisions: HashedTriageDecision[] = new Array(issues.length);
+  const pending: number[] = [];
+  for (const [index, issue] of issues.entries()) {
+    const earlier = old.get(issue.identifier) as HashedTriageDecision | undefined;
+    const hash = triageInputHash(issue, issues, tracks, earlier?.contextInputs ?? []);
+    if (earlier?.inputHash === hash && !earlier.deferred && !isTemporary(earlier)) {
+      decisions[index] = { ...earlier, inputHash: hash };
+      stats.reused++;
+    } else pending.push(index);
+  }
+
+  let cursor = 0;
+  const activeWork = new Set<Promise<TriageDecision>>();
+  const settleSignals = new Set<Promise<boolean>>();
+  const timedOut = Symbol('triage-timeout');
+  const worker = async (): Promise<void> => {
+    while (cursor < pending.length) {
+      const remaining = end - now();
+      if (remaining <= 0) return;
+      if (activeWork.size >= slots) {
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        const settled = Promise.race([...settleSignals]);
+        let deadlineElapsed: boolean;
+        try {
+          deadlineElapsed = await Promise.race([settled, new Promise<true>(resolve => { timer = setTimeout(() => resolve(true), remaining); })]);
+        } finally { if (timer) clearTimeout(timer); }
+        if (deadlineElapsed) return;
+        continue;
+      }
+      const index = pending[cursor++]!;
+      const issue = issues[index]!;
+      const observed = new Set<string>();
+      const observedIssues = issues.map(item => new Proxy(item, {
+        get(target, property, receiver) {
+          if (item.identifier !== issue.identifier && (property === 'ref' || property === 'body')) observed.add(item.identifier);
+          return Reflect.get(target, property, receiver);
+        },
+      }));
+      // Check immediately before invoking; a clock that advanced while preparing inputs must not start a new call.
+      const issueRemaining = end - now();
+      if (issueRemaining <= 0) { cursor--; return; }
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      let decision: TriageDecision;
+      try {
+        const work = Promise.resolve(judge(issue, observedIssues));
+        // Even a timed-out judge keeps its concurrency slot until the underlying call settles.
+        activeWork.add(work);
+        const settled = work.then(() => false, () => false);
+        void settled.then(() => {
+          activeWork.delete(work);
+          settleSignals.delete(settled);
+        });
+        settleSignals.add(settled);
+        const timeout = new Promise<never>((_, reject) => {
+          timer = setTimeout(() => reject(timedOut), Math.min(perIssueMs, issueRemaining));
+        });
+        decision = await Promise.race([work, timeout]);
+        stats.judged++;
+      } catch (error) {
+        if (error === timedOut) {
+          stats.timedOut++;
+          decision = { issue: issue.identifier, rung: 'hitl', hitlReason: 'other', dependsOn: [], priority: 0, why: 'triage judgment timed out — human review' };
+        } else {
+          stats.judged++;
+          decision = { issue: issue.identifier, rung: 'hitl', hitlReason: 'other', dependsOn: [], priority: 0, why: 'triage judgment unavailable — human review' };
+        }
+      } finally { if (timer) clearTimeout(timer); }
+      const contextInputs = [...observed].sort();
+      decisions[index] = { ...decision, inputHash: triageInputHash(issue, issues, tracks, contextInputs),
+        ...(contextInputs.length ? { contextInputs } : {}) };
+      onJudged?.(decisions[index]!);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(slots, pending.length) }, () => worker()));
+  for (const index of pending.slice(cursor)) {
+    const issue = issues[index]!;
+    const earlier = old.get(issue.identifier);
+    decisions[index] = earlier
+      ? { ...earlier, inputHash: earlier.inputHash ?? '', deferred: true }
+      : { issue: issue.identifier, rung: 'hitl', hitlReason: 'other', dependsOn: [], priority: 0,
+        why: 'triage deferred — deadline', inputHash: triageInputHash(issue, issues, tracks), deferred: true };
+    if (!earlier) onJudged?.(decisions[index]!);
+    stats.deferred++;
+  }
+  debug.log('steward.triage', 'budget', stats);
+  return { decisions, stats };
+}

package/src/steward/triage-plan.ts

@@ -0,0 +1,75 @@
+import { resolveRoleModel } from '../user-config.js';
+import type { HitlReason, Rung, TriageIssue } from './triage.js';
+
+export type StewardAsk = (prompt: string, role: 'classify' | 'planning') => Promise<unknown>;
+export interface ClassifiedIssue { issue: string; rung: Rung; why: string; hitlReason?: HitlReason; duplicateOf?: string }
+export interface IssuePlan { issue: string; priority: number; dependsOn: string[]; owner?: string }
+
+const unsafe: Array<[HitlReason, RegExp]> = [
+  ['money', /돈|유료|결제|구매|판매|송금|환불|크레딧\s*(?:추가|구매)|paid|payment|purchase/i],
+  ['public', /공개|발행|외부\s*게시|publish|public\s*release/i],
+  ['security', /보안|(?:API|보안|인증|접근)\s*키|(?:키|자격|권한|secret|credential|permission)\s*(?:변경|교체|발급|삭제|공유|노출)|키체인|\b(?:api[ -]?key|secret[ -]?key|access[ -]?token)\b/i],
+  ['irreversible', /비가역|강제\s*푸시|force.push|영구\s*삭제|리셋권\s*소비|drop\s*table|초기화/i],
+];
+
+export function unsafeReason(issue: TriageIssue): HitlReason | undefined {
+  return unsafe.find(([, pattern]) => pattern.test(`${issue.title}\n${issue.body}`))?.[0];
+}
+
+function parsed(raw: unknown): Record<string, unknown> {
+  const value: unknown = typeof raw === 'string'
+    ? JSON.parse(raw.replace(/^```(?:json)?\s*|\s*```$/g, '').trim()) : raw;
+  if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('Invalid steward response');
+  return value as Record<string, unknown>;
+}
+
+export function ruleJudgment(issue: TriageIssue, issues: TriageIssue[]): ClassifiedIssue | undefined {
+  const normalize = (text: string) => text.normalize('NFKC').trim().replace(/\s+/g, ' ').toLocaleLowerCase();
+  const title = normalize(issue.title);
+  const index = issues.findIndex(item => item.identifier === issue.identifier);
+  const prior = index < 0 ? issues.filter(item => item.identifier !== issue.identifier) : issues.slice(0, index);
+  // Same title alone is not proof: two different tasks can share a title. Only same title AND same body is a
+  // rule duplicate; anything else goes to classification.
+  const body = normalize(issue.body ?? '');
+  const duplicate = title && prior.find(item => normalize(item.title) === title && normalize(item.body ?? '') === body);
+  if (duplicate) return { issue: issue.identifier, rung: 0, duplicateOf: duplicate.identifier, why: `duplicate of ${duplicate.identifier}` };
+  return undefined;
+}
+
+export async function askSteward(prompt: string, role: 'classify' | 'planning'): Promise<unknown> {
+  const { streamLLM } = await import('../llm.js');
+  const result = await streamLLM([{ role: 'user', content: prompt }], () => {}, { model: resolveRoleModel(role).model });
+  return parsed(result);
+}
+
+export async function classifyIssue(issue: TriageIssue, ask: StewardAsk = askSteward): Promise<ClassifiedIssue> {
+  const candidate = unsafeReason(issue);
+  const response = parsed(await ask(`스튜어드 분류. JSON 객체만: {"rung":0|1|2|3|4|5|"hitl","hitlReason":null,"why":"한 문장"}. 0=이미됨, 1=셸, 2=CLI, 3=조사, 4=하니스 골, 5=외부 에이전트. 돈·공개·보안·비가역은 hitl; 그 외 사람 확인은 other. 확인되지 않은 완료를 추측하지 마라. ${candidate ? `안전 후보 ${candidate}: 이유를 확인하라.` : ''}\n이슈: ${JSON.stringify(issue)}`, 'classify'));
+  if (![0, 1, 2, 3, 4, 5, 'hitl'].includes(response.rung as Rung) || typeof response.why !== 'string' || !response.why.trim()) throw new Error(`Invalid steward classification: ${issue.identifier}`);
+  const reason = candidate ?? (unsafe.some(([name]) => name === response.hitlReason) ? response.hitlReason as HitlReason : undefined)
+    ?? (response.rung === 'hitl' ? 'other' : undefined);
+  return { issue: issue.identifier, rung: reason ? 'hitl' : response.rung as Rung,
+    ...(reason ? { hitlReason: reason } : {}), why: response.why.trim().replace(/\s+/g, ' ') };
+}
+
+/** One request for the current batch, never one request per issue. */
+export async function planIssues(classified: ClassifiedIssue[], ask: StewardAsk = askSteward, tracks?: Record<string, string>, issues: TriageIssue[] = []): Promise<IssuePlan[]> {
+  if (!classified.length) return [];
+  const keys = Object.keys(tracks ?? {});
+  const byId = new Map(issues.map(issue => [issue.identifier, issue]));
+  const response = parsed(await ask(`스튜어드 계획. 새로 분류한 이슈마다 priority(숫자), dependsOn(제공된 이슈 키 배열), owner(담당 트랙 키 또는 null)를 정해 JSON {"plans":[{"issue":"키","priority":1,"dependsOn":[],"owner":null}]} 만 출력. 새로 분류한 이슈만 한 번씩 포함하라. 다른 키를 의존으로 넣지 마라. 담당 트랙: ${JSON.stringify(tracks ?? {})}\n제공된 이슈 키: ${JSON.stringify(issues.map(row => ({ key: row.identifier, title: row.title })))}\n새로 분류한 이슈: ${JSON.stringify(classified.map(row => ({ ...row, title: byId.get(row.issue)?.title ?? '', body: byId.get(row.issue)?.body ?? '' })))}`, 'planning'));
+  const plans = response.plans;
+  if (!Array.isArray(plans) || plans.length !== classified.length) throw new Error('Invalid steward plan');
+  const allowed = new Set(issues.length ? issues.map(row => row.identifier) : classified.map(row => row.issue));
+  const planned = new Set(classified.map(row => row.issue));
+  const seen = new Set<string>();
+  return plans.map((raw: unknown) => {
+    const row = parsed(raw);
+    if (typeof row.issue !== 'string' || !planned.has(row.issue) || seen.has(row.issue) ||
+      typeof row.priority !== 'number' || !Number.isFinite(row.priority) ||
+      !Array.isArray(row.dependsOn) || !row.dependsOn.every((dep: unknown) => typeof dep === 'string' && allowed.has(dep) && dep !== row.issue)) throw new Error('Invalid steward plan');
+    seen.add(row.issue);
+    return { issue: row.issue, priority: row.priority, dependsOn: row.dependsOn as string[],
+      ...(typeof row.owner === 'string' && keys.includes(row.owner) ? { owner: row.owner } : {}) };
+  });
+}