elanous 0.2.27 → 0.2.29

package/src/oauth/codex-account-store.ts

@@ -17,6 +17,7 @@ import {
 import { authStorePath, defaultCodexHome, isUnderTestRunner, listProviders, loadTokens, saveTokens } from './store.js';
 import { readFreshAvailabilityState, quotaSignalDir, readQuotaSignal, readQuotaSignalCredits, readQuotaSignalUsedPercent, readQuotaSignalObservedAt, readQuotaSignalObservedAtRaw } from '../budget/codex-reset-credit-state.js';
 import { creditPaceStatus } from '../budget/codex-credit-pace.js';
+import { noteCodexBillingDecision, type CodexCreditSpendReason } from './codex-billing-route.js';
 import { loadLlmPolicy } from '../policy/llm-policy.js';
 import { getUserConfig } from '../user-config.js';
 import {
@@ -204,6 +205,8 @@ interface RunPin {
   readonly resolution: CodexAccountResolution;
   /** ⛔ 핀이 «갇혔는지»를 싸게 재려면 그 계정의 홈이 필요하다. 모르면 재지 못하므로 그대로 둔다. */
   readonly home: string | undefined;
+  /** 핀을 박은 판정이 크레딧 소진이었나 — 핀으로 돌려줄 때도 과금 경로를 같이 남긴다. */
+  readonly creditReason?: CodexCreditSpendReason;
 }
 const pinnedByRun = new Map<string, RunPin>();
 /** ⛔ 상한 — 장수 프로세스에서 runId 수만큼 «영구히» 자라면 안 된다(리뷰 should-fix).
@@ -213,6 +216,8 @@ const PIN_MAX = 256;
 /** ⛔ 테스트 심 — 고정을 푼다. 프로덕션에서는 부르지 않는다. */
 export function _resetCodexRotationPinForTesting(): void {
   pinnedByRun.clear();
+  // 판정이 남긴 과금 경로도 같이 푼다 — 안 풀면 다음 시험 파일의 codex usage 가 credit 으로 읽힌다.
+  noteCodexBillingDecision(undefined);
 }
 
 /** ⛔⭐⭐ 후보 조립은 «한 자»여야 한다 — 실행 경로와 조회(dry-run)가 다른 자를 쓰면
@@ -728,7 +733,7 @@ export function resolveCodexAccountForRun(
   const explicit = Boolean(env.ELANOUS_CODEX_ACCOUNT?.trim());
   // ⛔⭐ 사람이 «명시»했으면 고정보다 «먼저» 이긴다(결정 ③) — 고정을 읽지도 쓰지도 않는다.
   //   고정이 앞서면, 앞선 호출이 만든 회전 결과가 「명시한 계정」을 덮는다.
-  if (explicit) { observeRotation({ reason: 'explicit' }, current.name); return current; }
+  if (explicit) { observeRotation({ reason: 'explicit' }, current.name); noteCodexBillingDecision(undefined); return current; }
   // ⛔⭐⭐⭐ 설정 판정이 «핀보다 먼저»다(리뷰 must-fix).
   //   핀을 먼저 보면, 같은 런에서 이미 회전·핀된 뒤 설정이 false 로 바뀌어도
   //   ***계속 회전 계정을 돌려준다*** — 「config false 로만 꺼진다」가 핀 경유로 깨진다.
@@ -736,6 +741,7 @@ export function resolveCodexAccountForRun(
   const enabled = rotationConfig.enabled;
   if (!enabled) {
     observeRotation({ reason: 'disabled', disabledProvenance: rotationConfig.state }, current.name);
+    noteCodexBillingDecision(undefined);
     return current;
   }
   // ⛔⭐⭐⭐ 고정은 «런 신원이 있을 때만» 한다.
@@ -763,7 +769,7 @@ export function resolveCodexAccountForRun(
       //   🔑 전환은 «소진당 한 번»으로 갇히고, 그 뒤 다시 핀이 박힌다.
       const pinnedHome = pinned.home;
       const exhausted = pinnedHome !== undefined && pinnedAccountExhausted(pinnedHome, pinned.resolution.name);
-      if (!exhausted) return pinned.resolution;
+      if (!exhausted) { noteCodexBillingDecision(pinned.creditReason); return pinned.resolution; }
       pinnedByRun.delete(runKey);
       debug.log('oauth.codex-account', 'pin-released',
         { account: pinned.resolution.name, why: 'threshold-reached' }, { level: 'warn' });
@@ -806,6 +812,8 @@ export function resolveCodexAccountForRun(
   // CREDIT-SPEND-ORDER(10-12) — «다른 계정의 선불 크레딧으로 옮김»(`rotated` ⊕ creditEntry)도 크레딧 진입이다.
   const creditSpendReason = decision.reason === 'credits-allowed' || decision.reason === 'credit-pace' ? decision.reason
     : decision.reason === 'rotated' && decision.creditEntry ? 'credits-rotated' as const : undefined;
+  // CREDIT-BILLING-LABEL(10-14) — 이 판정으로 나가는 호출의 `llm.usage` 가 `billing='credit'` 이 되게 남긴다.
+  noteCodexBillingDecision(creditSpendReason);
   if (creditSpendReason && !deps.counterPath && isUnderTestRunner(process.env)) {
     // 시험 러너 가드(autoConsume 의 test-runtime-guard 와 같은 관용구) — 카운터를 주입 안 한 시험이 실제 카운터·송신기에 닿지 않는다.
     debug.log('oauth.codex-account', 'credit-spend-alert-skipped', { account: decision.to?.name ?? current.name, reason: 'test-runtime-guard' });
@@ -833,7 +841,11 @@ export function resolveCodexAccountForRun(
       const oldest = pinnedByRun.keys().next().value;
       if (oldest !== undefined) pinnedByRun.delete(oldest);
     }
-    pinnedByRun.set(runKey, { resolution: resolved, home: effectiveCodexHome(resolved, loadTokens(resolved.storeKey, path), env).home });
+    pinnedByRun.set(runKey, {
+      resolution: resolved,
+      home: effectiveCodexHome(resolved, loadTokens(resolved.storeKey, path), env).home,
+      ...(creditSpendReason ? { creditReason: creditSpendReason } : {}),
+    });
   }
   return resolved;
 }

package/src/oauth/codex-billing-route.ts

@@ -0,0 +1,31 @@
+/**
+ * codex 호출의 «과금 경로» 기억 — 회전 판정이 크레딧 소진을 정했으면 그 호출의 `llm.usage` 가 `billing='credit'` 이다.
+ *
+ * 🩸 10-14 운영 실측: 세 계정이 주간 100% 라 회전이 `credits-allowed` 로 default 계정 크레딧을 쓰는데,
+ *   같은 턴의 `llm.usage` 는 `billing=subscription` · `cost.kind=included($0)` 였다 — 원장·토큰 경보가 크레딧 지출을 $0 로 봤다.
+ *   자격 종류(oauth)만으로 과금 경로를 정하면 «구독 한도를 넘어 크레딧으로 나간 호출»을 구분 못 한다.
+ *
+ * 경로: `loadFreshCodexAuthState` → `resolveCodexAccountForRun`(요청마다 · 판정·핀) → 여기 기록
+ *   → 응답 끝 `logAgentTurnUsage` → `billingRouteForProvider('openai-codex')` 가 여기를 읽는다.
+ * ⚠️ 프로세스 단위 «마지막 판정»이다 — 같은 프로세스에서 다른 런이 동시에 다른 판정을 내리면 섞일 수 있다
+ *   (판정은 같은 스토어·설정을 읽으므로 보통 같은 답이다).
+ */
+
+export type CodexCreditSpendReason = 'credits-allowed' | 'credit-pace' | 'credits-rotated';
+
+let lastCreditReason: CodexCreditSpendReason | undefined;
+
+/** 계정 해석이 끝날 때마다 부른다 — 크레딧 소진이 아니면 `undefined` 로 지운다(앞 판정이 남지 않게). */
+export function noteCodexBillingDecision(reason: CodexCreditSpendReason | undefined): void {
+  lastCreditReason = reason;
+}
+
+/** 마지막 codex 계정 해석이 크레딧 소진이었으면 그 이유. */
+export function codexCreditSpendReason(): CodexCreditSpendReason | undefined {
+  return lastCreditReason;
+}
+
+/** ⛔ 테스트 심 — 프로덕션에서는 부르지 않는다. */
+export function _resetCodexBillingDecisionForTesting(): void {
+  lastCreditReason = undefined;
+}

package/src/ops/overview-collect.ts

@@ -10,7 +10,8 @@ import { effectiveInstanceRoot } from '../instance/resolve.js';
 import type { Checklist, ChecklistItem } from '../release-loop/checklist.js';
 import type { ReleaseSchedule } from '../release-loop/release-schedule.js';
 import type { ResourceView } from '../control-plane/ledger.js';
-import type { TaskCard } from '../task-agent/task-hand.js';
+import { cardPrNumber, type TaskCard } from '../task-agent/task-hand.js';
+import { measureLandingThroughput, type LandingThroughput } from '../task-agent/cover.js';
 import {
   okCell, unmeasured, type Cell, type CapacityInfo, type ChecklistCounts, type LaunchableInfo, type LoopRow, type MachineRow,
   type OverviewSnapshot, type OwnerTaskRow, type ParentsInfo, type PodMemberRow, type ReleaseRunInfo, type ScheduleInfo,
@@ -269,6 +270,22 @@ export async function collectOverview(opts: CollectOptions, injected: CollectDep
   const byOwner: Cell<Record<string, OwnerTaskRow>> = cards instanceof Error
     ? unmeasured('task-agent ledger', errText(cards))
     : okCell(ownerRows(cards, kstMidnight, opts.owner), `task-agent ledger(오늘 KST · owner=seat 키)`, iso(now));
+  const launchedCards = cards instanceof Error ? [] : cards.filter((card) => card.createdAt >= kstMidnight && card.status === 'launched');
+  const throughput = cards instanceof Error
+    ? unmeasured<LandingThroughput>('task-agent ledger', errText(cards))
+    : okCell(measureLandingThroughput({
+      launched: launchedCards.length,
+      cardPrs: launchedCards.filter((card) => cardPrNumber(card) !== undefined).length,
+      taskAgentActions: launchedCards.flatMap((card) => (card.landAttempts ?? [])
+        .filter((attempt) => attempt.at >= kstMidnight)
+        .map((attempt) => ({
+          kind: 'land' as const,
+          result: attempt.ok === true ? 'done' : attempt.ok === false ? 'failed' : 'pending',
+          reason: attempt.reason ?? attempt.detail,
+        }))),
+      allLands: null,
+      pendingLandingAgeSeconds: null,
+    }), 'task-agent ledger(오늘 KST · landAttempts)', iso(now));
   const done = unmeasured<number>('task-agent ledger', '착지 판정은 PR 조회가 필요 — owner 모델(OVW-OWNER)·card-evidence 연결 전');
 
   // 발사 가능 — 열린 판(앞으로의 컷) 전부.
@@ -334,7 +351,7 @@ export async function collectOverview(opts: CollectOptions, injected: CollectDep
       beat: okCell({ lastAt: b.lastAt, ageSeconds: b.ageSeconds, alive: b.alive }, `${SEAT_ERA_SOURCE} dispatcher-${b.seat}.pid`, b.lastAt) });
   }
 
-  return { generatedAt: iso(now), instanceRoot: root, since: opts.sinceLabel, release, tasks, machines, landings, loops };
+  return { generatedAt: iso(now), instanceRoot: root, since: opts.sinceLabel, release, tasks, machines, landings, throughput, loops };
 }
 
 export function parseSince(raw: string | undefined): { ms: number; label: string } {

package/src/panes/log-pane.ts

@@ -7,7 +7,7 @@
 import { C, stripAnsi, truncate, visibleWidth } from '../tui.js';
 import type { FoldMode } from '../log-entry.js';
 import { paneTitle } from './pane-title.js';
-import { highlightLineSegments } from '../log-pane/search.js';
+import { highlightLineSegments, type LogSearchResult } from '../log-pane/search.js';
 import type { PaneSpec, RenderCtx } from '../plugins/core/types.js';
 
 export interface LogPaneState {
@@ -60,6 +60,64 @@ export interface LogPaneViewport {
   visibleLineIndices: number[];
 }
 
+/** Dashboard scroll offsets count painted rows, while freeze/copy indices
+ *  still address original entries. Match the pane's filter before scrolling.
+ *  The common no-filter path counts delimiters without allocating rows. */
+export function physicalLogRowCount(
+  lines: readonly string[],
+  beforeIndex = lines.length,
+  filterQuery = '',
+): number {
+  let count = 0;
+  const query = filterQuery.trim().toLowerCase();
+  for (let i = 0; i < Math.min(beforeIndex, lines.length); i++) {
+    const entry = lines[i] ?? '';
+    if (query) {
+      count += entry.split(/\r\n|\r|\n/).filter(line => stripAnsi(line).toLowerCase().includes(query)).length;
+      continue;
+    }
+    count++;
+    for (let j = 0; j < entry.length; j++) {
+      if (entry[j] === '\n') count++;
+      else if (entry[j] === '\r') {
+        count++;
+        if (entry[j + 1] === '\n') j++;
+      }
+    }
+  }
+  return count;
+}
+
+export function visibleSearchRowOffset(
+  lines: readonly string[],
+  result: LogSearchResult,
+  filterQuery = '',
+): number {
+  const precedingRows = physicalLogRowCount(lines, result.lineIdx, filterQuery);
+  const entryRowsBeforeMatch = (lines[result.lineIdx] ?? '')
+    .split(/\r\n|\r|\n/)
+    .slice(0, result.physicalRowInEntry ?? 0);
+  const filter = filterQuery.trim().toLowerCase();
+  const withinEntry = filter
+    ? entryRowsBeforeMatch.filter(line => stripAnsi(line).toLowerCase().includes(filter)).length
+    : entryRowsBeforeMatch.length;
+  return precedingRows + withinEntry;
+}
+
+export function logPaneContentHeight(height: number, hasFooter: boolean, hasQueueRow: boolean): number {
+  return Math.max(0, height - 1 - (hasFooter ? (hasQueueRow ? 3 : 2) : 0));
+}
+
+export function maxLogPaneScroll(
+  lines: readonly string[],
+  height: number,
+  opts: { filterQuery?: string; frozenTailIndex?: number | null; hasFooter?: boolean; hasQueueRow?: boolean } = {},
+): number {
+  const sourceCount = opts.frozenTailIndex ?? lines.length;
+  const visibleRows = physicalLogRowCount(lines, sourceCount, opts.filterQuery);
+  return Math.max(0, visibleRows - logPaneContentHeight(height, !!opts.hasFooter, !!opts.hasQueueRow));
+}
+
 function buildScrollStatusLine(opts: {
   start: number;
   visibleCount: number;
@@ -96,11 +154,13 @@ export function buildLogPaneViewport(state: LogPaneState, ctx: RenderCtx): LogPa
   const frozenLines = frozen != null ? state.lines.slice(0, frozen) : state.lines;
   const hiddenBehindFreeze = frozen != null ? Math.max(0, state.lines.length - frozen) : 0;
   const filterQuery = state.filterQuery?.trim() ?? '';
-  const filtered = frozenLines.flatMap((line, index) => {
-    if (!filterQuery) return [{ line, index }];
-    return stripAnsi(line).toLowerCase().includes(filterQuery.toLowerCase())
-      ? [{ line, index }]
-      : [];
+  // Each source entry can contain embedded newlines. Expand it before
+  // viewport math so one array item never paints over the footer/input rows.
+  const physicalLines = frozenLines.flatMap((entry, index) =>
+    entry.split(/\r\n|\r|\n/).map(line => ({ line, index })));
+  const filtered = physicalLines.filter(({ line }) => {
+    if (!filterQuery) return true;
+    return stripAnsi(line).toLowerCase().includes(filterQuery.toLowerCase());
   });
   const visibleLines = filtered.map(item => item.line);
   const visibleLineIndices = filtered.map(item => item.index);
@@ -130,8 +190,7 @@ export function buildLogPaneViewport(state: LogPaneState, ctx: RenderCtx): LogPa
   // breathing gap above + 1-row footer) so the streamed text doesn't
   // feel crammed against the indicator.
   const hasQueueRow = hasFooter && state.queueRow != null && state.queueRow !== '';
-  const footerReserve = hasFooter ? (hasQueueRow ? 3 : 2) : 0;
-  const contentH = Math.max(0, bodyH - footerReserve);
+  const contentH = logPaneContentHeight(ctx.height, hasFooter, hasQueueRow);
   const maxScroll = Math.max(0, visibleLines.length - contentH);
   const start = state.scrollOffset < 0
     ? maxScroll

package/src/patents/ledger.ts

@@ -0,0 +1,128 @@
+import { Database } from 'bun:sqlite';
+import { chmodSync, mkdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { elanousStateRoot } from '../autopilot/state-paths.js';
+import { debug } from '../debug/log.js';
+
+/** 특허 후보의 갈래 — 구체 후보와 기전은 비공개 원장에만 둔다. */
+const PATENT_TRACKS = ['비공개', '출원', '신규'] as const;
+/** 특허 후보의 상태 — 조사/명세/출원/공개 허용 중 공개 허용 상태만 공개 읽기 통로에 나온다. */
+const PATENT_STATUSES = ['조사', '명세', '출원', '공개 허용'] as const;
+
+export type PatentTrack = (typeof PATENT_TRACKS)[number];
+export type PatentStatus = (typeof PATENT_STATUSES)[number];
+
+export class PatentsInputError extends Error {
+  override name = 'PatentsInputError';
+}
+
+export interface PatentCandidate {
+  id: string;
+  title: string;
+  track: PatentTrack;
+  status: PatentStatus;
+  deadline: string | null;
+  created_at: string;
+  updated_at: string;
+}
+export interface PatentLedgerOptions { stateDir?: string; now?: () => Date }
+
+function required(value: string, field: string): string {
+  if (typeof value !== 'string' || !value.trim()) throw new PatentsInputError(`${field} is required`);
+  return value.trim();
+}
+
+function trackOf(value: PatentTrack): PatentTrack {
+  if (!PATENT_TRACKS.includes(value)) throw new PatentsInputError(`invalid track: ${value}`);
+  return value;
+}
+
+function statusOf(value: PatentStatus): PatentStatus {
+  if (!PATENT_STATUSES.includes(value)) throw new PatentsInputError(`invalid status: ${value}`);
+  return value;
+}
+
+function isoDate(value: string, field: string): string {
+  if (typeof value !== 'string' || !/^\d{4}-\d\d-\d\d$/.test(value)) throw new PatentsInputError(`invalid ${field}: ${value}`);
+  const date = new Date(`${value}T00:00:00.000Z`);
+  if (Number.isNaN(date.getTime()) || date.toISOString().slice(0, 10) !== value) throw new PatentsInputError(`invalid ${field}: ${value}`);
+  return value;
+}
+
+/** 후보 식별자·갈래·상태·마감일의 비공개 원장 — 공개 허용 상태 후보만 읽기 통로로 노출한다. */
+export class PatentLedger {
+  readonly path: string;
+  private readonly now: () => Date;
+
+  constructor(options: PatentLedgerOptions = {}) {
+    this.path = join(options.stateDir ?? elanousStateRoot(), 'patents', 'patents.sqlite');
+    this.now = options.now ?? (() => new Date());
+  }
+
+  private open(): Database {
+    mkdirSync(dirname(this.path), { recursive: true });
+    const db = new Database(this.path, { create: true, strict: true });
+    try {
+      chmodSync(this.path, 0o600);
+      db.exec('PRAGMA busy_timeout = 10000');
+      db.exec('PRAGMA journal_mode = WAL');
+      db.exec(`CREATE TABLE IF NOT EXISTS patent_candidates (
+        id TEXT PRIMARY KEY, title TEXT NOT NULL,
+        track TEXT NOT NULL CHECK(track IN ('비공개','출원','신규')),
+        status TEXT NOT NULL CHECK(status IN ('조사','명세','출원','공개 허용')),
+        deadline TEXT, created_at TEXT NOT NULL, updated_at TEXT NOT NULL);`);
+      return db;
+    } catch (error) { db.close(); throw error; }
+  }
+
+  private using<T>(work: (db: Database) => T): T {
+    const db = this.open();
+    try { return work(db); } finally { db.close(); }
+  }
+
+  private transaction<T>(db: Database, work: () => T): T {
+    db.exec('BEGIN IMMEDIATE');
+    try { const result = work(); db.exec('COMMIT'); return result; }
+    catch (error) { db.exec('ROLLBACK'); throw error; }
+  }
+
+  private row(db: Database, id: string): PatentCandidate {
+    const row = db.query('SELECT id, title, track, status, deadline, created_at, updated_at FROM patent_candidates WHERE id = ?').get(id) as PatentCandidate | null;
+    if (!row) throw new PatentsInputError(`patent candidate not found: ${id}`);
+    return row;
+  }
+
+  add(input: { id: string; title: string; track: PatentTrack; status?: PatentStatus; deadline?: string }): PatentCandidate {
+    const id = required(input.id, 'id');
+    if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(id)) throw new PatentsInputError('invalid patent candidate id');
+    const title = required(input.title, 'title');
+    const track = trackOf(input.track);
+    const status = statusOf(input.status ?? '조사');
+    const deadline = input.deadline === undefined ? null : isoDate(input.deadline, 'deadline');
+    return this.using(db => this.transaction(db, () => {
+      if (db.query('SELECT 1 FROM patent_candidates WHERE id = ?').get(id)) throw new PatentsInputError(`patent candidate already exists: ${id}`);
+      const at = this.now().toISOString();
+      db.query('INSERT INTO patent_candidates (id, title, track, status, deadline, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?)')
+        .run(id, title, track, status, deadline, at, at);
+      debug.log('patents.ledger', 'add', { id, status });
+      return this.row(db, id);
+    }));
+  }
+
+  setStatus(id: string, status: PatentStatus): PatentCandidate {
+    const next = statusOf(status);
+    return this.using(db => this.transaction(db, () => {
+      this.row(db, id);
+      const at = this.now().toISOString();
+      db.query('UPDATE patent_candidates SET status = ?, updated_at = ? WHERE id = ?').run(next, at, id);
+      debug.log('patents.ledger', 'status', { id, status: next });
+      return this.row(db, id);
+    }));
+  }
+
+  /** 이 원장의 유일한 공개 읽기 통로 — 공개 허용 상태 후보만 나온다(조사·명세·출원 상태 후보는 나오지 않는다). */
+  listPublicCandidates(): PatentCandidate[] {
+    return this.using(db =>
+      db.query(`SELECT id, title, track, status, deadline, created_at, updated_at FROM patent_candidates WHERE status = '공개 허용' ORDER BY created_at, id`).all() as PatentCandidate[]);
+  }
+}

package/src/persona/presets.ts

@@ -225,3 +225,47 @@ export function describePreset(p: PersonaPreset): string[] {
     `  하지 않는 것: ${p.doesNot.join(' / ')}`,
   ];
 }
+
+// ── 0.2.29 PERSONA-STARTER — 첫 실행 직업 질문의 «경영» 스타터 계약 ────────
+//
+// persona-presets/*.yaml(MK 카탈로그)와는 다른 층이다: 첫 실행 wizard 의 직업
+// 질문에서 «경영»을 고른 순간 «한 장» 만들어 주는 계약 원본. 카탈로그 YAML
+// 원본은 그대로 두고 이 계약은 presets.ts 에서 정의해 기존 clonePreset 파이프라인으로
+// persona store 에 복제한다(마케팅·현장·교육 스타터는 후속 조각).
+
+/** 첫 실행 «경영» 스타터 — persona store 에 정확히 한 장 쓰인다. */
+const MANAGEMENT_STARTER_PRESET: PersonaPreset = {
+  personaId: 'starter-management',
+  displayName: '경영 스타터',
+  names: ['경영 스타터', '경영', 'starter-management'],
+  role: '경영 파트너',
+  title: '첫 실행 스타터',
+  oneLine: '회사 방향·판단·운영을 같이 세우는 짝.',
+  voice: {
+    rule: '짧고 단정하게 — 결론 먼저, 근거 한 줄.',
+    examples: [
+      '이번 주 우선순위는 셋뿐입니다. 첫째는 매출 회수입니다.',
+      '그 결정은 근거가 부족합니다 — 가장 싼 실험부터 하시죠.',
+    ],
+  },
+  tasks: [
+    { when: '아침 루프', what: '할 일·일정·미결 회의를 한 화면에 모아 첫 판단을 준다' },
+    { when: '판단이 갈릴 때', what: '선택지를 셋으로 좁혀 근거·비용·되돌림 수단을 나란히 놓는다' },
+    { when: '주간 정산', what: '지난 결정과 실제 결과를 대조해 다음 판단 기준을 고친다' },
+  ],
+  tools: [],
+  firstQuestions: [
+    '지금 가장 급한 경영 판단은 무엇인가요?',
+    '이번 주에 꼭 정해야 할 일이 있나요?',
+  ],
+  doesNot: [
+    '회사 기밀을 외부에 전송하지 않는다',
+    '합의되지 않은 지출·계약을 대신 실행하지 않는다',
+  ],
+  forWhom: '처음 elanous 를 여는 경영자 — 방향·판단·운영을 함께 시작하려는 사람.',
+};
+
+/** 첫 실행 «경영» 선택이 부르는 유일한 제작 입구 — 스타터 계약 한 장을 persona store 에 쓴다. */
+export function createManagementStarterContract(opts: PersonaWriteOptions = {}): PersonaWriteResult {
+  return clonePreset(MANAGEMENT_STARTER_PRESET, MANAGEMENT_STARTER_PRESET.displayName, opts);
+}

package/src/plugins/install/market-fetch.ts

@@ -1,7 +1,8 @@
 import { createHash } from 'node:crypto';
 import { chmodSync, existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { withFileLockSync } from '../../storage/file-lock.js';
-import { dirname, join, resolve } from 'node:path';
+import { loadPluginManifestFromDir } from '../core/manifest.js';
+import { dirname, isAbsolute, join, resolve } from 'node:path';
 import { elanousStateRoot } from '../../autopilot/state-paths.js';
 import { userConfigPath } from '../../user-config.js';
 import { OFFICIAL_INDEX_KEYS } from '../../market/official-keys.js';
@@ -37,6 +38,36 @@ export interface MarketIndex {
   signature: 'ok';
   keyId: string;
 }
+/** Resolve only an installed, available Codex plugin package to the local-path input
+ *  already accepted by `plugin add`. Codex marketplace records are not Elanous signed indices. */
+export function codexPluginPackagePath(response: unknown, name: string, marketplace: string): string {
+  if (!NAME.test(name) || !NAME.test(marketplace)) throw new MarketFetchError('io', 'invalid Codex plugin or marketplace name');
+  const inventory = response as { marketplaces?: unknown } | null;
+  if (!inventory || !Array.isArray(inventory.marketplaces)) throw new MarketFetchError('io', 'invalid Codex plugin/list response');
+  const matches: string[] = [];
+  for (const rawMarket of inventory.marketplaces) {
+    if (!rawMarket || typeof rawMarket !== 'object') throw new MarketFetchError('io', 'invalid Codex marketplace');
+    const market = rawMarket as { name?: unknown; plugins?: unknown };
+    if (market.name !== marketplace) continue;
+    if (!Array.isArray(market.plugins)) throw new MarketFetchError('io', 'invalid Codex marketplace plugins');
+    for (const rawPlugin of market.plugins) {
+      if (!rawPlugin || typeof rawPlugin !== 'object') continue;
+      const plugin = rawPlugin as Record<string, unknown>;
+      if (plugin.name !== name || plugin.installed !== true) continue;
+      if (typeof plugin.availability === 'string' && plugin.availability.toUpperCase() !== 'AVAILABLE') continue;
+      const path = plugin.installPath ?? plugin.path;
+      if (typeof path !== 'string' || !isAbsolute(path) || !existsSync(path) || !statSync(path).isDirectory()) {
+        throw new MarketFetchError('io', 'Codex installed plugin package directory unavailable');
+      }
+      const manifest = loadPluginManifestFromDir(path, { id: name }).manifest;
+      if (manifest.id !== name) throw new MarketFetchError('io', 'Codex package name differs from inventory');
+      matches.push(path);
+    }
+  }
+  if (matches.length !== 1) throw new MarketFetchError('io', `Codex plugin not installed or ambiguous: ${name}@${marketplace}`);
+  return matches[0]!;
+}
+
 export class MarketFetchError extends Error {
   constructor(public readonly reason: 'io' | 'signature', message: string) {
     super(message);

package/src/plugins/maker/wizard-generate.ts

@@ -63,8 +63,9 @@ export function generateWizardFiles(dir: string, slug: string, draft: WizardRese
   }
   const skillPath = join(dir, `skills/${slug}/SKILL.md`);
   const readmePath = join(dir, 'README.md');
-  const wizardReadme = options.regenerate && existsSync(readmePath) &&
-    readFileSync(readmePath, 'utf8').includes('Research draft only. Connector declarations contain credential names, not values.');
+  const readmeNotice = 'Research draft only. Connector declarations contain credential names, not values. The graph cannot perform the requested processing yet: implement and validate its steps, then remove extensions["ai.elanous"].researchDraft from plugin.json before installing or running it. No messages are sent.';
+  const wizardReadme = options.regenerate && existing && existsSync(readmePath) &&
+    readFileSync(readmePath, 'utf8') === `# ${slug}\n\n${existing.description}\n\n${readmeNotice}\n`;
   if (options.regenerate) {
     if (!existing || existing.extensions['ai.elanous'].researchDraft !== true || !existsSync(skillPath)) {
       throw new Error('wizard regeneration requires an existing research draft');
@@ -80,7 +81,8 @@ export function generateWizardFiles(dir: string, slug: string, draft: WizardRese
     requires: undefined as { knowledgePacks?: string[]; [key: string]: unknown } | undefined,
     extensions: { 'ai.elanous': { graphs: [`./graphs/${slug}.yaml`],
       capabilities: ['fs:workdir', 'proc:bun', 'proc:elanous'], connectors: [] as unknown[], researchDraft: true } } };
-  if (options.regenerate) manifest.description = draft.description;
+  // A maker scaffold may have no description or an earlier description; the research draft owns this field.
+  manifest.description = draft.description;
   if (draft.requires?.knowledgePacks !== undefined) {
     manifest.requires = { ...manifest.requires, knowledgePacks: [...new Set(draft.requires.knowledgePacks)] };
   }
@@ -108,7 +110,7 @@ console.log(JSON.stringify({ outcome: 'fail', error: step === 'prepare' || step
 process.exitCode = 1;
 `],
     ['examples/input.json', '{}\n'],
-    ['README.md', `# ${slug}\n\n${draft.description}\n\nResearch draft only. Connector declarations contain credential names, not values. The graph cannot perform the requested processing yet: implement and validate its steps, then remove extensions["ai.elanous"].researchDraft from plugin.json before installing or running it. No messages are sent.\n`],
+    ['README.md', `# ${slug}\n\n${draft.description}\n\n${readmeNotice}\n`],
     [`skills/${slug}/SKILL.md`, `---\n${stringifyYaml({ name: slug, description: draft.skill?.description ?? draft.description, requires: [...new Set(requires)] })}---\n\n${draft.skill?.instructions ?? draft.description}\n`],
   ];
   const generated = existing ? files.filter(([path]) => path === 'plugin.json' || path.startsWith('skills/') ||