elanous 0.2.10 → 0.2.11

package/src/self-implement/seams.ts

@@ -39,6 +39,7 @@ import { writeScopedTypecheckConfig } from './scoped-typecheck-config.js';
 // ⭐ 게이트 스코프 근본 수리(2026-07-26) — 풀 `bun test` 폴백 제거 + 연관 테스트 유도(순수).
 import { resolveGateScope } from './gate-scope.js';
 import { buildImporterTestIndex, isTestPath } from './importer-test-index.js';
+import { buildRouteConsumerTestIndex } from './route-consumer-test-index.js';
 import { countTestDeclarations } from './test-declarations.js';
 import {
   allowsBaselineOnlyFailure,
@@ -75,6 +76,7 @@ import { tscEnv, assessTypecheckExecution, classifyTypecheckErrors, diffTypechec
 import { nestCapReached, childNestEnv, nestInfo } from '../agent/nest-depth.js';
 import { harnessBoundaryEnv, harnessBoundaryRequestsEnv, harnessBoundaryResponsesEnv, harnessSpaceEnv, getHarnessSpace, normalizeSpaceId, getHarnessRunId, resolveRunIdentity } from '../harness/harness-space.js';
 import { debug } from '../debug/log.js';
+import { RELEASE_PATH_HOLD_MARKER, RELEASE_PATH_LABEL, releasePathHoldShouldPost, releasePathHoldCommentsArgs, releasePrFilePaths } from '../self-dev/release-path-guard.js';
 import { emitDecision } from '../live/detail-switch.js';
 import { gateDecision, reviewDecision, mergeDecision } from './decision-events.js';
 import { LogStore } from '../mss/logging/log-store.js';
@@ -85,7 +87,9 @@ import { countReflectFactConflicts, type MustFixRefutation, type ReflectEvidence
 import { isSupervisorDecisionSection, splitGoalSections, supervisorGoalDigest } from './goal-digest.js';
 import type { SupervisionReworkSource } from './supervision-vocabulary.js';
 import type { ReworkBudgetVerdict } from './run-outcome.js';
-import { runHeadlessGoalLoopPty } from './headless-elanous-driver.js';
+import { pickImplementRoleForGoal, runHeadlessGoalLoopPty } from './headless-elanous-driver.js';
+import { childLlmSelectionEnv } from '../agent/run-context.js';
+import { observeExternalEvent } from '../context-bus/external-events.js';
 import { buildLlmHitlRelay, SIDE_EFFECT_RE } from '../harness/llm-hitl-relay.js';
 import { dispatchAskUserQuestion } from '../ask-user-question/tool.js';
 import { parseQuestionRequest } from '../ask-user-question/types.js';
@@ -1641,7 +1645,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       if ((o.ptyAvailable ?? ptyAvailable)()) {
         try {
           const res = await (o.runHeadlessGoalLoopPty ?? runHeadlessGoalLoopPty)({
-            binRoot, cwd, featurePrompt: prompt, maxWaitSec, brain,
+            binRoot, cwd, featurePrompt: prompt, goalDocument: feature, maxWaitSec, brain,
             ...(activityGraceSec !== undefined ? { activityGraceSec, activityGraceSource: 'caller' as const } : {}),
             autoStop: getUserConfig().tools.selfImplement.autoStop,
             autoAssist: getUserConfig().tools.selfImplement.autoAssist,
@@ -1698,9 +1702,14 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
       // 폴백 — PTY 불가/cap 초과/에러. 기존 헤드리스 spawnSync 경로 보존(블로킹이지만 견고).
       const args = [`${binRoot}/bin/elanous.mjs`, 'dev', '--implement'];
       const executionId = randomUUID();
+      const fallbackImplementRole = !childLlm && !process.env.ELANOUS_LLM_MODEL?.trim()
+        ? pickImplementRoleForGoal(feature) : undefined;
       if (o.configDir) args.push('--config-dir', o.configDir);
       args.push(prompt);
-      const r = runSpawnSync('bun', args, {
+      const fallbackSource = `elanous://harness/${encodeURIComponent(runId ?? 'unknown')}/${encodeURIComponent(executionId)}`;
+      observeExternalEvent({ origin: 'harness-child', kind: 'started', summary: 'Harness child started (fallback)', source: fallbackSource });
+      let r: ReturnType<typeof runSpawnSync>;
+      try { r = runSpawnSync('bun', args, {
         cwd, encoding: 'utf8', timeout: maxWaitSec * 1000, maxBuffer: 32 * 1024 * 1024,
         stdio: ['ignore', 'pipe', 'pipe'],
         ...(executionSignal ? { signal: executionSignal } : {}),   // /cancel 또는 구현 timeout → 자식 SIGTERM(고아 방지)
@@ -1716,6 +1725,9 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
           //   ⇒ 실물: 쿼터 신호가 갱신 안 되는 우주를 봐서 전 계정 unknown ⇒ 회전이 100% 계정 선택 ⇒ 429(4회).
           ...(o.stateDir && o.stateDirSource ? { ELANOUS_STATE_DIR_SOURCE: o.stateDirSource } : {}),
           ...childNestEnv(),
+          ...childLlmSelectionEnv(childLlm ?? (fallbackImplementRole
+            ? { provider: fallbackImplementRole.provider, model: fallbackImplementRole.model, source: 'config' }
+            : undefined)),
           ...((): Record<string, string> => {
             const sp = getHarnessSpace() ?? { inHarness: true as const, kind: 'self-implement' as const, id: normalizeSpaceId(basename(cwd)), runId: getHarnessRunId() };
             // ★ K run-identity 공백 방어 — driver 와 동일 계약(호출자 > 상속 > canonical mint). 빈 runId 는
@@ -1727,7 +1739,12 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
           ...harnessBoundaryResponsesEnv(executionId),
           ...harnessPolicyEnv(),
         },
-      });
+      }); } catch (error) {
+        observeExternalEvent({ origin: 'harness-child', kind: 'finished', summary: 'Harness child failed (fallback)', source: fallbackSource });
+        throw error;
+      }
+      observeExternalEvent({ origin: 'harness-child', kind: 'finished',
+        summary: `Harness child finished (fallback): ${r.status ?? 'unknown'}`, source: fallbackSource });
       const transcript = `${r.stdout ?? ''}${r.stderr ?? ''}`;
       const errCode = (r.error as { code?: string } | undefined)?.code;
       const timedOut = errCode === 'ETIMEDOUT' || r.signal === 'SIGTERM';
@@ -1807,9 +1824,11 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         trackedFiles.filter(isTestPath),
         [...new Set([...trackedFiles, ...changedAll, ...observationChangedFiles])].filter((file) => /\.(?:[cm]?[jt]sx?)$/.test(file)),
       );
+      const routeConsumerTestIndex = buildRouteConsumerTestIndex(cwd, trackedFiles.filter(isTestPath), changedAll, comparisonBase ?? 'HEAD');
       // 워크트리에 없는 변경 경로 = 지운 파일 — 미검증으로 세지 않는다(gate-scope `isDeleted` · 2026-09-26 run-7dd4cce6).
       const isDeleted = (path: string): boolean => !isFile(path);
-      const scope = resolveGateScope(changedAll, isFile, importerTestIndex ?? undefined, postsync ? { mode: 'postsync', isDeleted } : { isDeleted });
+      const scopeOpts = { isDeleted, routeConsumerTestIndex: routeConsumerTestIndex ?? undefined };
+      const scope = resolveGateScope(changedAll, isFile, importerTestIndex ?? undefined, postsync ? { ...scopeOpts, mode: 'postsync' } : scopeOpts);
       const comparisonFailureReason = observationChanges.comparisonBaseStatus === 'unavailable'
         ? 'comparison-base-unavailable'
         : observationChanges.comparisonBaseStatus === 'comparison-failed'
@@ -1817,10 +1836,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
           : undefined;
       const unmeasuredPostsync = postsync && !comparisonFailureReason && scope.reason === 'unmeasured';
       const scopeReason = comparisonFailureReason ?? scope.reason;
-      const observationScope = resolveGateScope(observationChangedFiles, isFile, importerTestIndex ?? undefined);
-      const observedChangedTestFiles = observationScope.reason === 'changed-tests'
-        ? (observationScope.testArgs ?? []).filter((file) => !observationScope.pulledInRelatedTests.includes(file))
-        : [];
+      const observedChangedTestFiles = [...new Set(observationChangedFiles.filter((file) => isTestPath(file) && isFile(file)))];
       // This reads the merge-base without executing base tests. Its static declaration count is
       // observational: dynamic generation and renamed helpers can make it incomplete.
       const declarationDecline = testDeclarationDecline(cwd, comparisonBase, observedChangedTestFiles);
@@ -1863,6 +1879,9 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         documentPaths: scope.documentPaths.slice(0, 8), documentPathCount: scope.documentPaths.length,
         documentsWithoutDerivedTests: scope.documentsWithoutDerivedTests.slice(0, 8),
         documentsWithoutDerivedTestCount: scope.documentsWithoutDerivedTests.length,
+        callerTests: scope.callerTests,
+        callerTestsOverflow: scope.callerTestsOverflow,
+        routeBaseLookupFailures: routeConsumerTestIndex.lookupFailures,
         pulledInRelatedTests: scope.pulledInRelatedTests.slice(0, 8),
         pulledInRelatedTestCount: scope.pulledInRelatedTests.length,
         importerTestIndexAvailable: importerTestIndex !== null,
@@ -1871,7 +1890,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         importerTestsNotRunTruncated: scope.importerTestsNotRun?.truncated ?? null,
         unresolvedRelativeImportSpecifiers: scope.importerTestsNotRun?.unresolvedRelativeSpecifiers ?? null,
       // ⚠️ 커버 안 된 변경이 있으면 **테스트가 돌았어도** warn — debug 는 운영 로그에서 필터링된다(리뷰 should-fix).
-      }, { level: scope.reason === 'no-related-tests' || scope.missingTestFiles > 0 || scope.unverified.length > 0 ? 'warn' : 'debug' });
+      }, { level: scope.reason === 'no-related-tests' || scope.missingTestFiles > 0 || scope.unverified.length > 0 || scope.callerTestsOverflow.length > 0 || routeConsumerTestIndex.lookupFailures.length > 0 ? 'warn' : 'debug' });
       try { emitDecision(gateDecision({ runId: ctx?.runId, reason: scopeReason, testStepSkipped })); } catch { /* observation must not change the gate result */ }
       // `defaultSeams.gate` owns the changed-file list and runs before the test-step skip,
       // so platform-only changes remain measured even when gate-scope has no Bun filters.
@@ -2174,6 +2193,12 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
           + `${scope.pulledInRelatedTests.slice(0, 8).join(', ')}`
           + `\n(편집된 테스트만 돌렸다면 이것들이 빠졌다)`
         : '';
+      const callerOverflowNote = scope.callerTestsOverflow.length > 0
+        ? `\n\n[gate-scope] ⚠️ caller test cap exceeded — not run: ${scope.callerTestsOverflow.map(({ file, reasons }) => `${file} (${reasons.join('+')})`).join(', ')}`
+        : '';
+      const routeLookupNote = routeConsumerTestIndex.lookupFailures.length > 0
+        ? `\n\n[gate-scope] ⚠️ caller route base lookup failed — unmeasured: ${routeConsumerTestIndex.lookupFailures.map(({ source, reason }) => `${source} (${reason})`).join(', ')}`
+        : '';
       const scopeNote = testStepSkipped
         ? `\n\n[gate-scope] ${scope.reason} — test 스텝을 건너뛰었다(변경파일 tsc 만 검증). `
           + (scope.reason === 'no-related-tests'
@@ -2204,7 +2229,7 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
         : '';
       return {
         passed: gatePassed,
-        log: `${baseLog}${policyFailureLog}${dependencyFailureLog}${dependencyUnmeasuredNote}${comparisonFailureLog}${baselineNote}${verifyByBreakingNote}${scopeNote}${uncoveredNote}${pulledInRelatedTestsNote}`,
+        log: `${baseLog}${policyFailureLog}${dependencyFailureLog}${dependencyUnmeasuredNote}${comparisonFailureLog}${baselineNote}${verifyByBreakingNote}${scopeNote}${uncoveredNote}${pulledInRelatedTestsNote}${callerOverflowNote}${routeLookupNote}`,
         testStepExecuted: !testStepSkipped && testStep !== undefined && !testStep.skipped,
         scopeReason,
         comparisonBaseStatus: observationChanges.comparisonBaseStatus,
@@ -2349,11 +2374,47 @@ export function defaultSeams(o: DefaultSeamsOptions = {}): SelfImplementSeams {
     postPrComment: async ({ number, body, cwd }) => {
       // Round comments go out as the GitHub App like the PR itself — a personal `gh` login made the owner a
       // participant and mailed them on merge (#22089).
+      if (body.startsWith(RELEASE_PATH_HOLD_MARKER)) {
+        // Several merge surfaces may hold the same PR; post the release-path hold comment once.
+        let history: unknown;
+        try {
+          history = JSON.parse((await execFileAsync('gh', releasePathHoldCommentsArgs(number), {
+            cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env),
+          })).stdout);
+        } catch { history = undefined; }
+        if (!releasePathHoldShouldPost(() => history)) return;
+      }
       await execFileAsync('gh', ['pr', 'comment', String(number), '--body', body], {
         cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env),
       });
     },
 
+    addPrLabel: async ({ number, label, cwd }) => {
+      if (label === RELEASE_PATH_LABEL) {
+        const existing = await execFileAsync('gh', ['label', 'list', '--search', label, '--json', 'name'], {
+          cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, env: ghAutomationEnv(process.env),
+        });
+        const names: unknown = JSON.parse(existing.stdout);
+        if (!Array.isArray(names)) throw new Error('gh label list returned an invalid list');
+        if (!names.some((item: unknown) => !!item && typeof item === 'object' && 'name' in item && item.name === label)) {
+          await execFileAsync('gh', ['label', 'create', label, '--color', 'D93F0B', '--description', 'Release path requires OP approval'], {
+            cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, env: ghAutomationEnv(process.env),
+          });
+        }
+      }
+      await execFileAsync('gh', ['pr', 'edit', String(number), '--add-label', label], {
+        cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, env: ghAutomationEnv(process.env),
+      });
+    },
+    readPrFiles: async ({ number, cwd }) => {
+      // Paginate the PR file API: a single `gh pr view --json files` can omit files after the first page.
+      const { stdout } = await execFileAsync('gh', [
+        'api', '--paginate', '--slurp', '--method', 'GET', '-f', 'per_page=100',
+        `repos/{owner}/{repo}/pulls/${number}/files`,
+      ], { cwd, encoding: 'utf8', timeout: GIT_TIMEOUT, maxBuffer: 64 * 1024 * 1024, env: ghAutomationEnv(process.env) });
+      return releasePrFilePaths(JSON.parse(stdout));
+    },
+
     ...(o.approvePr ? { approvePr: o.approvePr } : {}),
 
     // ★ 내부 리뷰(2026-07-21·review-gated merge) — worktree diff → reviewPullRequest(agent-substrate·미션/

package/src/self-implement/test-seams.ts

@@ -32,6 +32,7 @@ export function seams(over: Partial<SelfImplementSeams> & { gateResults?: boolea
     defaultBranchRef: () => 'origin/main',
     mergeMain: async () => ({ status: 'up-to-date' }),
     openPr: async ({ head }) => ({ url: `https://pr/${head}`, number: 7 }),
+    readPrFiles: async () => ['src/ordinary.ts'],
     readPrDiff: async () => '',
     readPrCommitShas: async () => ({ baseCommit: 'base-sha', headCommit: 'checked-head-sha' }),
     approvePr: async () => true,

package/src/self-implement/uncommitted-work.ts

@@ -0,0 +1,59 @@
+import { spawnSync } from 'node:child_process';
+import { isElanousRuntimeArtifactPath } from './gate-scope.js';
+
+export type UncommittedWork =
+  | { status: 'clean'; trackedChanges: string[]; untrackedFiles: string[] }
+  | { status: 'changes'; trackedChanges: string[]; untrackedFiles: string[] }
+  | { status: 'unavailable'; reason: string };
+
+/** Observe the index and working tree without staging, refreshing, or changing any files. */
+export function detectUncommittedWork(worktree: string): UncommittedWork {
+  const gitEnv = { ...process.env };
+  for (const key of Object.keys(gitEnv)) {
+    if (key.startsWith('GIT_')) delete gitEnv[key];
+  }
+  let result: ReturnType<typeof spawnSync>;
+  try {
+    result = spawnSync('git', ['--no-optional-locks', 'status', '--porcelain=v1', '-z', '--untracked-files=all'], {
+      cwd: worktree,
+      env: gitEnv,
+      encoding: 'utf8',
+      timeout: 10_000,
+    });
+  } catch (error) {
+    return { status: 'unavailable', reason: error instanceof Error ? error.message : String(error) };
+  }
+  if (result.error || result.status !== 0 || typeof result.stdout !== 'string') {
+    const stderr = typeof result.stderr === 'string' ? result.stderr.trim() : '';
+    return { status: 'unavailable', reason: result.error?.message || stderr || 'git status failed' };
+  }
+
+  const trackedChanges = new Set<string>();
+  const untrackedFiles = new Set<string>();
+  const entries = result.stdout.split('\0');
+  if (entries.at(-1) !== '') return { status: 'unavailable', reason: 'incomplete git status output' };
+  entries.pop();
+  for (let i = 0; i < entries.length; i += 1) {
+    const entry = entries[i]!;
+    if (entry.length < 4 || entry[2] !== ' ') return { status: 'unavailable', reason: 'invalid git status output' };
+    const kind = entry.slice(0, 2);
+    const path = entry.slice(3);
+    if (!path) return { status: 'unavailable', reason: 'invalid git status path' };
+    if (kind === '??') {
+      if (!isElanousRuntimeArtifactPath(path) && path !== '.elanous-test' && !path.startsWith('.elanous-test/')
+        && path !== '.elanous-skill-artifacts' && !path.startsWith('.elanous-skill-artifacts/')) {
+        untrackedFiles.add(path);
+      }
+    } else if (kind !== '!!') {
+      trackedChanges.add(path);
+      if (kind.includes('R') || kind.includes('C')) {
+        const original = entries[++i];
+        if (!original) return { status: 'unavailable', reason: 'incomplete git rename/copy output' };
+        if (kind.includes('R')) trackedChanges.add(original);
+      }
+    }
+  }
+  return trackedChanges.size || untrackedFiles.size
+    ? { status: 'changes', trackedChanges: [...trackedChanges], untrackedFiles: [...untrackedFiles] }
+    : { status: 'clean', trackedChanges: [], untrackedFiles: [] };
+}

package/src/session/index.ts

@@ -453,6 +453,33 @@ function writeIndex(entries: SessionMeta[], root: string = sessionRoot(), remove
   });
 }
 
+/** 세션 메타 하나를 잠금 «안에서» 디스크의 최신 목록 위에 고쳐 쓴다(IA1b).
+ *  `appendMessage` 가 잠금 밖에서 읽은 목록을 통째로 쓰면, 그 사이 다른 프로세스가 바꾼
+ *  같은 세션의 `projectId`·`messageCount` 를 옛 값으로 덮었다. 없는 id 면 `null`. */
+export function updateSessionMeta(
+  id: string,
+  mutate: (meta: SessionMeta) => void,
+  root: string = sessionRoot(),
+  opts: { bubble?: boolean } = {},
+): SessionMeta | null {
+  ensureRoots(root);
+  const p = indexPath(root);
+  return withDirLock(join(root, '.index.lock'), INDEX_LOCK_TIMEOUT_MS, () => {
+    const idx = readIndex(root);
+    const pos = idx.findIndex((m) => m.id === id);
+    if (pos < 0) return null;
+    const meta = { ...idx[pos] };
+    mutate(meta);
+    idx.splice(pos, 1);
+    if (opts.bubble) idx.unshift(meta);
+    else idx.splice(pos, 0, meta);
+    const tmp = `${p}.${process.pid}.${randomUUID().slice(0, 8)}.tmp`;
+    writeFileSync(tmp, JSON.stringify(idx, null, 2) + '\n', 'utf-8');
+    renameSync(tmp, p);
+    return meta;
+  });
+}
+
 // ── Tier 1 Phase 3 — listener primitive ──────────────────────────────
 //
 // Channel-agnostic subscribe API the daemon-mirror module (PR 2) hooks
@@ -633,20 +660,16 @@ export function appendMessage(id: string, msg: SerializedMessage, root: string =
   const line = JSON.stringify(enriched) + '\n';
   appendFileSync(file, line, 'utf-8');
 
-  const idx = readIndex(root);
-  const pos = idx.findIndex(m => m.id === id);
-  if (pos < 0) throw new Error(`session missing from index: ${id}`);
-  const meta = idx[pos];
-  meta.updatedAt = msg.ts || new Date().toISOString();
-  meta.messageCount = meta.messageCount + 1;
-  // Auto-title on first user message.
-  if (meta.title === '(new session)' && msg.role === 'user' && msg.content) {
-    meta.title = msg.content.replace(/\s+/g, ' ').slice(0, 60).trim() || '(empty)';
-  }
   // Bubble to front of index so listSessions returns newest-first.
-  idx.splice(pos, 1);
-  idx.unshift(meta);
-  writeIndex(idx, root);
+  const meta = updateSessionMeta(id, (m) => {
+    m.updatedAt = msg.ts || new Date().toISOString();
+    m.messageCount = m.messageCount + 1;
+    // Auto-title on first user message.
+    if (m.title === '(new session)' && msg.role === 'user' && msg.content) {
+      m.title = msg.content.replace(/\s+/g, ' ').slice(0, 60).trim() || '(empty)';
+    }
+  }, root, { bubble: true });
+  if (!meta) throw new Error(`session missing from index: ${id}`);
   // Tier 1 Phase 3 — fire AFTER on-disk write + index update.
   // Listeners (daemon-mirror) read the just-appended message + meta
   // from a consistent state.

package/src/skills/gift-install.ts

@@ -0,0 +1,215 @@
+import { createHash } from 'node:crypto';
+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 { debug } from '../debug/log.js';
+
+export interface GiftInstallOptions {
+  pack: string;
+  code?: string;
+  email?: string;
+  agree?: boolean;
+  endpoint?: string;
+  fetch?: typeof fetch;
+  targets?: string[];
+  /** Caps (defaults below); tests pass small values. */
+  maxDownloadBytes?: number;
+  maxUnpackedBytes?: number;
+  maxEntries?: number;
+}
+
+export type GiftInstallResult =
+  | { ok: true; names: string[]; paths: string[]; collisions: string[]; needsKeys: boolean; message: string }
+  | { ok: false; reason: string; message: string };
+
+// 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.
+export const MAX_DOWNLOAD_BYTES = 20 * 1024 * 1024;
+export const MAX_UNPACKED_BYTES = 100 * 1024 * 1024;
+export const MAX_ENTRIES = 5000;
+const CONSENT_NOTICE = '선물 스킬 전달과 안내 메일을 위해 이메일을 받습니다 · 보관은 알림 신청과 같은 기간 · 동의하면 --agree 를 붙여 다시 시도해 주세요.';
+const ERROR_MESSAGES: Record<string, string> = {
+  'email-required': CONSENT_NOTICE,
+  'consent-required': CONSENT_NOTICE,
+  'unknown-code': '코드를 다시 확인해 주세요.',
+  'used-up': '이미 다 쓴 코드예요 · 업데이트 소식 신청을 확인해 주세요.',
+  expired: '만료된 코드예요.',
+};
+
+/** Redeem, verify and install a gift without modifying an existing skill directory. */
+export async function installGiftPack({
+  pack, code, email, agree, endpoint = 'https://elanous.ai', fetch: fetchImpl = fetch,
+  targets = [join(homedir(), '.agents', 'skills'), join(homedir(), '.claude', 'skills')],
+  maxDownloadBytes = MAX_DOWNLOAD_BYTES, maxUnpackedBytes = MAX_UNPACKED_BYTES, maxEntries = MAX_ENTRIES,
+}: GiftInstallOptions): Promise<GiftInstallResult> {
+  const codePrefix = code && code.length > 4 ? code.slice(0, 4) : undefined;
+  const reject = (reason: string, message: string): GiftInstallResult => {
+    debug.log('skills.gift', 'rejected', { pack, reason, count: 0, codePrefix });
+    return { ok: false, reason, message };
+  };
+  if (!email?.trim() || !agree) return reject(!email?.trim() ? 'email-required' : 'consent-required', CONSENT_NOTICE);
+  if (!code?.trim()) return reject('unknown-code', ERROR_MESSAGES['unknown-code']!);
+  let gift: Record<string, unknown>;
+  try {
+    const response = await fetchImpl(`${endpoint.replace(/\/$/, '')}/api/gift`, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ code, email, consent: true }),
+    });
+    // The gift API assigns these reasons by HTTP status; error bodies may be absent or malformed.
+    const statusReason = ({ 404: 'unknown-code', 409: 'used-up', 410: 'expired' } as Record<number, string | undefined>)[response.status];
+    if (statusReason) return reject(statusReason, ERROR_MESSAGES[statusReason]!);
+    const payload: unknown = await response.json();
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+      return reject('invalid-response', '선물 응답을 확인할 수 없습니다. 다시 시도해 주세요.');
+    }
+    gift = payload as Record<string, unknown>;
+    if (!response.ok) {
+      const reason = response.status === 400 && (gift.reason === 'email-required' || gift.reason === 'consent-required')
+        ? gift.reason : 'request-rejected';
+      return reject(reason, ERROR_MESSAGES[reason] ?? '선물을 받을 수 없습니다. 다시 시도해 주세요.');
+    }
+  } catch {
+    return reject('network-error', '네트워크에 연결할 수 없습니다. 다시 시도해 주세요.');
+  }
+  if (gift.ok !== true || gift.pack !== pack || typeof gift.zipUrl !== 'string' || !/^https?:\/\//.test(gift.zipUrl)
+    || typeof gift.sha256 !== 'string' || !/^[a-f0-9]{64}$/i.test(gift.sha256)) {
+    return reject('invalid-response', '선물 응답을 확인할 수 없습니다. 다시 시도해 주세요.');
+  }
+  let zip: Buffer;
+  const tooLarge = () => reject('too-large', '선물 zip 이 허용 크기를 넘습니다. 설치하지 않았습니다.');
+  try {
+    const response = await fetchImpl(gift.zipUrl, { redirect: 'error' });
+    if (!response.ok) throw new Error('download-failed');
+    const declared = Number(response.headers.get('content-length'));
+    if (Number.isFinite(declared) && declared > maxDownloadBytes) return tooLarge();
+    // Count the bytes actually received too — a missing or lying Content-Length must not bypass the cap.
+    const chunks: Uint8Array[] = [];
+    let received = 0;
+    if (response.body) {
+      const reader = response.body.getReader();
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        received += value.byteLength;
+        if (received > maxDownloadBytes) { await reader.cancel().catch(() => {}); return tooLarge(); }
+        chunks.push(value);
+      }
+    }
+    zip = Buffer.concat(chunks);
+  } catch {
+    return reject('network-error', '다운로드에 실패했습니다. 다시 시도해 주세요.');
+  }
+  if (createHash('sha256').update(zip).digest('hex').toLowerCase() !== gift.sha256.toLowerCase()) {
+    debug.log('skills.gift', 'checksum-mismatch', { pack, reason: 'sha256', count: 0, codePrefix });
+    return { ok: false, reason: 'checksum-mismatch', message: '다운로드 검증(sha256)에 실패했습니다. 설치하지 않았습니다.' };
+  }
+  const temp = mkdtempSync(join(tmpdir(), 'elanous-gift-'));
+  const created: string[] = [];
+  let incomplete: string | undefined;
+  try {
+    const zipPath = join(temp, 'gift.zip');
+    const extracted = join(temp, 'extracted');
+    mkdirSync(extracted);
+    writeFileSync(zipPath, zip);
+    // Reject archive symlinks and traversal paths before extracting any entry.
+    execFileSync('python3', ['-c', `import os, stat, sys, zipfile
+root = sys.argv[2]
+max_unpacked = int(sys.argv[3]); max_entries = int(sys.argv[4])
+with zipfile.ZipFile(sys.argv[1]) as archive:
+    entries = archive.infolist()
+    if len(entries) > max_entries or sum(entry.file_size for entry in entries) > max_unpacked:
+        sys.exit(3)
+    for entry in entries:
+        parts = entry.filename.split('/')
+        mode = entry.external_attr >> 16
+        if (not entry.filename or entry.filename.startswith('/') or '\\u005c' in entry.filename
+            or any(part in ('', '.', '..') for part in parts[:-1])
+            or parts[-1] in ('.', '..') or (not entry.is_dir() and not parts[-1])
+            or stat.S_ISLNK(mode)):
+            raise ValueError('invalid archive entry')
+    written = 0
+    for entry in entries:
+        path = os.path.join(root, entry.filename)
+        if entry.is_dir():
+            os.makedirs(path, exist_ok=True)
+        else:
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            with archive.open(entry) as source, open(path, 'xb') as target:
+                while True:
+                    block = source.read(65536)
+                    if not block:
+                        break
+                    written += len(block)
+                    if written > max_unpacked:
+                        sys.exit(3)
+                    target.write(block)
+`, zipPath, extracted, String(maxUnpackedBytes), String(maxEntries)], { stdio: 'pipe' });
+    const skillDirs = (root: string) => readdirSync(root, { withFileTypes: true })
+      // SKILL.md must be a regular file — a `SKILL.md/` directory or a symlink is not a skill.
+      .filter((entry) => entry.isDirectory() && lstatSync(join(root, entry.name, 'SKILL.md'), { throwIfNoEntry: false })?.isFile() === true)
+      .map((entry) => ({ name: entry.name, path: join(root, entry.name) }));
+    let skills = skillDirs(extracted);
+    if (!skills.length) {
+      const roots = readdirSync(extracted, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory()).map((entry) => join(extracted, entry.name));
+      if (roots.length === 1) {
+        skills = skillDirs(roots[0]!);
+        if (!skills.length && existsSync(join(roots[0]!, 'skills'))) skills = skillDirs(join(roots[0]!, 'skills'));
+      }
+    }
+    // Directory listing order differs between filesystems — keep the bundle order, then names.
+    const rank = (name: string) => { const i = ESSENTIAL_SKILLS.indexOf(name); return i < 0 ? ESSENTIAL_SKILLS.length : i; };
+    skills = [...skills].sort((a, b) => rank(a.name) - rank(b.name) || a.name.localeCompare(b.name));
+    if (!skills.length || !targets.length) return reject('invalid-pack', '설치할 스킬 폴더나 대상 경로를 찾지 못했습니다.');
+    if (pack === 'essential' && (skills.length !== ESSENTIAL_SKILLS.length
+      || ESSENTIAL_SKILLS.some((name) => !skills.some((skill) => skill.name === name)))) {
+      return reject('invalid-pack', '필수 스킬 다섯이 모두 들어 있지 않습니다. 설치하지 않았습니다.');
+    }
+    const paths: string[] = [];
+    const collisions: string[] = [];
+    const date = new Date().toISOString().slice(0, 10);
+    for (const target of targets) {
+      mkdirSync(target, { recursive: true });
+      for (const skill of skills) {
+        const desired = join(target, skill.name);
+        let dest = desired;
+        if (lstatSync(desired, { throwIfNoEntry: false })) {
+          dest = `${desired}.gift-${date}`;
+          let n = 2;
+          while (lstatSync(dest, { throwIfNoEntry: false })) dest = `${desired}.gift-${date}-${n++}`;
+          collisions.push(`${skill.name} → ${dest}`);
+        }
+        // Reserve the destination exclusively: a concurrent installer must not be overwritten.
+        mkdirSync(dest);
+        incomplete = dest;
+        for (const entry of readdirSync(skill.path)) {
+          cpSync(join(skill.path, entry), join(dest, entry), { recursive: true, errorOnExist: true, force: false });
+        }
+        created.push(dest);
+        incomplete = undefined;
+        paths.push(dest);
+      }
+    }
+    const names = skills.map((skill) => skill.name);
+    const needsKeys = skills.some((skill) => existsSync(join(skill.path, '.env.example')));
+    const message = `${collisions.length ? `기존 폴더는 그대로 두고 옆에 설치했습니다: ${collisions.join(', ')}\n` : ''}${needsKeys ? '.env.example 이 있습니다 — 키는 가이드대로 설정해 주세요.\n' : ''}설치한 스킬: ${names.join(', ')}`;
+    debug.log('skills.gift', 'installed', { pack, reason: 'ok', count: paths.length, codePrefix });
+    return { ok: true, names, paths, collisions, needsKeys, message };
+  } catch (error) {
+    if ((error as { status?: number }).status === 3 && !created.length) return tooLarge();
+    const remaining: string[] = [];
+    for (const path of [...(incomplete ? [incomplete] : []), ...created.reverse()]) {
+      try { rmSync(path, { recursive: true }); }
+      catch { remaining.push(path); }
+    }
+    if (remaining.length) {
+      debug.log('skills.gift', 'rejected', { pack, reason: 'partial-install', count: remaining.length, codePrefix });
+      return { ok: false, reason: 'partial-install', message: `일부 설치된 스킬을 되돌리지 못했습니다: ${remaining.join(', ')}` };
+    }
+    return reject('invalid-pack', '선물 zip 을 안전하게 풀 수 없습니다. 설치하지 않았습니다.');
+  } finally {
+    rmSync(temp, { recursive: true, force: true });
+  }
+}

package/src/skills/tools/web-search.ts

@@ -101,7 +101,10 @@ export async function dispatchWebSearch(args: Record<string, unknown>, ctx: { si
   });
 
   const notePrefix = result.note ? `\n\n${result.note}\n` : '';
-  const output = [header, notePrefix.trim(), ...hitLines].filter(Boolean).join('\n\n');
+  const xStatus = result.xSearch === 'unavailable'
+    ? 'X search unavailable: these results do not establish reactions on X; do not cite them as X posts.'
+    : '';
+  const output = [header, xStatus, notePrefix.trim(), ...hitLines].filter(Boolean).join('\n\n');
 
   return {
     output,