brainclaw 0.19.12 → 0.20.0

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/claude-desktop-extension.js

@@ -0,0 +1,224 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { memoryExists } from './io.js';
+const CLAUDE_DESKTOP_TOOLS = [
+    { name: 'bclaw_session_start', description: 'Open a Brainclaw session and surface Claude-targeted tasks plus compact execution context.' },
+    { name: 'bclaw_get_context', description: 'Retrieve ranked Brainclaw project context for the current task or path.' },
+    { name: 'bclaw_list_surface_tasks', description: 'List queued or completed Brainclaw tasks delegated to Claude Desktop.' },
+    { name: 'bclaw_update_surface_task', description: 'Mark a delegated Claude Desktop task as in progress or completed.' },
+];
+export function buildClaudeDesktopExtension(options = {}) {
+    const cwd = path.resolve(options.cwd ?? process.cwd());
+    if (!memoryExists(cwd)) {
+        throw new Error('Project memory not initialized. Run `brainclaw init` first.');
+    }
+    const workspaceDir = path.resolve(options.workspaceDir ?? path.join(cwd, 'internal-docs', 'desktop-extensions', 'claude-desktop-brainclaw'));
+    const outputFile = path.resolve(options.outputFile ?? path.join(cwd, 'internal-docs', 'desktop-extensions', 'brainclaw-claude-desktop.mcpb'));
+    if (outputFile.startsWith(`${workspaceDir}${path.sep}`) || outputFile === workspaceDir) {
+        throw new Error('The .mcpb output file must live outside the extension workspace directory.');
+    }
+    const projectRoot = path.resolve(options.projectRoot ?? cwd);
+    const runtimeRoot = path.resolve(options.runtimeRootOverride ?? resolveRuntimeRoot());
+    const packageRoot = path.resolve(options.packageRootOverride ?? findPackageRoot(runtimeRoot));
+    const metadata = readPackageMetadata(packageRoot);
+    const copiedDependencies = options.dependenciesOverride ?? resolveRuntimeDependencies(packageRoot);
+    fs.rmSync(workspaceDir, { recursive: true, force: true });
+    fs.mkdirSync(workspaceDir, { recursive: true });
+    fs.cpSync(runtimeRoot, path.join(workspaceDir, 'runtime'), { recursive: true });
+    fs.mkdirSync(path.join(workspaceDir, 'server'), { recursive: true });
+    fs.mkdirSync(path.dirname(outputFile), { recursive: true });
+    for (const dep of copiedDependencies) {
+        const sourceDir = path.join(packageRoot, 'node_modules', dep);
+        if (!fs.existsSync(sourceDir)) {
+            throw new Error(`Missing runtime dependency for Claude Desktop extension: ${dep}`);
+        }
+        fs.cpSync(sourceDir, path.join(workspaceDir, 'node_modules', dep), { recursive: true });
+    }
+    const version = metadata.version ?? '0.0.0';
+    const manifestPath = path.join(workspaceDir, 'manifest.json');
+    const entryPointPath = path.join(workspaceDir, 'server', 'index.js');
+    const packageJsonPath = path.join(workspaceDir, 'package.json');
+    fs.writeFileSync(entryPointPath, buildServerEntryPoint(), 'utf-8');
+    fs.writeFileSync(packageJsonPath, `${JSON.stringify({
+        name: 'brainclaw-claude-desktop-extension',
+        private: true,
+        type: 'module',
+        version,
+    }, null, 2)}\n`, 'utf-8');
+    fs.writeFileSync(manifestPath, `${JSON.stringify(buildManifest(metadata, version, projectRoot), null, 2)}\n`, 'utf-8');
+    const packed = options.pack !== false ? packClaudeDesktopExtension(workspaceDir, outputFile) : false;
+    return {
+        workspaceDir,
+        outputFile,
+        packed,
+        manifestPath,
+        entryPointPath,
+        packageRoot,
+        runtimeRoot,
+        projectRoot,
+        copiedDependencies,
+    };
+}
+function buildServerEntryPoint() {
+    return `import process from 'node:process';
+
+const projectRoot = process.env.BRAINCLAW_PROJECT_ROOT?.trim();
+if (projectRoot) {
+  process.chdir(projectRoot);
+}
+
+const { runMcp } = await import('../runtime/commands/mcp.js');
+runMcp();
+`;
+}
+function buildManifest(metadata, version, projectRoot) {
+    return {
+        manifest_version: '0.3',
+        name: 'brainclaw-claude-desktop',
+        display_name: 'Brainclaw Project Memory',
+        version,
+        description: 'Brainclaw local project memory and delegated task inbox for Claude Desktop.',
+        author: {
+            name: 'Brainclaw',
+            ...(metadata.homepage ? { url: metadata.homepage } : {}),
+        },
+        ...(typeof metadata.repository === 'string'
+            ? { repository: { type: 'git', url: metadata.repository } }
+            : metadata.repository
+                ? { repository: metadata.repository }
+                : {}),
+        ...(metadata.homepage ? { homepage: metadata.homepage } : {}),
+        server: {
+            type: 'node',
+            entry_point: 'server/index.js',
+            mcp_config: {
+                command: 'node',
+                args: ['${__dirname}/server/index.js'],
+                env: {
+                    BRAINCLAW_PROJECT_ROOT: '${user_config.project_root}',
+                    BRAINCLAW_SKIP_SETUP_REQUIREMENT: '1',
+                },
+            },
+        },
+        tools: CLAUDE_DESKTOP_TOOLS,
+        compatibility: {
+            platforms: ['win32', 'darwin'],
+            runtimes: {
+                node: '>=20.0.0',
+            },
+        },
+        user_config: {
+            project_root: {
+                type: 'directory',
+                title: 'Project Root',
+                description: 'Brainclaw project root that Claude Desktop should operate on.',
+                required: true,
+                default: projectRoot,
+            },
+        },
+    };
+}
+function resolveRuntimeRoot() {
+    return path.resolve(fileURLToPath(new URL('..', import.meta.url)));
+}
+function findPackageRoot(startDir) {
+    let current = startDir;
+    while (true) {
+        const candidate = path.join(current, 'package.json');
+        if (fs.existsSync(candidate)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            throw new Error(`Could not locate package.json from ${startDir}`);
+        }
+        current = parent;
+    }
+}
+function readPackageMetadata(packageRoot) {
+    const packageJsonPath = path.join(packageRoot, 'package.json');
+    return JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+}
+function resolveRuntimeDependencies(packageRoot) {
+    const metadata = readPackageMetadata(packageRoot);
+    return Object.keys(metadata.dependencies ?? {});
+}
+function packClaudeDesktopExtension(workspaceDir, outputFile) {
+    fs.rmSync(outputFile, { force: true });
+    const pythonCommand = resolveAvailableCommand(process.platform === 'win32'
+        ? ['python', 'py', 'python3']
+        : ['python3', 'python', 'py']);
+    if (pythonCommand) {
+        const script = [
+            'import os, sys, zipfile',
+            'src, dest = sys.argv[1], sys.argv[2]',
+            'with zipfile.ZipFile(dest, "w", zipfile.ZIP_DEFLATED) as zf:',
+            '  for root, _, files in os.walk(src):',
+            '    for name in files:',
+            '      full = os.path.join(root, name)',
+            '      rel = os.path.relpath(full, src)',
+            '      zf.write(full, rel)',
+        ].join('; ');
+        const result = spawnSync(pythonCommand, ['-c', script, workspaceDir, outputFile], {
+            encoding: 'utf-8',
+        });
+        if (result.status === 0) {
+            return true;
+        }
+    }
+    if (process.platform === 'win32') {
+        const shell = resolveAvailableCommand(['pwsh', 'powershell']);
+        if (!shell) {
+            throw new Error('Could not find Python or PowerShell to create the Claude Desktop .mcpb archive.');
+        }
+        const command = `Compress-Archive -Path (Join-Path '${escapePowerShellPath(workspaceDir)}' '*') -DestinationPath '${escapePowerShellPath(outputFile)}' -Force`;
+        const result = spawnSync(shell, ['-NoProfile', '-Command', command], {
+            encoding: 'utf-8',
+        });
+        if (result.status === 0) {
+            return true;
+        }
+    }
+    const zipCommand = resolveAvailableCommand(['zip']);
+    if (zipCommand) {
+        const result = spawnSync(zipCommand, ['-qr', outputFile, '.'], {
+            cwd: workspaceDir,
+            encoding: 'utf-8',
+        });
+        if (result.status === 0) {
+            return true;
+        }
+    }
+    throw new Error('Failed to create a .mcpb archive. Install Python 3, PowerShell, or zip.');
+}
+function resolveAvailableCommand(candidates) {
+    for (const candidate of candidates) {
+        const result = spawnSync(candidate, ['--version'], { encoding: 'utf-8' });
+        if (result.status === 0) {
+            return candidate;
+        }
+    }
+    return undefined;
+}
+function escapePowerShellPath(value) {
+    return value.replace(/'/g, "''");
+}
+export function renderClaudeDesktopExtensionSummary(result) {
+    const lines = [
+        'Claude Desktop extension scaffold ready.',
+        `Workspace: ${path.relative(process.cwd(), result.workspaceDir) || result.workspaceDir}`,
+        `Manifest: ${path.relative(process.cwd(), result.manifestPath) || result.manifestPath}`,
+        `Server entry: ${path.relative(process.cwd(), result.entryPointPath) || result.entryPointPath}`,
+    ];
+    if (result.packed) {
+        lines.push(`Package: ${path.relative(process.cwd(), result.outputFile) || result.outputFile}`);
+        lines.push('Install in Claude Desktop via Developer -> Extensions -> Install Extension.');
+    }
+    else {
+        lines.push('Archive packing skipped (--no-pack).');
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=claude-desktop-extension.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;

package/dist/core/ids.js

@@ -11,6 +11,7 @@ const PREFIXES = {
     plan_items: 'pln',
     plan_steps: 'stp',
     instruction_entries: 'ins',
+    ai_surface_tasks: 'ast',
 };
 const ID_COUNTER_FILE = '.id-counter.json';
 function counterPath(cwd) {