elanous 0.2.22 → 0.2.24

package/src/self-implement/stop-autoheal.ts

@@ -15,12 +15,19 @@
  *   evidence-uncovered → derive-evidence-rejudge  런 출력·시험·배선에서 증거를 끌어내 1회 재판정
  *   review-repeat · review-out-of-scope · fabric · launch-failed · unclassified → needs-owner(새 라운드 없음)
  *
+ * 사다리의 «출처»: `graphs/overlays/stop-heal-ladder.yaml` 이 갈래마다 처방 노드(id = 처방 이름)를 선언한다.
+ *    그 갈래에 얹힌 오버레이가 더한 노드 id 가 처방이다(source='graph'). 선언이 없거나 못 읽으면
+ *    위 표(`AUTOHEAL_ACTION_BY_CLASS`)로 간다(source='code-default'). 둘이 같은 답을 내는지는 시험이 문다.
+ *
  * 모드 `tools.selfImplement.autoheal.mode` = `shadow`(기본: 할 일을 원장에만 적고 손대지 않는다) | `live`.
  * ⛔ live 에서도 행동은 주입 seam 으로만 한다 — seam 이 없는 행동은 `needs-owner`(action-unwired)로 떨어진다.
  *    «안 이어진 손»을 「고쳤다」로 읽지 않게.
  * 관측 = `debug.log('self-implement.autoheal', …)` ⊕ 원장 `event='autoheal'`.
  */
 import { debug } from '../debug/log.js';
+import { applyGraphOverlays, defaultOverlaysDir, loadGraphOverlays, selectOverlays, type GraphOverlaySpec } from './graph-overlay-yaml.js';
+import type { GraphTemplateSpec } from './graph-yaml.js';
+import { GRAPH_SPECS } from './graph-templates.js';
 import { appendRunLedgerEntry, loadRunLedger, type RunLedgerEntry, type RunLedgerWriter } from './run-ledger.js';
 import type { RunStopClass, RunStopRecord } from './run-stop.js';
 
@@ -48,6 +55,58 @@ export const AUTOHEAL_ACTION_BY_CLASS: Readonly<Record<RunStopClass, AutohealAct
   unclassified: 'needs-owner',
 };
 
