@handsupmin/gc-tree 1.1.2 → 1.1.4

package/dist/src/cli.js

@@ -9,7 +9,7 @@ import { dispatchGcTreeHook } from './hook.js';
 import { onboardBranch } from './onboard.js';
 import { buildProviderLaunchPlan, maybeLaunchProvider, promptLanguageSelection, promptLaunchProviderSelection, promptProviderSelection, } from './provider.js';
 import { DEFAULT_BRANCH, branchDir, resolveHome } from './paths.js';
-import { branchRepoMapPath, branchScopeStatus, detectCurrentRepoId, promptResolveScopeDecision, readBranchRepoMap, resolveBranchForRepo, setRepoScopeForBranch, } from './repo-map.js';
+import { branchRepoMapPath, detectCurrentRepoId, promptResolveScopeDecision, readBranchRepoMap, resolveBranchForRepo, setRepoScopeForBranch, } from './repo-map.js';
 import { findRelatedDocs, getDocById, resolveContext } from './resolve.js';
 import { scaffoldHostIntegration } from './scaffold.js';
 import { appendScaffoldedHost, requirePreferredProvider, writeSettings, readSettings } from './settings.js';
@@ -47,14 +47,14 @@ function usage() {
   gctree branches [--home DIR]
   gctree repo-map [--home DIR]
   gctree set-repo-scope --branch NAME [--repo NAME] [--cwd DIR] (--include|--exclude) [--home DIR]
-  gctree status [--home DIR] [--cwd DIR]
+  gctree status [--home DIR] [--branch NAME] [--cwd DIR]
   gctree onboard [--home DIR] [--branch NAME] [--provider <codex|claude-code>] [--target DIR] [--no-launch]
   gctree verify-onboarding [--home DIR] [--branch NAME]
   gctree reset-gc-branch [--home DIR] [--branch NAME] --yes
   gctree uninstall [--home DIR] [--target DIR] [--host <codex|claude-code|both>] [--keep-home] --yes
   gctree resolve --query TEXT [--home DIR] [--branch NAME] [--cwd DIR]
-  gctree show-doc --id ID [--home DIR] [--branch NAME]
-  gctree related --id ID [--home DIR] [--branch NAME]
+  gctree show-doc --id ID [--home DIR] [--branch NAME] [--cwd DIR]
+  gctree related --id ID [--home DIR] [--branch NAME] [--cwd DIR]
   gctree update-global-context [--home DIR] [--branch NAME] [--provider <codex|claude-code>] [--target DIR] [--no-launch]
   gctree update-gc [--home DIR] [--branch NAME] [--provider <codex|claude-code>] [--target DIR] [--no-launch]
   gctree ugc [--home DIR] [--branch NAME] [--provider <codex|claude-code>] [--target DIR] [--no-launch]
@@ -78,6 +78,15 @@ async function readStdinText() {
     }
     return Buffer.concat(chunks).toString('utf8');
 }
