@handsupmin/gc-tree 0.8.13 → 0.8.15

package/dist/src/cli.js

@@ -86,6 +86,22 @@ function compactMatchCommands(id, home, branch) {
         related: `gctree related --id ${JSON.stringify(id)} ${homeArg} ${branchArg}`,
     };
 }
+function formatResolveText({ status, gcBranch, currentRepo, matches, message, }) {
+    if (status !== 'matched') {
+        return `[gc-tree] ${message}\n`;
+    }
+    const lines = [
+        `[gc-tree] 관련 문서 ${matches.length}개 gc-branch="${gcBranch}" repo="${currentRepo || 'unscoped'}"`,
+    ];
+    for (const match of matches.slice(0, 5)) {
+        const keyword = (match.label || match.title || match.id).trim();
+        const context = (match.summary || match.excerpt || '').trim();
+        const shortContext = context.length > 140 ? `${context.slice(0, 137).trim()}...` : context;
+        lines.push(`[${keyword}] 관련 문서 존재${shortContext ? `: ${shortContext}` : ''}`);
+        lines.push(`[${keyword}] 세부 정보 탐색: gctree show-doc --id "${match.id}" --branch "${gcBranch}"`);
+    }
+    return `${lines.join('\n')}\n`;
+}
 function normalizeProvider(value) {
     if (!value)
         return undefined;
@@ -360,6 +376,7 @@ async function main() {
             const currentRepo = resolved.current_repo;
             let scopeStatus = resolved.scope_status;
             const settings = await readSettings(home);
+            const jsonOutput = hasFlag('--json');
             if (currentRepo && scopeStatus === 'unmapped') {
                 const decision = await promptResolveScopeDecision(gcBranch, currentRepo, settings?.preferred_language || 'English');
                 if (decision === 'always-use') {
@@ -368,19 +385,31 @@ async function main() {
                 }
                 else if (decision === 'ignore') {
                     await setRepoScopeForBranch({ home, branch: gcBranch, repo: currentRepo, mode: 'exclude' });
-                    console.log(JSON.stringify({
+                    const payload = {
+                        status: 'excluded',
                         gc_branch: gcBranch,
                         query,
                         current_repo: currentRepo,
                         source: resolved.source,
                         repo_scope_status: 'excluded',
+                        message: `Repo "${currentRepo}" is excluded from gc-branch "${gcBranch}".`,
                         matches: [],
-                    }, null, 2));
+                    };
+                    if (jsonOutput)
+                        console.log(JSON.stringify(payload, null, 2));
+                    else
+                        stdout.write(formatResolveText({
+                            status: payload.status,
+                            gcBranch,
+                            currentRepo,
+                            matches: [],
+                            message: payload.message,
+                        }));
                     return;
                 }
             }
             if (currentRepo && scopeStatus === 'excluded') {
-                console.log(JSON.stringify({
+                const payload = {
                     status: 'excluded',
                     gc_branch: gcBranch,
                     query,
@@ -389,12 +418,22 @@ async function main() {
                     repo_scope_status: 'excluded',
                     message: `Repo "${currentRepo}" is excluded from gc-branch "${gcBranch}".`,
                     matches: [],
-                }, null, 2));
+                };
+                if (jsonOutput)
+                    console.log(JSON.stringify(payload, null, 2));
+                else
+                    stdout.write(formatResolveText({
+                        status: payload.status,
+                        gcBranch,
+                        currentRepo,
+                        matches: [],
+                        message: payload.message,
+                    }));
                 return;
             }
             const branchStatus = await statusForBranch(home, gcBranch);
             if (branchStatus.doc_count === 0) {
-                console.log(JSON.stringify({
+                const payload = {
                     status: 'empty_branch',
                     gc_branch: gcBranch,
                     query,
@@ -403,25 +442,49 @@ async function main() {
                     repo_scope_status: scopeStatus,
                     message: `gc-branch "${gcBranch}" has no docs yet. Run gctree onboard to add durable context.`,
                     matches: [],
-                }, null, 2));
+                };
+                if (jsonOutput)
+                    console.log(JSON.stringify(payload, null, 2));
+                else
+                    stdout.write(formatResolveText({
+                        status: payload.status,
+                        gcBranch,
+                        currentRepo,
+                        matches: [],
+                        message: payload.message,
+                    }));
                 return;
             }
             const result = await resolveContext({ home, branch: gcBranch, query });
-            console.log(JSON.stringify({
-                status: result.matches.length > 0 ? 'matched' : 'no_match',
+            const status = result.matches.length > 0 ? 'matched' : 'no_match';
+            const message = result.matches.length > 0
+                ? `Found ${result.matches.length} matching docs. Use show-doc/related for progressive disclosure.`
+                : `No matching docs found in gc-branch "${gcBranch}" for this query.`;
+            const payload = {
+                status,
                 gc_branch: result.branch,
                 query: result.query,
                 current_repo: currentRepo,
                 source: resolved.source,
                 repo_scope_status: scopeStatus,
-                message: result.matches.length > 0
-                    ? `Found ${result.matches.length} matching docs. Use show-doc/related for progressive disclosure.`
-                    : `No matching docs found in gc-branch "${gcBranch}" for this query.`,
+                message,
                 matches: result.matches.map((match) => ({
                     ...match,
                     commands: compactMatchCommands(match.id, home, gcBranch),
                 })),
-            }, null, 2));
+            };
+            if (jsonOutput) {
+                console.log(JSON.stringify(payload, null, 2));
+            }
+            else {
+                stdout.write(formatResolveText({
+                    status,
+                    gcBranch,
+                    currentRepo,
+                    matches: result.matches,
+                    message,
+                }));
+            }
             return;
         }
         case 'show-doc': {
@@ -532,13 +595,35 @@ async function main() {
                 usage();
             const explicitTarget = readArg('--target');
             const isGlobal = !explicitTarget || Object.values({ codex: gctreeGlobalRoot('codex'), claude: gctreeGlobalRoot('claude-code') }).some((r) => resolve(explicitTarget) === resolve(r));
-            const result = await ensureScaffold({
+            if (isGlobal) {
+                const result = await ensureScaffold({
+                    providerMode: host,
+                    scope: 'global',
+                    force: hasFlag('--force'),
+                    home,
+                });
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            const globalResult = await ensureScaffold({
                 providerMode: host,
-                ...(isGlobal ? { scope: 'global' } : { targetDir: explicitTarget, scope: 'local' }),
+                scope: 'global',
                 force: hasFlag('--force'),
                 home,
             });
-            console.log(JSON.stringify(result, null, 2));
+            const localResult = await ensureScaffold({
+                providerMode: host,
+                targetDir: explicitTarget,
+                scope: 'local',
+                force: hasFlag('--force'),
+                home,
+            });
+            console.log(JSON.stringify({
+                hosts: host,
+                target_dir: explicitTarget,
+                written: [...globalResult.written, ...localResult.written],
+                skipped_existing: [...globalResult.skipped_existing, ...localResult.skipped_existing],
+            }, null, 2));
             return;
         }
         case 'update': {

package/dist/src/hook.js

@@ -1,8 +1,8 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { mkdir, open, readFile, rm, stat, writeFile } from 'node:fs/promises';
 import { createHash } from 'node:crypto';
 import { dirname } from 'node:path';
 import { DEFAULT_BRANCH } from './paths.js';
-import { hookCachePath, } from './paths.js';
+import { hookCachePath, hookCacheDir, } from './paths.js';
 import { branchScopeStatus, readBranchRepoMap, resolveBranchForRepo } from './repo-map.js';
 import { resolveContext } from './resolve.js';
 import { readHead, statusForBranch } from './store.js';
@@ -24,17 +24,21 @@ function recentDuplicate(previousAt, now, windowMs = 5000) {
 function limitMatches(matches, max = 3) {
     return matches.slice(0, max);
 }
+function displayKeyword(match) {
+    return (match.label || match.title || match.id).trim();
+}
 function formatMatches(matches) {
     return limitMatches(matches)
-        .map((match, index) => {
+        .map((match) => {
         const summary = match.summary?.trim() ?? '';
         const excerpt = match.excerpt?.trim() ?? '';
-        // Use summary if it looks actionable (long enough to contain patterns).
-        // Fall back to a trimmed excerpt when summary is a short description-only sentence.
-        const context = summary.length >= 60 ? summary : (excerpt.slice(0, 300) || summary);
-        return context
-            ? `${index + 1}. ${match.title} [${match.id}]\n   > ${context}`
-            : `${index + 1}. ${match.title} [${match.id}]`;
+        const context = summary || excerpt;
+        const shortContext = context.length > 180 ? `${context.slice(0, 177).trim()}...` : context;
+        const showDoc = `gctree show-doc --id "${match.id}"`;
+        return [
+            `[${displayKeyword(match)}] 관련 문서 존재${shortContext ? `: ${shortContext}` : ''}`,
+            `[${displayKeyword(match)}] 세부 정보 탐색: ${showDoc}`,
+        ].join('\n');
     })
         .join('\n');
 }
@@ -54,7 +58,7 @@ function buildMatchContext({ gcBranch, currentRepo, repoScopeStatus, matches, })
     const lines = [
         `[gc-tree] USE FIRST: ${Math.min(matches.length, 3)} docs gc-branch="${gcBranch}" repo="${currentRepo || 'unscoped'}" scope=${repoScopeStatus}.`,
         formatMatches(matches),
-        `Rule: summaries above are mandatory context — read them now. Only run \`gctree resolve --id <id>\` if a summary is insufficient for the task.`,
+        `Rule: 위 문서를 먼저 근거로 삼고, 부족하면 표시된 show-doc 명령으로 세부 정보를 확인.`,
     ];
     if (repoScopeStatus === 'unmapped' && currentRepo) {
         lines.push(`Note: repo "${currentRepo}" is unmapped. If it belongs here, offer to run: gctree set-repo-scope --branch ${gcBranch} --include`);
@@ -107,127 +111,166 @@ function readSessionId(payload) {
     const raw = normalizeText(payload.session_id || '');
     return raw || 'default-session';
 }
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function acquireHookLock(home, sessionId) {
+    const lockPath = `${hookCachePath(home, sessionId)}.lock`;
+    await mkdir(hookCacheDir(home), { recursive: true });
+    for (let attempt = 0; attempt < 50; attempt += 1) {
+        try {
+            const handle = await open(lockPath, 'wx');
+            await handle.close();
+            return async () => {
+                await rm(lockPath, { force: true });
+            };
+        }
+        catch (error) {
+            const code = error.code;
+            if (code !== 'EEXIST')
+                throw error;
+            try {
+                const info = await stat(lockPath);
+                if (Date.now() - info.mtimeMs > 10_000) {
+                    await rm(lockPath, { force: true });
+                    continue;
+                }
+            }
+            catch {
+                continue;
+            }
+            await sleep(25);
+        }
+    }
+    return async () => { };
+}
 export async function dispatchGcTreeHook({ event, home, payload, }) {
-    const cwd = payload.cwd || process.cwd();
-    const head = (await readHead(home)) || DEFAULT_BRANCH;
-    const resolved = await resolveBranchForRepo({ home, head, cwd });
-    const gcBranch = resolved.gc_branch;
-    const currentRepo = resolved.current_repo;
-    const mapping = await readBranchRepoMap(home);
-    const repoScopeStatus = branchScopeStatus(mapping, gcBranch, currentRepo);
     const sessionId = readSessionId(payload);
-    const now = new Date();
-    if (event === 'SessionStart') {
+    const releaseLock = await acquireHookLock(home, sessionId);
+    try {
+        const cwd = payload.cwd || process.cwd();
+        const head = (await readHead(home)) || DEFAULT_BRANCH;
+        const resolved = await resolveBranchForRepo({ home, head, cwd });
+        const gcBranch = resolved.gc_branch;
+        const currentRepo = resolved.current_repo;
+        const mapping = await readBranchRepoMap(home);
+        const repoScopeStatus = branchScopeStatus(mapping, gcBranch, currentRepo);
+        const now = new Date();
+        if (event === 'SessionStart') {
+            const previousCache = await readHookCache(home, sessionId);
+            const signature = hashQuery(`${event}:${gcBranch}:${currentRepo || ''}:${repoScopeStatus}`);
+            if (previousCache?.last_session_start_signature === signature &&
+                recentDuplicate(previousCache.last_session_start_at, now)) {
+                return null;
+            }
+            await writeHookCache(home, {
+                version: 1,
+                session_id: sessionId,
+                gc_branch: gcBranch,
+                current_repo: currentRepo,
+                repo_scope_status: repoScopeStatus,
+                branch_empty: previousCache?.branch_empty ?? false,
+                branch_excluded: previousCache?.branch_excluded ?? false,
+                no_match_signatures: previousCache?.no_match_signatures ?? [],
+                unmapped_shown_repos: previousCache?.unmapped_shown_repos ?? [],
+                prompt_count: previousCache?.prompt_count ?? 0,
+                last_session_start_signature: signature,
+                last_session_start_at: now.toISOString(),
+                last_prompt_signature: previousCache?.last_prompt_signature,
+                last_prompt_at: previousCache?.last_prompt_at,
+                updated_at: now.toISOString(),
+            });
+            return {
+                hookSpecificOutput: {
+                    hookEventName: event,
+                    additionalContext: buildSessionStartContext({
+                        gcBranch,
+                        currentRepo,
+                        repoScopeStatus,
+                    }),
+                },
+            };
+        }
+        const prompt = normalizeText(payload.user_prompt || payload.prompt || '');
+        if (!prompt)
+            return null;
+        const branchStatus = await statusForBranch(home, gcBranch);
         const previousCache = await readHookCache(home, sessionId);
-        const signature = hashQuery(`${event}:${gcBranch}:${currentRepo || ''}:${repoScopeStatus}`);
-        if (previousCache?.last_session_start_signature === signature &&
-            recentDuplicate(previousCache.last_session_start_at, now)) {
+        const promptSignature = hashQuery(`${event}:${gcBranch}:${currentRepo || ''}:${repoScopeStatus}:${prompt}`);
+        if (previousCache?.last_prompt_signature === promptSignature &&
+            recentDuplicate(previousCache.last_prompt_at, now)) {
             return null;
         }
-        await writeHookCache(home, {
-            version: 1,
-            session_id: sessionId,
-            gc_branch: gcBranch,
-            current_repo: currentRepo,
-            repo_scope_status: repoScopeStatus,
-            branch_empty: previousCache?.branch_empty ?? false,
-            branch_excluded: previousCache?.branch_excluded ?? false,
-            no_match_signatures: previousCache?.no_match_signatures ?? [],
-            unmapped_shown_repos: previousCache?.unmapped_shown_repos ?? [],
-            prompt_count: previousCache?.prompt_count ?? 0,
-            last_session_start_signature: signature,
-            last_session_start_at: now.toISOString(),
-            last_prompt_signature: previousCache?.last_prompt_signature,
-            last_prompt_at: previousCache?.last_prompt_at,
-            updated_at: now.toISOString(),
-        });
-        return {
-            hookSpecificOutput: {
-                hookEventName: event,
-                additionalContext: buildSessionStartContext({
-                    gcBranch,
-                    currentRepo,
-                    repoScopeStatus,
-                }),
-            },
-        };
-    }
-    const prompt = normalizeText(payload.user_prompt || payload.prompt || '');
-    if (!prompt)
-        return null;
-    const branchStatus = await statusForBranch(home, gcBranch);
-    const previousCache = await readHookCache(home, sessionId);
-    const promptSignature = hashQuery(`${event}:${gcBranch}:${currentRepo || ''}:${repoScopeStatus}:${prompt}`);
-    if (previousCache?.last_prompt_signature === promptSignature &&
-        recentDuplicate(previousCache.last_prompt_at, now)) {
-        return null;
-    }
-    const cache = nextCacheState(previousCache, {
-        sessionId,
-        gcBranch,
-        currentRepo,
-        repoScopeStatus,
-    });
-    cache.last_prompt_signature = promptSignature;
-    cache.last_prompt_at = now.toISOString();
-    let additionalContext;
-    if (repoScopeStatus === 'excluded') {
-        cache.branch_excluded = true;
-        additionalContext = buildExcludedContext({
+        const cache = nextCacheState(previousCache, {
+            sessionId,
             gcBranch,
             currentRepo,
-            cached: previousCache?.branch_excluded === true,
+            repoScopeStatus,
         });
-    }
-    else if (branchStatus.doc_count === 0) {
-        const wasCached = cache.branch_empty;
-        cache.branch_empty = true;
-        additionalContext = buildEmptyBranchContext({ gcBranch, currentRepo, cached: wasCached });
-    }
-    else if (repoScopeStatus === 'unmapped' && currentRepo && cache.unmapped_shown_repos.includes(currentRepo)) {
-        // Already showed context for this unmapped repo this session — skip silently.
-        cache.updated_at = now.toISOString();
-        await writeHookCache(home, cache);
-        return null;
-    }
-    else {
-        // For unmapped repos: use prompt only (no repo prefix) to avoid bias; apply higher score threshold.
-        const isUnmapped = repoScopeStatus === 'unmapped';
-        const query = !isUnmapped && currentRepo ? `${currentRepo} ${prompt}` : prompt;
-        const signature = hashQuery(query);
-        if (!isUnmapped && cache.no_match_signatures.includes(signature)) {
-            additionalContext = buildNoMatchContext({ gcBranch, currentRepo, cached: true });
+        cache.last_prompt_signature = promptSignature;
+        cache.last_prompt_at = now.toISOString();
+        let additionalContext;
+        if (repoScopeStatus === 'excluded') {
+            cache.branch_excluded = true;
+            additionalContext = buildExcludedContext({
+                gcBranch,
+                currentRepo,
+                cached: previousCache?.branch_excluded === true,
+            });
+        }
+        else if (branchStatus.doc_count === 0) {
+            const wasCached = cache.branch_empty;
+            cache.branch_empty = true;
+            additionalContext = buildEmptyBranchContext({ gcBranch, currentRepo, cached: wasCached });
+        }
+        else if (repoScopeStatus === 'unmapped' && currentRepo && cache.unmapped_shown_repos.includes(currentRepo)) {
+            // Already showed context for this unmapped repo this session — skip silently.
+            cache.updated_at = now.toISOString();
+            await writeHookCache(home, cache);
+            return null;
         }
         else {
-            const result = await resolveContext({ home, branch: gcBranch, query });
-            const effectiveMatches = result.matches;
-            if (effectiveMatches.length === 0) {
-                if (isUnmapped) {
-                    // Unmapped + no strong match: skip silently, no noise.
-                    cache.updated_at = now.toISOString();
-                    await writeHookCache(home, cache);
-                    return null;
-                }
-                cache.no_match_signatures = [...new Set([...cache.no_match_signatures, signature])];
-                additionalContext = buildNoMatchContext({ gcBranch, currentRepo, cached: false });
+            // For unmapped repos: use prompt only (no repo prefix) to avoid bias; apply higher score threshold.
+            const isUnmapped = repoScopeStatus === 'unmapped';
+            const query = !isUnmapped && currentRepo ? `${currentRepo} ${prompt}` : prompt;
+            const signature = hashQuery(query);
+            if (!isUnmapped && cache.no_match_signatures.includes(signature)) {
+                additionalContext = buildNoMatchContext({ gcBranch, currentRepo, cached: true });
             }
             else {
-                if (!isUnmapped) {
-                    cache.no_match_signatures = cache.no_match_signatures.filter((entry) => entry !== signature);
+                const result = await resolveContext({ home, branch: gcBranch, query });
+                const effectiveMatches = result.matches;
+                if (effectiveMatches.length === 0) {
+                    if (isUnmapped) {
+                        // Unmapped + no strong match: skip silently, no noise.
+                        cache.updated_at = now.toISOString();
+                        await writeHookCache(home, cache);
+                        return null;
+                    }
+                    cache.no_match_signatures = [...new Set([...cache.no_match_signatures, signature])];
+                    additionalContext = buildNoMatchContext({ gcBranch, currentRepo, cached: false });
                 }
-                else if (currentRepo) {
-                    // Mark this unmapped repo as shown so we don't repeat next prompt.
-                    cache.unmapped_shown_repos = [...new Set([...cache.unmapped_shown_repos, currentRepo])];
+                else {
+                    if (!isUnmapped) {
+                        cache.no_match_signatures = cache.no_match_signatures.filter((entry) => entry !== signature);
+                    }
+                    else if (currentRepo) {
+                        // Mark this unmapped repo as shown so we don't repeat next prompt.
+                        cache.unmapped_shown_repos = [...new Set([...cache.unmapped_shown_repos, currentRepo])];
+                    }
+                    additionalContext = buildMatchContext({ gcBranch, currentRepo, repoScopeStatus, matches: effectiveMatches });
                 }
-                additionalContext = buildMatchContext({ gcBranch, currentRepo, repoScopeStatus, matches: effectiveMatches });
+            }
+            if (cache.prompt_count > 0 && cache.prompt_count % SELF_REVIEW_INTERVAL === 0) {
+                additionalContext += buildSelfReviewAppend(cache.prompt_count);
+                cache.prompt_count = 0;
             }
         }
-        if (cache.prompt_count > 0 && cache.prompt_count % SELF_REVIEW_INTERVAL === 0) {
-            additionalContext += buildSelfReviewAppend(cache.prompt_count);
-            cache.prompt_count = 0;
-        }
+        cache.updated_at = now.toISOString();
+        await writeHookCache(home, cache);
+        return { hookSpecificOutput: { hookEventName: event, additionalContext } };
+    }
+    finally {
+        await releaseLock();
     }
-    cache.updated_at = now.toISOString();
-    await writeHookCache(home, cache);
-    return { hookSpecificOutput: { hookEventName: event, additionalContext } };
 }

package/dist/src/markdown.js

@@ -295,14 +295,31 @@ export function extractTitle(markdown) {
     return match?.[1]?.trim() || '';
 }
 export function extractExcerpt(markdown, query) {
-    const content = String(markdown || '').replace(/\s+/g, ' ').trim();
+    const content = String(markdown || '')
+        .replace(/^#+\s+/gm, '')
+        .replace(/\s+/g, ' ')
+        .trim();
     if (!content)
         return '';
-    const normalized = query.toLowerCase();
-    const index = content.toLowerCase().indexOf(normalized);
-    if (index === -1)
-        return content.slice(0, 140);
-    const start = Math.max(0, index - 40);
-    const end = Math.min(content.length, index + normalized.length + 80);
-    return content.slice(start, end).trim();
+    const tokens = String(query || '')
+        .toLowerCase()
+        .split(/[^\p{L}\p{N}]+/u)
+        .flatMap((t) => t.split(/(?<=[a-z0-9])(?=[^\x00-\x7f])|(?<=[^\x00-\x7f])(?=[a-z0-9])/))
+        .filter((t) => t.length >= 2);
+    if (tokens.length === 0)
+        return content.slice(0, 180);
+    const chunks = content
+        .split(/(?<=[.!?。！？])\s+|\s+-\s+|(?=\b[A-Z][A-Za-z ]+:)/)
+        .map((chunk) => chunk.trim())
+        .filter(Boolean);
+    const scored = chunks
+        .map((chunk, index) => ({
+        chunk,
+        index,
+        score: tokens.reduce((sum, token) => sum + (chunk.toLowerCase().includes(token) ? 1 : 0), 0),
+    }))
+        .filter((entry) => entry.score > 0)
+        .sort((a, b) => b.score - a.score || a.index - b.index);
+    const best = scored[0]?.chunk || content;
+    return best.length > 220 ? `${best.slice(0, 217).trim()}...` : best;
 }

package/dist/src/resolve.js

@@ -27,8 +27,7 @@ function makeTokenRegex(token) {
         ? new RegExp(`\\b${token}\\b`)
         : new RegExp(`(?<!\\p{L})${token}(?!\\p{L})`, 'u');
 }
-function scoreText(text, query) {
-    const tokens = tokenize(query);
+function countTokenMatches(text, tokens) {
     if (tokens.length === 0)
         return 0;
     const haystack = String(text || '').toLowerCase();
@@ -42,13 +41,58 @@ function scoreText(text, query) {
         }
     }, 0);
 }
+function scoreText(text, query) {
+    return countTokenMatches(text, tokenize(query));
+}
+function exactPhraseScore(text, query) {
+    const phrase = String(query || '').trim().toLowerCase();
+    if (phrase.length < 4)
+        return 0;
+    return String(text || '').toLowerCase().includes(phrase) ? 6 : 0;
+}
+function scoreDoc(entry, query) {
+    const tokens = tokenize(query);
+    if (tokens.length === 0)
+        return 0;
+    const labelScore = countTokenMatches(entry.label, tokens) * 10;
+    const titleScore = countTokenMatches(entry.title, tokens) * 7;
+    const summaryScore = countTokenMatches(entry.summary, tokens) * 5;
+    const categoryScore = countTokenMatches(entry.category, tokens) * 2;
+    const pathScore = countTokenMatches(entry.path, tokens) * 2;
+    const contentScore = countTokenMatches(entry.content, tokens);
+    const phraseScore = exactPhraseScore(entry.label, query) +
+        exactPhraseScore(entry.title, query) +
+        exactPhraseScore(entry.summary, query) +
+        exactPhraseScore(entry.content, query);
+    return labelScore + titleScore + summaryScore + categoryScore + pathScore + contentScore + phraseScore;
+}
+function minimumUsefulScore(query) {
+    return tokenize(query).length <= 1 ? 1 : 2;
+}
+function labelQueryPosition(label, query) {
+    const normalizedQuery = String(query || '').toLowerCase();
+    const positions = tokenize(label)
+        .map((token) => normalizedQuery.indexOf(token))
+        .filter((index) => index >= 0);
+    return positions.length > 0 ? Math.min(...positions) : Number.MAX_SAFE_INTEGER;
+}
+function betterMatch(candidate, previous, query) {
+    return (!previous ||
+        candidate.score > previous.score ||
+        (candidate.score === previous.score &&
+            labelQueryPosition(candidate.label, query) < labelQueryPosition(previous.label, query)));
+}
 async function readBranchDocs(home, branch) {
     const indexRaw = await readFile(branchIndexPath(home, branch), 'utf8');
     const entries = parseIndexEntries(indexRaw);
-    const uniqueEntries = [...new Map(entries.map((entry) => [entry.path, entry])).values()];
-    return Promise.all(uniqueEntries.map(async (entry) => {
+    const contentCache = new Map();
+    return Promise.all(entries.map(async (entry) => {
         const fullPath = join(branchDir(home, branch), entry.path);
-        const raw = await readFile(fullPath, 'utf8');
+        let raw = contentCache.get(fullPath);
+        if (!raw) {
+            raw = await readFile(fullPath, 'utf8');
+            contentCache.set(fullPath, raw);
+        }
         return {
             id: entry.id || docIdFromPath(entry.path),
             title: extractTitle(raw) || entry.title,
@@ -62,16 +106,13 @@ async function readBranchDocs(home, branch) {
 }
 export async function resolveContext({ home, branch, query, }) {
     const entries = await readBranchDocs(home, branch);
-    const matches = [];
+    const matchesById = new Map();
+    const minScore = minimumUsefulScore(query);
     for (const entry of entries) {
-        const combined = `${entry.title}\n${entry.summary}\n${entry.content}`;
-        // Title matches count double (higher signal density)
-        const titleScore = scoreText(entry.title, query);
-        const bodyScore = scoreText(`${entry.summary}\n${entry.content}`, query);
-        const score = titleScore * 2 + bodyScore;
-        if (score <= 0)
+        const score = scoreDoc(entry, query);
+        if (score < minScore)
             continue;
-        matches.push({
+        const match = {
             id: entry.id,
             label: entry.label,
             category: entry.category,
@@ -80,12 +121,15 @@ export async function resolveContext({ home, branch, query, }) {
             score,
             summary: entry.summary,
             excerpt: extractExcerpt(entry.content, query),
-        });
+        };
+        if (betterMatch(match, matchesById.get(match.id), query)) {
+            matchesById.set(match.id, match);
+        }
     }
     return {
         branch,
         query,
-        matches: matches.sort((a, b) => b.score - a.score || a.title.localeCompare(b.title)),
+        matches: [...matchesById.values()].sort((a, b) => b.score - a.score || a.title.localeCompare(b.title)),
     };
 }
 export async function getDocById({ home, branch, id, }) {
@@ -102,26 +146,26 @@ export async function findRelatedDocs({ home, branch, id, limit = 5, }) {
         return { status: 'doc_not_found', selected: null, matches: [] };
     }
     const query = `${selected.title}\n${selected.summary}`;
-    const matches = docs
-        .filter((doc) => doc.id !== selected.id)
-        .map((doc) => {
-        const titleScore = scoreText(doc.title, query);
-        const bodyScore = scoreText(`${doc.summary}\n${doc.content}`, query);
-        const score = titleScore * 2 + bodyScore;
-        return score > 0
-            ? {
-                id: doc.id,
-                label: doc.label,
-                category: doc.category,
-                title: doc.title,
-                path: doc.path,
-                score,
-                summary: doc.summary,
-                excerpt: extractExcerpt(doc.content, query),
-            }
-            : null;
-    })
-        .filter((match) => Boolean(match))
+    const matchesById = new Map();
+    for (const doc of docs.filter((doc) => doc.id !== selected.id)) {
+        const score = scoreDoc(doc, query);
+        if (score <= 0)
+            continue;
+        const match = {
+            id: doc.id,
+            label: doc.label,
+            category: doc.category,
+            title: doc.title,
+            path: doc.path,
+            score,
+            summary: doc.summary,
+            excerpt: extractExcerpt(doc.content, query),
+        };
+        if (betterMatch(match, matchesById.get(match.id), query)) {
+            matchesById.set(match.id, match);
+        }
+    }
+    const matches = [...matchesById.values()]
         .sort((a, b) => b.score - a.score || a.title.localeCompare(b.title))
         .slice(0, limit);
     return {

package/dist/src/scaffold.js

@@ -301,11 +301,19 @@ export async function scaffoldHostIntegration({ host, targetDir, force = false,
             await unmergeGcTreeHooksJson(oldHooksPath);
         }
     }
-    await mergeGcTreeHooksJson({
-        filePath: hookPath,
-        target: isCodex ? 'codex' : 'claude-code',
-    });
-    written.push(hookPath);
+    if (scope === 'local') {
+        const status = await unmergeGcTreeHooksJson(hookPath);
+        if (status !== 'missing') {
+            written.push(hookPath);
+        }
+    }
+    else {
+        await mergeGcTreeHooksJson({
+            filePath: hookPath,
+            target: isCodex ? 'codex' : 'claude-code',
+        });
+        written.push(hookPath);
+    }
     const targets = files.map((file) => ({
         ...file,
         fullPath: join(resolvedTargetDir, file.path),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@handsupmin/gc-tree",
-  "version": "0.8.13",
+  "version": "0.8.15",
   "description": "Global Context Tree, a lightweight branch-aware global context orchestrator for AI coding tools",
   "type": "module",
   "private": false,