elanous 0.2.20 → 0.2.22

package/src/index.ts

@@ -613,9 +613,10 @@ function buildHarnessAskSayDevCliSpec(
   input: { file: string },
   cliOpts: ReturnType<typeof harnessAskSayOptionsToDevCliOpts>,
   entranceId: EntranceId,
+  runId: string,
 ) {
   return {
-    ...buildDevCliSpec(input, { kind: 'self' }, cliOpts, Object.keys(cliOpts), entranceId),
+    ...buildDevCliSpec(input, { kind: 'self' }, cliOpts, Object.keys(cliOpts), entranceId, undefined, undefined, runId),
     ...(cliOpts.json ? { humanReadableOutput: false } : {}),
   };
 }
@@ -661,6 +662,7 @@ async function runDevAskFromAskFile(askPath: string, opts: HarnessAskSayChildLlm
         { file: flowResult.goalFile },
         cliOpts,
         CLI_HARNESS_ASK_ENTRANCE.id,
+        identity.runId,
       ),
       ...(pieceFeature === undefined ? {} : { input: { text: pieceFeature } }),
       ...(base === undefined ? {} : { base }),
@@ -765,6 +767,7 @@ async function runDevAskFromGoalFile(goalPath: string, opts: HarnessAskSayChildL
         { file: goalPath },
         cliOpts,
         CLI_HARNESS_ASK_ENTRANCE.id,
+        identity.runId,
       ),
       runId: identity.runId,
       runIdSource: identity.source,
@@ -868,6 +871,7 @@ async function runDevSayFromWords(
         { file: flowResult.goalFile },
         cliOpts,
         entrance,
+        identity.runId,
       ),
       runId: identity.runId,
       runIdSource: identity.source,
