elanous 0.2.21 → 0.2.22

package/src/harness/harness-queue.ts

@@ -4,6 +4,7 @@ import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync
 import { join, resolve } from 'node:path';
 import { Database } from 'bun:sqlite';
 import { debug } from '../debug/log.js';
+import { stateDirSourceForChild } from '../agent/identity-env.js';
 import { findTreeRoot } from '../cli/test-flag.js';
 import { readLogInstances, type LogInstanceView } from '../mss/logging/instance-registry.js';
 import { effectiveInstanceRoot, prodInstanceRoot, releaseLedgerRoot } from '../instance/resolve.js';
@@ -20,6 +21,7 @@ import { hostLeaseCounts, leaseHasPendingPod } from '../pod-lease/host-lease.js'
 import { leaseKubectl, measurePoolLease } from '../task-orchestrator/surfaces/pod-lease.js';
 import { parsePodPool, podPoolHostLease, resolvePodPoolSpec } from '../task-orchestrator/surfaces/pod-pool.js';
 import { writeHarnessQueueReceipt } from './harness-queue-child.js';
+import { adviseLaunch, compareLaunchAdvice, type LaunchAdvice } from './launch-advice.js';
 import { finishAdvice, measureFinish, recordFinishHistory, type FinishMetrics } from '../loops/orchestrator/finish-rate.js';
 
 export type QueueSeat = 'OP' | 'TC' | 'MK' | 'UX';
