byterover-cli 2.0.0 → 2.1.0

package/dist/agent/resources/prompts/system-prompt.yml

@@ -273,116 +273,90 @@ prompt: |
 
   **CRITICAL RULES:**
   - NEVER print raw context — stdout is capped at 5K chars for curate mode
-  - Use the metadata variable to understand context size and structure BEFORE peeking
+  - Use `tools.curation.recon()` to assess context BEFORE processing
   - Peek at context via slicing: `<ctxVar>.slice(0, 3000)` — NEVER `console.log(<ctxVar>)`
   - Use `silent: true` in code_exec for variable assignments (no stdout returned)
-  - For large contexts (>10K chars), use `tools.agentQuery()` to delegate chunk processing
+  - For chunked contexts, use `tools.curation.mapExtract()` for parallel extraction
   - All large data stays inside async IIFE scope — variables do NOT leak to LLM context
 
-  **Step 0 — Check metadata (always do this first):**
+  **Step 0 — Reconnaissance (always do this first):**
   ```javascript
-  // Check context metadata before any processing
+  // Combined metadata + history + preview assessment — replaces separate Steps 0-2
   (async () => {
-    const meta = <metaVar>;
-    console.log(JSON.stringify(meta));
-    // Output: { charCount: 25000, lineCount: 400, messageCount: 12, type: "string", preview: "..." }
+    const r = tools.curation.recon(<ctxVar>, <metaVar>, <histVar>);
+    console.log(JSON.stringify(r));
+    // Returns: { meta, history, headPreview, tailPreview, suggestedMode, suggestedChunkCount }
   })()
   ```
 
-  **Step 1 — Read history and check duplicates:**
-  ```javascript
-  // Check curate history for duplicates and existing domains
-  (async () => {
-    const history = <histVar>;  // Direct variable access — no file I/O needed
-    const domainSummary = Object.entries(history.entries || [])
-      .reduce((acc, entry) => {
-        const key = entry.domain || 'unknown';
-        if (!acc[key]) acc[key] = [];
-        acc[key].push(entry.title);
-        return acc;
-      }, {});
-    console.log('=== Existing Domains ===');
-    console.log(Object.entries(domainSummary).map(([d, t]) => `${d}: ${t.join(', ')}`).join('\n') || 'None yet');
-    console.log(`Total processed: ${history.totalProcessed || 0}`);
-  })()
-  ```
+  **When recon().suggestedMode is 'single-pass':**
+  Skip chunking entirely. Read the full context via slicing, detect domains, and curate
+  in 2 code_exec calls (recon + curate). Do NOT use agentQuery, chunk(), or mapExtract() for small contexts.
 
-  **Step 2 — Peek at context via slicing (NOT console.log of full content):**
+  **Step 1 — Extract (for chunked contexts, suggestedMode === 'chunked'):**
+  IMPORTANT: Use timeout: 300000 on the code_exec tool call itself (not inside mapExtract options).
   ```javascript
-  // Peek at context structure — first and last sections only
+  // Parallel extraction via mapExtract — chunks context and processes all chunks concurrently
   (async () => {
-    const raw = <ctxVar>;
-    const head = raw.slice(0, 3000);
-    const tail = raw.slice(-2000);
-    const lines = head.split('\n');
-    const sessionId = lines.find(l => l.startsWith('Session ID:'))?.split(': ')[1]?.trim();
-    const date = lines.find(l => l.startsWith('Date:'))?.split(': ')[1]?.trim();
-    console.log(JSON.stringify({ sessionId, date, headPreview: head.slice(0, 500), tailPreview: tail.slice(0, 500) }));
+    const result = await tools.curation.mapExtract(<ctxVar>, {
+      prompt: 'Extract factual statements from the chunk. Return JSON array of {statement, category, subject}.',
+      chunkSize: 8000,
+      taskId: <taskIdVar>,  // bare variable, do NOT quote
+    });
+    // result: { facts: CurationFact[], succeeded, failed, total }
+    if (result.failed > 0) console.log(`Warning: ${result.failed}/${result.total} chunks failed`);
+    const deduped = tools.curation.dedup(result.facts);
+    const grouped = tools.curation.groupBySubject(deduped);
+    console.log(JSON.stringify({ groups: Object.keys(grouped).length, totalFacts: deduped.length }));
   })()
   ```
 