@@ -1271,9 +1275,10 @@ marketCmd.command('publish').description('Publish a local signed marketplace ind
   .option('--source-sha <sha>', 'Git source commit')
   .option('--source-base <path>', 'Git source plugin base directory')
   .option('--bundle-root <dir>', 'Root that extensions["ai.elanous"].bundle paths resolve against (usually the repository root)')
+  .option('--keep-existing', 'Carry over previous index entries whose name has no folder under --dir (unchanged entry and archive)')
   .option('--json', 'JSON result')
   .action(async (opts: { dir: string; out: string; key: string; keyId: string; marketName: string; displayName: string;
-    sourceRepo?: string; sourceSha?: string; sourceBase?: string; bundleRoot?: string; json?: boolean }) => {
+    sourceRepo?: string; sourceSha?: string; sourceBase?: string; bundleRoot?: string; keepExisting?: boolean; json?: boolean }) => {
     try {
       const sourceOptions = [opts.sourceRepo, opts.sourceSha, opts.sourceBase];
       if (sourceOptions.some(Boolean) && !sourceOptions.every(Boolean)) throw new Error('source-repo, source-sha and source-base must be provided together');
@@ -1282,12 +1287,14 @@ marketCmd.command('publish').description('Publish a local signed marketplace ind
         market: { name: opts.marketName, displayName: opts.displayName },
         key: { keyId: opts.keyId, privateKeyPem: readFileSync(opts.key, 'utf8') },
         ...(opts.bundleRoot ? { bundleRoot: opts.bundleRoot } : {}),
+        ...(opts.keepExisting ? { keepExisting: true } : {}),
         ...(opts.sourceRepo && opts.sourceSha && opts.sourceBase
           ? { source: { repoUrl: opts.sourceRepo, sha: opts.sourceSha, basePath: opts.sourceBase } } : {}),
       });
       if (opts.json) await writeStdoutJson(JSON.stringify(result) + '\n');
       else {
-        console.log(`Published ${result.published.length} plugins (sequence ${result.sequence}); skipped ${result.skipped.length}`);
+        console.log(`Published ${result.published.length} plugins (sequence ${result.sequence}); skipped ${result.skipped.length}` +
+          (opts.keepExisting ? `; kept ${result.kept.length}` : ''));
         for (const warning of result.warnings) console.warn(`⚠ ${warning.dir}: ${warning.graph} uses recipes it does not ship (${warning.recipes.join(', ')}) — third-party graphs should use their own recipes.yaml or custom nodes`);
       }
       for (const item of result.skipped) {
@@ -3477,8 +3484,10 @@ coordCmd.command('event').command('record')
   .requiredOption('--header <line>', '채널 글 첫 줄')
   .option('--url <url>', '채널 코멘트 URL')
   .action(async (opts: { seat: string; header: string; url?: string }) => {
-    const { parseCoordHeader, recordCoordEvent } = await import('./context-bus/coord-events.js');
-    recordCoordEvent({ ...parseCoordHeader(opts.seat, opts.header), url: opts.url || null });
+    const { parseCoordHeader, recordCoordEvent, mirrorCoordDecision } = await import('./context-bus/coord-events.js');
+    const input = { ...parseCoordHeader(opts.seat, opts.header), url: opts.url || null, at: new Date().toISOString() };
+    try { recordCoordEvent(input); }
+    finally { mirrorCoordDecision(input); }
   });
 coordCmd.command('events')
   .option('--since <ISO|2h>', '조회 시작', '2h')
@@ -4465,8 +4474,10 @@ selfCmd
     };
     try {
       const { dispatchHeavyCheck } = await import('./self-implement/gate-remote.js');
-      const { execFileSync } = await import('node:child_process');
-      const repo = execFileSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).trim();
+      const { runGitCommand } = await import('./git-fs/runner.js');
+      const topLevel = runGitCommand(process.cwd(), ['rev-parse', '--show-toplevel'], { encoding: 'utf8' });
+      if (topLevel.status !== 0) throw new Error(`git rev-parse --show-toplevel failed: ${topLevel.stderr.trim() || `rc=${topLevel.status}`}`);
+      const repo = topLevel.stdout.trim();
       // Only a committed --base range is reproducible on another host: the default mode measures uncommitted files, --pr
       // reads files through gh on this host, and the remote checkout runs from the repository root — those stay local.
       const { realpathSync } = await import('node:fs');
@@ -4891,7 +4902,7 @@ const selfOrchestrateCmd = selfCmd
         // ☸️ 풀이 «원격 노드뿐»이면 이 기계의 이미지는 아무도 안 쓴다 — 로컬 판정·굽기를 건너뛰고 기준 판 = HEAD 로 노드 동기화만 한다.
         //   🩸 2026-09-26 실측: 원격 전용 풀인데 로컬 이미지가 없다고 로컬에서 굽다가 로컬 클러스터(elanous-h1)가 없어 런이 시작도 전에 죽었다.
         const remoteOnlyPool = poolMembers.length > 0 && poolMembers.every((m) => Boolean(m.sshHost));
-        const headCommit = remoteOnlyPool ? ((await import('node:child_process')).spawnSync('git', ['rev-parse', 'HEAD'], { encoding: 'utf8' }).stdout?.trim() || null) : null;
+        const headCommit = remoteOnlyPool ? ((await import('./git-fs/runner.js')).runGitCommand(process.cwd(), ['rev-parse', 'HEAD'], { encoding: 'utf8' }).stdout.trim() || null) : null;
         let image = remoteOnlyPool
           ? { imageCommit: headCommit, headCommit, fresh: true, reason: 'remote-only pool — 노드 쪽에서 맞춘다' }
           : podImageFreshness();
@@ -4901,7 +4912,8 @@ const selfOrchestrateCmd = selfCmd
           } else {
             if (!opts.json) ui.info(`[pod] 이미지 다시 굽기 — ${image.reason} (~1분)`);
             const { spawnSync } = await import('node:child_process');
-            const top = spawnSync('git', ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).stdout.trim() || process.cwd();
+            const { runGitCommand } = await import('./git-fs/runner.js');
+            const top = runGitCommand(process.cwd(), ['rev-parse', '--show-toplevel'], { encoding: 'utf8' }).stdout.trim() || process.cwd();
             // bun 1.4 applies the 1 MiB default maxBuffer: a docker build log past it kills the child (ENOBUFS · status null).
             const b = spawnSync('bash', [`${top}/docker/harness/build.sh`], { encoding: 'utf8', timeout: 900_000, maxBuffer: 64 * 1024 * 1024 });
             if (b.status !== 0) { ui.error(`--substrate pod: 이미지 굽기 실패 rc=${b.status}${b.error ? ` (${(b.error as NodeJS.ErrnoException).code ?? b.error.message})` : ''}: ${(b.stdout + b.stderr).slice(-400)}`); process.exit(2); }
@@ -7314,8 +7326,8 @@ const selfDevCmd = program
         console.error(`[dev] 외부 backend 미션의 자기 명령은 \`elanous agent-mission mission\` 입니다; 대응 명령: elanous agent-mission mission --backend ${executor.backend}`);
       }
       let spec = invokedAsDrive
-        ? devCli.buildDriveAliasDevSpec(hasText ? textParts.join(' ') : undefined, devOpts, devCli.explicitDevOptionNames(command))
-        : buildDevCliSpec(input, executor, devOpts, devCli.explicitDevOptionNames(command));
+        ? devCli.buildDriveAliasDevSpec(hasText ? textParts.join(' ') : undefined, devOpts, devCli.explicitDevOptionNames(command), devRunId)
+        : buildDevCliSpec(input, executor, devOpts, devCli.explicitDevOptionNames(command), 'cli-dev-ask', undefined, undefined, devRunId);
       if (!opts.json && spec.notice) console.error(spec.notice);
       // 역할별 LLM은 현재 프로세스 설정이다. self-mission 구현 자식에 전달되지 않는 조합은 위 검증이 먼저 거부한다.
       if (Array.isArray(opts.roleLlm) && opts.roleLlm.length > 0) {
@@ -7816,6 +7828,26 @@ configCmd
     if (report.prodStatus !== 'ok') process.exit(1);
   });
 
+configCmd
+  .command('classify')
+  .description('읽기 전용 — 운영 config 잎의 자리(기본값·기계 사실·비밀·운영 정책)와 덮어쓰기 수 (CFG-CLASSIFY)')
+  .option('--json', '잎 전체를 JSON 으로 출력 (비밀 값 제외)')
+  .action(async (o: { json?: boolean }) => {
+    const { getElanousConfigDir } = await import('./elanous-config-dir.js');
+    const { readUniverseConfig } = await import('./cli/config-drift.js');
+    const { classifyConfig, renderClassify } = await import('./cli/config-classify.js');
+    const { buildUserConfig } = await import('./user-config.js');
+    const prod = readUniverseConfig(getElanousConfigDir(), []);
+    if (prod.status !== 'ok' || !prod.raw) {
+      console.error(`config classify — config 못 읽음(${prod.status}${prod.error ? `: ${prod.error}` : ''})`);
+      process.exitCode = 1;
+      return;
+    }
+    const report = classifyConfig(prod.raw, buildUserConfig('/nonexistent/elanous-config-drift/config.json') as unknown as Record<string, unknown>);
+    if (o.json) await (await import('./cli/stdout-flush.js')).writeStdoutFully(JSON.stringify(report, null, 2));
+    else console.log(renderClassify(report));
+  });
+
 configCmd
   .command('explain <key>')
   .description('읽기 전용 — 운영 값 ⊕ 출처 층 ⊕ 파생 시험 우주별 값 (CFG-STORE1)')

