brainclaw 0.19.14 → 0.20.0

package/dist/core/agent-capability.js

@@ -0,0 +1,184 @@
+/**
+ * Agent capability profiles — describes what integration surfaces each
+ * agent supports so brainclaw can adapt its instruction file content,
+ * integration depth, and pressure level accordingly.
+ *
+ * Three profile tiers drive instruction file templates:
+ *   A (full)    — MCP + hooks + auto-approve → lightweight instructions
+ *   B (standard) — MCP, no hooks → directive instructions with top traps
+ *   C (limited) — no MCP → rich static content (plans, traps, decisions)
+ */
+const PROFILES = {
+    'claude-code': {
+        name: 'claude-code',
+        hasMcp: true,
+        hasHooks: true,
+        hasAutoApprove: true,
+        hasSkills: true,
+        hasRules: true,
+        instructionFile: 'CLAUDE.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'both',
+        templateTier: 'A',
+    },
+    cursor: {
+        name: 'cursor',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.cursor/rules/brainclaw.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'machine',
+        templateTier: 'B',
+    },
+    windsurf: {
+        name: 'windsurf',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.windsurfrules',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'machine',
+        templateTier: 'B',
+    },
+    cline: {
+        name: 'cline',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: true,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.clinerules/brainclaw.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'project',
+        templateTier: 'B',
+    },
+    roo: {
+        name: 'roo',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: true,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.roo/rules/brainclaw.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'project',
+        templateTier: 'B',
+    },
+    continue: {
+        name: 'continue',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: '.continue/rules/brainclaw.md',
+        sharedInstructionFile: false,
+        mcpConfigScope: 'both',
+        templateTier: 'B',
+    },
+    opencode: {
+        name: 'opencode',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: 'AGENTS.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'project',
+        templateTier: 'B',
+    },
+    codex: {
+        name: 'codex',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: 'AGENTS.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'machine',
+        templateTier: 'B',
+    },
+    antigravity: {
+        name: 'antigravity',
+        hasMcp: true,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: false,
+        hasRules: true,
+        instructionFile: 'GEMINI.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'machine',
+        templateTier: 'B',
+    },
+    'github-copilot': {
+        name: 'github-copilot',
+        hasMcp: false,
+        hasHooks: false,
+        hasAutoApprove: false,
+        hasSkills: true,
+        hasRules: true,
+        instructionFile: '.github/copilot-instructions.md',
+        sharedInstructionFile: true,
+        mcpConfigScope: 'none',
+        templateTier: 'C',
+    },
+};
+/**
+ * Get the capability profile for a known agent.
+ * Returns undefined for unknown agent names.
+ */
+export function getAgentCapabilityProfile(name) {
+    return PROFILES[name];
+}
+/**
+ * Get all known agent capability profiles.
+ */
+export function getAllAgentCapabilityProfiles() {
+    return Object.values(PROFILES);
+}
+/**
+ * Get all agent names that match a given template tier.
+ */
+export function getAgentsByTier(tier) {
+    return Object.values(PROFILES).filter((p) => p.templateTier === tier);
+}
+/**
+ * Check if an agent name is a known brainclaw-supported agent.
+ */
+export function isKnownAgent(name) {
+    return name in PROFILES;
+}
+/**
+ * Summarize which integration surfaces are available for a given agent.
+ * Useful for setup UI to explain what brainclaw will configure.
+ */
+export function describeAgentSurfaces(name) {
+    const profile = getAgentCapabilityProfile(name);
+    if (!profile)
+        return [];
+    const surfaces = [];
+    if (profile.hasMcp) {
+        surfaces.push(`MCP server (${profile.mcpConfigScope})`);
+    }
+    if (profile.hasRules) {
+        surfaces.push(`Instruction file (${profile.instructionFile})`);
+    }
+    if (profile.hasAutoApprove) {
+        surfaces.push('Auto-approve MCP tools');
+    }
+    if (profile.hasHooks) {
+        surfaces.push('Session hooks (pre-prompt + stop)');
+    }
+    if (profile.hasSkills) {
+        surfaces.push('Slash command / skill');
+    }
+    return surfaces;
+}
+//# sourceMappingURL=agent-capability.js.map