+async function resolveCommandBranch({ home, explicitBranch, cwd, }) {
+    const head = (await readHead(home)) || DEFAULT_BRANCH;
+    return resolveBranchForRepo({
+        home,
+        head,
+        explicitBranch,
+        cwd: cwd || process.cwd(),
+    });
+}
 function compactMatchCommands(id, home, branch) {
     const homeArg = `--home ${JSON.stringify(home)}`;
     const branchArg = `--branch ${JSON.stringify(branch)}`;
@@ -276,22 +285,26 @@ async function main() {
             return;
         }
         case 'status': {
-            const gcBranch = (await readHead(home)) || DEFAULT_BRANCH;
+            const resolved = await resolveCommandBranch({
+                home,
+                explicitBranch: readArg('--branch') || undefined,
+                cwd: readArg('--cwd') || process.cwd(),
+            });
+            const gcBranch = resolved.gc_branch;
             if (!existsSync(branchDir(home, gcBranch))) {
                 throw new Error('gc-tree is not initialized. Run `gctree init` first.');
             }
             const result = await statusForBranch(home, gcBranch);
             const settings = await readSettings(home);
-            const mapping = await readBranchRepoMap(home);
-            const currentRepo = await detectCurrentRepoId(readArg('--cwd') || process.cwd());
             console.log(JSON.stringify({
                 ...result,
                 provider_mode: settings?.provider_mode || null,
                 preferred_provider: settings?.preferred_provider || null,
                 preferred_language: settings?.preferred_language || null,
-                current_repo: currentRepo,
+                current_repo: resolved.current_repo,
+                source: resolved.source,
                 branch_repo_map_path: branchRepoMapPath(home),
-                repo_scope_status: branchScopeStatus(mapping, gcBranch, currentRepo),
+                repo_scope_status: resolved.scope_status,
             }, null, 2));
             return;
         }
@@ -365,10 +378,8 @@ async function main() {
             const query = readArg('--query');
             if (!query)
                 usage();
-            const head = (await readHead(home)) || DEFAULT_BRANCH;
-            const resolved = await resolveBranchForRepo({
+            const resolved = await resolveCommandBranch({
                 home,
-                head,
                 explicitBranch: readArg('--branch') || undefined,
                 cwd: readArg('--cwd') || process.cwd(),
             });
@@ -491,10 +502,24 @@ async function main() {
             const id = readArg('--id');
             if (!id)
                 usage();
-            const gcBranch = readArg('--branch') || (await readHead(home)) || DEFAULT_BRANCH;
+            const resolved = await resolveCommandBranch({
+                home,
+                explicitBranch: readArg('--branch') || undefined,
+                cwd: readArg('--cwd') || process.cwd(),
+            });
+            const gcBranch = resolved.gc_branch;
             const branchStatus = await statusForBranch(home, gcBranch);
             if (branchStatus.doc_count === 0) {
-                console.log(JSON.stringify({ status: 'empty_branch', gc_branch: gcBranch, id, message: `gc-branch "${gcBranch}" has no docs yet.`, doc: null }, null, 2));
+                console.log(JSON.stringify({
+                    status: 'empty_branch',
+                    gc_branch: gcBranch,
+                    id,
+                    current_repo: resolved.current_repo,
+                    source: resolved.source,
+                    repo_scope_status: resolved.scope_status,
+                    message: `gc-branch "${gcBranch}" has no docs yet.`,
+                    doc: null,
+                }, null, 2));
                 return;
             }
             const doc = await getDocById({ home, branch: gcBranch, id });
@@ -502,6 +527,9 @@ async function main() {
                 status: doc ? 'matched' : 'doc_not_found',
                 gc_branch: gcBranch,
                 id,
+                current_repo: resolved.current_repo,
+                source: resolved.source,
+                repo_scope_status: resolved.scope_status,
                 message: doc ? `Loaded doc "${id}".` : `Doc "${id}" was not found in gc-branch "${gcBranch}".`,
                 doc,
             }, null, 2));
@@ -511,12 +539,20 @@ async function main() {
             const id = readArg('--id');
             if (!id)
                 usage();
-            const gcBranch = readArg('--branch') || (await readHead(home)) || DEFAULT_BRANCH;
+            const resolved = await resolveCommandBranch({
+                home,
+                explicitBranch: readArg('--branch') || undefined,
+                cwd: readArg('--cwd') || process.cwd(),
+            });
+            const gcBranch = resolved.gc_branch;
             const result = await findRelatedDocs({ home, branch: gcBranch, id });
             console.log(JSON.stringify({
                 status: result.status,
                 gc_branch: gcBranch,
                 id,
+                current_repo: resolved.current_repo,
+                source: resolved.source,
+                repo_scope_status: resolved.scope_status,
                 message: result.status === 'matched'
                     ? `Found ${result.matches.length} related docs for "${id}".`
                     : result.status === 'no_related_docs'

package/dist/src/hook.js

@@ -27,14 +27,14 @@ function limitMatches(matches, max = 3) {
 function displayKeyword(match) {
     return (match.label || match.title || match.id).trim();
 }
-function formatMatches(matches) {
+function formatMatches(matches, gcBranch) {
     return limitMatches(matches)
         .map((match) => {
         const summary = match.summary?.trim() ?? '';
         const excerpt = match.excerpt?.trim() ?? '';
         const context = summary || excerpt;
         const shortContext = context.length > 180 ? `${context.slice(0, 177).trim()}...` : context;
-        const showDoc = `gctree show-doc --id "${match.id}"`;
+        const showDoc = `gctree show-doc --id "${match.id}" --branch "${gcBranch}"`;
         return [
             `[${displayKeyword(match)}]`,
             shortContext,
@@ -59,7 +59,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),
+        formatMatches(matches, gcBranch),
         '',
         `Rule: 위 문서를 먼저 근거로 삼고, 부족하면 details 명령으로 세부 정보를 확인.`,
     ];

package/dist/src/scaffold.js

@@ -107,25 +107,45 @@ function renderCodexOnboardSkill() {
 function renderUpdateProtocol() {
     return [
         '1. Run `gctree status` and state the active gc-branch.',
-        '2. Understand what changed — read the user\'s request, inspect relevant code or docs if needed, and determine the right content to capture.',
-        '3. Decide category and path automatically based on content — never ask the user about scope or placement:',
+        '2. Find the target doc before writing. Use `gctree resolve --query "<new fact or term>"`; if a match is incomplete, read the full doc with `gctree show-doc --id "<id>"`. For an existing doc, preserve useful existing details and index entries unless the user explicitly wants them removed.',
+        '3. Decide category and slug automatically based on content — never ask the user about scope or placement:',
         '   - `docs/workflows/<name>.md` — cross-repo action sequences, step-by-step procedures',
         '   - `docs/conventions/<repo>.md` — code patterns, naming, validation, DTO/service conventions for a repo',
         '   - `docs/repos/<repo>.md` — repo role, key paths, cross-repo dependencies',
         '   - `docs/domain/<concept>.md` — domain terms, acronyms, business logic',
         '   - `docs/infra/<topic>.md` — infra, deployment, environment config',
         '   - `docs/role/<name>.md` — team member roles, responsibilities',
-        '4. Write a `## Summary` that is actionable: actual patterns/commands/constraints a developer needs — not a sentence about what the doc covers.',
-        '5. Include a `## Index Entries` section in each doc\'s content with many keywords: aliases, related terms, command names, field names, workflow names, acronyms. More entries = more chances of being found by `gctree resolve`. Fewer than 5 entries almost always means more are needed.',
-        '5a. **Bilingual index entries**: when the workflow language is not English, every doc\'s `## Index Entries` MUST contain BOTH the workflow language AND English forms for every technical term, repo name, workflow name, and concept. gc-tree retrieval is token-overlap based and cannot translate at query time, so a Korean-language doc that omits English aliases will silently miss any English query (and vice versa). Acronyms (JWT, EMPI, VCF) stay in original form in both. Body and `## Summary` stay in the workflow language; bilingual coverage lives in the index.',
-        '6. Create a temporary JSON file with the updated `docs[]` and run `gctree __apply-update --input <temp-file>`.',
-        '7. Run `gctree verify-onboarding --branch <gc-branch>` and inspect the output:',
+        '4. In the update JSON, `slug` is the path without `docs/` and without `.md`. Example: existing file `docs/conventions/mvldev-assignment-backend-smson.md` must use `slug: "conventions/mvldev-assignment-backend-smson"`.',
+        '5. Use exactly this JSON schema. Unknown fields are rejected; do not use `id`, `path`, or `content`.',
+        '```json',
+        '{',
+        '  "branch": "<gc-branch>",',
+        '  "docs": [',
+        '    {',
+        '      "title": "conventions: example repo",',
+        '      "slug": "conventions/example-repo",',
+        '      "category": "conventions",',
+        '      "summary": "Actionable one-paragraph summary with patterns, commands, and constraints.",',
+        '      "body": "## Patterns\\n\\n- Details body only. Do not include # title, ## Summary, or ## Index Entries here.",',
+        '      "indexLabel": "example repo conventions",',
+        '      "indexEntries": ["example repo", "ExampleRepo", "주요 한국어 검색어", "command names", "field names"]',
+        '    }',
+        '  ]',
+        '}',
+        '```',
+        '6. Write an actionable `summary`: actual patterns/commands/constraints a developer needs — not a sentence about what the doc covers.',
+        '7. Put search terms in `indexEntries`, not inside `body`. Include aliases, related terms, command names, field names, workflow names, acronyms, and the exact phrases users are likely to ask. Fewer than 5 entries almost always means more are needed.',
+        '7a. **Bilingual index entries**: when the workflow language is not English, `indexEntries` MUST contain BOTH the workflow language AND English forms for every technical term, repo name, workflow name, and concept. gc-tree retrieval is token-overlap based and cannot translate at query time. Acronyms (JWT, EMPI, VCF) stay in original form in both. Body and summary stay in the workflow language; bilingual coverage lives in the index.',
+        '8. Create a temporary JSON file with the updated `docs[]` and run `gctree __apply-update --input <temp-file>`.',
+        '9. Run `gctree verify-onboarding --branch <gc-branch>` and inspect the output:',
         '   - Check that every updated doc appears in the verified doc list.',
         '   - Check that index entries for the new content exist and are searchable (not just generic titles).',
         '   - Check that no doc has `category: "general"` — reassign to correct category if so.',
         '   - Check that important concepts from the update are present as index labels — if missing, re-apply with added index entries.',
         '   - Self-heal any issues without asking the user: fix category, add index entries, re-run `gctree __apply-update`, re-verify.',
-        '8. Show the user which docs were updated and confirm the index now covers the new content.',
+        '10. Run `gctree resolve --query "<new keyword>"` and `gctree show-doc --id "<slug>"` for at least one new keyword/doc to prove retrieval and details are correct.',
+        '11. If you intended to update an existing doc and `doc_count` increased unexpectedly, do not report success. Inspect the duplicate, remove the accidental doc, then re-apply with the correct `slug`.',
+        '12. Show the user which docs were updated and confirm the index now covers the new content.',
     ];
 }
 function renderCodexUpdateSkill() {

package/dist/src/update.js

@@ -4,6 +4,14 @@ import { dirname, join } from 'node:path';
 import { renderDocMarkdown, slugify } from './markdown.js';
 import { branchDocsDir, DEFAULT_BRANCH, settingsPath } from './paths.js';
 import { ensureBranchExists, updateBranchMeta, writeIndexFromDocs } from './store.js';
+const UPDATE_ROOT_KEYS = new Set(['branch', 'branchSummary', 'docs']);
+const UPDATE_DOC_KEYS = new Set(['title', 'slug', 'summary', 'body', 'tags', 'category', 'indexLabel', 'indexEntries']);
+const VALID_UPDATE_CATEGORIES = new Set(['role', 'repos', 'domain', 'workflows', 'conventions', 'infra', 'verification']);
+const LEGACY_DOC_FIELD_HINTS = {
+    id: 'use `slug` instead, without `docs/` or `.md`',
+    path: 'use `slug` instead, without `docs/` or `.md`',
+    content: 'use `body` instead, and put search terms in `indexEntries`',
+};
 function docRelativePath(doc) {
     if (doc.slug?.includes('/'))
         return `${doc.slug.replace(/\.md$/i, '')}.md`;
@@ -11,7 +19,118 @@ function docRelativePath(doc) {
     const category = doc.category ? slugify(doc.category) : '';
     return category ? `${category}/${fileBase}.md` : `${fileBase}.md`;
 }
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function unknownKeys(record, allowed) {
+    return Object.keys(record).filter((key) => !allowed.has(key));
+}
+function requireNonEmptyString(record, key, subject) {
+    const value = record[key];
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new Error(`Invalid gctree update input: ${subject}.${key} must be a non-empty string.`);
+    }
+    return value.trim();
+}
+function validateOptionalString(record, key, subject) {
+    const value = record[key];
+    if (value === undefined)
+        return undefined;
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new Error(`Invalid gctree update input: ${subject}.${key} must be a non-empty string when provided.`);
+    }
+    return value.trim();
+}
+function validateOptionalStringArray(record, key, subject) {
+    const value = record[key];
+    if (value === undefined)
+        return undefined;
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string')) {
+        throw new Error(`Invalid gctree update input: ${subject}.${key} must be an array of strings when provided.`);
+    }
+    const entries = value.map((entry) => entry.trim()).filter(Boolean);
+    if (entries.length === 0) {
+        throw new Error(`Invalid gctree update input: ${subject}.${key} must contain at least one non-empty string when provided.`);
+    }
+    return entries;
+}
+function validateUpdateSlug(slug, subject) {
+    if (slug.startsWith('docs/')) {
+        throw new Error(`Invalid gctree update input: ${subject}.slug must omit the docs/ prefix. Example: use "conventions/example" instead of "docs/conventions/example.md".`);
+    }
+    if (slug.endsWith('.md')) {
+        throw new Error(`Invalid gctree update input: ${subject}.slug must omit the .md suffix. Example: use "conventions/example" instead of "conventions/example.md".`);
+    }
+    if (slug.startsWith('/') || slug.includes('\\') || slug.split('/').includes('..')) {
+        throw new Error(`Invalid gctree update input: ${subject}.slug must be a relative doc slug without absolute paths, backslashes, or "..".`);
+    }
+    if (slug.includes('/')) {
+        const category = slug.split('/')[0];
+        if (!VALID_UPDATE_CATEGORIES.has(category)) {
+            throw new Error(`Invalid gctree update input: ${subject}.slug category must be one of ${[...VALID_UPDATE_CATEGORIES].join(', ')}.`);
+        }
+    }
+}
+function validateUpdateBody(body, subject) {
+    if (/^\s*#\s+/.test(body)) {
+        throw new Error(`Invalid gctree update input: ${subject}.body must not include the top-level markdown title; use the title field.`);
+    }
+    if (/^## Summary\b/m.test(body)) {
+        throw new Error(`Invalid gctree update input: ${subject}.body must not include ## Summary; use the summary field.`);
+    }
+    if (/^## Index Entries\b/m.test(body)) {
+        throw new Error(`Invalid gctree update input: ${subject}.body must not include ## Index Entries; use the indexEntries array.`);
+    }
+}
+function validateContextUpdateInput(input) {
+    if (!isRecord(input)) {
+        throw new Error('Invalid gctree update input: root must be an object with docs[].');
+    }
+    const extraRootKeys = unknownKeys(input, UPDATE_ROOT_KEYS);
+    if (extraRootKeys.length > 0) {
+        throw new Error(`Invalid gctree update input: unsupported root field(s): ${extraRootKeys.join(', ')}.`);
+    }
+    validateOptionalString(input, 'branch', 'input');
+    validateOptionalString(input, 'branchSummary', 'input');
+    if (!Array.isArray(input.docs) || input.docs.length === 0) {
+        throw new Error('Invalid gctree update input: docs must be a non-empty array.');
+    }
+    input.docs.forEach((doc, index) => {
+        const subject = `docs[${index}]`;
+        if (!isRecord(doc)) {
+            throw new Error(`Invalid gctree update input: ${subject} must be an object.`);
+        }
+        const extraDocKeys = unknownKeys(doc, UPDATE_DOC_KEYS);
+        if (extraDocKeys.length > 0) {
+            const hints = extraDocKeys
+                .map((key) => LEGACY_DOC_FIELD_HINTS[key])
+                .filter((hint) => Boolean(hint));
+            const suffix = hints.length > 0 ? ` ${[...new Set(hints)].join('; ')}.` : '';
+            throw new Error(`Invalid gctree update input: ${subject} has unsupported field(s): ${extraDocKeys.join(', ')}.${suffix}`);
+        }
+        requireNonEmptyString(doc, 'title', subject);
+        const slug = requireNonEmptyString(doc, 'slug', subject);
+        requireNonEmptyString(doc, 'summary', subject);
+        const body = requireNonEmptyString(doc, 'body', subject);
+        const category = validateOptionalString(doc, 'category', subject);
+        validateOptionalString(doc, 'indexLabel', subject);
+        validateOptionalStringArray(doc, 'tags', subject);
+        const indexEntries = validateOptionalStringArray(doc, 'indexEntries', subject);
+        if (!indexEntries) {
+            throw new Error(`Invalid gctree update input: ${subject}.indexEntries must be a non-empty array of search terms.`);
+        }
+        validateUpdateSlug(slug, subject);
+        validateUpdateBody(body, subject);
+        if (category && !VALID_UPDATE_CATEGORIES.has(category)) {
+            throw new Error(`Invalid gctree update input: ${subject}.category must be one of ${[...VALID_UPDATE_CATEGORIES].join(', ')}.`);
+        }
+        if (category && slug.includes('/') && slug.split('/')[0] !== category) {
+            throw new Error(`Invalid gctree update input: ${subject}.category must match the first segment of slug "${slug}".`);
+        }
+    });
+}
 export async function updateBranchContext({ home, input, branch, }) {
+    validateContextUpdateInput(input);
     const targetBranch = branch || input.branch || DEFAULT_BRANCH;
     await ensureBranchExists(home, targetBranch);
     await mkdir(branchDocsDir(home, targetBranch), { recursive: true });

package/package.json

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

package/skills/update-global-context/SKILL.md

@@ -18,4 +18,34 @@ Use guided updates for durable changes and reserve onboarding for empty gc-branc
    - `gctree update-global-context`
    - `gctree update-gc`
    - `gctree ugc`
-4. Keep the current gc-branch explicit throughout the conversation.
+4. Before writing update JSON, find the target doc with `gctree resolve --query "<new fact or term>"`. If the summary is insufficient, read the full doc with `gctree show-doc --id "<id>"`.
+5. For an existing doc, preserve useful existing Details and Index Entries unless the user explicitly wants them removed.
+6. Use `slug` as the durable path without `docs/` and without `.md`. Example: `docs/conventions/mvldev-assignment-backend-smson.md` becomes `"slug": "conventions/mvldev-assignment-backend-smson"`.
+7. Use exactly this `gctree __apply-update` JSON schema. Do not invent fields. In particular, never use `id`, `path`, or `content`; use `slug`, `body`, and `indexEntries`.
+
+```json
+{
+  "branch": "<gc-branch>",
+  "docs": [
+    {
+      "title": "conventions: example repo",
+      "slug": "conventions/example-repo",
+      "category": "conventions",
+      "summary": "Actionable one-paragraph summary with patterns, commands, and constraints.",
+      "body": "## Patterns\n\n- Details body only. Do not include # title, ## Summary, or ## Index Entries here.",
+      "indexLabel": "example repo conventions",
+      "indexEntries": ["example repo", "ExampleRepo", "주요 한국어 검색어", "command names", "field names"]
+    }
+  ]
+}
+```
+
+8. `body` is only the Details body. It may contain useful second-level sections such as `## Patterns`, but must not contain the top-level title, `## Summary`, or `## Index Entries`.
+9. `indexEntries` is mandatory. Add aliases, related terms, command names, field names, workflow names, acronyms, Korean terms, and English terms so `gctree resolve` can find the doc without translation.
+10. Apply the update with `gctree __apply-update --input <temp-file>`.
+11. Verify immediately:
+    - `gctree verify-onboarding --branch <gc-branch>`
+    - `gctree resolve --query "<new keyword>"`
+    - `gctree show-doc --id "<slug>"`
+12. If you intended to update an existing doc and `doc_count` increases unexpectedly, do not report success. Inspect the duplicate, remove the accidental doc, and re-apply with the correct `slug`.
+13. Keep the current gc-branch explicit throughout the conversation and tell the user exactly which docs changed.

package/dist/src/proposals.js

@@ -1,73 +0,0 @@
-import { mkdir, readFile, readdir, writeFile } from 'node:fs/promises';
-import { basename, join } from 'node:path';
-import { renderDocMarkdown, slugify } from './markdown.js';
-import { branchDir, branchDocsDir, branchProposalsDir, DEFAULT_BRANCH } from './paths.js';
-import { ensureBranchExists, updateBranchMeta, writeIndexFromDocs } from './store.js';
-export async function proposeUpdate({ home, input, branch, }) {
-    const targetBranch = branch || input.branch || DEFAULT_BRANCH;
-    await ensureBranchExists(home, targetBranch);
-    await mkdir(branchProposalsDir(home, targetBranch), { recursive: true });
-    const now = new Date().toISOString();
-    const id = `${now.replace(/[:.]/g, '-')}-${slugify(input.title)}`;
-    const proposal = {
-        version: 1,
-        id,
-        status: 'proposed',
-        branch: targetBranch,
-        title: input.title.trim(),
-        summary: input.summary.trim(),
-        created_at: now,
-        changes: input.docs.map((doc) => ({
-            path: `docs/${slugify(doc.slug || doc.title)}.md`,
-            title: doc.title.trim(),
-            summary: doc.summary.trim(),
-            body: doc.body.trim(),
-            ...(doc.tags?.length ? { tags: doc.tags } : {}),
-        })),
-    };
-    const proposalPath = join(branchProposalsDir(home, targetBranch), `${id}.json`);
-    await writeFile(proposalPath, `${JSON.stringify(proposal, null, 2)}\n`, 'utf8');
-    return { proposal_path: proposalPath, proposal };
-}
-export async function applyProposal({ home, proposalPath, }) {
-    const raw = await readFile(proposalPath, 'utf8');
-    const proposal = JSON.parse(raw);
-    await ensureBranchExists(home, proposal.branch);
-    await mkdir(branchDocsDir(home, proposal.branch), { recursive: true });
-    const updatedDocs = [];
-    for (const change of proposal.changes) {
-        const fullPath = join(branchDir(home, proposal.branch), change.path);
-        await writeFile(fullPath, renderDocMarkdown({
-            title: change.title,
-            summary: change.summary,
-            body: change.body,
-            tags: change.tags,
-        }), 'utf8');
-        updatedDocs.push(fullPath);
-    }
-    proposal.status = 'applied';
-    proposal.applied_at = new Date().toISOString();
-    await writeFile(proposalPath, `${JSON.stringify(proposal, null, 2)}\n`, 'utf8');
-    await writeIndexFromDocs(home, proposal.branch);
-    await updateBranchMeta(home, proposal.branch, {
-        summary: proposal.summary || (await readBranchSummary(home, proposal.branch)),
-    });
-    return {
-        branch: proposal.branch,
-        updated_docs: updatedDocs,
-        proposal_path: proposalPath,
-    };
-}
-async function readBranchSummary(home, branch) {
-    const branchJson = await readFile(join(branchDir(home, branch), 'branch.json'), 'utf8');
-    return JSON.parse(branchJson).summary || '';
-}
-export async function listProposals(home, branch) {
-    return (await readdir(branchProposalsDir(home, branch)).catch(() => []))
-        .filter((file) => file.endsWith('.json'))
-        .sort()
-        .map((file) => join(branchProposalsDir(home, branch), file));
-}
-export function proposalBasename(path) {
-    return basename(path);
-}