+/** 처방 노드 id 로 인정하는 이름 — 오버레이가 더한 노드 중 이 넷만 처방으로 읽는다. */
+const HEAL_ACTION_NODE_IDS: ReadonlySet<string> = new Set<Exclude<AutohealAction, 'needs-owner'>>([
+  'clean-workspace-regate', 'rebase-regate', 'resume-from-salvage', 'derive-evidence-rejudge',
+]);
+
+/** 처방이 «어디서» 왔나 — `graph` = 그 갈래에 얹힌 오버레이가 더한 노드 · `code-default` = 위 표. */
+export type AutohealActionSource = 'graph' | 'code-default';
+
+export interface AutohealPick {
+  action: AutohealAction;
+  source: AutohealActionSource;
+  /** source='graph' 일 때 그 처방 노드를 더한 오버레이. */
+  overlayId?: string;
+}
+
+/** 사다리를 읽어 오는 자리 — 활성 템플릿 선언 ⊕ 오버레이 목록. 시험이 갈아 끼운다. */
+export interface AutohealLadder {
+  template: GraphTemplateSpec | undefined;
+  overlays: readonly GraphOverlaySpec[];
+}
+
+function loadDefaultLadder(): AutohealLadder {
+  return { template: GRAPH_SPECS['self-implement'], overlays: loadGraphOverlays(defaultOverlaysDir()).overlays };
+}
+
+/**
+ * 갈래 → 처방. 그 `stop_class` 에 얹힌 오버레이가 활성 템플릿에 더한 처방 노드 id 를 고른다.
+ * ⛔ 오버레이가 없거나 · 조건 키가 없거나 · 로드·적용이 실패하거나 · 처방 노드가 정확히 하나가 아니면
+ *    «조용히» 코드 표로 간다 — 그 사실은 `source` 가 말한다. 던지지 않는다.
+ */
+export function pickAutohealAction(cls: RunStopClass, loadLadder: () => AutohealLadder = loadDefaultLadder): AutohealPick {
+  const codeDefault: AutohealPick = { action: AUTOHEAL_ACTION_BY_CLASS[cls] ?? 'needs-owner', source: 'code-default' };
+  try {
+    const { template, overlays } = loadLadder();
+    if (!template) return codeDefault;
+    const { applied } = selectOverlays(overlays, { graphId: template.graphId, stage: 'heal', state: { stop_class: cls } });
+    const declared = new Set(template.nodes.map((node) => node.nodeId));
+    for (const overlay of applied) {
+      const result = applyGraphOverlays(template, [overlay]);
+      if (!result.ok) {
+        observe('overlay-rejected', { stopClass: cls, overlayId: overlay.overlayId, rejections: result.rejections.map((r) => r.kind) });
+        continue;
+      }
+      const added = result.template.nodes.map((node) => node.nodeId).filter((id) => !declared.has(id) && HEAL_ACTION_NODE_IDS.has(id));
+      if (added.length === 1) return { action: added[0] as AutohealAction, source: 'graph', overlayId: overlay.overlayId };
+    }
+  } catch (error) {
+    observe('ladder-unreadable', { stopClass: cls, error: error instanceof Error ? error.message : String(error) });
+  }
+  return codeDefault;
+}
+
 /** 설정 원값 → 모드. 모르는 값은 «좁은 쪽»(shadow). */
 export function parseAutohealMode(raw: unknown): AutohealMode {
   return raw === 'live' ? 'live' : 'shadow';
@@ -84,6 +143,10 @@ export interface AutohealResult {
   runId: string;
   class: RunStopClass;
   action: AutohealAction;
+  /** 처방을 «어디서» 골랐나 — 그래프 선언 또는 코드 표. */
+  source: AutohealActionSource;
+  /** source='graph' 일 때 처방 노드를 더한 오버레이. */
+  overlayId?: string;
   mode: AutohealMode;
   outcome: AutohealOutcome;
   /** needs-owner 일 때 사람이 볼 이유(멈춘 원인 그대로 또는 행동 실패). */
@@ -98,6 +161,8 @@ export interface AutohealDeps {
   /** 가드용 원장 읽기 — 기본 `loadRunLedger(runId)`. null = 원장 없음(첫 시도). */
   loadLedger?: (runId: string) => readonly RunLedgerEntry[] | null;
   writeLedger?: RunLedgerWriter;
+  /** 사다리 선언 읽기 — 기본은 활성 템플릿 ⊕ `graphs/overlays`. 던지면 코드 표로 간다. */
+  loadLadder?: () => AutohealLadder;
 }
 
 /**
@@ -128,8 +193,8 @@ function observe(event: string, data: Record<string, unknown>): void {
 export async function autohealFromStop(ctx: AutohealContext, deps: AutohealDeps = {}): Promise<AutohealResult> {
   const mode = deps.mode ?? DEFAULT_AUTOHEAL_MODE;
   const cls = ctx.record.class;
-  const action = AUTOHEAL_ACTION_BY_CLASS[cls] ?? 'needs-owner';
-  const base = { runId: ctx.runId, class: cls, action, mode };
+  const { action, source, overlayId } = pickAutohealAction(cls, deps.loadLadder);
+  const base = { runId: ctx.runId, class: cls, action, source, ...(overlayId ? { overlayId } : {}), mode };
 
   let ledger: readonly RunLedgerEntry[] | null = null;
   try {
@@ -145,6 +210,8 @@ export async function autohealFromStop(ctx: AutohealContext, deps: AutohealDeps
     return { ...base, outcome: 'already-attempted' };
   }
 
+  observe('action-source', { stopClass: cls, action, source, overlayId: overlayId ?? null });
+
   let outcome: AutohealOutcome;
   let reason: string | undefined;
   let detail: string | undefined;

package/src/self-implement/train-gate-remote.ts

@@ -0,0 +1,158 @@
+/** LAND-QUEUE-P3 — the merge train's integration gate (changed-file tsc · changed tests · PWA reach/build) for ONE
+ *  integration commit, run only on the gate host (node-b) through the GATE-REMOTE path (`runOnRemote`).
+ *  Unlike `dispatchHeavyCheck` it never falls back to a local run: a busy host or an infra failure is «unmeasured».
+ *  The only local commands are git (cat-file · rev-parse · push · diff). */
+import { debug } from '../debug/log.js';
+import { getDefaultLogStore } from '../mss/logging/log-store.js';
+import {
+  realGateRemoteRunner, resolveGateRemoteSettings, runOnRemote,
+  type GateRemoteRunner, type GateRemoteSettings, type RemoteRunOutcome,
+} from './gate-remote.js';
+
+export type TrainGateOutcome = 'pass' | 'fail' | 'unmeasured';
+
+export interface TrainGateInput {
+  repo: string;
+  /** The integration commit (40-char sha, present locally — need not be checked out). */
+  commit: string;
+  /** The base the changed-file checks measure against (TSC_BASE_REF). */
+  baseSha: string;
+  /** Repo-relative changed paths of the integration commit vs baseSha. */
+  changedFiles: readonly string[];
+  /** Paths deleted by the integration commit — kept in `changedFiles` for tsc/PWA reach, never run as tests. */
+  deletedFiles?: readonly string[];
+  settings?: GateRemoteSettings;
+}
+
+export interface TrainGateResult { outcome: TrainGateOutcome; host: string; ms?: number; rc?: number; reason?: string }
+
+export interface TrainGateObservation {
+  host: string; commit: string; baseSha: string; outcome: TrainGateOutcome;
+  rc?: number; ms?: number; reason?: string; changedFiles: number;
+}
+
+export interface TrainGateDeps {
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
+  /** Observation sink (default: category `merge-queue` in the log store, so a standalone CLI records it too). */
+  observe?: (entry: TrainGateObservation) => void;
+}
+
+const quote = (value: string) => `'${value.replaceAll("'", `'\\''`)}'`;
+const TEST_FILE = /\.test\.[cm]?[jt]sx?$/;
+
+/** The host-side shell body: each step runs only if the one before it passed. Exported for tests. */
+export function trainGateScript(baseSha: string, changedFiles: readonly string[], deleted: ReadonlySet<string> = new Set()): string {
+  // A deleted test file is a changed path (tsc/PWA reach) but not something to run.
+  const tests = changedFiles.filter((file) => TEST_FILE.test(file) && !deleted.has(file));
+  const steps = [
+    `TSC_BASE_REF=${quote(baseSha)} bun scripts/ci-typecheck-changed.ts --local`,
+    ...(tests.length ? [`bun run test:deterministic ${tests.map(quote).join(' ')}`] : []),
+    `bun scripts/ci-pwa-build-gate.ts --changed-files ${changedFiles.map(quote).join(' ')}`,
+  ];
+  return steps.join(' && ');
+}
+
+async function loadSettings(): Promise<GateRemoteSettings> {
+  try {
+    const { getUserConfig } = await import('../user-config.js');
+    return resolveGateRemoteSettings(getUserConfig().gateRemote);
+  } catch { return resolveGateRemoteSettings(undefined); }
+}
+
+function defaultObserve(entry: TrainGateObservation): void {
+  const store = getDefaultLogStore();
+  if (!store) return;
+  store.insertBatch([{ rec: { ts: new Date().toISOString(), category: 'merge-queue', event: 'train-gate', data: entry }, surface: 'merge-queue' }]);
+}
+
+/** The integration gate runs only on the gate host (LAND-QUEUE-P3 · review must-fix): another configured host is «unmeasured». */
+export const TRAIN_GATE_HOST = 'node-b';
+
+export async function runTrainGateOnHost(input: TrainGateInput, runner: GateRemoteRunner = realGateRemoteRunner, deps: TrainGateDeps = {}): Promise<TrainGateResult> {
+  const settings = input.settings ?? await loadSettings();
+  const host = settings.host;
+  if (host !== TRAIN_GATE_HOST) {
+    const entry: TrainGateObservation = { host, commit: input.commit, baseSha: input.baseSha, outcome: 'unmeasured', reason: `host-not-gate-host (${host} ≠ ${TRAIN_GATE_HOST})`, changedFiles: input.changedFiles.length };
+    debug.log('merge-queue', 'train-gate', entry);
+    try { (deps.observe ?? defaultObserve)(entry); } catch { /* observation only */ }
+    return { outcome: 'unmeasured', host, reason: entry.reason };
+  }
+  const sleep = deps.sleep ?? ((ms: number) => new Promise<void>((resolve) => setTimeout(resolve, ms)));
+  const now = deps.now ?? Date.now;
+  const deadline = now() + settings.slotWaitSeconds * 1000;
+  const script = trainGateScript(input.baseSha, input.changedFiles, new Set(input.deletedFiles ?? []));
+  let outcome: RemoteRunOutcome;
+  for (;;) {
+    try {
+      outcome = runOnRemote({
+        repo: input.repo, host, mirror: settings.mirror, commit: input.commit, refs: [input.baseSha],
+        argv: ['sh', '-c', script], installPwa: true, hostCap: settings.hostCap,
+      }, runner);
+    } catch (error) {
+      outcome = { kind: 'infra', reason: `exception: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (outcome.kind !== 'busy') break;
+    const left = deadline - now();
+    if (left <= 0) break;
+    await sleep(Math.min(15_000, left));
+    if (now() >= deadline) break;
+  }
+  const result: TrainGateResult = outcome.kind === 'ran'
+    ? { outcome: outcome.rc === 0 ? 'pass' : 'fail', host, ms: outcome.ms, rc: outcome.rc }
+    : { outcome: 'unmeasured', host, reason: outcome.kind === 'busy' ? `host-busy (cap ${settings.hostCap} held for ${settings.slotWaitSeconds}s)` : outcome.reason };
+  const entry: TrainGateObservation = {
+    host, commit: input.commit, baseSha: input.baseSha, outcome: result.outcome,
+    rc: result.rc, ms: result.ms, reason: result.reason, changedFiles: input.changedFiles.length,
+  };
+  debug.log('merge-queue', 'train-gate', entry);
+  try { (deps.observe ?? defaultObserve)(entry); } catch (error) {
+    debug.log('merge-queue', 'train-gate-observe-failed', { error: error instanceof Error ? error.message : String(error) });
+  }
+  return result;
+}
+
+/** The merge train's `gate` seam: `(commitSha, prNumbers) → 'pass' | 'fail' | 'unmeasured'`. Changed files are the
+ *  integration commit's diff against `baseSha` (local git only); a diff failure is «unmeasured», never a local run. */
+export type TrainGate = (commitSha: string, prNumbers: readonly number[]) => Promise<TrainGateOutcome>;
+
+export function trainGateOnHost(opts: { repo: string; baseSha: string; settings?: GateRemoteSettings }, runner: GateRemoteRunner = realGateRemoteRunner, deps: TrainGateDeps = {}): TrainGate {
+  const unmeasured = (commitSha: string, reason: string): 'unmeasured' => {
+    const entry: TrainGateObservation = { host: opts.settings?.host ?? TRAIN_GATE_HOST, commit: commitSha, baseSha: opts.baseSha, outcome: 'unmeasured', reason, changedFiles: 0 };
+    debug.log('merge-queue', 'train-gate', entry);
+    try { (deps.observe ?? defaultObserve)(entry); } catch { /* observation only */ }
+    return 'unmeasured';
+  };
+  return async (commitSha) => {
+    try {
+      const diff = runner.local('git', ['diff', '--name-status', '-z', opts.baseSha, commitSha], opts.repo);
+      if (diff.rc !== 0 || diff.error) return unmeasured(commitSha, 'changed-files-unavailable');
+      const { changedFiles, deletedFiles } = parseNameStatus(diff.stdout);
+      return (await runTrainGateOnHost({ repo: opts.repo, commit: commitSha, baseSha: opts.baseSha, changedFiles, deletedFiles, settings: opts.settings }, runner, deps)).outcome;
+    } catch (error) {
+      // Any preparation failure (local git spawn, parse, settings) is «unmeasured» — never a rejected promise, never a local run.
+      return unmeasured(commitSha, `prepare-failed: ${error instanceof Error ? error.message : String(error)}`.slice(0, 200));
+    }
+  };
+}
+
+/** `git diff --name-status -z` → changed paths (renames contribute both sides) ⊕ deleted paths. Exported for tests. */
+export function parseNameStatus(out: string): { changedFiles: string[]; deletedFiles: string[] } {
+  const parts = out.split('\0').filter((part) => part !== '');
+  const changed: string[] = [];
+  const deleted: string[] = [];
+  for (let i = 0; i < parts.length;) {
+    const status = parts[i++]!;
+    if (/^[RC]/.test(status)) {
+      const from = parts[i++]; const to = parts[i++];
+      if (from) { changed.push(from); if (status.startsWith('R')) deleted.push(from); }
+      if (to) changed.push(to);
+    } else {
+      const path = parts[i++];
+      if (!path) break;
+      changed.push(path);
+      if (status === 'D') deleted.push(path);
+    }
+  }
+  return { changedFiles: [...new Set(changed)], deletedFiles: [...new Set(deleted)] };
+}