package/dist/core/agent-context.js

@@ -60,12 +60,30 @@ function readAgentsMarkdown(cwd) {
     const raw = fs.readFileSync(filepath, 'utf-8');
     const lines = raw.split(/\r?\n/);
     const title = lines.find((line) => line.trim().startsWith('#'))?.replace(/^#+\s*/, '').trim();
-    const rules = lines
-        .map((line) => line.trim())
-        .filter((line) => /^([-*]|\d+\.)\s+/.test(line))
-        .map((line) => line.replace(/^([-*]|\d+\.)\s+/, '').trim())
-        .filter(Boolean)
-        .slice(0, MAX_AGENT_RULES);
+    // Only extract rules from actionable sections, not from descriptive sections
+    // like "why this matters" which contain explanatory bullets, not instructions.
+    const SKIP_SECTIONS = /why this matters|what it provides|what brainclaw/i;
+    let currentSection = '';
+    let skipSection = false;
+    const rules = [];
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith('#')) {
+            currentSection = trimmed.replace(/^#+\s*/, '');
+            skipSection = SKIP_SECTIONS.test(currentSection);
+            continue;
+        }
+        if (skipSection)
+            continue;
+        if (/^([-*]|\d+\.)\s+/.test(trimmed)) {
+            const text = trimmed.replace(/^([-*]|\d+\.)\s+/, '').trim();
+            if (text) {
+                rules.push(text);
+                if (rules.length >= MAX_AGENT_RULES)
+                    break;
+            }
+        }
+    }
     return {
         present: true,
         title,

package/dist/core/bootstrap.js

@@ -267,6 +267,12 @@ function buildBootstrapArtifacts(input) {
     const repoAnalysis = analyzeRepository(input.cwd);
     sourcesScanned.push('repo-analysis');
     seeds.push(...extractRepoAnalysisSeeds(repoAnalysis, input.target));
+    // Additional brownfield sources (step 12)
+    const additionalSeeds = extractAdditionalBrownfieldSeeds(input.cwd, input.target);
+    if (additionalSeeds.seeds.length > 0) {
+        sourcesScanned.push(...additionalSeeds.sources);
+        seeds.push(...additionalSeeds.seeds);
+    }
     const gitProbe = probeGit(input.cwd, input.target);
     if (gitProbe.available) {
         sourcesScanned.push('git');
@@ -703,6 +709,44 @@ function probeGit(cwd, target) {
             }));
         }
     }