package/src/intake-plane/digest.ts

@@ -125,6 +125,19 @@ export function buildIntakeDigest(root: string, day: string, readFile: (p: strin
   };
 }
 
+function digestNoteRef(e: DigestEntry): string {
+  return e.noteName ? `[[${e.noteName}]]` : e.note?.trim() || e.url?.trim() || e.id;
+}
+
+/** 참고 줄에 이름을 다는 상한 — 많은 날에도 화면 한 장을 지킨다(M 은 그대로 센다). */
+const DIGEST_REFERENCE_NAMED = 10;
+
+function digestReferenceLine(entries: DigestEntry[]): string {
+  const named = entries.slice(0, DIGEST_REFERENCE_NAMED).map(digestNoteRef).join(', ');
+  const rest = entries.length - DIGEST_REFERENCE_NAMED;
+  return `참고 ${entries.length}편 — 노트: ${named}${rest > 0 ? ` 외 ${rest}편 · 원장 \`elanous intake items\`` : ''}`;
+}
+
 /** 노트 절 — 축별 묶음 · 노트 링크 · 한 줄 요약 · 골 후보. */
 export function renderDigestMarkdown(d: IntakeDigest): string {
   const L: string[] = [`## 📰 오늘의 흡수 요약 (${d.absorbed.length})`, ''];
@@ -165,14 +178,9 @@ export function renderDigestMarkdown(d: IntakeDigest): string {
 
 /** 텔레그램 — 흡수 렌즈가 대조한 항목만 SCQA 짧은 판으로 낸다. */
 export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: string; notePath?: string } = {}): string {
-  if (d.seat && !d.absorbed.length) return '오늘 새 소식 없음';
-  if (d.seat) return [
-    `흡수 ${d.absorbed.length}`,
-    ...d.absorbed.map((item) => `- ${item.oneLiner ?? item.noteName ?? item.id}${item.url ? ` · ${item.url}` : ''}`),
-  ].join('\n');
   // «Touching» is decided by the lens verdict alone; a missing note summary only changes how S reads (ACP must-fix).
   const touching = d.absorbed.filter((e) => e.impact);
-  const L = [`흡수 ${d.absorbed.length} → 우리에게 닿는 것 ${touching.length}`];
+  const L = [`흡수 ${d.absorbed.length}편 → 우리에게 닿는 것 ${touching.length}`];
   // 관심 뉴스는 최대 셋 — 기사마다 S(요약 첫 줄) · A(엘라누스 함의 첫 줄) · 링크를 한 덩어리로(NEWS-INTAKE).
   for (const article of (d.news ?? []).slice(0, 3)) {
     L.push(`📰 ${article.title}`);
@@ -181,9 +189,7 @@ export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: strin
     L.push(article.url);
   }
   if (d.shadowSuggestions?.length) L.push(`뉴스 칸 제안 ${d.shadowSuggestions.length}건 (그림자·판 미등록): ${d.shadowSuggestions.slice(0, 3).map((s) => `[${s.verdict}] ${s.fact}${s.url ? ` ${s.url}` : ''}`).join(' · ')}`);
-  if (!touching.length) return L.join('\n');
-  // At most three items are shown, each as its own S·C·A·link block so context and source stay paired;
-  // a later item sharing (verdict, target) says «위와 같은 행동» instead of repeating the A sentence (ACP must-fix).
+  // At most three items are shown, each as its own S·C·A·note block so context and source stay paired.
   // S must be the note's own summary: items without one still count as touching but are not shown (ACP must-fix).
   const shownItems = touching.filter((e) => e.oneLiner?.trim()).slice(0, 3);
   const actionSeen = new Set<string>();
@@ -205,10 +211,11 @@ export function renderDigestTelegram(d: IntakeDigest, _opts: { vaultRoot?: strin
       `S 무엇: ${e.oneLiner?.trim() || '노트 한 줄 요약 없음'}`,
       `C 우리에게 왜: ${impact.why}`,
       `A 그래서 무엇을 하나: ${action}`,
-      `🔗 원문 링크: ${e.url?.trim() || '링크 없음'}`,
+      `🔗 노트: ${digestNoteRef(e)}`,
     );
   }
   if (touching.length > shownItems.length) L.push('', `닿는 것 ${touching.length - shownItems.length}건 더(요약 없는 것 포함) · 원장 \`elanous intake items\``);
-  if (d.absorbed.length > touching.length) L.push('', `그 밖 ${d.absorbed.length - touching.length}건 · 참고`);
+  const reference = d.absorbed.filter((e) => !e.impact);
+  if (reference.length) L.push('', digestReferenceLine(reference));
   return L.join('\n');
 }

package/src/knowledge/conclusion-compress.ts

