elanous 0.2.38 → 0.2.41

package/src/input/external-input-queue.ts

@@ -43,6 +43,8 @@ export interface ExternalInputHost {
   submit(text: string, source: InputSourceRef): boolean;
   /** 지금 턴을 ESC 와 같은 경로로 멈춘다. 멈출 턴(escGate)이 없으면 false. 없으면 외부 stop 은 «턴 없음»으로 처리. */
   requestStop?(): boolean;
+  /** Consume submitted external text as the answer to a live non-modal TUI question. */
+  handleInlineChoice?(text: string): boolean;
   /** 외부 stop 의 결과 표지(채팅 로그 한 줄). */
   onExternalStop?(result: 'stopped' | 'no-turn' | 'failed'): void;
   /** 대기열의 현재 상태가 바뀌었다 — 화면 표지를 다시 그린다. */
@@ -214,6 +216,14 @@ export function createExternalInputQueue(deps: ExternalInputQueueDeps = {}) {
         try { turnActive = host.isTurnActive(); composer = host.composerText(); pendingKeys = host.hasPendingKeys(); }
         catch { return 'passthrough'; }
       }
+      if (line?.submit && host?.handleInlineChoice) {
+        let consumed = false;
+        try { consumed = host.handleInlineChoice(line.text); } catch { consumed = false; }
+        if (consumed) {
+          log('route', { length: chars.length, submit: true, turnActive, route: 'inline-choice', pending: pending.length });
+          return 'submitted';
+        }
+      }
       const { decision, reason } = decideExternalInputRoute({
         line, hostRegistered: host !== null, pendingCount: pending.length, turnActive, composerText: composer, pendingKeys,
       });

package/src/instance/dev-project.ts

@@ -3,10 +3,14 @@ import { createHash, randomBytes } from 'node:crypto';
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join, resolve } from 'node:path';
 import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { appendBoundaryResponseLine, HARNESS_BOUNDARY_RESPONSES_ENV } from '../harness/harness-space.js';
+import { anonymousExport, suggestProjectForFolder } from '../project/project-store.js';
 
 export interface DevProjectDeps {
   git?: (dir: string, args: readonly string[]) => string | null;
   stateDir?: string;
+  /** TENANT-BOUNDARY (0.2.41): 회신 mailbox 경계 채널용 env — 생산은 process.env 기본값. */
+  env?: Record<string, string | undefined>;
 }
 
 interface DevProjectRegistry {
@@ -60,9 +64,30 @@ export function resolveDevProject(dir: string, deps: DevProjectDeps = {}): strin
   try {
     writeJsonAtomically(join(root, '.elanous', 'project.json'), { identityKey, devProject: id } satisfies DevProjectCache);
   } catch { /* cache only */ }
+
+  exportTenantBoundaryRecord(root, id, deps.env ?? process.env);
   return id;
 }
 