+    // Step 13: Active branches
+    const branchResult = spawnSync('git', ['branch', '--no-merged', 'HEAD', '--format=%(refname:short)'], {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 5000,
+    });
+    if (branchResult.status === 0) {
+        const branches = branchResult.stdout.split(/\r?\n/).map((b) => b.trim()).filter(Boolean).slice(0, 5);
+        for (const branch of branches) {
+            hotspotSeeds.push(createSeed({
+                text: `Active branch: ${branch}`,
+                seedKind: 'hotspot',
+                sourceKind: 'git',
+                sourceRef: `branch:${branch}`,
+                confidence: 'low',
+                tags: ['bootstrap', 'git', 'branch'],
+            }));
+        }
+    }
+    // Step 13: Recent tags
+    const tagResult = spawnSync('git', ['tag', '--sort=-creatordate', '-l'], {
+        cwd,
+        encoding: 'utf-8',
+        timeout: 5000,
+    });
+    if (tagResult.status === 0) {
+        const tags = tagResult.stdout.split(/\r?\n/).map((t) => t.trim()).filter(Boolean).slice(0, 3);
+        if (tags.length > 0) {
+            hotspotSeeds.push(createSeed({
+                text: `Version tags: ${tags.join(', ')} (${tags.length} most recent)`,
+                seedKind: 'convention',
+                sourceKind: 'git',
+                sourceRef: 'tags',
+                confidence: 'medium',
+                tags: ['bootstrap', 'git', 'versioning'],
+            }));
+        }
+    }
     return {
         available: true,
         repoFingerprint,
@@ -1594,4 +1638,137 @@ function normalizeTarget(target) {
     const trimmed = target?.trim();
     return trimmed && trimmed.length > 0 ? trimmed : undefined;
 }
+// ─── Step 12: Additional brownfield sources ──────────────────────────────────
+const CI_WORKFLOW_DIRS = ['.github/workflows', '.gitlab'];
+const CI_FILES = ['.gitlab-ci.yml', 'Jenkinsfile', '.circleci/config.yml'];
+const CONTRIBUTING_FILES = ['CONTRIBUTING.md', 'CONTRIBUTING'];
+const CHANGELOG_FILES = ['CHANGELOG.md', 'CHANGELOG', 'HISTORY.md'];
+const DOCKER_FILES = ['Dockerfile', 'docker-compose.yml', 'docker-compose.yaml', 'compose.yml', 'compose.yaml'];
+const ENV_EXAMPLE_FILES = ['.env.example', '.env.sample', '.env.template'];
+const ADR_DIRS = ['doc/adr', 'docs/adr', 'doc/decisions', 'docs/decisions', 'adr'];
+function extractAdditionalBrownfieldSeeds(cwd, target) {
+    const seeds = [];
+    const sources = [];
+    // CI/CD workflows
+    for (const dir of CI_WORKFLOW_DIRS) {
+        const fullPath = path.join(cwd, dir);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+            sources.push('ci_workflows');
+            try {
+                const files = fs.readdirSync(fullPath).filter((f) => f.endsWith('.yml') || f.endsWith('.yaml'));
+                if (files.length > 0) {
+                    seeds.push(createSeed({
+                        text: `CI/CD: ${files.length} workflow(s) in ${dir}/`,
+                        seedKind: 'convention',
+                        sourceKind: 'ci_config',
+                        sourceRef: dir,
+                        confidence: 'medium',
+                        tags: ['bootstrap', 'ci'],
+                        relatedPaths: target ? [target] : undefined,
+                    }));
+                }
+            }
+            catch { /* skip unreadable */ }
+            break;
+        }
+    }
+    for (const file of CI_FILES) {
+        if (fs.existsSync(path.join(cwd, file))) {
+            if (!sources.includes('ci_workflows'))
+                sources.push('ci_config');
+            seeds.push(createSeed({
+                text: `CI/CD config: ${file}`,
+                seedKind: 'convention',
+                sourceKind: 'ci_config',
+                sourceRef: file,
+                confidence: 'medium',
+                tags: ['bootstrap', 'ci'],
+            }));
+            break;
+        }
+    }
+    // CONTRIBUTING.md
+    const contributingPath = findFirstExisting(cwd, CONTRIBUTING_FILES);
+    if (contributingPath) {
+        sources.push('contributing');
+        seeds.push(createSeed({
+            text: `Contributing guide found: ${path.basename(contributingPath)}`,
+            seedKind: 'convention',
+            sourceKind: 'contributing',
+            sourceRef: path.basename(contributingPath),
+            confidence: 'medium',
+            tags: ['bootstrap', 'contributing'],
+        }));
+    }
+    // CHANGELOG
+    const changelogPath = findFirstExisting(cwd, CHANGELOG_FILES);
+    if (changelogPath) {
+        sources.push('changelog');
+        seeds.push(createSeed({
+            text: `Changelog found: ${path.basename(changelogPath)}`,
+            seedKind: 'convention',
+            sourceKind: 'changelog',
+            sourceRef: path.basename(changelogPath),
+            confidence: 'low',
+            tags: ['bootstrap', 'changelog'],
+        }));
+    }
+    // Docker
+    for (const file of DOCKER_FILES) {
+        if (fs.existsSync(path.join(cwd, file))) {
+            sources.push('docker');
+            seeds.push(createSeed({
+                text: `Docker config: ${file}`,
+                seedKind: 'convention',
+                sourceKind: 'docker',
+                sourceRef: file,
+                confidence: 'medium',
+                tags: ['bootstrap', 'docker', 'infrastructure'],
+            }));
+            break;
+        }
+    }
+    // .env.example
+    const envPath = findFirstExisting(cwd, ENV_EXAMPLE_FILES);
+    if (envPath) {
+        sources.push('env_example');
+        try {
+            const content = fs.readFileSync(envPath, 'utf-8');
+            const varCount = content.split(/\r?\n/).filter((l) => l.includes('=') && !l.startsWith('#')).length;
+            seeds.push(createSeed({
+                text: `Environment template: ${path.basename(envPath)} (${varCount} variables)`,
+                seedKind: 'convention',
+                sourceKind: 'env_example',
+                sourceRef: path.basename(envPath),
+                confidence: 'medium',
+                tags: ['bootstrap', 'env', 'configuration'],
+            }));
+        }
+        catch { /* skip unreadable */ }
+    }
+    // ADR (Architecture Decision Records)
+    for (const dir of ADR_DIRS) {
+        const fullPath = path.join(cwd, dir);
+        if (fs.existsSync(fullPath) && fs.statSync(fullPath).isDirectory()) {
+            sources.push('adr');
+            try {
+                const files = fs.readdirSync(fullPath).filter((f) => f.endsWith('.md'));
+                if (files.length > 0) {
+                    seeds.push(createSeed({
+                        text: `Architecture Decision Records: ${files.length} ADR(s) in ${dir}/`,
+                        seedKind: 'convention',
+                        sourceKind: 'adr',
+                        sourceRef: dir,
+                        confidence: 'high',
+                        tags: ['bootstrap', 'adr', 'architecture'],
+                        relatedPaths: target ? [target] : undefined,
+                    }));
+                }
+            }
+            catch { /* skip unreadable */ }
+            break;
+        }
+    }
+    return { seeds, sources: [...new Set(sources)] };
+}
 //# sourceMappingURL=bootstrap.js.map