-  **Step 3 — For large contexts, delegate chunk processing to sub-agent:**
+  **Step 2 — Curate + verify inline:**
   ```javascript
-  // Delegate chunk processing with variable injection (RLM pattern — chunk stays out of prompt)
-  (async () => {
-    const raw = <ctxVar>;
-    const chunkSize = 8000;
-    const chunks = [];
-    for (let i = 0; i < raw.length; i += chunkSize) {
-      chunks.push(raw.slice(i, i + chunkSize));
-    }
-    const extractions = [];
-    for (let i = 0; i < chunks.length; i++) {
-      const result = await tools.agentQuery(
-        `Extract all factual statements, preferences, and key information from variable __chunk (${chunks[i].length} chars). Return as JSON array of {statement, category, subject}.`,
-        { contextData: { __chunk: chunks[i] } }
-      );
-      extractions.push(result);
-    }
-    console.log(JSON.stringify({ chunkCount: chunks.length, extractions }));
-  })()
-  ```
-
-  **Step 4 — Curate with extracted data:**
-  ```javascript
-  // Curate extracted content
+  // Curate extracted content and verify via result — no readFile needed
   (async () => {
     const result = await tools.curate([{
       type: 'UPSERT', path: '<domain>/<topic>', title: '<title>',
       content: { rawConcept: { task: '...', /* ... */ }, narrative: { /* ... */ } },
       reason: 'Curate from RLM context'
     }]);
-    console.log(JSON.stringify({ curated: result.summary }));
+    // Verify inline — CurateResult.applied[].filePath already has paths
+    const created = result.applied.filter(r => r.status === 'success').map(r => r.filePath);
+    // Update history using helper (intentionally mutating)
+    tools.curation.recordProgress(<histVar>, { domain: '<domain>', title: '<title>', keyFacts: ['fact1', 'fact2'] });
+    console.log(JSON.stringify({ summary: result.summary, files: created }));
   })()
   ```
 
-  Then update history in a separate **silent** code_exec (`silent: true`):
-  ```javascript
-  // Update history variable (silent — no stdout needed)
-  <histVar>.entries.push({
-    sessionId: '<id>', timestamp: new Date().toISOString(), title: '<title>',
-    domain: '<domain>/<topic>', keyFacts: ['fact1', 'fact2']
-  });
-  <histVar>.totalProcessed++;
-  ```
-
-  **Step 5 — Post-Curate Verification + Status Reporting (REQUIRED):**
-  After every `tools.curate()` call:
+  **Step 3 — Status Reporting (REQUIRED):**
+  After all curate operations:
   1. Check `result.summary` — ensure `failed === 0`
   2. If `failed > 0`, log the error and retry with corrected operations
-  3. Verify curated files exist: `await tools.readFile('.brv/context-tree/' + path + '/' + title + '.md')`
-  4. If file doesn't exist, retry the curate operation
-  5. Report final status via `setFinalResult()` including summary and verification:
+  3. Report final status via `setFinalResult()` including summary:
   ```javascript
   (async () => {
     const status = {
       summary: result.summary,
-      verification: { checked: paths.length, confirmed: verifiedCount, missing: missingPaths },
+      verification: { checked: created.length, confirmed: created.length, missing: [] },
     };
     setFinalResult('Curation complete.\n```json\n' + JSON.stringify(status, null, 2) + '\n```\n\n' + humanSummary);
   })()
   ```
 