package/src/session-runtime/index.ts

@@ -365,6 +365,15 @@ const SESSION_TOOL_FAMILY_RULES: SessionToolFamilyRule[] = [
       '왜 실패', '기억', '회상', '알림', '이상 없', '뭐 돌', '뭐 하는 중',
     ]),
   },
+  {
+    id: 'release-read',
+    description: 'Read-only release status, features, cells, schedules, and current operations.',
+    names: ['release_status', 'context_now'],
+    match: (text) => hasAny(text, [
+      'release', 'version', 'checklist', '발행', '버전', '릴리스', '피처',
+      '체크리스트', '칸', '컷', '일정', '판올림', '다음 판', '이번 판', '운영 상태',
+    ]),
+  },
   {
     id: 'runtime-debug',
     description: 'Runtime inspection, traces, and input/debug history.',
@@ -1721,7 +1730,7 @@ const ESSENTIAL_NATIVE_RULE_IDS = [
   // Keep dev-harness in the assembly candidate set so the catalog policy below is the single model-exposure authority.
   'agent', 'agent-output', 'agent-reply', 'agent-stop', 'agent-list', 'self-implement', 'self-orchestrate', 'dev-harness',
 ] as const;
-const ESSENTIAL_HOST_FAMILY_IDS = ['self-ops'] as const;
+const ESSENTIAL_HOST_FAMILY_IDS = ['self-ops', 'release-read'] as const;
 const ESSENTIAL_RUNTIME_FAMILY_IDS = ['bash', 'run-shell', 'pty-shell', 'run-tests', 'elanous_skills_list', 'skill_exec', 'code-grounding'] as const;
 const ESSENTIAL_OPTIONAL_TOOL_NAMES = [
   'GetDashboardState',

package/src/session-runtime/retry-api.ts

@@ -80,6 +80,9 @@ export interface FetchApiWithRetryOpts {
   /** Fallbacks still unused. When > 0, k consecutive overload-class
    *  failures throw OverloadFailoverError before another retry sleep. */
   remainingFallbacks?: number;
+  /** BEDROCK-PROVIDER — 재시도 «직전»마다 요청을 다시 만든다(SigV4 서명은 `x-amz-date` 기준 수 분만 유효 —
+   *  `retry-after` 대기가 길면 옛 서명은 403). 없으면 종전처럼 같은 `init` 을 다시 쓴다(다른 provider 불변). */
+  refreshInit?: () => Promise<RequestInit>;
 }
 
 /** Raised when overload repeats k times and a fallback is still unused.
@@ -128,6 +131,8 @@ export async function fetchApiWithRetry(
   let lastErr: unknown;
   while (attempt < maxAttempts) {
     let response: Response | null = null;
+    // ⛔ try «밖» — 재서명 실패(자격 부재 등)는 재시도할 네트워크 오류가 아니다. 그대로 던진다.
+    if (attempt > 0 && opts.refreshInit) init = await opts.refreshInit();
     try {
       response = await fetch(url, init);
       if (response.ok) {
@@ -179,7 +184,12 @@ export async function fetchApiWithRetry(
       const fp = fingerprintError(err, `api:${opts.provider}`);
       const doomStatus = tracker.record(fp);
       const retryAfter = err instanceof ApiHttpError ? err.retryAfter : undefined;
-      const decision = decideRetry(err, {
+      // OpenRouter may report an upstream transient as a non-5xx HTTP status.
+      // Keep the original status/error for callers, but classify this specific body as retryable.
+      const policyError = opts.provider === 'openrouter' && err instanceof ApiHttpError
+        && /Provider returned error/i.test(err.bodyText)
+        ? Object.assign(new Error(err.message), { code: '503' }) : err;
+      const decision = decideRetry(policyError, {
         attempt,
         doomStatus,
         retryAfter,

package/src/session-runtime/retry-policy.ts

@@ -225,7 +225,8 @@ export function providerNamesFromFallbackChain(chain: readonly string[]): string
   const out: string[] = [];
   const seen = new Set<string>();
   for (const step of chain) {
-    const name = step === 'grok' ? 'grok' : step === 'codex-rotate' ? 'openai-codex' : undefined;
+    // `codex-credits`(체인 마지막 칸 · 크레딧)도 provider 는 openai-codex 다 — 이미 앞에 있으면 중복이라 빠진다.
+    const name = step === 'grok' ? 'grok' : step === 'codex-rotate' || step === 'codex-credits' ? 'openai-codex' : undefined;
     if (!name || seen.has(name)) continue;
     seen.add(name);
     out.push(name);

package/src/skills/gift-install.ts

@@ -3,7 +3,13 @@ import { execFileSync } from 'node:child_process';
 import { cpSync, existsSync, lstatSync, mkdtempSync, mkdirSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
 import { homedir, tmpdir } from 'node:os';
 import { join } from 'node:path';
+import { gunzipSync } from 'node:zlib';
 import { debug } from '../debug/log.js';
+import { ensureInternalMarketIndex, ensureMarketIndex, type MarketFetchOptions } from '../plugins/install/market-fetch.js';
+import { scanPackInternalRefs } from '../market/pack-internal-refs.js';
+import { createPack } from '../knowledge/kgs/pack.js';
+import { KgsSqliteStore } from '../knowledge/kgs/sqlite-store.js';
+import type { KnowledgeCard, KnowledgeKind } from '../knowledge/kgs/types.js';
 
 export interface GiftInstallOptions {
   pack: string;
@@ -23,6 +29,119 @@ export type GiftInstallResult =
   | { ok: true; names: string[]; paths: string[]; collisions: string[]; needsKeys: boolean; message: string }
   | { ok: false; reason: string; message: string };
 
+export type KnowledgePackInstallResult =
+  | { ok: true; packId: string; citations: string[] }
+  | { ok: false; reason: string };
+
+/** Install a named knowledge pack from a configured, signed market; no gift code or skill target is involved. */
+export async function installMarketKnowledgePack(input: {
+  pack: string;
+  market: string;
+  enterpriseId?: string;
+  marketOptions?: MarketFetchOptions;
+  fetch?: typeof fetch;
+  store?: Pick<KgsSqliteStore, 'writePack'>;
+}): Promise<KnowledgePackInstallResult> {
+  try {
+    const verified = input.enterpriseId
+      ? await ensureInternalMarketIndex(input.market, input.enterpriseId, input.marketOptions)
+      : await ensureMarketIndex(input.market, input.marketOptions);
+    const entry = verified.index.knowledgePacks?.find(item => item.name === input.pack);
+    if (!entry || (input.enterpriseId ? entry.visibility !== 'internal' || entry.enterpriseId !== input.enterpriseId : entry.visibility !== 'public')) {
+      return { ok: false, reason: 'pack-not-in-verified-market' };
+    }
+    const key = entry.artifact.key;
+    if (!key || key.startsWith('/') || key.includes('\\') || key.split('/').some(part => !part || part === '.' || part === '..')) {
+      return { ok: false, reason: 'invalid-artifact-key' };
+    }
+    const base = new URL(verified.market.url);
+    const artifactUrl = new URL(key, base);
+    if (key.includes('%') || key.includes('?') || key.includes('#') || base.protocol !== 'https:') return { ok: false, reason: 'invalid-artifact-key' };
+    if (artifactUrl.origin !== base.origin || !artifactUrl.pathname.startsWith(base.pathname) || artifactUrl.search || artifactUrl.hash) {
+      return { ok: false, reason: 'invalid-artifact-key' };
+    }
+    if (entry.artifact.bytes > MAX_DOWNLOAD_BYTES) return { ok: false, reason: 'artifact-mismatch' };
+    const response = await (input.fetch ?? fetch)(artifactUrl.href, { redirect: 'error' });
+    if (!response.ok || response.redirected || (response.url && response.url !== artifactUrl.href)) return { ok: false, reason: 'artifact-download-failed' };
+    const reader = response.body?.getReader();
+    if (!reader) return { ok: false, reason: 'artifact-download-failed' };
+    const chunks: Uint8Array[] = [];
+    let length = 0;
+    for (;;) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      length += value.byteLength;
+      if (length > MAX_DOWNLOAD_BYTES || length > entry.artifact.bytes) { await reader.cancel(); return { ok: false, reason: 'artifact-mismatch' }; }
+      chunks.push(value);
+    }
+    const bytes = Buffer.concat(chunks);
+    if (bytes.length !== entry.artifact.bytes ||
+      createHash('sha256').update(bytes).digest('hex').toLowerCase() !== entry.artifact.sha256.toLowerCase()) {
+      return { ok: false, reason: 'artifact-mismatch' };
+    }
+    const archive = gunzipSync(bytes, { maxOutputLength: MAX_UNPACKED_BYTES });
+    const files = new Map<string, string>();
+    const decoder = new TextDecoder('utf-8', { fatal: true });
+    let endOffset = 0;
+    for (let offset = 0; offset + 512 <= archive.length;) {
+      const header = archive.subarray(offset, offset + 512);
+      if (header.every(byte => byte === 0)) { endOffset = offset; break; }
+      const field = (start: number, end: number) => header.subarray(start, end).toString('utf8').replace(/\0.*$/, '');
+      const checksum = parseInt(field(148, 156).trim(), 8);
+      const actualChecksum = header.reduce((sum, byte, index) => sum + (index >= 148 && index < 156 ? 32 : byte), 0);
+      if (checksum !== actualChecksum) return { ok: false, reason: 'invalid-archive' };
+      const size = parseInt(field(124, 136).trim(), 8);
+      const name = field(0, 100);
+      const prefix = field(345, 500);
+      const path = prefix ? `${prefix}/${name}` : name;
+      if (!Number.isSafeInteger(size) || size < 0 || !path || path.includes('\\') ||
+        path.split('/').some(part => !part || part === '.' || part === '..') || header[156] !== 48 ||
+        offset + 512 + size > archive.length || files.has(path)) return { ok: false, reason: 'invalid-archive' };
+      files.set(path, decoder.decode(archive.subarray(offset + 512, offset + 512 + size)));
+      offset += 512 + Math.ceil(size / 512) * 512;
+      if (files.size > MAX_ENTRIES) return { ok: false, reason: 'invalid-archive' };
+    }
+    if (!endOffset || archive.length - endOffset < 1024 || !archive.subarray(endOffset).every(byte => byte === 0)) return { ok: false, reason: 'invalid-archive' };
+    const manifest = JSON.parse(files.get('knowledge-pack.json') ?? 'null') as Record<string, unknown> | null;
+    if (files.size !== (Array.isArray(manifest?.content) ? manifest.content.length + 1 : -1)) return { ok: false, reason: 'invalid-content' };
+    if (!manifest || manifest.kind !== 'knowledge-pack' || manifest.name !== entry.name || manifest.version !== entry.version ||
+      !/^[a-z0-9][a-z0-9-]{1,62}[a-z0-9]$/.test(entry.name) || !/^\d+\.\d+\.\d+$/.test(entry.version) ||
+      typeof manifest.description !== 'string' || !manifest.description || manifest.description.length > 200 ||
+      !Array.isArray(manifest.content) || !manifest.content.length ||
+      !Array.isArray(manifest.dependencies) || manifest.dependencies.length !== 0 ||
+      manifest.visibility !== entry.visibility || typeof manifest.license !== 'string' || !manifest.license ||
+      !manifest.signature || typeof manifest.signature !== 'object' ||
+      (manifest.signature as Record<string, unknown>).algorithm !== 'ed25519' ||
+      (manifest.signature as Record<string, unknown>).keyId !== verified.keyId) return { ok: false, reason: 'invalid-manifest' };
+    const now = new Date().toISOString();
+    const cards: KnowledgeCard[] = [];
+    for (const item of manifest.content) {
+      if (!item || typeof item !== 'object') return { ok: false, reason: 'invalid-content' };
+      const { path, kind } = item as Record<string, unknown>;
+      if (typeof path !== 'string' || !/^content\/[a-z0-9-]+(?:\/[a-z0-9-]+)*\.md$/.test(path) || typeof kind !== 'string' ||
+        !['document', 'glossary', 'procedure', 'rule', 'qa'].includes(kind) || !files.has(path)) return { ok: false, reason: 'invalid-content' };
+      const body = files.get(path)!;
+      cards.push({ schema_version: 2, id: path, createdAt: now, updatedAt: now, author: entry.name,
+        title: body.match(/^# (.+)$/m)?.[1] ?? path, body, nature: 'fact',
+        kind: ({ procedure: 'playbook', glossary: 'wiki', qa: 'card', rule: 'checklist', document: 'note' } as Record<string, KnowledgeKind>)[kind]!,
+        reliability: 'self-reported', source: { kind: 'external', url: artifactUrl.href }, tags: [entry.name] });
+    }
+    if (cards.length > 200 || new Set(cards.map(card => card.id)).size !== cards.length ||
+      scanPackInternalRefs([...files].map(([path, text]) => ({ path, text }))).length) return { ok: false, reason: 'invalid-content' };
+    const pack = createPack({ id: { slug: entry.name, version: entry.version }, title: manifest.description as string,
+      intent: manifest.description as string, audience: input.enterpriseId ? 'team' : 'public', kind: 'generic',
+      author: entry.name, cards });
+    if (input.store) input.store.writePack(pack);
+    else {
+      const store = new KgsSqliteStore();
+      try { store.writePack(pack); } finally { store.close(); }
+    }
+    return { ok: true, packId: `pack:${entry.name}@${entry.version}`, citations: cards.map(card => `pack:${entry.name}@${entry.version}#${card.id}`) };
+  } catch {
+    return { ok: false, reason: 'knowledge-pack-install-failed' };
+  }
+}
+
 // GK1 public bundle: packs/elanous-essentials/plugin.json extensions.ai.elanous.bundle.
 const ESSENTIAL_SKILLS = ['youtube-master', 'omni-crawl', 'omni-digest', 'diagram-master', 'lecture-note-digitizer'];
 // A malicious or broken gift must not exhaust the temp disk: cap the download, the unpacked total and the entry count.

package/src/skills/runner.ts

@@ -3,6 +3,9 @@
 // substitute template variables, and run them through the selected LLM provider.
 
 import { debug } from '../debug/log.js';
+import type { SkillTier } from './skill-tier.js';
+import { randomUUID } from 'node:crypto';
+import { recordSkillRunSafe, type SkillRun } from './skill-feedback.js';
 import { readFileSync, readdirSync, existsSync, statSync } from 'fs';
 import { join } from 'path';
 import { LOCAL_SKILLS_DIR } from '../config.js';
@@ -307,7 +310,7 @@ export interface SkillManifest {
 }
 
 /** Ordered weak→strong. Session 21. */
-export type SkillTier = 'T3' | 'T2' | 'T1';
+export type { SkillTier } from './skill-tier.js';
 const TIER_RANK: Record<SkillTier, number> = { T3: 1, T2: 2, T1: 3 };
 
 /** True when `active` is at least as strong as `min`. Missing `min`
@@ -690,6 +693,9 @@ export interface ExecuteSkillOpts {
    *  pure-builder input so tests and future callers can reason about
    *  the final message shape without opening the SQLite store. */
   promptBankContext?: string;
+  /** Use this provider instead of resolving one from config/model hint
+   *  (tests and hosts that already hold a provider). */
+  provider?: LLMProvider;
 }
 
 export interface ExecuteSkillResult {
@@ -968,6 +974,57 @@ export async function executeSkill(
   args: string,
   onChunk: (delta: string, full: string) => void,
   opts: ExecuteSkillOpts = {},
+): Promise<ExecuteSkillResult> {
+  // SK1: one feedback ledger line per run. Recording is fail-soft — the
+  // result returned and the exception thrown are exactly the run's own.
+  let started: number | undefined;
+  try { started = Date.now(); } catch { /* clock trouble must not block the skill */ }
+  const feedback = (outcome: SkillRun['outcome'], failureKind?: string): SkillRun => ({
+    skill: manifest.name,
+    runId: randomUUID(),
+    outcome,
+    ...(failureKind ? { failureKind } : {}),
+    userCorrected: false,
+    retries: 0,
+    durationMs: started === undefined ? 0 : Math.max(0, Date.now() - started),
+    at: new Date().toISOString(),
+  });
+  const record = (outcome: SkillRun['outcome'], failureKind?: string): void => {
+    try {
+      recordSkillRunSafe(feedback(outcome, failureKind));
+    } catch (error) {
+      // Building the record itself failed — still fail-soft, still observed.
+      try {
+        debug.log('skill.feedback', 'record-failed', { skill: manifest.name, error: String(error) }, { level: 'warn' });
+      } catch { /* never let observation change the skill outcome */ }
+    }
+  };
+  let result: ExecuteSkillResult;
+  try {
+    result = await executeSkillUnrecorded(manifest, args, onChunk, opts);
+  } catch (error) {
+    record('failure', skillFailureKind(error));
+    throw error;
+  }
+  record('success');
+  return result;
+}
+
+/** Failure kind for the feedback ledger: the exception's name, else 'error'. */
+function skillFailureKind(error: unknown): string {
+  try {
+    const name = (error as { name?: unknown } | null)?.name;
+    return typeof name === 'string' && name !== '' ? name : 'error';
+  } catch {
+    return 'error';
+  }
+}
+
+async function executeSkillUnrecorded(
+  manifest: SkillManifest,
+  args: string,
+  onChunk: (delta: string, full: string) => void,
+  opts: ExecuteSkillOpts,
 ): Promise<ExecuteSkillResult> {
   debug.log('skill.router', 'executeSkill', {
     skill: manifest.name,
@@ -982,7 +1039,7 @@ export async function executeSkill(
   // vars. Previously getProvider(modelHint) — env-only — meant a user
   // with config.provider=openai-codex but XAI_API_KEY still in env
   // would see every skill fall back to Grok.
-  const provider: LLMProvider = resolveDefaultProvider(rawModelHint);
+  const provider: LLMProvider = opts.provider ?? resolveDefaultProvider(rawModelHint);
   // If the skill's declared model belongs to a DIFFERENT provider
   // family than the one user-config resolved to, drop it. Example:
   // user has openai-codex configured but a skill's SKILL.md says

package/src/skills/skill-feedback.ts

@@ -1,5 +1,7 @@
-import { appendFileSync, readFileSync } from 'node:fs';
+import { appendFileSync, mkdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
 import { debug } from '../debug/log.js';
+import { effectiveInstanceRoot } from '../instance/resolve.js';
 
 export interface SkillRun {
   skill: string;
@@ -25,6 +27,34 @@ export function appendSkillRun(ledgerPath: string, run: SkillRun): void {
   appendFileSync(ledgerPath, `${JSON.stringify(run)}\n`, 'utf8');
 }
 
+/**
+ * Ledger for skill runs: `<root>/skills/feedback.jsonl`, root defaulting to the
+ * effective instance (state) root — never a skill folder. Creates the directory.
+ */
+export function skillFeedbackLedgerPath(root: string = effectiveInstanceRoot()): string {
+  const dir = join(root, 'skills');
+  mkdirSync(dir, { recursive: true });
+  return join(dir, 'feedback.jsonl');
+}
+
+/**
+ * Fail-soft record of one skill run: resolving or writing the ledger never
+ * throws to the caller; a failure leaves a single `record-failed` observation.
+ */
+export function recordSkillRunSafe(run: SkillRun, ledgerPath?: string): void {
+  try {
+    appendSkillRun(ledgerPath ?? skillFeedbackLedgerPath(), run);
+  } catch (error) {
+    try {
+      debug.log('skill.feedback', 'record-failed', { skill: run.skill, error: String(error) }, { level: 'warn' });
+    } catch { /* observation must not break the skill result either */ }
+    return;
+  }
+  try {
+    debug.log('skill.feedback', 'recorded', { skill: run.skill, outcome: run.outcome, durationMs: run.durationMs });
+  } catch { /* fail-soft */ }
+}
+
 /** Read the JSONL ledger in append order; an absent ledger has no runs. */
 export function readSkillRuns(ledgerPath: string): SkillRun[] {
   let text: string;

package/src/skills/skill-tier.ts

@@ -0,0 +1 @@
+export type SkillTier = 'T3' | 'T2' | 'T1';