package/dist/core/context.js

@@ -1,7 +1,8 @@
+import path from 'node:path';
 import { loadConfig } from './config.js';
 import { resolveCrossProjectLinks, loadCrossProjectState } from './cross-project.js';
 import { buildContextDiff } from './context-diff.js';
-import { resolveStoreChain } from './store-resolution.js';
+import { resolveContextStoreCwd, resolveStoreChain } from './store-resolution.js';
 import { findAgentIdentityByName, resolveCurrentAgentIdentity } from './agent-registry.js';
 import { hasReusableBootstrapProfile, runBootstrapProfile, selectDerivedSignals } from './bootstrap.js';
 import { buildAgentToolingContext } from './agent-context.js';
@@ -18,26 +19,28 @@ import { isTrapActive, listOperationalTraps } from './traps.js';
 import { buildEstimationReport } from '../commands/estimation-report.js';
 export const CONTEXT_SCHEMA_VERSION = '1.2';
 export function buildContext(options = {}) {
-    const state = loadState(options.cwd);
-    const config = loadConfig(options.cwd);
+    const requestedCwd = options.cwd ?? process.cwd();
+    const contextCwd = resolveContextStoreCwd(requestedCwd, options.target);
+    const state = loadState(contextCwd);
+    const config = loadConfig(contextCwd);
     // Resolve parent stores for multi-store merge (walk-up from cwd)
-    const storeChain = resolveStoreChain(options.cwd ?? process.cwd());
+    const storeChain = resolveStoreChain(contextCwd);
     const profile = options.profile ?? config.profile ?? 'dev';
     const projectMode = config.project_mode ?? 'auto';
     const projectStrategy = config.projects?.strategy ?? 'manual';
     const currentHost = resolveCurrentHostId();
-    const memoryVersion = getVisibleMemoryVersion({ cwd: options.cwd, hostId: options.host, allHosts: options.allHosts });
-    const target = options.target?.trim() ?? '';
+    const memoryVersion = getVisibleMemoryVersion({ cwd: contextCwd, hostId: options.host, allHosts: options.allHosts });
+    const target = normalizeContextTarget(options.target, requestedCwd, contextCwd);
     const project = options.project?.trim() || inferProjectFromTarget(target, config);
     const agent = options.agent?.trim() || config.current_agent?.trim();
     const currentAgentIdentity = agent
-        ? (options.agent?.trim() ? findAgentIdentityByName(agent, options.cwd) : resolveCurrentAgentIdentity(options.cwd))
+        ? (options.agent?.trim() ? findAgentIdentityByName(agent, contextCwd) : resolveCurrentAgentIdentity(contextCwd))
         : undefined;
     const profileMaxItems = { compact: 6, copilot: 5, quick: 3 };
     const maxItems = options.maxItems ?? profileMaxItems[profile] ?? 8;
     const maxChars = options.maxChars && options.maxChars > 0 ? options.maxChars : undefined;
     // Instructions will be resolved after parent-store merge below (line ~460)
-    const rankingLookup = buildReputationRankingLookup(options.cwd);
+    const rankingLookup = buildReputationRankingLookup(contextCwd);
     const profileSections = {
         compact: ['plan', 'constraint'],
         copilot: ['constraint', 'trap'],
@@ -123,7 +126,7 @@ export function buildContext(options = {}) {
             },
         });
     }