@@ -0,0 +1,93 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { releaseLedgerRoot } from '../instance/resolve.js';
+import { listChecklist, setItem } from '../release-loop/checklist.js';
+import { withFileLockSync } from '../storage/file-lock.js';
+
+export type ConclusionKind = 'evidence' | 'decision' | 'lesson';
+export type ConclusionSource = 'goal' | 'handoff' | 'run-log' | 'channel' | 'pr-discussion';
+export interface ConclusionRecord {
+  source: ConclusionSource;
+  cell: string;
+  kind: ConclusionKind;
+  conclusion: string;
+  /** Original URL, or a relative path to the original for non-channel sources. */
+  ref: string;
+  body: string;
+  /** The original post's UTC timestamp; required when compressing a channel day. */
+  createdAt?: string;
+  /** Terminal status is required before a run can be archived. */
+  status?: string;
+}
+export interface ConclusionBatch {
+  version: string;
+  day: string;
+  records: ConclusionRecord[];
+}
+export interface ConclusionReceipt {
+  archive: string;
+  lines: string[];
+  originalBytes: number;
+  conclusionBytes: number;
+}
+
+const kinds = new Set<ConclusionKind>(['evidence', 'decision', 'lesson']);
+const sources = new Set<ConclusionSource>(['goal', 'handoff', 'run-log', 'channel', 'pr-discussion']);
+const closed = new Set(['done', 'failed', 'cancelled', 'superseded', 'completed', 'abandoned']);
+const validDay = (day: string) => /^\d{4}-\d{2}-\d{2}$/.test(day) && new Date(`${day}T00:00:00Z`).toISOString().slice(0, 10) === day;
+
+/** Archive a complete input batch; publish only source-linked, explicitly supplied conclusions to the checklist ledger. */
+export function compressConclusions(batch: ConclusionBatch, root = releaseLedgerRoot()): ConclusionReceipt {
+  if (!batch || !Array.isArray(batch.records) || !batch.records.length || !validDay(batch.day)) throw new Error('invalid day or empty records');
+  if (!/^\d+\.\d+\.\d+(?:-(?:rc|alpha|beta)\.\d+)?$/.test(batch.version)) throw new Error('invalid checklist version');
+  if (resolve(root) !== resolve(releaseLedgerRoot())) throw new Error('archive and checklist must share a ledger root');
+  const checklist = listChecklist(batch.version);
+  const digest = createHash('sha256').update(JSON.stringify(batch)).digest('hex');
+  const archiveRef = `knowledge-compress/archive/${digest}.json`;
+  const byCell = new Map<string, string[]>();
+  for (const [index, record] of batch.records.entries()) {
+    if (!record || !sources.has(record.source) || !kinds.has(record.kind) ||
+      !checklist.items.some(item => item.id === record.cell) || !record.body?.trim() ||
+      !record.conclusion?.trim() || /[\r\n]/.test(record.conclusion) || !record.ref?.trim()) {
+      throw new Error('unverified source, conclusion or checklist cell');
+    }
+    if (record.source === 'channel') {
+      if (!/^https:\/\/github\.com\/[^\s]+#issuecomment-\d+$/.test(record.ref) ||
+        !record.createdAt || !Number.isFinite(Date.parse(record.createdAt)) ||
+        new Date(record.createdAt).toISOString().slice(0, 10) !== batch.day) throw new Error('channel comment must link to the selected UTC day');
+    }
+    if (record.source === 'run-log' && !closed.has(record.status ?? '')) throw new Error('run is not finished');
+    const conclusion = record.conclusion.trim().replace(/\s+/g, ' ');
+    if (conclusion.length > 160 || !conclusion) throw new Error('conclusion exceeds one line');
+    const ref = record.ref.trim();
+    if (/\s|[\r\n]/.test(ref) || (record.source !== 'channel' && !/^(https:\/\/|[^/][^\s]*$)/.test(ref))) throw new Error('invalid source pointer');
+    const line = `${record.kind}: ${conclusion} (${record.source === 'channel' ? ref : `${archiveRef}#record-${index + 1}`})`;
+    byCell.set(record.cell, [...(byCell.get(record.cell) ?? []), line]);
+  }
+  const lines = [...byCell].flatMap(([cell, entries]) => [...new Set(entries)].map(line => `${cell} · ${line}`));
+  const originalBytes = Buffer.byteLength(JSON.stringify(batch.records));
+  const conclusionBytes = Buffer.byteLength(lines.join('\n'));
+  if (conclusionBytes * 10 > originalBytes) throw new Error(`conclusions exceed 1/10 of original (${conclusionBytes}/${originalBytes} bytes)`);
+
+  const dir = join(root, 'knowledge-compress');
+  const archive = join(root, archiveRef);
+  const lock = join(dir, 'conclusions.lock');
+  mkdirSync(dirname(archive), { recursive: true });
+  return withFileLockSync(lock, () => {
+    if (existsSync(archive)) {
+      if (readFileSync(archive, 'utf8') !== JSON.stringify(batch)) throw new Error('archive digest collision');
+    } else {
+      const temp = `${archive}.${randomUUID()}.tmp`;
+      writeFileSync(temp, JSON.stringify(batch), { flag: 'wx', mode: 0o600 });
+      renameSync(temp, archive);
+    }
+    for (const [cell, entries] of byCell) {
+      const existing = listChecklist(batch.version).items.find(item => item.id === cell);
+      if (!existing) throw new Error(`checklist cell disappeared: ${cell}`);
+      const additions = [...new Set(entries)].filter(line => !existing.evidence?.split('\n').includes(line));
+      if (additions.length) setItem(batch.version, cell, { evidence: [existing.evidence, ...additions].filter(Boolean).join('\n') }, 'knowledge-compress');
+    }
+    return { archive: resolve(archive), lines, originalBytes, conclusionBytes };
+  });
+}

package/src/knowledge/know-find.ts

@@ -3,6 +3,7 @@ import { LessonLedger, type LessonRow } from '../lessons/lesson-ledger.js';
 import { DecisionLedger, type DecisionEntry, type SeatDecisionRecord } from '../decisions/decision-ledger.js';
 import { devVersion, listChecklist, type Checklist } from '../release-loop/checklist.js';
 import { debug } from '../debug/log.js';
+import { queryInstalledPack } from './query.js';
 
 /** Directive row fields this search reads — kept local because `src/directives/directive-index` is excluded from the public export. */
 export interface DirectiveRow { ts: string; text: string; source_file: string; line_no: number }