+/**
+ * TENANT-BOUNDARY (0.2.41 · nfr:security): 고객 원장의 설치 밖 출구는 익명 내보내기 하나다.
+ * 경계 회신 mailbox(HARNESS_BOUNDARY_RESPONSES_ENV)가 열려 있을 때만, 고객 프로젝트 원장을
+ * `anonymousExport`(식별 필드 → 토큰)로 바꿔 한 줄(JSONL)로 남긴다. 원장 식별 원문은 절대
+ * 설치 밖으로 나가지 않는다. 채널이 없으면 아무 일도 일어나지 않고(기본 동작 보존),
+ * 채널 쓰기가 실패해도 id 해소를 막지 않는다(fail-open).
+ */
+function exportTenantBoundaryRecord(root: string, devProject: string, env: Record<string, string | undefined>): void {
+  const mailbox = env[HARNESS_BOUNDARY_RESPONSES_ENV]?.trim();
+  if (!mailbox) return;
+  try {
+    const project = suggestProjectForFolder(root);
+    appendBoundaryResponseLine(env as NodeJS.ProcessEnv, {
+      devProject,
+      ...(project ? { project: anonymousExport(project) } : {}),
+    });
+  } catch { /* boundary export must never block id resolution */ }
+}
+
 function runGit(dir: string, args: readonly string[]): string | null {
   try {
     return execFileSync('git', ['-C', dir, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] });

package/src/intake-plane/collect-telegram-saved.ts

@@ -22,6 +22,19 @@ export function savedMessageToRaws(m: SavedMessage): RawIntakeItem[] {
 }
 
 function cursorFile(root: string): string { return join(intakeLedgerDir(root), 'telegram-saved.cursor.json'); }
+function recoveryFile(root: string): string { return join(intakeLedgerDir(root), 'telegram-saved.recovery.json'); }
+
+function readRecoveryCursor(root: string): number | undefined {
+  try {
+    const cursor = Number(JSON.parse(readFileSync(recoveryFile(root), 'utf8')).lastId);
+    return Number.isSafeInteger(cursor) ? cursor : undefined;
+  } catch { return undefined; }
+}
+
+function writeRecoveryCursor(root: string, lastId: number): void {
+  mkdirSync(intakeLedgerDir(root), { recursive: true });
+  writeFileSync(recoveryFile(root), JSON.stringify({ lastId }) + '\n');
+}
 
 export function readSavedCursor(root: string): number {
   try { return Number(JSON.parse(readFileSync(cursorFile(root), 'utf8')).lastId) || 0; } catch { return 0; }
@@ -89,7 +102,27 @@ export function renderCollectTelegramSavedResult(res: CollectSavedResult): strin
  */
 export async function collectTelegramSaved(root: string, fetch: FetchSavedMessages, opts: { max: number; dryRun?: boolean }): Promise<CollectSavedResult> {
   const cursorBefore = readSavedCursor(root);
-  const messages = await fetch(cursorBefore, opts.max);
+  const fetched = await fetch(cursorBefore, opts.max);
+  let messages = fetched.filter((message) => Number.isSafeInteger(message.id) && message.id > cursorBefore);
+  // A cursor may have advanced without this consumer seeing the bounded interval. Scan that span
+  // once for each cursor value, even when the forward read has newer messages. Telegram's minId is
+  // exclusive, so include the cursor ID because another consumer may have consumed it.
+  if (cursorBefore > 0 && readRecoveryCursor(root) !== cursorBefore) {
+    const recoveryLimit = Math.max(1, opts.max);
+    let recoveryFrom = Math.max(0, cursorBefore - recoveryLimit - 1);
+    const recovered: SavedMessage[] = [];
+    while (recoveryFrom < cursorBefore) {
+      const recovery = await fetch(recoveryFrom, recoveryLimit);
+      const page = recovery.filter((message) => Number.isSafeInteger(message.id)
+        && message.id > recoveryFrom && message.id <= cursorBefore);
+      recovered.push(...page);
+      if (page.length < recoveryLimit) break;
+      const nextFrom = page.reduce((last, message) => Math.max(last, message.id), recoveryFrom);
+      if (nextFrom <= recoveryFrom) break;
+      recoveryFrom = nextFrom;
+    }
+    messages = [...recovered, ...messages];
+  }
   const rowsPerMessage = messages.map(savedMessageToRaws);
   const raws = rowsPerMessage.flat();
   const droppedByFilter = rowsPerMessage.filter((rows) => rows.length === 0).length;
@@ -98,6 +131,8 @@ export async function collectTelegramSaved(root: string, fetch: FetchSavedMessag
   if (!opts.dryRun) {
     result.ingest = ingestIntakeItems(root, 'telegram-saved', raws);
     if (cursorAfter > cursorBefore) writeSavedCursor(root, cursorAfter);
+    // The marker commits the scan only after ingestion succeeds; keep it monotonic at the saved cursor boundary.
+    writeRecoveryCursor(root, Math.max(cursorAfter, cursorBefore));
   }
   // ⛔ 본문·링크는 싣지 않는다 — 커서와 건수만. 두 축(메시지·원장 입력)을 따로 남겨 사흘 0 을 갈라 읽게.
   debug.log('intake.collect', 'telegram-saved', {

package/src/intake-plane/intake-to-tasks.ts

@@ -1,5 +1,5 @@
 import { createHash, randomUUID } from 'node:crypto';
-import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from 'node:fs';
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
 import { debug } from '../debug/log.js';
 import type { TaskPriority } from '../task-orchestrator/types.js';
@@ -71,15 +71,187 @@ export function interpretIntakeInput(response: string): IntakeInputInterpretatio
   return { tasks, questions };
 }
 
+export const CHANNEL_PUBLISH_APPROVAL_CATEGORIES = ['first-release', 'patent', 'external-contract'] as const;
+export const CHANNEL_PUBLISH_CROWN_OWNER = '\u{1F451}';
+export type ChannelPublishApprovalCategory = (typeof CHANNEL_PUBLISH_APPROVAL_CATEGORIES)[number];
+export type ChannelPublishStatus = 'queued' | 'approved' | 'published';
+type ChannelPublishApproval = { kind: 'automatic' } | { kind: 'human'; approvedBy: string };
+
+export interface ChannelPublishDraft {
+  channel: string;
+  cadence: string;
+  voice: string;
+  owner: string;
+  category: ChannelPublishApprovalCategory | (string & {});
+  title: string;
+  body: string;
+}
+
+export interface ChannelPublishPlan extends ChannelPublishDraft {
+  status: ChannelPublishStatus;
+  approvedBy?: string;
+}
+
+export interface ChannelPublishConnector {
+  publish(plan: ChannelPublishPlan): Promise<{ publishedId: string }>;
+}
+
+// MK·crown 소유자의 첫 공개·특허·외부 계약 초안은 사람 승인 전 자동 승인하지 않는다.
+export function isChannelPublishApprovable(draft: ChannelPublishDraft): boolean {
+  if (draft.owner !== 'MK' && draft.owner !== CHANNEL_PUBLISH_CROWN_OWNER) return true;
+  return !(CHANNEL_PUBLISH_APPROVAL_CATEGORIES as readonly string[]).includes(draft.category);
+}
+
+export function toChannelPublishDraft(row: Record<string, unknown>): ChannelPublishDraft | null {
+  const text = (key: string, max: number): string | null => {
+    const value = row[key];
+    if (typeof value !== 'string') return null;
+    const trimmed = value.trim();
+    return trimmed && trimmed.length <= max ? trimmed : null;
+  };
+  const channel = text('channel', 200);
+  const cadence = text('cadence', 200);
+  const voice = text('voice', 200);
+  const owner = text('owner', 200);
+  const category = text('category', 200);
+  const title = text('title', TASK_DEFAULTS.titleMaxLen);
+  const body = text('body', TASK_DEFAULTS.descriptionMaxLen);
+  if (!channel || !cadence || !voice || !owner || !category || !title || !body) return null;
+  return { channel, cadence, voice, owner, category, title, body };
+}
+
+function isChannelPublishPlan(value: unknown): value is ChannelPublishPlan {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return false;
+  const plan = value as Record<string, unknown>;
+  return toChannelPublishDraft(plan) !== null
+    && (plan.status === 'queued' || plan.status === 'approved' || plan.status === 'published')
+    && (plan.approvedBy === undefined || typeof plan.approvedBy === 'string');
+}
+
+export class ChannelPublishQueue {
+  readonly queueDir: string;
+  readonly publishedFile: string;
+
+  constructor(instanceRoot: string) {
+    this.queueDir = join(intakeLedgerDir(instanceRoot), 'channel-publish', 'queue');
+    this.publishedFile = join(intakeLedgerDir(instanceRoot), 'channel-publish', 'published.jsonl');
+    mkdirSync(this.queueDir, { recursive: true, mode: 0o700 });
+  }
+
+  entryPath(id: string): string {
+    return join(this.queueDir, `${createHash('sha256').update(`channel:${id}`).digest('hex')}.json`);
+  }
+
+  tryAcquirePublish(id: string): (() => void) | null {
+    const path = `${this.entryPath(id)}.publishing`;
+    const token = randomUUID();
+    // Do not auto-steal stale locks: a takeover race could duplicate an irreversible external post.
+    // If a process dies mid-publish, reconcile the approved queue entry and lock explicitly.
+    let fd: number;
+    try {
+      fd = openSync(path, 'wx', 0o600);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code === 'EEXIST') return null;
+      throw error;
+    }
+    try { writeFileSync(fd, token); }
+    catch (error) { rmSync(path, { force: true }); throw error; }
+    finally { closeSync(fd); }
+    return () => {
+      // Never let a late releaser remove a lock created by another publisher.
+      try {
+        if (readFileSync(path, 'utf8') === token) rmSync(path);
+      } catch { /* The lock is already gone; leave a replacement untouched. */ }
+    };
+  }
+
+  plan(id: string): ChannelPublishPlan | null {
+    const path = this.entryPath(id);
+    if (!existsSync(path)) return null;
+    const value: unknown = JSON.parse(readFileSync(path, 'utf8'));
+    if (!isChannelPublishPlan(value)) throw new Error('invalid channel publish plan');
+    return value;
+  }
+
+  entries(): ChannelPublishPlan[] {
+    return readdirSync(this.queueDir).filter((name) => /^[a-f0-9]{64}\.json$/.test(name))
+      .map((name) => {
+        const value: unknown = JSON.parse(readFileSync(join(this.queueDir, name), 'utf8'));
+        if (!isChannelPublishPlan(value)) throw new Error('invalid channel publish plan');
+        return value;
+      });
+  }
+
+  count(): number { return this.entries().length; }
+
+  publishedIds(): Set<string> {
+    if (!existsSync(this.publishedFile)) return new Set();
+    const ids = new Set<string>();
+    for (const line of readFileSync(this.publishedFile, 'utf8').split('\n')) {
+      try {
+        const row: unknown = JSON.parse(line);
+        if (row && typeof row === 'object' && !Array.isArray(row) && typeof (row as Record<string, unknown>).id === 'string') {
+          ids.add((row as { id: string }).id);
+        }
+      } catch { /* ignore incomplete ledger lines */ }
+    }
+    return ids;
+  }
+
+  enqueue(id: string, draft: ChannelPublishDraft): ChannelPublishPlan {
+    if (this.publishedIds().has(id)) return { ...draft, status: 'published' };
+    const existing = this.plan(id);
+    if (existing) return existing;
+    const plan: ChannelPublishPlan = { ...draft, status: 'queued' };
+    this.savePlan(id, plan);
+    return plan;
+  }
+
+  approve(id: string, plan: ChannelPublishPlan, approval: ChannelPublishApproval): ChannelPublishPlan {
+    if (plan.status !== 'queued') return plan;
+    if (!isChannelPublishApprovable(plan) && approval.kind !== 'human') return plan;
+    if (approval.kind === 'human' && approval.approvedBy !== 'MK' && approval.approvedBy !== CHANNEL_PUBLISH_CROWN_OWNER) return plan;
+    const approvedBy = approval.kind === 'human' ? approval.approvedBy : 'automation';
+    const approved: ChannelPublishPlan = { ...plan, status: 'approved', approvedBy };
+    this.savePlan(id, approved);
+    return approved;
+  }
+
+  savePlan(id: string, plan: ChannelPublishPlan): void {
+    const path = this.entryPath(id);
+    const temporary = `${path}.${randomUUID()}.tmp`;
+    writeFileSync(temporary, JSON.stringify(plan));
+    renameSync(temporary, path);
+  }
+
+  recordPublished(id: string, plan: ChannelPublishPlan, publishedId: string): void {
+    // Ledger first, then remove the plan: a crash between the connector call and this append may
+    // republish (at-least-once), matching the HookQueue queue-file/seen ordering across restarts.
+    appendFileSync(this.publishedFile, JSON.stringify({ id, channel: plan.channel, publishedId }) + '\n');
+    rmSync(this.entryPath(id), { force: true });
+  }
+}
+
+/** Explicit approval entry point for a human-controlled API, CLI, or UI action. */
+export function approveChannelPublish(instanceRoot: string, id: string, approvedBy: string): ChannelPublishPlan | null {
+  const queue = new ChannelPublishQueue(instanceRoot);
+  const plan = queue.plan(id);
+  if (!plan || plan.status !== 'queued' || isChannelPublishApprovable(plan)
+    || (approvedBy !== 'MK' && approvedBy !== CHANNEL_PUBLISH_CROWN_OWNER)) return null;
+  return queue.approve(id, plan, { kind: 'human', approvedBy });
+}
+
 export type IntakeTaskInput =
   | { kind: 'goal-line'; id: string; fact: string; current: string; url?: string }
-  | { kind: 'idea-note'; id: string; content: string; url?: string };
+  | { kind: 'idea-note'; id: string; content: string; url?: string }
+  | { kind: 'channel-post'; id: string; draft: ChannelPublishDraft | null };
 
 export interface IntakeToTasksDeps {
   llm: (input: IntakeTaskInput) => Promise<string>;
   post: (request: IntakeTaskRequest) => Promise<{ taskId: string; deduplicated?: boolean }>;
   list?: typeof listIntakeItems;
   readNote?: (path: string) => string;
+  connector?: ChannelPublishConnector;
 }
 
 export interface IntakeToTasksResult {
@@ -87,7 +259,19 @@ export interface IntakeToTasksResult {
   created: number;
   skipped: number;
   failed: number;
-  items: Array<{ id: string; status: 'created' | 'deduplicated' | 'dry-run' | 'skipped' | 'failed'; taskId?: string; types?: IntakeTaskType[]; reason?: string }>;
+  items: Array<{
+    id: string;
+    status: 'created' | 'deduplicated' | 'dry-run' | 'skipped' | 'failed' | 'queued' | 'approved' | 'published';
+    taskId?: string;
+    types?: IntakeTaskType[];
+    reason?: string;
+    channel?: string;
+    cadence?: string;
+    voice?: string;
+    owner?: string;
+    category?: string;
+    publishedId?: string;
+  }>;
 }
 
 export function interpretIntakeItem(response: string): IntakeTaskInterpretation | null {
@@ -180,6 +364,10 @@ function goalLines(root: string): IntakeTaskInput[] {
         const value: unknown = JSON.parse(line);
         if (!value || typeof value !== 'object' || Array.isArray(value)) return;
         const row = value as Record<string, unknown>;
+        if (row.kind === 'channel-post') {
+          rows.push({ kind: 'channel-post', id: goalLineId(file, index), draft: toChannelPublishDraft(row) });
+          return;
+        }
         if (typeof row.fact !== 'string' || !row.fact.trim()) return;
         rows.push({ kind: 'goal-line', id: goalLineId(file, index), fact: row.fact, current: typeof row.current === 'string' ? row.current : '',
           ...(typeof row.url === 'string' ? { url: row.url } : {}) });
@@ -240,6 +428,61 @@ export async function runIntakeToTasks(
     .filter(({ input }) => !consumed.has(input.id)).slice(0, limit);
   const result: IntakeToTasksResult = { processed: selected.length, created: 0, skipped: 0, failed: 0, items: [] };
   for (const { input, path } of selected) {
+    if (input.kind === 'channel-post') {
+      if (opts.dryRun) {
+        result.items.push({ id: input.id, status: 'dry-run' });
+        continue;
+      }
+      if (!input.draft) {
+        result.skipped++;
+        result.items.push({ id: input.id, status: 'skipped', reason: 'invalid-channel-post-draft' });
+        continue;
+      }
+      const queue = new ChannelPublishQueue(instanceRoot);
+      try {
+        const queued = queue.enqueue(input.id, input.draft);
+        const plan = isChannelPublishApprovable(queued) ? queue.approve(input.id, queued, { kind: 'automatic' }) : queued;
+        if (plan.status === 'published') {
+          // Crash between the publish ledger and the consumed ledger: the post is already out.
+          appendFileSync(consumedFile(instanceRoot), JSON.stringify({ id: input.id }) + '\n');
+          result.items.push({ id: input.id, status: 'published', channel: plan.channel, cadence: plan.cadence, voice: plan.voice });
+          continue;
+        }
+        if (plan.status === 'approved' && deps.connector) {
+          const release = queue.tryAcquirePublish(input.id);
+          if (release) {
+            try {
+              // Recheck under the per-item lock; another process may have completed before it was acquired.
+              const current = queue.plan(input.id);
+              if (current?.status === 'approved' && !queue.publishedIds().has(input.id)) {
+                const { publishedId } = await deps.connector.publish(current);
+                queue.recordPublished(input.id, current, publishedId);
+                appendFileSync(consumedFile(instanceRoot), JSON.stringify({ id: input.id, publishedId }) + '\n');
+                result.items.push({
+                  id: input.id, status: 'published', channel: current.channel, cadence: current.cadence,
+                  voice: current.voice, owner: current.owner, category: current.category, publishedId,
+                });
+                continue;
+              }
+              if (queue.publishedIds().has(input.id)) {
+                appendFileSync(consumedFile(instanceRoot), JSON.stringify({ id: input.id }) + '\n');
+                result.items.push({ id: input.id, status: 'published', channel: plan.channel, cadence: plan.cadence, voice: plan.voice });
+                continue;
+              }
+            } finally { release(); }
+          }
+          // Another process owns the publish attempt. Leave this item approved for its next pass.
+          result.items.push({ id: input.id, status: 'approved', channel: plan.channel, cadence: plan.cadence, voice: plan.voice });
+          continue;
+        }
+        result.items.push({ id: input.id, status: plan.status, channel: plan.channel, cadence: plan.cadence, voice: plan.voice });
+      } catch {
+        result.failed++;
+        result.items.push({ id: input.id, status: 'failed', reason: 'channel publish failed' });
+        debug.log('intake.to-tasks', 'channel-publish-failed', { id: input.id });
+      }
+      continue;
+    }
     try {
       let plan = loadTaskPlan(instanceRoot, input.id);
       if (!plan) {

package/src/intelligence-map/model-alias.ts

@@ -49,7 +49,7 @@ const MODEL_ALIASES: Readonly<Record<string, string>> = {
   'pro':             'gemini-3.1-pro-preview',
   'gemini-pro':      'gemini-3.1-pro-preview',
   // OpenAI / Codex
-  'codex':           'gpt-6-sol',   // ⭐ 2026-09-25: 운영 codex 기본(gpt-6-sol)과 맞춘다 — gpt-5.5 는 두 세대 낡았다
+  'codex':           'gpt-6.1-terra',
   'gpt-5':           'gpt-5.5',
   'mini':            'gpt-5-mini',
   'nano':            'gpt-5-nano',
@@ -57,15 +57,16 @@ const MODEL_ALIASES: Readonly<Record<string, string>> = {
   //   🔑 왜 — `sol`·`luna` 라는 «같은 이름»이 두 세대에 걸쳐 있다. 세대를 안 쓰면
   //     «어느 세대인지 말하지 않은 것»이고, 그때 골라야 할 것은 ***최신***이다.
   //     (실제로 이 겹침 때문에 커뮤니티 조사기가 5.6 과 6 을 섞어 답한 일이 있었다.)
-  //   ⛔ `terra` 는 GPT-6 에 «없다» — 중간 등급이 접혔고 GPT-6 Sol 이 그 가격대를 흡수했다.
-  //     그래서 `terra` 는 5.6 을 계속 가리킨다(은퇴가 아니라 «후속이 없는» 것이다).
+  //   GPT-6.1 restores a Terra tier; unsuffixed aliases follow the current 6.1 generation.
   //   📏 세대 확인 = `curl /v1/models` ⊕ `codex debug models` (2026-09-23 둘 다 실측).
   'astra':           'gpt-6-astra',
-  'sol':             'gpt-6-sol',
+  'sol':             'gpt-6.1-sol',
   'luna':            'gpt-6-luna',
-  'terra':           'gpt-5.6-terra',   // ⛔ GPT-6 에 후속 없음
+  'terra':           'gpt-6.1-terra',
   // 세대를 «명시»해 부르는 길 — 겹치는 이름을 또렷하게 가리킬 때.
   '6-sol':           'gpt-6-sol',
+  '6.1-sol':         'gpt-6.1-sol',
+  '6.1-terra':       'gpt-6.1-terra',
   '6-luna':          'gpt-6-luna',
   '5.6-sol':         'gpt-5.6-sol',
   '5.6-terra':       'gpt-5.6-terra',

package/src/intelligence-map/model-catalog.ts

@@ -13,6 +13,7 @@ import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from '
 import { dirname, join } from 'node:path';
 import { homedir } from 'node:os';
 import type { ModelCatalog, ModelEntry } from './types.js';
+import { resolveModelAlias } from './model-alias.js';
 
 // 2026-05-03 snapshot — added Kimi (Moonshot) / Qwen 3.6 (Alibaba) /
 // GLM 5.x (Zhipu) families. Open-weight vs cloud-only is captured by
@@ -172,16 +173,55 @@ export const BUILTIN_CATALOG: ModelCatalog = {
       inputPerMtok: 2,
       outputPerMtok: 10,
       local: false,
-      tags: ['coding', 'reasoning', 'agentic', 'balanced', 'long-context'],
+      tags: ['coding', 'reasoning', 'agentic', 'balanced', 'legacy', 'long-context'],
       bestFor: ['daily-coding', 'multi-file-edit', 'autonomous-implementation', 'complex-architecture'],
       reservedOutputTokens: 12_000,
+      // Coarse capability tier (legacy state is recorded in tags; this schema has no `legacy` tier).
       tier: 'better',
       variantOf: 'gpt-6',
       effortAxis: 'sol',
       reasoningEffortCeiling: 'max',
       releasedAt: '2026-09-22',
       classification: { source: 'builtin', at: '2026-09-23' },
-      notes: '대표 2026-09-23 운영 기본(medium) — 구 gpt-5.6-terra 대체. 구독·API 둘 다 확인. effort none/low/medium(기본)/high/xhigh/max · 1.05M ctx(입력 922K · 출력 128K) · 컷오프 2026-04-20. ⚠️ 272K 초과 프롬프트는 input·cache 2배 · output 1.5배로 «요청 전체»가 재과금된다.',
+      notes: 'Legacy GPT-6 Sol retained for explicit compatibility; GPT-6.1 Terra is the current Codex default. 1.05M context. Per OP 2026-10-28 price direction, its cached-input estimate matches GPT-6.1 Sol ($0.10/M).',
+    },
+    {
+      id: 'gpt-6.1-terra',
+      provider: 'openai-codex',
+      family: 'gpt-6',
+      contextWindow: 500_000,
+      inputPerMtok: 1,
+      outputPerMtok: 5,
+      local: false,
+      tags: ['coding', 'reasoning', 'agentic', 'balanced'],
+      bestFor: ['daily-coding', 'multi-file-edit', 'autonomous-implementation'],
+      reservedOutputTokens: 12_000,
+      tier: 'better',
+      variantOf: 'gpt-6',
+      effortAxis: 'terra',
+      reasoningEffortCeiling: 'max',
+      releasedAt: '2026-10-26',
+      classification: { source: 'builtin', at: '2026-10-28' },
+      notes: 'GPT-6.1 Terra · Codex CLI 0.164.0 카탈로그 실측 · 500K context · $1/$5, cached input $0.05/M. CLI 기본 effort=low; elanous 경로 기본 medium 유지.',
+    },
+    {
+      id: 'gpt-6.1-sol',
+      provider: 'openai-codex',
+      family: 'gpt-6',
+      contextWindow: 500_000,
+      inputPerMtok: 2,
+      outputPerMtok: 10,
+      local: false,
+      tags: ['coding', 'reasoning', 'agentic', 'frontier'],
+      bestFor: ['complex-architecture', 'long-horizon-agentic', 'deep-analysis'],
+      reservedOutputTokens: 16_000,
+      tier: 'best',
+      variantOf: 'gpt-6',
+      effortAxis: 'sol',
+      reasoningEffortCeiling: 'max',
+      releasedAt: '2026-10-26',
+      classification: { source: 'builtin', at: '2026-10-28' },
+      notes: 'GPT-6.1 Sol · Codex CLI 0.164.0 카탈로그 실측 · 500K context · $2/$10, cached input $0.10/M. CLI 기본 effort=low; elanous 경로 기본 medium 유지.',
     },
     {
       id: 'gpt-6-luna',
@@ -944,6 +984,23 @@ export function reasoningEffortCeiling(modelId: string | undefined): ReasoningEf
   return 'medium';                               // local 등 미상 — 보수적
 }
 
+export const CHILD_LLM_EFFORT_LADDER = ['minimal', 'low', 'medium', 'high', 'xhigh', 'max'] as const;
+
+/** Shared explicit effort check for task hand and the dev entrypoint. */
+export function childLlmEffortProblem(model: string, entered: string): string | undefined {
+  const effort = entered.trim().toLowerCase();
+  const ladder: readonly string[] = CHILD_LLM_EFFORT_LADDER;
+  if (!ladder.includes(effort)) {
+    return `--child-llm-effort 알 수 없음: ${entered} · 후보: ${CHILD_LLM_EFFORT_LADDER.join(', ')}`;
+  }
+  const ceiling = reasoningEffortCeiling(resolveModelAlias(model.trim()) ?? model.trim());
+  if (ceiling === 'none') return `--child-llm-effort 거부: ${model} 은 추론 노력을 «안 받는다»(ceiling=none)`;
+  if (ladder.indexOf(effort) > ladder.indexOf(ceiling)) {
+    return `--child-llm-effort 거부: ${effort} 가 ${model} 의 상한(${ceiling})을 넘는다`;
+  }
+  return undefined;
+}
+
 // ── Paths ──────────────────────────────────────────────────────────────
 
 export function getCatalogPath(home: string = homedir()): string {