@@ -73,6 +75,8 @@ export interface HarnessQueueDeps {
   configPath?: string;
   cap?: (seat: QueueSeat) => number;
   pool?: () => QueuePool;
+  /** Shadow-only advice seam; exceptions must not affect the queue decision. */
+  advice?: typeof adviseLaunch;
   launch?: (item: QueueItem, args: string[], root: string) => Promise<number>;
   /** Test seam: runs after a direct CLI call enqueued its row and before that call's own tick (race tests). */
   afterEnqueue?: (item: QueueItem) => void | Promise<void>;
@@ -385,24 +389,25 @@ export function listHarnessQueue(deps: HarnessQueueDeps = {}): QueueItem[] {
   return read(harnessQueuePath(deps.root ?? effectiveInstanceRoot()));
 }
 
-/** A missing row is not proof of failure unless the queue left a cancellation marker. */
-export function harnessQueueOutcome(id: string, deps: HarnessQueueDeps = {}): 'pending' | 'succeeded' | 'retryable' | 'unknown' {
+/** A missing row is not proof of failure; explicit removal and terminal receipts have distinct markers. */
+export function harnessQueueOutcome(id: string, deps: HarnessQueueDeps = {}): 'pending' | 'succeeded' | 'retryable' | 'removed' | 'unknown' {
   const root = deps.root ?? effectiveInstanceRoot();
   const row = listHarnessQueue(deps).find((item) => item.id === id);
   if (!row) {
     const marker = join(root, 'harness', `${id}.outcome`);
     if (!existsSync(marker)) return 'unknown';
     const value = readFileSync(marker, 'utf8');
-    return value === 'succeeded' || value === 'retryable' ? value : 'unknown';
+    return value === 'succeeded' || value === 'retryable' || value === 'removed' ? value : 'unknown';
   }
   return queueRowOutcome(row, root);
 }
 
 const keyMarkerPath = (root: string, key: string) => join(root, 'harness', 'by-key', `${createHash('sha256').update(key).digest('hex')}.id`);
 
-function recordQueueOutcome(root: string, id: string, outcome: 'succeeded' | 'retryable', key?: string): void {
+function recordQueueOutcome(root: string, id: string, outcome: 'succeeded' | 'retryable' | 'removed', key?: string): void {
   const path = join(root, 'harness', `${id}.outcome`);
-  if (!existsSync(path)) writeFileSync(path, outcome, { flag: 'wx', mode: 0o600 });
+  if (outcome === 'removed') writeFileSync(path, outcome, { mode: 0o600 });
+  else if (!existsSync(path)) writeFileSync(path, outcome, { flag: 'wx', mode: 0o600 });
   // The row is about to leave the queue; keep «which id last held this key» so a caller that crashed before
   // recording the id can still find the outcome (LOOP-LIVE1 · seat loop recovery).
   if (key) {
@@ -491,10 +496,8 @@ export async function removeHarnessQueue(id: string, deps: HarnessQueueDeps = {}
       if (state !== 'finished' && state !== 'not-started'
         || (deps.processes ?? readHarnessQueueProcesses)().some((row) => row.launchId === item.launchId)) return false;
     }
-    const outcome = item.status === 'queued' ? 'retryable' : queueRowOutcome(item, root);
-    if (item.idempotencyKey && (outcome === 'retryable' || outcome === 'succeeded')) {
-      recordQueueOutcome(root, id, outcome, item.idempotencyKey);
-    }
+    const outcome = queueRowOutcome(item, root) === 'succeeded' ? 'succeeded' : 'removed';
+    if (item.idempotencyKey) recordQueueOutcome(root, id, outcome, item.idempotencyKey);
     save(path, rows.filter((row) => row.id !== id));
     observe('skipped', { id, seat: item.seat, reason: 'removed' }, deps);
     return true;
@@ -699,6 +702,26 @@ export function readHarnessQueueInventory(probe: ProcessProbe = {}): QueueInvent
     if (prior && prior !== record.seat) { ledgerSeats.delete(pid); ambiguousPids.add(pid); }
     else ledgerSeats.set(pid, record.seat!);
   }
+  // One lsof for every candidate: a per-pid lsof (~0.1–0.3 s each) made a tick on a busy host take 10 s+ (10-08). lsof exits 1
+  // when some pid is gone yet still prints the others; a pid it does not print stays unattributed (charged to all seats).
+  let batchCwds: Map<number, string> | undefined;
+  const readBatchCwds = (): Map<number, string> => {
+    const cwds = new Map<number, string>();
+    const started = Date.now();
+    const lsof = run('lsof', ['-a', '-d', 'cwd', '-Fpn', '-p', candidates.map(({ pid }) => pid).join(',')],
+      { encoding: 'utf8', timeout: 5_000, maxBuffer: 16 * 1024 * 1024 });
+    if (!lsof.error && typeof lsof.stdout === 'string') {
+      let current: number | undefined;
+      for (const line of lsof.stdout.split('\n')) {
+        if (line.startsWith('p')) current = Number(line.slice(1));
+        else if (line.startsWith('n/') && current !== undefined) cwds.set(current, line.slice(1));
+      }
+    }
+    try { debug.log('harness.queue', 'cwd-batch', { pids: candidates.length, read: cwds.size, ms: Date.now() - started,
+      ...(lsof.error ? { error: String(lsof.error).slice(0, 240) } : {}) }); }
+    catch { /* Observation cannot affect dispatch. */ }
+    return cwds;
+  };
   const rows: QueueProcess[] = [];
   // Attribute a run after grouping: the orchestrator may switch working trees while its launcher stays in HQ.
   for (const root of candidates.filter((row) => !byPid.has(row.ppid))) {
@@ -736,9 +759,9 @@ export function readHarnessQueueInventory(probe: ProcessProbe = {}): QueueInvent
         if (probe.cwd) cwd = probe.cwd(pid);
         else if (platform === 'linux') cwd = readlinkSync(`/proc/${pid}/cwd`);
         else {
-          const lsof = run('lsof', ['-a', '-p', String(pid), '-d', 'cwd', '-Fn'], { encoding: 'utf8', timeout: 5_000 });
-          if (lsof.error || lsof.status !== 0 || typeof lsof.stdout !== 'string') throw new Error('cwd unavailable');
-          cwd = lsof.stdout.split('\n').find((line) => line.startsWith('n/'))?.slice(1) ?? '';
+          const found = (batchCwds ??= readBatchCwds()).get(pid);
+          if (found === undefined) throw new Error('cwd unavailable');
+          cwd = found;
         }
         if (!cwd.startsWith('/')) continue;
         const found = queueSeatForCwd(cwd, trees);
@@ -816,7 +839,8 @@ async function launch(item: QueueItem, args: string[], root: string, command?: s
       harnessQueueReceiptPath(root, item.launchId!), command ?? join(repo, 'bin', 'elanous.mjs'),
       ...(resolve(root) === prodInstanceRoot() ? [] : [`--test=${root}`]), ...args], {
       cwd: item.launchCwd ?? repo, detached: true, stdio: ['ignore', fd, fd],
-      env: { ...process.env, ELANOUS_STATE_DIR: root, ELANOUS_HARNESS_SEAT: item.seat,
+      env: { ...process.env, ELANOUS_STATE_DIR: root,
+        ELANOUS_STATE_DIR_SOURCE: stateDirSourceForChild(root), ELANOUS_HARNESS_SEAT: item.seat,
         ELANOUS_HARNESS_QUEUE_LAUNCH: item.launchId! },
     });
     const pid = await new Promise<number>((done, reject) => {
@@ -1187,7 +1211,13 @@ export async function tickHarnessQueue(deps: HarnessQueueDeps = {}, requestedId?
 
 async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string | undefined, followUp: boolean): Promise<QueueTick> {
   const root = deps.root ?? effectiveInstanceRoot();
-  return locked(root, async (path) => {
+  const caller = 'harness-queue-tick' as const;
+  let advice: LaunchAdvice = { verdict: 'unknown', why: 'pool not measured before queue decision' };
+  const shadow = (pool: QueuePool | undefined): void => {
+    try { advice = (deps.advice ?? adviseLaunch)({ pool, caller }); }
+    catch { advice = { verdict: 'unknown', why: 'launch advice unavailable' }; }
+  };
+  const actual = await locked<QueueTick>(root, async (path): Promise<QueueTick> => {
     // A burst follow-up already ran the author shadow and the idle request in this tick's first pass.
     if (!followUp) try {
       const now = (deps.now ?? (() => new Date()))();
@@ -1196,7 +1226,11 @@ async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string
         debug.log('loops.author-depth', 'shadow-skipped-test', {});
       } else {
         const shadow = deps.authorShadow ?? (await import('../loops/orchestrator/author-depth.js')).runAuthorDepthShadow;
+        const started = Date.now();
         await shadow(root, now);
+        // The shadow runs inside the queue lock; its duration is what other ticks wait on.
+        try { debug.log('harness.queue', 'author-shadow', { ms: Date.now() - started }); }
+        catch { /* Observation cannot affect dispatch. */ }
       }
     } catch (error) {
       try { debug.log('loops.author-depth', 'shadow-failed', { reason: String(error) }); }
@@ -1463,6 +1497,7 @@ async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string
         if (pool && (![pool.running, pool.pending, pool.reserved, pool.limit].every((n) => Number.isSafeInteger(n) && n >= 0) || pool.limit < 1)) {
           poolReason = 'pod lease status incomplete';
         }
+        shadow(poolReason ? undefined : pool);
         if (pool && !poolReason) {
           const queueLaunching = current.filter((row) => row.status === 'launching' || row.status === 'launched').length;
           // CHILD-UNIV-HOLD: each unreadable child universe is charged one pool slot (conservative), never a seat slot.
@@ -1545,4 +1580,13 @@ async function tickHarnessQueueOnce(deps: HarnessQueueDeps, requestedId: string
     }
     return waiting();
   });
+  // An empty queue tick has nothing to advise on; logging it would flood the advice-unknown sample.
+  if (actual.outcome === 'skipped' && !actual.item) return actual;
+  try {
+    const { kind } = compareLaunchAdvice(advice, actual.outcome);
+    debug.log('resource.advice', 'launch-advice', {
+      caller, verdict: advice.verdict, why: advice.why, actual: actual.outcome, kind, itemId: actual.item?.id ?? null,
+    });
+  } catch { /* Shadow observation cannot affect the queue result. */ }
+  return actual;
 }

package/src/harness/launch-advice.ts

@@ -0,0 +1,23 @@
+import type { QueuePool, QueueTick } from './harness-queue.js';
+
+export type LaunchAdvice = { verdict: 'launch-now' | 'wait' | 'unknown'; why: string; retryAfterHint?: string };
+export type LaunchAdviceInput = { pool: QueuePool | null | undefined; caller: 'harness-queue-tick' | 'hand-task' | 'release-run' };
+
+/** A pool-only suggestion; queue, seat, freeze and finish gates remain the dispatcher's decisions. */
+export function adviseLaunch(input: LaunchAdviceInput): LaunchAdvice {
+  const pool = input.pool;
+  if (!pool || ![pool.running, pool.pending, pool.reserved, pool.limit].every(n => Number.isSafeInteger(n) && n >= 0)
+    || pool.limit < 1) return { verdict: 'unknown', why: 'pool unavailable or incomplete' };
+  const used = pool.running + pool.pending + pool.reserved;
+  if (used >= pool.limit) return { verdict: 'wait', why: `pool ${used}/${pool.limit} occupied`, retryAfterHint: 'when a pool slot is released' };
+  return { verdict: 'launch-now', why: `pool ${used}/${pool.limit} occupied` };
+}
+
+export function compareLaunchAdvice(advice: LaunchAdvice, actualOutcome: QueueTick['outcome']): {
+  agree: boolean; kind: 'advice-launch-actual-wait' | 'advice-wait-actual-launch' | 'advice-unknown' | 'agree';
+} {
+  if (advice.verdict === 'unknown' || actualOutcome === 'skipped') return { agree: false, kind: 'advice-unknown' };
+  if (advice.verdict === 'launch-now' && actualOutcome === 'waiting') return { agree: false, kind: 'advice-launch-actual-wait' };
+  if (advice.verdict === 'wait' && actualOutcome === 'launched') return { agree: false, kind: 'advice-wait-actual-launch' };
+  return { agree: true, kind: 'agree' };
+}

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')
@@ -7317,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) {
@@ -7819,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/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,