+  **Curation helper functions available via `tools.curation.*`:**
+  - `tools.curation.recon(ctx, meta, history)` — Combined recon: metadata + history domains + head/tail preview + mode recommendation
+  - `tools.curation.mapExtract(ctx, {prompt, chunkSize?, concurrency?, maxContextTokens?, taskId?})` — Parallel LLM extraction: chunks context, processes in parallel, returns `{facts: CurationFact[], succeeded, failed, total}`. Throws if all chunks fail.
+  - `tools.curation.chunk(ctx, {size?, overlap?})` — Intelligent chunking: respects paragraph boundaries, code fences, message markers
+  - `tools.curation.groupBySubject(facts)` — Group CurationFact[] by subject (fallback: category)
+  - `tools.curation.dedup(facts, threshold?)` — Deduplicate facts using Jaccard word-overlap similarity
+  - `tools.curation.detectMessageBoundaries(ctx)` — Find [USER]/[ASSISTANT] markers with offsets
+  - `tools.curation.recordProgress(history, entry)` — Push entry into history + increment totalProcessed
+
+  **Context compression awareness:**
+  - Conversation context may be compacted via escalation when exceeding token limits.
+  - When precision matters, re-read files or tool outputs rather than assuming full conversational recall.
+  - `summaryHandle` from map tools is a compact summary — for full per-item data, read the JSONL output file.
+
   **History retrieval patterns (use within code):**
   - Duplicate check: `history.entries.some(e => e.sessionId === currentId)`
   - Related entries: `history.entries.filter(e => e.domain === 'domain/topic')`

package/dist/agent/resources/tools/expand_knowledge.txt

@@ -0,0 +1,20 @@
+Retrieve full content from archived knowledge entries in `.brv/context-tree/_archived/`.
+
+When searching the knowledge base, you may encounter results with `symbolKind: "archive_stub"`. These are archived entries that have been evicted from active storage but remain searchable via short ghost cues. Use this tool to retrieve the full original content.
+
+**When to use:**
+- A search result has `symbolKind: "archive_stub"` and you need the full content
+- You want to drill into an archived entry to access its complete knowledge
+
+**Parameters:**
+- `stubPath` (required): Path to the `.stub.md` file (the `path` field from search results where `symbolKind === "archive_stub"`)
+
+**Returns:**
+- `originalPath`: The original file path before archiving
+- `fullContent`: Complete original content of the archived entry
+- `tokenCount`: Estimated token count of the full content
+
+**Example:**
+- Search returns: `{ path: "_archived/auth/jwt-tokens/refresh-flow.stub.md", symbolKind: "archive_stub" }`
+- Call: `expand_knowledge({ stubPath: "_archived/auth/jwt-tokens/refresh-flow.stub.md" })`
+- Returns full original content of the refresh-flow knowledge entry

package/dist/oclif/commands/curate/index.js

@@ -91,8 +91,7 @@ Bad examples:
                     throw new Error('No provider connected. Run "brv providers connect byterover" to use the free built-in provider, or connect another provider.');
                 }
                 if (active.providerKeyMissing) {
-                    throw new Error(active.providerCredentialError
-                        ?? `${active.activeProvider} API key is missing from storage.\nPlease reconnect: brv providers connect ${active.activeProvider} --api-key <your-key>`);
+                    throw new Error(`${active.activeProvider} API key is missing from storage.\nPlease reconnect: brv providers connect ${active.activeProvider} --api-key <your-key>`);
                 }
                 await this.submitTask({ client, content: resolvedContent, flags, format, projectRoot, taskType });
             }, {

package/dist/oclif/commands/main.js

@@ -35,5 +35,6 @@ export default class Main extends Command {
         await startRepl({
             version: this.config.version,
         });
+        this.exit(0);
     }
 }

package/dist/oclif/commands/providers/connect.d.ts