-    for (const trap of listOperationalTraps({ hostId: options.host, includeAllHosts: options.allHosts }, options.cwd).filter((entry) => isTrapActive(entry))) {
+    for (const trap of listOperationalTraps({ hostId: options.host, includeAllHosts: options.allHosts }, contextCwd).filter((entry) => isTrapActive(entry))) {
         items.push({
             id: trap.id,
             section: 'trap',
@@ -157,7 +160,7 @@ export function buildContext(options = {}) {
     const runtimeNotes = listRuntimeNotes({
         hostId: options.host,
         includeAllHosts: options.allHosts,
-    }, options.cwd);
+    }, contextCwd);
     for (const note of runtimeNotes) {
         if (project && note.project && note.project !== project) {
             continue;
@@ -191,7 +194,7 @@ export function buildContext(options = {}) {
         });
     }
     if (options.includePending) {
-        for (const p of listCandidates('pending', options.cwd)) {
+        for (const p of listCandidates('pending', contextCwd)) {
             const meta = [`${p.type}`, `stars:${p.star_count ?? 0}`, `uses:${p.usage_count ?? 0}`];
             if (p.author_id)
                 meta.push(`author_id:${p.author_id}`);
@@ -294,7 +297,7 @@ export function buildContext(options = {}) {
         catch { /* non-fatal */ }
     }
     // Merge instructions from all stores in the chain
-    const allInstructions = [...loadInstructions(options.cwd)];
+    const allInstructions = [...loadInstructions(contextCwd)];
     for (const parentStore of storeChain.slice(1)) {
         try {
             const parentInstrs = loadInstructions(parentStore.cwd);
@@ -330,34 +333,34 @@ export function buildContext(options = {}) {
         .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
         .slice(0, maxItems);
     const selected = maxChars ? applyCharBudget(ranked, maxChars) : ranked;
-    const resumeSummary = buildCurrentAgentResumeSummary(options.cwd);
+    const resumeSummary = buildCurrentAgentResumeSummary(contextCwd);
     const scopedActivity = buildScopedActivity({
         target,
         project,
         state,
         runtimeNotes,
-        pendingCandidates: listCandidates('pending', options.cwd),
+        pendingCandidates: listCandidates('pending', contextCwd),
     });
     const memoryDensity = classifyMemoryDensity(selected.length);
     const bootstrapEnabled = options.bootstrap !== false;
-    let bootstrapAvailable = hasReusableBootstrapProfile(target, options.cwd);
+    let bootstrapAvailable = hasReusableBootstrapProfile(target, contextCwd);
     let derivedSignals;
     if (bootstrapEnabled && (options.refreshBootstrap || memoryDensity === 'low')) {
         const bootstrap = runBootstrapProfile({
             target,
             refresh: options.refreshBootstrap,
-            cwd: options.cwd,
+            cwd: contextCwd,
         });
         bootstrapAvailable = bootstrap.profile.seed_count > 0;
         if (memoryDensity === 'low') {
-            const signals = selectDerivedSignals(target, 5, options.cwd);
+            const signals = selectDerivedSignals(target, 5, contextCwd);
             if (signals.length > 0) {
                 derivedSignals = signals;
             }
         }
     }
     else if (bootstrapEnabled && bootstrapAvailable && memoryDensity === 'low') {
-        const signals = selectDerivedSignals(target, 5, options.cwd);
+        const signals = selectDerivedSignals(target, 5, contextCwd);
         if (signals.length > 0) {
             derivedSignals = signals;
         }
@@ -365,7 +368,7 @@ export function buildContext(options = {}) {
     const executionSensitive = isExecutionSensitiveTarget(target);
     const derivedUsesExecution = derivedSignals?.some((signal) => signal.source_kind === 'machine') ?? false;
     const derivedUsesTooling = derivedSignals?.some((signal) => signal.source_kind === 'skill' || signal.source_kind === 'mcp') ?? false;
-    const rawAgentTooling = buildAgentToolingContext({ cwd: options.cwd });
+    const rawAgentTooling = buildAgentToolingContext({ cwd: contextCwd });
     const actionableAgentRules = rawAgentTooling.agents_rules.length > 0;
     const blockingTooling = rawAgentTooling.mcp_servers.some((server) => server.availability === 'missing_command');
     const shouldExposeExecution = memoryDensity === 'low' || executionSensitive || derivedUsesExecution;
@@ -375,7 +378,7 @@ export function buildContext(options = {}) {
         || actionableAgentRules
         || blockingTooling;
     const executionContext = shouldExposeExecution
-        ? compactExecutionContext(buildExecutionContext({ cwd: options.cwd }))
+        ? compactExecutionContext(buildExecutionContext({ cwd: contextCwd }))
         : undefined;
     const agentTooling = shouldExposeAgentTooling
         ? summariseAgentTooling(rawAgentTooling)
@@ -385,7 +388,7 @@ export function buildContext(options = {}) {
     if (currentAgentIdentity || agent) {
         const agentName = agent;
         const agentId = currentAgentIdentity?.agent_id;
-        const allClaims = [...listClaims(options.cwd), ...parentStoreClaims];
+        const allClaims = [...listClaims(contextCwd), ...parentStoreClaims];
         const activeClaims = allClaims.filter((c) => c.status === 'active' && (agentId ? c.agent_id === agentId : c.agent === agentName));
         const claimPlanIds = new Set(activeClaims.map((c) => c.plan_id).filter(Boolean));
         const inProgressPlans = state.plan_items.filter((p) => p.status === 'in_progress' &&
@@ -399,7 +402,7 @@ export function buildContext(options = {}) {
     }
     // Cross-project items (subscriber links — read-only, always injected, bypass scoring)
     const crossProjectItems = [];
-    for (const link of resolveCrossProjectLinks(options.cwd)) {
+    for (const link of resolveCrossProjectLinks(contextCwd)) {
         if (!link.available)
             continue;
         try {
@@ -448,7 +451,7 @@ export function buildContext(options = {}) {
         context_diff: options.sinceSession
             ? buildContextDiff({
                 session: options.sinceSession,
-                cwd: options.cwd,
+                cwd: contextCwd,
                 includeItems: true,
             })
             : undefined,
@@ -460,7 +463,7 @@ export function buildContext(options = {}) {
             : undefined,
         estimation_calibration: (() => {
             try {
-                const report = buildEstimationReport({ agent, cwd: options.cwd });
+                const report = buildEstimationReport({ agent, cwd: contextCwd });
                 return report.summary.with_both >= 3 ? report.summary.calibration_hint : undefined;
             }
             catch {
@@ -1053,6 +1056,26 @@ function tokenise(input) {
         .map((x) => x.trim())
         .filter(Boolean);
 }
+function normalizeContextTarget(target, requestedCwd, contextCwd) {
+    const trimmed = target?.trim() ?? '';
+    if (!trimmed) {
+        return '';
+    }
+    if (path.resolve(requestedCwd) === path.resolve(contextCwd)) {
+        return trimmed;
+    }
+    if (!(path.isAbsolute(trimmed) || trimmed.includes('/') || trimmed.includes('\\') || trimmed.startsWith('.'))) {
+        return trimmed;
+    }
+    const absoluteTarget = path.isAbsolute(trimmed)
+        ? path.resolve(trimmed)
+        : path.resolve(requestedCwd, trimmed);
+    const relativeToContext = path.relative(contextCwd, absoluteTarget);
+    if (relativeToContext.startsWith('..') || path.isAbsolute(relativeToContext)) {
+        return trimmed;
+    }
+    return relativeToContext.split(path.sep).join('/');
+}
 function matchesPath(pattern, target) {
     if (pattern === target)
         return true;