@@ -14,7 +15,7 @@ function openDirectiveIndex(): { search(q: string): DirectiveRow[]; close(): voi
   return new mod.DirectiveIndex();
 }
 
-export type KnowSource = 'directive' | 'decision' | 'checklist' | 'lesson';
+export type KnowSource = 'directive' | 'decision' | 'checklist' | 'lesson' | 'pack';
 export interface KnowHit {
   source: KnowSource;
   id: string;
@@ -36,6 +37,7 @@ export interface KnowFindDeps {
   lessons: (query: string) => LessonRow[];
   versions: () => string[];
   now: () => Date;
+  pack?: typeof queryInstalledPack;
 }
 
 function versions(): string[] {
@@ -55,6 +57,7 @@ const defaults: KnowFindDeps = {
   lessons: (query) => new LessonLedger().find(query),
   versions,
   now: () => new Date(),
+  pack: queryInstalledPack,
 };
 
 function matches(text: string, words: string[]): boolean {
@@ -62,7 +65,7 @@ function matches(text: string, words: string[]): boolean {
   return words.every((word) => normalized.includes(word));
 }
 
-export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}): KnowResult {
+export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}, packId?: string): KnowResult {
   const read = { ...defaults, ...deps };
   const words = query.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean);
   if (!words.length) throw new Error('know: 질문이 필요합니다');
@@ -106,6 +109,10 @@ export function knowFind(query: string, deps: Partial<KnowFindDeps> = {}): KnowR
     for (const row of read.lessons(query)) rows.push({ source: 'lesson', id: row.id, title: row.incident,
       status: row.status, at: row.updated_at, current: row.occurrence_count > 1, ref: `lesson show ${row.id}` });
   });