@@ -9,14 +9,12 @@ export default class ProviderConnect extends Command {
     static flags: {
         'api-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        'credential-file': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         format: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         model: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
     };
-    protected connectProvider({ apiKey, baseUrl, credentialFile, model, providerId }: {
+    protected connectProvider({ apiKey, baseUrl, model, providerId }: {
         apiKey?: string;
         baseUrl?: string;
-        credentialFile?: string;
         model?: string;
         providerId: string;
     }, options?: DaemonClientOptions): Promise<{

package/dist/oclif/commands/providers/connect.js

@@ -17,7 +17,6 @@ export default class ProviderConnect extends Command {
         '<%= config.bin %> providers connect byterover',
         '<%= config.bin %> providers connect openai-compatible --base-url http://localhost:11434/v1',
         '<%= config.bin %> providers connect openai-compatible --base-url http://localhost:11434/v1 --api-key sk-xxx --model llama3',
-        '<%= config.bin %> providers connect google-vertex --credential-file /path/to/service-account.json',
     ];
     static flags = {
         'api-key': Flags.string({
@@ -28,10 +27,6 @@ export default class ProviderConnect extends Command {
             char: 'b',
             description: 'Base URL for OpenAI-compatible providers (e.g., http://localhost:11434/v1)',
         }),
-        'credential-file': Flags.string({
-            char: 'f',
-            description: 'Path to service account JSON key file (for Google Vertex AI)',
-        }),
         format: Flags.string({
             default: 'text',
             description: 'Output format (text or json)',
@@ -42,7 +37,7 @@ export default class ProviderConnect extends Command {
             description: 'Model to set as active after connecting',
         }),
     };
-    async connectProvider({ apiKey, baseUrl, credentialFile, model, providerId }, options) {
+    async connectProvider({ apiKey, baseUrl, model, providerId }, options) {
         return withDaemonRetry(async (client) => {
             // 1. Verify provider exists
             const { providers } = await client.requestWithAck(ProviderEvents.LIST);
@@ -69,21 +64,7 @@ export default class ProviderConnect extends Command {
                     }
                 }
             }
-            // 3. Validate credential file for google-vertex
-            if (providerId === 'google-vertex') {
-                if (credentialFile) {
-                    const validation = await client.requestWithAck(ProviderEvents.VALIDATE_API_KEY, { apiKey: credentialFile, providerId });
-                    if (!validation.isValid) {
-                        throw new Error(validation.error ?? 'The credential file is invalid. Please check the path and try again.');
-                    }
-                }
-                else if (!provider.isConnected) {
-                    throw new Error('Provider "google-vertex" requires a service account credential file. Use the --credential-file flag.'
-                        + '\nExample: brv providers connect google-vertex --credential-file /path/to/service-account.json'
-                        + '\nGet your service account key at: https://console.cloud.google.com/iam-admin/serviceaccounts');
-                }
-            }
-            // 4. Validate API key if provided and required (skip for openai-compatible)
+            // 3. Validate API key if provided and required (skip for openai-compatible)
             if (apiKey && provider.requiresApiKey) {
                 const validation = await client.requestWithAck(ProviderEvents.VALIDATE_API_KEY, { apiKey, providerId });
                 if (!validation.isValid) {
@@ -94,14 +75,12 @@ export default class ProviderConnect extends Command {
                 throw new Error(`Provider "${providerId}" requires an API key. Use the --api-key flag to provide one.`
                     + (provider.apiKeyUrl ? `\nDon't have one? Get your API key at: ${provider.apiKeyUrl}` : ''));
             }
-            // 5. Connect or switch active provider
-            // For google-vertex, credentialFile is passed as apiKey through the transport layer
-            const effectiveApiKey = providerId === 'google-vertex' ? credentialFile : apiKey;
-            const hasNewConfig = effectiveApiKey || baseUrl;
+            // 4. Connect or switch active provider
+            const hasNewConfig = apiKey || baseUrl;
             await (provider.isConnected && !hasNewConfig
                 ? client.requestWithAck(ProviderEvents.SET_ACTIVE, { providerId })
-                : client.requestWithAck(ProviderEvents.CONNECT, { apiKey: effectiveApiKey, baseUrl, providerId }));
-            // 6. Set model if specified
+                : client.requestWithAck(ProviderEvents.CONNECT, { apiKey, baseUrl, providerId }));
+            // 5. Set model if specified
             if (model) {
                 await client.requestWithAck(ModelEvents.SET_ACTIVE, { modelId: model, providerId });
             }
@@ -113,11 +92,10 @@ export default class ProviderConnect extends Command {
         const providerId = args.provider;
         const apiKey = flags['api-key'];
         const baseUrl = flags['base-url'];
-        const credentialFile = flags['credential-file'];
         const { model } = flags;
         const format = flags.format;
         try {
-            const result = await this.connectProvider({ apiKey, baseUrl, credentialFile, model, providerId });
+            const result = await this.connectProvider({ apiKey, baseUrl, model, providerId });
             if (format === 'json') {
                 writeJsonResponse({ command: 'providers connect', data: result, success: true });
             }

package/dist/oclif/commands/query.js

@@ -54,8 +54,7 @@ Bad:
                     throw new Error('No provider connected. Run "brv providers connect byterover" to use the free built-in provider, or connect another provider.');
                 }
                 if (active.providerKeyMissing) {
-                    throw new Error(active.providerCredentialError
-                        ?? `${active.activeProvider} API key is missing from storage.\nPlease reconnect: brv providers connect ${active.activeProvider} --api-key <your-key>`);
+                    throw new Error(`${active.activeProvider} API key is missing from storage.\nPlease reconnect: brv providers connect ${active.activeProvider} --api-key <your-key>`);
                 }
                 await this.submitTask({ client, format, projectRoot, query: args.query });
             }, {

package/dist/server/constants.d.ts

@@ -59,3 +59,10 @@ export declare const AGENT_PROCESS_READY_TIMEOUT_MS = 15000;
 export declare const AGENT_PROCESS_STOP_TIMEOUT_MS = 5000;
 export declare const CURATE_LOG_DIR = "curate-log";
 export declare const CURATE_LOG_ID_PREFIX = "cur";
+export declare const SUMMARY_INDEX_FILE = "_index.md";
+export declare const ARCHIVE_DIR = "_archived";
+export declare const STUB_EXTENSION = ".stub.md";
+export declare const FULL_ARCHIVE_EXTENSION = ".full.md";
+export declare const MANIFEST_FILE = "_manifest.json";
+export declare const ARCHIVE_IMPORTANCE_THRESHOLD = 35;
+export declare const DEFAULT_GHOST_CUE_MAX_TOKENS = 220;

package/dist/server/constants.js

@@ -80,3 +80,11 @@ export const AGENT_PROCESS_STOP_TIMEOUT_MS = 5000; // 5s max wait for child proc
 // Curate log
 export const CURATE_LOG_DIR = 'curate-log';
 export const CURATE_LOG_ID_PREFIX = 'cur';
+// === Hierarchical DAG (summary, archive, manifest) ===
+export const SUMMARY_INDEX_FILE = '_index.md';
+export const ARCHIVE_DIR = '_archived';
+export const STUB_EXTENSION = '.stub.md';
+export const FULL_ARCHIVE_EXTENSION = '.full.md';
+export const MANIFEST_FILE = '_manifest.json';
+export const ARCHIVE_IMPORTANCE_THRESHOLD = 35;
+export const DEFAULT_GHOST_CUE_MAX_TOKENS = 220;

package/dist/server/core/domain/entities/provider-registry.js

@@ -97,19 +97,6 @@ export const PROVIDER_REGISTRY = {
         name: 'Google Gemini',
         priority: 4,
     },
-    'google-vertex': {
-        apiKeyUrl: 'https://console.cloud.google.com/iam-admin/serviceaccounts',
-        baseUrl: '',
-        category: 'popular',
-        defaultModel: 'gemini-2.5-flash',
-        description: 'Gemini via Google Cloud Vertex AI',
-        envVars: ['GOOGLE_APPLICATION_CREDENTIALS'],
-        headers: {},
-        id: 'google-vertex',
-        modelsEndpoint: '',
-        name: 'Google Vertex AI',
-        priority: 5,
-    },
     groq: {
         apiKeyUrl: 'https://console.groq.com/keys',
         baseUrl: 'https://api.groq.com/openai/v1',
@@ -286,9 +273,8 @@ export function providerRequiresApiKey(id) {
     if (!provider)
         return false;
     // Internal providers (byterover) don't need API keys.
-    // Vertex AI uses Application Default Credentials, not API keys.
     // OpenAI Compatible has optional API key (handled in provider-command).
-    if (id === 'byterover' || id === 'google-vertex' || id === 'openai-compatible')
+    if (id === 'byterover' || id === 'openai-compatible')
         return false;
     return true;
 }

package/dist/server/core/domain/knowledge/memory-scoring.js

@@ -21,7 +21,7 @@ export const ACCESS_IMPORTANCE_BONUS = 3;
 /** Importance bonus per curate update */
 export const UPDATE_IMPORTANCE_BONUS = 5;
 /** BM25 relevance weight in compound score */
-export const W_RELEVANCE = 1.0;
+export const W_RELEVANCE = 1;
 /** Importance weight in compound score */
 export const W_IMPORTANCE = 0;
 /** Recency weight in compound score */

package/dist/server/core/domain/knowledge/summary-types.d.ts

@@ -0,0 +1,126 @@
+/**
+ * Type definitions for the Hierarchical DAG architecture.
+ *
+ * Covers summary nodes, archive stubs, manifest entries, and
+ * result types used by summary/archive/manifest services.
+ */
+/** Condensation order: 0 = raw context, 1 = topic, 2 = domain, 3 = root */
+export type CondensationOrder = 0 | 1 | 2 | 3;
+/** Summary level labels corresponding to condensation orders */
+export type SummaryLevel = 'd0' | 'd1' | 'd2' | 'd3';
+export interface SummaryFrontmatter {
+    /** Hash of sorted path:contentHash pairs for staleness detection */
+    children_hash: string;
+    /** Compression ratio achieved (output tokens / input tokens) */
+    compression_ratio: number;
+    /** Condensation order (depth from leaves) */
+    condensation_order: CondensationOrder;
+    /** Sorted child names this summary covers */
+    covers: string[];
+    /** Total tokens across all covered children */
+    covers_token_total: number;
+    /** Summary level label */
+    summary_level: SummaryLevel;
+    /** Token count of this summary */
+    token_count: number;
+    /** Discriminator */
+    type: 'summary';
+}
+export interface ArchiveStubFrontmatter {
+    /** ISO timestamp when the entry was evicted */
+    evicted_at: string;
+    /** Importance score at eviction time */
+    evicted_importance: number;
+    /** Original relative path before archiving (for restore) */
+    original_path: string;
+    /** Original token count before archiving */
+    original_token_count: number;
+    /** Relative path to the .full.md preserved content */
+    points_to: string;
+    /** Discriminator */
+    type: 'archive_stub';
+}
+export interface ManifestEntry {
+    /** Importance score from frontmatter (0-100, default 50) */
+    importance?: number;
+    /** Condensation order (only for summaries) */
+    order?: CondensationOrder;
+    /** Relative path within the context tree */
+    path: string;
+    /** Estimated token count */
+    tokens: number;
+    /** Entry type */
+    type: 'context' | 'stub' | 'summary';
+}
+export interface LaneTokens {
+    contexts: number;
+    stubs: number;
+    summaries: number;
+}
+export interface ContextManifest {
+    /** Active context entries selected by lane budgeting */
+    active_context: ManifestEntry[];
+    /** ISO timestamp when the manifest was generated */
+    generated_at: string;
+    /** Token allocation per lane */
+    lane_tokens: LaneTokens;
+    /** Fingerprint of source files (hash of sorted path:mtime:size) for freshness check */
+    source_fingerprint: string;
+    /** Total tokens across all active entries */
+    total_tokens: number;
+    /** Schema version */
+    version: 1;
+}
+export declare const DEFAULT_LANE_BUDGETS: LaneTokens;
+export interface StalenessCheckResult {
+    /** Recomputed hash from current children */
+    currentChildrenHash: string;
+    /** Whether the summary is stale */
+    isStale: boolean;
+    /** Directory path checked */
+    path: string;
+    /** Hash stored in existing _index.md (empty string if no summary exists) */
+    storedChildrenHash: string;
+}
+export interface SummaryGenerationResult {
+    /** Whether a summary was actually written */
+    actionTaken: boolean;
+    /** Compression ratio achieved (0 if not generated) */
+    compressionRatio: number;
+    /** Directory path */
+    path: string;
+    /** Why generation was skipped (only set when actionTaken is false) */
+    reason?: 'empty_directory' | 'io_error' | 'llm_error';
+    /** Which escalation tier succeeded */
+    tier?: 'aggressive' | 'fallback' | 'normal';
+    /** Token count of the generated summary (0 if not generated) */
+    tokenCount: number;
+}
+export interface ArchiveResult {
+    /** Path to the .full.md preserved content */
+    fullPath: string;
+    /** Token count of the ghost cue */
+    ghostCueTokenCount: number;
+    /** Original relative path of the archived entry */
+    originalPath: string;
+    /** Path to the .stub.md ghost cue */
+    stubPath: string;
+}
+export interface DrillDownResult {
+    /** Full original content */
+    fullContent: string;
+    /** Original path before archiving */
+    originalPath: string;
+    /** Token count of the full content */
+    tokenCount: number;
+}
+export interface ResolvedEntry {
+    /** File content */
+    content: string;
+    /** Relative path */
+    path: string;
+    /** Token count */
+    tokens: number;
+    /** Entry type */
+    type: 'context' | 'stub' | 'summary';
+}

package/dist/server/core/domain/knowledge/summary-types.js

@@ -0,0 +1,7 @@
+/**
+ * Type definitions for the Hierarchical DAG architecture.
+ *
+ * Covers summary nodes, archive stubs, manifest entries, and
+ * result types used by summary/archive/manifest services.
+ */
+export const DEFAULT_LANE_BUDGETS = { contexts: 4000, stubs: 500, summaries: 2000 };

package/dist/server/core/domain/transport/schemas.d.ts

@@ -468,12 +468,8 @@ export interface ProviderConfigResponse {
     provider?: string;
     providerApiKey?: string;
     providerBaseUrl?: string;
-    providerCredentialError?: string;
-    providerCredentialPath?: string;
     providerHeaders?: Record<string, string>;
     providerKeyMissing?: boolean;
-    providerLocation?: string;
-    providerProject?: string;
 }
 /**
  * Transport-generated client lifecycle events.

package/dist/server/core/interfaces/context-tree/i-context-tree-archive-service.d.ts

@@ -0,0 +1,30 @@
+import type { ICipherAgent } from '../../../../agent/core/interfaces/i-cipher-agent.js';
+import type { ArchiveResult, DrillDownResult } from '../../domain/knowledge/summary-types.js';
+/**
+ * Service for archiving and restoring context tree entries.
+ *
+ * Archives low-importance entries into _archived/ with:
+ * - .stub.md: searchable ghost cue (~220 tokens)
+ * - .full.md: lossless preserved original content
+ */
+export interface IContextTreeArchiveService {
+    /**
+     * Archive a context entry: write .full.md + .stub.md, delete original.
+     * Uses LLM to generate ghost cue with deterministic fallback.
+     */
+    archiveEntry(relativePath: string, agent: ICipherAgent, directory?: string): Promise<ArchiveResult>;
+    /**
+     * Drill down into an archived entry: read .full.md via stub's points_to.
+     * No LLM call — purely file-based lookup.
+     */
+    drillDown(stubPath: string, directory?: string): Promise<DrillDownResult>;
+    /**
+     * Find entries that are candidates for archiving.
+     * Returns paths where importance < ARCHIVE_IMPORTANCE_THRESHOLD and maturity === 'draft'.
+     */
+    findArchiveCandidates(directory?: string): Promise<string[]>;
+    /**
+     * Restore an archived entry: write .full.md content to original_path, delete stub + full.
+     */
+    restoreEntry(stubPath: string, directory?: string): Promise<string>;
+}

package/dist/server/core/interfaces/context-tree/i-context-tree-archive-service.js

@@ -0,0 +1 @@
+export {};

package/dist/server/core/interfaces/context-tree/i-context-tree-manifest-service.d.ts

@@ -0,0 +1,30 @@
+import type { ContextManifest, LaneTokens, ResolvedEntry } from '../../domain/knowledge/summary-types.js';
+/**
+ * Service for building and reading the context manifest (_manifest.json).
+ *
+ * The manifest allocates context tree entries into three lanes
+ * (summaries, contexts, stubs) with token budgets, enabling
+ * efficient context injection for queries.
+ */
+export interface IContextTreeManifestService {
+    /**
+     * Build (or rebuild) the manifest from current context tree state.
+     * Writes _manifest.json and returns the manifest.
+     */
+    buildManifest(directory?: string, laneBudgets?: LaneTokens): Promise<ContextManifest>;
+    /**
+     * Read the manifest from disk. Returns null if no manifest exists.
+     */
+    readManifest(directory?: string): Promise<ContextManifest | null>;
+    /**
+     * Read the manifest only if it is fresh (source-fingerprint match).
+     * Returns null if the manifest is stale or missing.
+     */
+    readManifestIfFresh(directory?: string): Promise<ContextManifest | null>;
+    /**
+     * Resolve manifest entries into content ready for prompt injection.
+     * Orders: summaries (broadest first) → contexts → stubs.
+     * If query is provided, reorders contexts by BM25 relevance.
+     */
+    resolveForInjection(manifest: ContextManifest, query?: string, directory?: string): Promise<ResolvedEntry[]>;
+}

package/dist/server/core/interfaces/context-tree/i-context-tree-manifest-service.js

@@ -0,0 +1 @@
+export {};

package/dist/server/core/interfaces/context-tree/i-context-tree-summary-service.d.ts

@@ -0,0 +1,29 @@
+import type { ICipherAgent } from '../../../../agent/core/interfaces/i-cipher-agent.js';
+import type { StalenessCheckResult, SummaryGenerationResult } from '../../domain/knowledge/summary-types.js';
+/**
+ * Service for managing hierarchical summary nodes (_index.md) in the context tree.
+ *
+ * Agent is passed per-call (not setter-based) to avoid race conditions
+ * with concurrent tasks (AGENT_MAX_CONCURRENT_TASKS = 5).
+ */
+export interface IContextTreeSummaryService {
+    /**
+     * Check whether the summary for a directory is stale.
+     * Returns isStale: true if no _index.md exists or if children hash has changed.
+     */
+    checkStaleness(directoryPath: string, directory?: string): Promise<StalenessCheckResult>;
+    /**
+     * Generate or regenerate the _index.md summary for a directory.
+     * Uses three-tier escalation: normal → aggressive → deterministic fallback.
+     * Fail-open: returns { actionTaken: false } on any error.
+     */
+    generateSummary(directoryPath: string, agent: ICipherAgent, directory?: string): Promise<SummaryGenerationResult>;
+    /** Check whether a directory has an existing _index.md summary. */
+    hasSummary(directoryPath: string, directory?: string): Promise<boolean>;
+    /**
+     * Propagate staleness upward from changed paths.
+     * Processes bottom-up: regenerates stale summaries from deepest to shallowest.
+     * Stops climbing on LLM/IO errors; continues on empty directories.
+     */
+    propagateStaleness(changedPaths: string[], agent: ICipherAgent, directory?: string): Promise<SummaryGenerationResult[]>;
+}

package/dist/server/core/interfaces/context-tree/i-context-tree-summary-service.js

@@ -0,0 +1 @@
+export {};