+  if (packId) attempt('pack', () => {
+    for (const card of (read.pack ?? queryInstalledPack)(packId, query)) rows.push({ source: 'pack', id: card.id, title: card.title,
+      status: 'installed', at: card.updatedAt, current: true, ref: card.ref });
+  });
   rows.sort((a, b) => Number(b.current) - Number(a.current) || (Date.parse(b.at) || 0) - (Date.parse(a.at) || 0)
     || a.source.localeCompare(b.source) || a.id.localeCompare(b.id));
   debug.log('knowledge.know', 'query', { query, counts: Object.fromEntries((['directive', 'decision', 'checklist', 'lesson'] as const)

package/src/knowledge/query.ts

@@ -10,6 +10,26 @@ import { readFileSync, existsSync, readdirSync, statSync } from 'node:fs';
 import { join, relative, sep } from 'node:path';
 import { parseFrontmatter, type ObsidianVault } from '../auto-research/obsidian-bridge.js';
 import type { KnowledgeKind, KnowledgeNote, KnowledgeQueryInput, KnowledgeQueryResult } from './types.js';
+import { PACK_KINDS, parsePackIdString, packIdString } from './kgs/pack.js';
+import { kgsStoreSingleton, type KgsSqliteStore } from './kgs/sqlite-store.js';
+
+/** Search only cards belonging to a pack present in the local KGS index. No vault fallback. */
+export function listInstalledPacks(store: Pick<KgsSqliteStore, 'listPacksByKind'> = kgsStoreSingleton()): Array<{ id: string; title: string }> {
+  return PACK_KINDS.flatMap(kind => store.listPacksByKind(kind).map(pack => ({ id: packIdString(pack.metadata.id), title: pack.metadata.title })));
+}
+
+export function queryInstalledPack(packId: string, question: string, store: Pick<KgsSqliteStore, 'readPack'> = kgsStoreSingleton()): Array<{ id: string; title: string; body: string; ref: string; updatedAt: string }> {
+  const id = parsePackIdString(packId);
+  if (!id) throw new Error(`invalid pack id: ${packId}`);
+  const pack = store.readPack(id.slug, id.version);
+  if (!pack) throw new Error(`pack not installed: ${packId}`);
+  const words = question.trim().toLocaleLowerCase().split(/\s+/).filter(Boolean);
+  return pack.cards.map(card => ({ card, score: words.filter(word => `${card.title} ${card.body}`.toLocaleLowerCase().includes(word)).length }))
+    .filter(hit => hit.score > 0 || words.length === 0)
+    .sort((a, b) => b.score - a.score || a.card.id.localeCompare(b.card.id))
+    .map(({ card }) => ({ id: card.id, title: card.title, body: card.body,
+      ref: `${packIdString(pack.metadata.id)}#${card.id}`, updatedAt: card.updatedAt }));
+}
 
 const DEFAULT_LIMIT = 20;
 const MAX_LIMIT = 100;

package/src/llm.ts

@@ -1746,7 +1746,7 @@ export const REASONING_CYCLE: readonly import('./user-config.js').ReasoningLevel
 
 /** Does the (provider, model) pair support a "think before answering"
  *  reasoning surface? Capability-based: gpt-5 family on Codex /
- *  Responses API + Anthropic claude-4 / claude-3.7 (extended thinking)
+ *  Responses API + Anthropic Claude 3.7+ (extended thinking)
  *  + OpenAI o-series. Other providers / older models return false so
  *  the HUD pill auto-hides and the wire body skips the reasoning
  *  field — no user toggle required. */
@@ -1768,9 +1768,7 @@ export function modelSupportsReasoning(
     return m.startsWith('o1') || m.startsWith('o3') || m.startsWith('o4');
   }
   if (provider === 'anthropic') {
-    // Extended thinking is GA on claude-3.7 onward — anything 4-family
-    // (opus-4, sonnet-4, haiku-4) plus the 3.7 line.
-    return m.includes('-4-') || m.includes('-3-7') || m.includes('3.7') || m.includes('claude-4');
+    return claudeSupportsThinking(model);
   }
   if (provider === 'gemini') {
     // Gemini 2.5+ family supports thinking budget (thinkingConfig).
@@ -1926,16 +1924,32 @@ function mapReasoningLevelToAnthropicEffort(
  *  🩹 그래서 규칙을 이름 목록이 아니라 «수»로 둔다 — 목록은 새 모델마다 늙지만 세대 비교는 안 늙는다.
  *  ⚠️ 알 수 없는 형태는 legacy 로 둔다(무회귀). 판정 못 하면 종전 동작이 정답이다. */
 function usesAdaptiveThinking(model: string | undefined): boolean {
+  const version = claudeVersion(model, true);
+  if (!version) return false;
+  if (version.generation >= 5) return true;
+  return version.generation === 4 && version.minor >= 7;
+}
+
+/** Shared numeric version parser for adaptive API shape and extended-thinking support. */
+function claudeVersion(model: string | undefined, requireTerminal = false): { generation: number; minor: number } | undefined {
   // 끝에 붙는 릴리스 날짜(`-20251101`)는 버전이 아니다 — 떼고 본다.
   const m = (model ?? '').toLowerCase().replace(/-\d{8}$/, '');
-  const v = /-(\d+)(?:[-.](\d+))?$/.exec(m);
-  if (!v) return false;
-  const generation = Number(v[1]);
-  const minor = v[2] === undefined ? 0 : Number(v[2]);
-  if (generation >= 5) return true;
-  return generation === 4 && minor >= 7;
+  for (const v of m.matchAll(/-(\d+)(?:[-.](\d+))?(?=-|$)/g)) {
+    if (requireTerminal && v.index + v[0].length !== m.length) continue;
+    return { generation: Number(v[1]), minor: v[2] === undefined ? 0 : Number(v[2]) };
+  }
+  return undefined;
 }
 
+function claudeSupportsThinking(model: string | undefined): boolean {
+  // includes, not startsWith: prefixed ids (`us.anthropic.claude-…`, `anthropic/claude-…`) passed the old substring check.
+  if (!model?.toLowerCase().includes('claude-')) return false;
+  const version = claudeVersion(model);
+  return version !== undefined && (version.generation > 3 || version.generation === 3 && version.minor >= 7);
+}
+
+export const _claudeSupportsThinkingForContractTest = claudeSupportsThinking;
+
 /** ⛔ 테스트 전용 노출이 아니다 — 모델 계열 계약은 «이름을 가진 판정»이라 회귀를 테스트로 물어야 한다.
  *  이 파일 안 두 조립부(:3102·:9591)가 그 값을 쓰고, 그 계약이 틀리면 provider 가 통째로 막힌다. */
 export const _usesAdaptiveThinkingForContractTest = usesAdaptiveThinking;
@@ -3134,13 +3148,9 @@ async function* streamAnthropicEvents(
   //   forcing a single thinking block before all tools). Improves
   //   multi-tool turn quality — the model can decide what to call
   //   next based on the prior tool's output thinking. Only supported
-  //   on extended-thinking-capable models (claude-3-7 / 4 family).
-  const model: string = (body?.model ?? '') as string;
-  const m = model.toLowerCase();
-  const supportsThinking =
-    m.includes('-4-') || m.includes('-3-7') || m.includes('3.7') || m.includes('claude-4');
+  //   on extended-thinking-capable models (Claude 3.7+).
   const betas: string[] = ['fine-grained-tool-streaming-2025-05-14'];
-  if (supportsThinking) betas.push('interleaved-thinking-2025-05-14');
+  if (claudeSupportsThinking(body?.model)) betas.push('interleaved-thinking-2025-05-14');
 
   const response = await fetchApiWithRetry(
     ANTHROPIC_API_URL,

package/src/loops/neighbor-runtime.ts

@@ -0,0 +1,88 @@
+import { debug } from '../debug/log.js';
+import { openMsgStore } from '../msg/msg-store.js';
+import { judgeNeighbor, type Neighbor } from './neighbors.js';
+import { join } from 'node:path';
+
+export type LoopHealth = 'healthy' | 'degraded';
+export type NeighborIncident = { observer: string; neighbor: string; state: 'absent'; reason: string; action: Neighbor['onAbsent']['action']; to: string; at: string; lastSeenAt: string | null };
+
+export const SEAT_NEIGHBORS: Record<string, Neighbor[]> = Object.fromEntries(['OP', 'TC', 'MK', 'UX'].map(seat => [seat,
+  [
+    ...['OP', 'TC', 'MK', 'UX'].filter(peer => peer !== seat).map(peer => ({
+      id: peer === 'MK' ? 'cmo-seat' : `${peer.toLowerCase()}-seat`, exchange: ['status'] as Neighbor['exchange'],
+      heartbeat: { everyMinutes: 15, missedTicks: 2 },
+      onAbsent: peer === 'OP' ? { action: 'delegate' as const, delegateTo: 'steward' }
+        : peer === 'TC' ? { action: 'escalate' as const, delegateTo: 'orchestrator' }
+          : { action: 'defer' as const, delegateTo: 'orchestrator' },
+    })),
+    { id: 'orchestrator', exchange: ['status'], heartbeat: { everyMinutes: 120, missedTicks: 2 },
+      onAbsent: { action: 'escalate', delegateTo: 'human' } },
+  ],
+]));
+
+type Signal = { at: string; health: LoopHealth; ends_at: string | null };
+
+function withStore<T>(root: string, fn: (store: ReturnType<typeof openMsgStore>) => T): T {
+  const store = openMsgStore(join(root, 'msg', 'messages.db'));
+  try {
+    store.db.exec(`CREATE TABLE IF NOT EXISTS loop_signals (loop_id TEXT PRIMARY KEY, at TEXT NOT NULL, health TEXT NOT NULL, ends_at TEXT);
+      CREATE TABLE IF NOT EXISTS loop_watches (observer TEXT NOT NULL, neighbor TEXT NOT NULL, first_at TEXT NOT NULL, PRIMARY KEY(observer, neighbor));
+      CREATE TABLE IF NOT EXISTS loop_incidents (observer TEXT NOT NULL, neighbor TEXT NOT NULL, signal_at TEXT NOT NULL,
+        reason TEXT NOT NULL, action TEXT NOT NULL, recipient TEXT NOT NULL, at TEXT NOT NULL,
+        PRIMARY KEY(observer, neighbor, signal_at, reason));`);
+    return fn(store);
+  } finally { store.close(); }
+}
+
+/** Durable signal, independent of chat sessions or the seat work-item ledger. */
+export function emitLoopHeartbeat(root: string, loopId: string, health: LoopHealth, now: Date, endsAt?: string): void {
+  if (!/^[a-z][a-z0-9-]*$/.test(loopId) || !Number.isFinite(now.getTime())) throw new Error('invalid loop heartbeat');
+  if (endsAt && !Number.isFinite(Date.parse(endsAt))) throw new Error('invalid heartbeat end');
+  withStore(root, store => {
+    store.db.query(`INSERT INTO loop_signals(loop_id, at, health, ends_at) VALUES(?, ?, ?, ?)
+      ON CONFLICT(loop_id) DO UPDATE SET at=excluded.at, health=excluded.health, ends_at=excluded.ends_at
+      WHERE loop_signals.at <= excluded.at`).run(loopId, now.toISOString(), health, endsAt ?? null);
+  });
+  debug.log(`loop.${loopId}`, 'heartbeat', { loopId, at: now.toISOString(), health, endsAt: endsAt ?? null });
+}
+
+/** First watch starts the missing-signal clock. Action receipt and message commit atomically. */
+export function checkLoopNeighbors(root: string, observer: string, neighbors: readonly Neighbor[], now: Date): NeighborIncident[] {
+  return withStore(root, store => {
+    const incidents: NeighborIncident[] = [];
+    for (const neighbor of neighbors) {
+      if (neighbor.id === observer) continue;
+      try {
+        store.db.exec('BEGIN IMMEDIATE');
+        store.db.query('INSERT OR IGNORE INTO loop_watches(observer, neighbor, first_at) VALUES(?, ?, ?)').run(observer, neighbor.id, now.toISOString());
+        const signal = store.db.query('SELECT at, health, ends_at FROM loop_signals WHERE loop_id=?').get(neighbor.id) as Signal | null;
+        const watch = store.db.query('SELECT first_at FROM loop_watches WHERE observer=? AND neighbor=?').get(observer, neighbor.id) as { first_at: string };
+        const judgment = judgeNeighbor({ neighbor, lastSeenAt: signal?.at ?? watch.first_at, now });
+        const expired = !!signal?.ends_at && Date.parse(signal.ends_at) <= now.getTime();
+        // A declared lease (ends_at in the future) outranks the heartbeat interval: a scheduled loop idle between
+        // windows is not absent until its own declared end passes.
+        const leased = !!signal?.ends_at && !expired;
+        const absent = expired || signal?.health === 'degraded' || (!leased && judgment.state === 'absent');
+        if (!absent) { store.db.exec('COMMIT'); continue; }
+        const reason = expired ? 'end-expired' : signal?.health === 'degraded' ? 'degraded' : judgment.reason;
+        const signalAt = signal?.at ?? watch.first_at;
+        const { action, delegateTo: to } = neighbor.onAbsent;
+        const inserted = store.db.query(`INSERT OR IGNORE INTO loop_incidents(observer, neighbor, signal_at, reason, action, recipient, at)
+          VALUES(?, ?, ?, ?, ?, ?, ?)`).run(observer, neighbor.id, signalAt, reason, action, to, now.toISOString());
+        if (inserted.changes) {
+          const incident: NeighborIncident = { observer, neighbor: neighbor.id, state: 'absent', reason, action, to,
+            at: now.toISOString(), lastSeenAt: signal?.at ?? null };
+          store.append({ from: observer, to, kind: `neighbor-${action}`,
+            body: `[${observer} → ${to}] ${neighbor.id} ${reason}: ${action}` });
+          incidents.push(incident);
+        }
+        store.db.exec('COMMIT');
+      } catch (error) {
+        try { store.db.exec('ROLLBACK'); } catch { /* no open transaction */ }
+        debug.log('loop.neighbors', 'check-failed', { observer, neighbor: neighbor.id, error: String(error) }, { level: 'warn' });
+      }
+    }
+    for (const incident of incidents) debug.log('loop.neighbors', 'absent', incident, { level: 'warn' });
+    return incidents;
+  });
+}

package/src/loops/orchestrator/author-depth.ts

@@ -12,7 +12,7 @@ import { getUserConfig, ORCHESTRATOR_DEFAULTS, type OrchestratorSeat } from '../
 import { checkAuthorInput } from './author-input-check.js';
 import { AuthorLedger } from './author-ledger.js';
 import { collectWork, findOverlaps, type WorkItem } from './overlap.js';
-import { seatOfTree, trafficTick, TRAFFIC_SEATS } from './traffic.js';
+import { isTrafficLaunch, seatOfTree, trafficTick, TRAFFIC_SEATS } from './traffic.js';
 
 export type AuthorCell = Pick<ChecklistItem, 'id' | 'title' | 'owner' | 'status' | 'evidence'> & { version: string };
 export type AuthorQueueRow = Pick<QueueItem, 'seat' | 'status'> & Partial<Pick<QueueItem, 'input' | 'kind'>>;
@@ -101,8 +101,12 @@ export interface CollectAuthorDepthDeps {
   versions?: () => readonly [string, string];
   ledger?: Pick<AuthorLedger, 'request'>;
   log?: (category: string, event: string, data: Record<string, unknown>) => void;
+  listProcesses?: typeof defaultListHarnessProcesses;
 }
 
+/** Budget for the shadow's process read (it runs inside the queue lock, whose waiters give up after 30 s). */
+export const AUTHOR_DEPTH_PROCESS_DEADLINE_MS = 10_000;
+
 function defaultVersions(now: Date, root = releaseLedgerRoot()): readonly [string, string] {
   if (!existsSync(join(root, 'release', 'features.sqlite'))) throw new Error('release schedule ledger unavailable');
   const upcoming = listSchedules(root).filter(row => row.cutAt && Date.parse(row.cutAt) > now.getTime())
@@ -122,15 +126,6 @@ export function collectAuthorDepth(deps: CollectAuthorDepthDeps = {}): AuthorDep
   };
   const cfg = deps.caps && deps.running ? null : observe('config', () => getUserConfig().loops?.orchestrator ?? ORCHESTRATOR_DEFAULTS);
   const caps = deps.caps ? observe('caps', deps.caps) : cfg === null ? null : observe('caps', () => cfg.seatCaps);
-  const running = deps.running ? observe('running', deps.running) : cfg === null ? null : observe('running', () => {
-    const observation = defaultListHarnessProcesses();
-    if (observation.status !== 'ok') throw new Error(`process observation ${observation.status}`);
-    const processes = observation.records.map(process => ({ ...process,
-      seat: seatOfTree(process.cwdStatus === 'unknown' ? undefined : process.cwd, cfg) }));
-    const measured = trafficTick({ processes, now, caps: cfg.seatCaps, openCells: [] });
-    if (measured.unassigned) throw new Error(`${measured.unassigned} unassigned harness launch process(es)`);
-    return Object.fromEntries(measured.seats.map(row => [row.seat, row.running]));
-  });
   const queued = observe('queue', deps.queued ?? (() => listHarnessQueue({ root: deps.root })));
   const releaseRoot = deps.root ?? releaseLedgerRoot();
   const versions = observe('versions', deps.versions ?? (() => defaultVersions(now, releaseRoot)));
@@ -139,7 +134,30 @@ export function collectAuthorDepth(deps: CollectAuthorDepthDeps = {}): AuthorDep
       throw new Error('checklist ledger unavailable');
     return deps.cells?.(version) ?? listChecklist(version, deps.root).items.map(item => ({ ...item, version }));
   }));
-  const overlaps = observe('overlap', deps.overlaps ?? (() => {
+  // Without release cells there is no candidate to compare, and the host reads below are the expensive ones (every launch's
+  // cwd · open PRs over the network) — a fresh --test universe has no release ledger, so it skips them (10-08 tick hang).
+  const noCells = cells === null && !deps.cells;
+  if (noCells && !deps.running && cfg !== null) unreadable.push({ source: 'running', reason: 'skipped: no release cells to compare' });
+  const running = deps.running ? observe('running', deps.running) : cfg === null || noCells ? null : observe('running', () => {
+    // Only launch processes are counted, so only they need a cwd; the whole read is bounded because the queue tick runs
+    // this shadow inside its lock (10-08: ~490 host processes × lsof kept a --test tick for minutes).
+    const started = Date.now();
+    const observation = (deps.listProcesses ?? defaultListHarnessProcesses)({ include: record => isTrafficLaunch(record.command),
+      cwdOnly: true, deadlineMs: AUTHOR_DEPTH_PROCESS_DEADLINE_MS });
+    if (observation.status !== 'ok') throw new Error(`process observation ${observation.status}`);
+    const late = observation.records.filter(process => process.cwdFailureReason?.startsWith('observation deadline')).length;
+    (deps.log ?? ((category: string, event: string, data: Record<string, unknown>) => debug.log(category, event, data)))(
+      'loop.orchestrator', 'author-depth-processes', { launches: observation.records.length, late, ms: Date.now() - started,
+        deadlineMs: AUTHOR_DEPTH_PROCESS_DEADLINE_MS });
+    if (late) throw new Error(`process observation deadline ${AUTHOR_DEPTH_PROCESS_DEADLINE_MS}ms: ${late} launch cwd(s) unread`);
+    const processes = observation.records.map(process => ({ ...process,
+      seat: seatOfTree(process.cwdStatus === 'unknown' ? undefined : process.cwd, cfg) }));
+    const measured = trafficTick({ processes, now, caps: cfg.seatCaps, openCells: [] });
+    if (measured.unassigned) throw new Error(`${measured.unassigned} unassigned harness launch process(es)`);
+    return Object.fromEntries(measured.seats.map(row => [row.seat, row.running]));
+  });
+  if (noCells && !deps.overlaps) unreadable.push({ source: 'overlap', reason: 'skipped: no release cells to compare' });
+  const overlaps = noCells && !deps.overlaps ? null : observe('overlap', deps.overlaps ?? (() => {
     const observed = collectWork();
     if (observed.unreadableTrees || observed.unreadableGoals || observed.work.some(item => item.unreadable))
       throw new Error(`incomplete work observation: trees=${observed.unreadableTrees} goals=${observed.unreadableGoals}`);