devworkspace 0.3.2 → 0.4.0

package/dist/services/taskContext.d.ts

@@ -2,6 +2,9 @@ import { type CommandEntry, type Fact } from '../config/schemas.js';
 import type { TaskType } from '../tasks/task.js';
 import { type ContextResult } from './knowledge.js';
 import type { ServiceOptions } from './common.js';
+export declare const CONTEXT_ROLES: readonly ["explorer", "tester", "reviewer"];
+export type ContextRole = (typeof CONTEXT_ROLES)[number];
+export declare function isContextRole(v: unknown): v is ContextRole;
 export interface ContextItem {
     kind: 'fact' | 'check' | 'decision' | 'document' | 'rule';
     id: string;
@@ -48,12 +51,32 @@ export interface TaskContextResult {
         decisions: [number, number];
         documents: [number, number];
     };
+    role?: ContextRole;
+    roleGuidance?: string[];
+    roleFindings?: {
+        entryPoints?: string[];
+        graphNodes?: {
+            id: string;
+            status: string;
+            path: string | null;
+            symbol: string | null;
+        }[];
+        features?: {
+            id: string;
+            name: string;
+            status?: string;
+        }[];
+        testFrameworks?: string[];
+        zeroTestSafeguards?: string[];
+        diffNotice?: string;
+    };
 }
-/**
- * Task-aware context. Selection is deterministic (sorted inputs, no clocks, no randomness) and rule-based: the request is
- * classified, its keywords select facts/decisions/packages, and the type decides which broader groups come along.
- * Safety rules are included for every type; the per-package "not run automatically" list whenever checks are included.
- */
 export declare function getTaskContext(o: ServiceOptions, opts: {
     request: string;
+    role?: ContextRole;
+}): Promise<TaskContextResult>;
+export declare function getAgentContextSlice(o: ServiceOptions, opts: {
+    request: string;
+    role: ContextRole;
+    base?: TaskContextResult;
 }): Promise<TaskContextResult>;

package/dist/services/taskContext.js

@@ -10,14 +10,125 @@ import { pathExists } from '../utils/fs.js';
 import { classifyCommand, readManifestEvidence } from '../verification/safety.js';
 import { dirtyFiles, packageDirs } from '../verification/scope.js';
 import { SAFETY_RULES } from './knowledge.js';
-const STOP = new Set(['the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'does', 'how', 'what', 'where', 'why', 'when', 'which', 'fix', 'add', 'bug', 'make', 'new', 'can', 'are', 'not', 'our', 'all', 'use', 'get', 'set']);
+import { loadFeatures } from './features.js';
+import { loadGraphData, findMatchingStartNode } from './graph.js';
+export const CONTEXT_ROLES = ['explorer', 'tester', 'reviewer'];
+export function isContextRole(v) {
+    return typeof v === 'string' && CONTEXT_ROLES.includes(v);
+}
+const STOP = new Set([
+    'the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'does', 'how',
+    'what', 'where', 'why', 'when', 'which', 'fix', 'add', 'bug', 'make', 'new',
+    'can', 'are', 'not', 'our', 'all', 'use', 'get', 'set', 'let', 'may'
+]);
+const WEAK_TERMS = new Set(['error', 'errors', 'check', 'checks', 'data', 'improve', 'update', 'run', 'test', 'handle', 'handling', 'code']);
+const PATH_STRUCTURAL_TERMS = new Set([
+    'backend', 'frontend', 'service', 'services', 'controller', 'controllers',
+    'worker', 'workers', 'dto', 'dtos', 'src', 'modules', 'app', 'tests',
+    'unit', 'integration', 'test', 'spec', 'ts', 'tsx', 'js', 'jsx', 'json', 'md'
+]);
 const CLIP = 400;
 const SECURITY_WORDS = /auth|tenant|permission|rbac|security|isolation|role|session|ownership/i;
 const ISSUE_KEY = /^(?:issue|limit|known|bug|risk)/i;
 /** Facts that describe the stack and layout; implementation-style tasks need them, a lookup question does not. */
 const STACK_KEY = /^(?:stack\.|repo\.packages|repo\.monorepo|repo\.entry-points|convention|style|arch|pattern|testing)/i;
 const BROAD_TYPES = ['FEATURE', 'REFACTOR', 'ARCHITECTURE', 'TESTING', 'PERFORMANCE', 'MAINTENANCE', 'RELEASE'];
-const words = (text) => [...new Set((text.toLowerCase().match(/[a-z0-9_][a-z0-9_.-]{2,}/g) ?? []).filter((w) => !STOP.has(w)))].sort();
+/** Normalizes words by stripping standard English inflectional suffixes deterministically. */
+function normalizeStem(w) {
+    const s = w.toLowerCase().trim();
+    if (s.endsWith('ies') && s.length > 4)
+        return s.slice(0, -3) + 'y';
+    if (s.endsWith('es') && s.length > 4 && /[sxz]|ch|sh$/.test(s.slice(0, -2)))
+        return s.slice(0, -2);
+    if (s.endsWith('s') && s.length > 3 && !s.endsWith('ss'))
+        return s.slice(0, -1);
+    if (s.endsWith('ing') && s.length > 5)
+        return s.slice(0, -3);
+    if (s.endsWith('tion') && s.length > 6)
+        return s.slice(0, -4);
+    if (s.endsWith('ed') && s.length > 4)
+        return s.slice(0, -2);
+    return s;
+}
+/** Explicit domain synonym dictionary grounded in engineering tasks and repository knowledge. */
+const DOMAIN_SYNONYMS = {
+    // Database, migrations, schema and persistence
+    table: ['database', 'schema', 'orm', 'migration', 'sql'],
+    column: ['database', 'schema', 'migration', 'sql'],
+    schema: ['database', 'orm', 'migration', 'sql', 'drizzle', 'postgres'],
+    migration: ['database', 'schema', 'migrate', 'sql', 'drizzle'],
+    migrate: ['database', 'schema', 'migration', 'sql'],
+    sql: ['database', 'postgres', 'drizzle', 'query'],
+    db: ['database', 'postgres', 'drizzle', 'orm'],
+    database: ['db', 'schema', 'orm', 'postgres', 'drizzle'],
+    drizzle: ['database', 'orm', 'schema'],
+    postgres: ['database', 'sql'],
+    // Authentication, tenancy, and authorization
+    auth: ['jwt', 'session', 'security', 'tenant', 'permission'],
+    jwt: ['auth', 'session', 'token', 'security'],
+    password: ['hash', 'argon2', 'auth', 'security'],
+    hash: ['password', 'argon2', 'security'],
+    tenant: ['tenancy', 'isolation', 'security', 'auth'],
+    tenancy: ['tenant', 'isolation', 'security'],
+    isolation: ['tenant', 'tenancy', 'security'],
+    // Billing and financial
+    invoice: ['billing', 'cents', 'precision'],
+    billing: ['invoice', 'cents', 'precision'],
+    cents: ['billing', 'invoice', 'precision'],
+    payment: ['stripe', 'gateway'],
+    // API, HTTP, and Backend Services
+    endpoint: ['api', 'controller', 'service', 'dto'],
+    api: ['endpoint', 'controller', 'service', 'dto'],
+    supplier: ['supplier', 'dto', 'service'],
+    controller: ['service', 'dto', 'api', 'endpoint'],
+    dto: ['validation', 'typebox', 'schema', 'controller'],
+    // Frontend and UI
+    component: ['ui', 'frontend', 'page', 'react'],
+    pagination: ['ui', 'component', 'frontend', 'table'],
+    frontend: ['ui', 'component', 'react'],
+    ui: ['component', 'frontend', 'react'],
+    react: ['ui', 'component', 'frontend'],
+    // Inventory and Stock
+    stock: ['inventory', 'product', 'service'],
+    inventory: ['stock', 'product', 'service'],
+    product: ['inventory', 'stock', 'service'],
+    sku: ['product', 'inventory', 'barcode'],
+    barcode: ['sku', 'product', 'inventory']
+};
+/** Extracts words from text without punctuation. */
+const words = (text) => [...new Set((text.toLowerCase().match(/[a-z0-9_][a-z0-9_.-]{1,}/g) ?? []).filter((w) => !STOP.has(w)))].sort();
+/** Expands terms using word stemming and explicit domain synonym clusters. */
+function expandQueryTerms(rawWords) {
+    const expanded = new Set(rawWords);
+    for (const w of rawWords) {
+        const stem = normalizeStem(w);
+        if (stem.length >= 2)
+            expanded.add(stem);
+        const syns = DOMAIN_SYNONYMS[w] ?? DOMAIN_SYNONYMS[stem];
+        if (syns) {
+            for (const s of syns)
+                expanded.add(s);
+        }
+    }
+    return [...expanded].sort();
+}
+/** Matches terms against text with token/boundary precision. */
+function matchesQuery(text, terms) {
+    const lower = text.toLowerCase();
+    const matched = [];
+    for (const term of terms) {
+        if (term.includes('.') || term.includes('/')) {
+            if (lower.includes(term))
+                matched.push(term);
+        }
+        else {
+            const re = new RegExp(`(?:^|[\\s._/:-])${term}(?:$|[\\s._/:-])`, 'i');
+            if (re.test(lower))
+                matched.push(term);
+        }
+    }
+    return matched;
+}
 const norm = (s) => s.toLowerCase().replace(/\s+/g, ' ').trim();
 /** Which context documents are worth pointing at for a task type. */
 const DOCS_BY_TYPE = {
@@ -35,33 +146,106 @@ const DOCS_BY_TYPE = {
  * classified, its keywords select facts/decisions/packages, and the type decides which broader groups come along.
  * Safety rules are included for every type; the per-package "not run automatically" list whenever checks are included.
  */
-export async function getTaskContext(o, opts) {
+async function buildBaseTaskContext(o, request) {
     const ws = await requireWorkspace(o.cwd);
     const project = await loadProject(ws);
-    const cls = classifyRequest(opts.request);
+    const cls = classifyRequest(request);
     const type = cls.type;
-    const kw = words(opts.request);
+    const kw = words(request);
+    const expandedTerms = expandQueryTerms(kw);
     const included = [];
-    const hit = (text) => kw.filter((w) => text.includes(w));
+    const hit = (text) => matchesQuery(text, expandedTerms);
+    // Packages and the testing contract
+    let allChecks = [];
+    if (await pathExists(ws.commands))
+        allChecks = (await readVersioned(ws.commands, 'commands', SCHEMA_VERSION, validateCommands)).data.checks;
+    const pkgReason = new Map();
+    for (const d of packageDirs(allChecks)) {
+        const m = matchesQuery(request, [d]);
+        if (m.length > 0)
+            pkgReason.set(d, `request names "${m[0]}"`);
+    }
+    // Enhanced package discovery from domain context when not explicitly named
+    if (pkgReason.size === 0 && packageDirs(allChecks).length > 1) {
+        const hasBackend = matchesQuery(request, ['api', 'endpoint', 'endpoints', 'controller', 'controllers', 'dto', 'dtos', 'database', 'migration', 'migrations', 'migrate', 'sql', 'postgres', 'drizzle', 'orm', 'fastify', 'server', 'jwt', 'argon2', 'service', 'services', 'invoice']).length > 0;
+        const hasFrontend = matchesQuery(request, ['ui', 'component', 'components', 'frontend', 'page', 'pages', 'pagination', 'react', 'vite', 'view', 'views', 'button', 'modal']).length > 0;
+        const available = packageDirs(allChecks);
+        if (hasBackend && !hasFrontend && available.includes('backend')) {
+            pkgReason.set('backend', 'inferred from backend domain terminology');
+        }
+        else if (hasFrontend && !hasBackend && available.includes('frontend')) {
+            pkgReason.set('frontend', 'inferred from frontend UI terminology');
+        }
+        else if (hasBackend && hasFrontend) {
+            if (available.includes('backend'))
+                pkgReason.set('backend', 'request spans backend');
+            if (available.includes('frontend'))
+                pkgReason.set('frontend', 'request spans frontend');
+        }
+    }
+    // dirtyFiles already leaves out documentation and tool-managed files, so a docs-only change selects no package.
+    // Only worth the Git calls when the request did not already pick a package and there is more than one to choose from.
+    const dirty = type !== 'QUESTION' && type !== 'DOCUMENTATION' && pkgReason.size === 0 && packageDirs(allChecks).length > 1 ? await dirtyFiles(ws.root) : null;
+    for (const f of Object.keys(dirty?.files ?? {})) {
+        const d = packageDirs(allChecks).find((x) => f === x || f.startsWith(`${x}/`));
+        if (d && !pkgReason.has(d))
+            pkgReason.set(d, 'has uncommitted code changes');
+    }
     // Facts
     const all = (await loadFacts(ws)).facts;
     const picked = new Map();
+    const isSinglePackage = pkgReason.size === 1;
+    const targetPkg = isSinglePackage ? [...pkgReason.keys()][0] : null;
     for (const f of all) {
-        const m = hit(`${f.key} ${f.value} ${f.source}`.toLowerCase());
-        if (m.length > 0)
-            picked.set(f.key, `matches "${m.slice(0, 3).join('", "')}"`);
+        // If request confidently targets a single package, avoid pulling in unrelated package facts
+        if (targetPkg === 'backend') {
+            if (f.source.startsWith('frontend/') || f.key === 'stack.ui' || f.key.startsWith('convention.frontend')) {
+                continue;
+            }
+        }
+        else if (targetPkg === 'frontend') {
+            if (f.source.startsWith('backend/') || f.key === 'stack.database' || f.key === 'stack.orm' || f.key.startsWith('testing.db')) {
+                continue;
+            }
+        }
+        // Match terms against fact key and value; only match source path against specific non-structural request words
+        const mText = hit(`${f.key} ${f.value}`);
+        const mSource = matchesQuery(f.source, kw.filter((w) => !PATH_STRUCTURAL_TERMS.has(w)));
+        const m = [...new Set([...mText, ...mSource])];
+        const nonWeak = m.filter(w => !WEAK_TERMS.has(w));
+        if (nonWeak.length > 0)
+            picked.set(f.key, `matches "${nonWeak.slice(0, 3).join('", "')}"`);
     }
     const group = (re, why, also) => {
-        for (const f of all)
-            if (!picked.has(f.key) && (re.test(f.key) || also?.(f)))
+        for (const f of all) {
+            if (picked.has(f.key))
+                continue;
+            if (targetPkg === 'backend' && (f.source.startsWith('frontend/') || f.key === 'stack.ui' || f.key.startsWith('convention.frontend')))
+                continue;
+            if (targetPkg === 'frontend' && (f.source.startsWith('backend/') || f.key === 'stack.database' || f.key === 'stack.orm' || f.key.startsWith('testing.db')))
+                continue;
+            if (re.test(f.key) || also?.(f))
                 picked.set(f.key, why);
+        }
     };
-    if (type !== 'QUESTION' && type !== 'DOCUMENTATION')
-        group(/^repo\.(?:packages|entry-points)$/, `package layout (${type})`);
+    // Package layout facts: include in multi-package/cross-package/uncertain contexts, omit global entry points in single-package tasks
+    if (type !== 'QUESTION' && type !== 'DOCUMENTATION') {
+        if (!isSinglePackage || type === 'ARCHITECTURE') {
+            group(/^repo\.(?:packages|entry-points|monorepo)$/, `package layout (${type})`);
+        }
+    }
     if (type === 'BUG' || type === 'SECURITY')
         group(ISSUE_KEY, 'known issue / limitation', (f) => f.status === 'STALE' && f.sourceType !== 'detector');
-    if (BROAD_TYPES.includes(type))
-        group(STACK_KEY, `stack and conventions (${type})`);
+    if (BROAD_TYPES.includes(type)) {
+        group(/^stack\.ecosystem$/, `stack and conventions (${type})`);
+        if (targetPkg === 'backend' || !isSinglePackage) {
+            group(/^(?:arch\.modules|convention\.service-layer)$/, `architecture conventions (${type})`);
+            group(/^(?:stack\.framework|stack\.database|stack\.orm)$/, `backend stack (${type})`);
+        }
+        if (targetPkg === 'frontend' || !isSinglePackage) {
+            group(/^(?:convention\.frontend-components|stack\.ui)$/, `frontend stack (${type})`);
+        }
+    }
     if (type === 'SECURITY')
         group(/^$/, 'security / authorization rule', (f) => SECURITY_WORDS.test(`${f.key} ${f.value}`));
     if (type === 'DOCUMENTATION')
@@ -85,24 +269,6 @@ export async function getTaskContext(o, opts) {
         facts.push(clip ? { ...f, value: f.value.slice(0, CLIP), clipped: f.value.length - CLIP } : f);
         included.push({ kind: 'fact', id: f.key, reason: picked.get(f.key) });
     }
-    // Packages and the testing contract
-    let allChecks = [];
-    if (await pathExists(ws.commands))
-        allChecks = (await readVersioned(ws.commands, 'commands', SCHEMA_VERSION, validateCommands)).data.checks;
-    const pkgReason = new Map();
-    for (const d of packageDirs(allChecks)) {
-        const m = hit(d.toLowerCase());
-        if (m.length > 0)
-            pkgReason.set(d, `request names "${m[0]}"`);
-    }
-    // dirtyFiles already leaves out documentation and tool-managed files, so a docs-only change selects no package.
-    // Only worth the Git calls when the request did not already pick a package and there is more than one to choose from.
-    const dirty = type !== 'QUESTION' && type !== 'DOCUMENTATION' && pkgReason.size === 0 && packageDirs(allChecks).length > 1 ? await dirtyFiles(ws.root) : null;
-    for (const f of Object.keys(dirty?.files ?? {})) {
-        const d = packageDirs(allChecks).find((x) => f === x || f.startsWith(`${x}/`));
-        if (d && !pkgReason.has(d))
-            pkgReason.set(d, 'has uncommitted code changes');
-    }
     const usable = allChecks.filter((c) => c.available);
     const scoped = pkgReason.size > 0 ? usable.filter((c) => !c.cwd || c.cwd === '.' || pkgReason.has(c.cwd)) : usable;
     const checks = type === 'QUESTION' || type === 'DOCUMENTATION' ? [] : scoped;
@@ -116,17 +282,19 @@ export async function getTaskContext(o, opts) {
             safety.push({ package: c.cwd ?? '.', check: c.id, command: c.command, safety: s.safety, reasons: s.reasons });
     }
     SAFETY_RULES.forEach((_, i) => included.push({ kind: 'rule', id: `safety-${i + 1}`, reason: 'safety rule, included in every context' }));
-    // Decisions: titles and file references only
+    // Decisions: titles, context, decision, consequences, and file references
     const decs = (await listDecisions(ws)).decisions;
     const wantAll = type === 'ARCHITECTURE' || type === 'SECURITY';
     const decisions = [];
     for (const d of decs) {
-        const m = hit(`${d.title} ${d.decision} ${d.context}`.toLowerCase());
-        if (d.status === 'superseded' && m.length === 0)
+        const fullText = `${d.title} ${d.decision} ${d.context} ${d.consequences} ${d.file}`;
+        const m = matchesQuery(fullText, expandedTerms);
+        const nonWeak = m.filter(w => !WEAK_TERMS.has(w));
+        if (d.status === 'superseded' && nonWeak.length === 0)
             continue;
-        if (m.length > 0 || wantAll) {
+        if (nonWeak.length > 0 || wantAll) {
             decisions.push({ number: d.number, title: d.title, status: d.status, file: d.file });
-            included.push({ kind: 'decision', id: String(d.number).padStart(4, '0'), reason: m.length > 0 ? `matches "${m[0]}"` : `${type} tasks review all decisions` });
+            included.push({ kind: 'decision', id: String(d.number).padStart(4, '0'), reason: nonWeak.length > 0 ? `matches "${nonWeak[0]}"` : `${type} tasks review all decisions` });
         }
     }
     // Documents: referenced, never embedded
@@ -136,7 +304,7 @@ export async function getTaskContext(o, opts) {
         for (const name of (await fs.readdir(ws.contextDir)).filter((n) => n.endsWith('.md')).sort()) {
             docCount++;
             const byType = (DOCS_BY_TYPE[type] ?? []).includes(name);
-            const m = hit(name.toLowerCase());
+            const m = matchesQuery(name, expandedTerms);
             if (byType || m.length > 0) {
                 documents.push({ name, bytes: (await fs.stat(path.join(ws.contextDir, name))).size });
                 included.push({ kind: 'document', id: name, reason: byType ? `reference for ${type}` : `request names "${m[0]}"` });
@@ -145,7 +313,7 @@ export async function getTaskContext(o, opts) {
     }
     return {
         project: { name: project.name, id: project.projectId },
-        request: opts.request,
+        request,
         type,
         confidence: cls.confidence,
         readOnly: cls.readOnly,
@@ -161,4 +329,216 @@ export async function getTaskContext(o, opts) {
         counts: { facts: [facts.length, all.length], checks: [checks.length, usable.length], decisions: [decisions.length, decs.length], documents: [documents.length, docCount] },
     };
 }
+export async function getTaskContext(o, opts) {
+    const base = await buildBaseTaskContext(o, opts.request);
+    if (!opts.role)
+        return base;
+    return getAgentContextSlice(o, { request: opts.request, role: opts.role, base });
+}
+export async function getAgentContextSlice(o, opts) {
+    const ws = await requireWorkspace(o.cwd);
+    const base = opts.base ?? (await buildBaseTaskContext(o, opts.request));
+    const role = opts.role;
+    const kw = words(opts.request);
+    const expandedTerms = expandQueryTerms(kw);
+    const hit = (text) => matchesQuery(text, expandedTerms);
+    let slicedFacts = [...base.facts];
+    let slicedChecks = [...base.checks];
+    let slicedDecisions = [...base.decisions];
+    let slicedDocuments = [...base.documents];
+    let roleGuidance = [];
+    const roleFindings = {};
+    if (role === 'explorer') {
+        // Explorer: Prioritize entry points, symbols, features, graph connections.
+        // Avoid unrelated test commands, entire file contents, complete repo dumps.
+        slicedChecks = [];
+        slicedFacts = base.facts.filter((f) => {
+            if (/^repo\.(?:entry-points|packages|monorepo)$/.test(f.key))
+                return true;
+            if (STACK_KEY.test(f.key) && !/^convention\.test/i.test(f.key))
+                return true;
+            const m = hit(`${f.key} ${f.value}`);
+            return m.length > 0 && !/^convention\.test/i.test(f.key);
+        });
+        slicedDecisions = base.decisions.slice(0, 3);
+        slicedDocuments = base.documents.filter((d) => ['architecture.md', 'integrations.md'].includes(d.name));
+        // Entry points from facts or packages
+        const epFact = base.facts.find((f) => f.key === 'repo.entry-points');
+        const entryPoints = [];
+        if (epFact && epFact.value) {
+            for (const p of epFact.value.split(',').map((x) => x.trim()).filter(Boolean)) {
+                if (!entryPoints.includes(p))
+                    entryPoints.push(p);
+            }
+        }
+        if (entryPoints.length === 0 && base.packages.length > 0) {
+            entryPoints.push(...base.packages);
+        }
+        if (entryPoints.length > 0)
+            roleFindings.entryPoints = entryPoints.slice(0, 10);
+        // Feature knowledge map references
+        try {
+            const featFile = await loadFeatures(ws);
+            const matchedFeats = featFile.features.filter((f) => {
+                const text = `${f.id} ${f.name} ${f.description ?? ''} ${(f.tags ?? []).join(' ')}`;
+                return hit(text).length > 0;
+            });
+            if (matchedFeats.length > 0) {
+                roleFindings.features = matchedFeats.slice(0, 8).map((f) => ({
+                    id: f.id,
+                    name: f.name,
+                    status: f.status,
+                }));
+            }
+        }
+        catch {
+            // Graceful fallback if features file unreadable
+        }
+        // Graphify graph lookup
+        try {
+            const graph = await loadGraphData(ws.root);
+            if (graph.exists && graph.data && graph.data.nodes) {
+                const matchedNodes = [];
+                for (const w of expandedTerms) {
+                    const n = findMatchingStartNode(graph.data.nodes, w);
+                    if (n && !matchedNodes.some((x) => x.id === n.id)) {
+                        matchedNodes.push({
+                            id: n.id,
+                            status: typeof n.status === 'string' ? n.status : 'symbol',
+                            path: n.path || n.file || null,
+                            symbol: typeof n.name === 'string' ? n.name : null,
+                        });
+                    }
+                    if (matchedNodes.length >= 6)
+                        break;
+                }
+                if (matchedNodes.length > 0)
+                    roleFindings.graphNodes = matchedNodes;
+            }
+        }
+        catch {
+            // Graceful fallback if graph lookup fails
+        }
+        roleGuidance = [
+            'Investigate referenced entry points and feature components before reading full files.',
+            'Trace deep call dependencies with "devworkspace graph trace <symbol>".',
+            'Conclude exploration with a concise handoff: identified files, uncertainty, and next step.',
+        ];
+    }
+    else if (role === 'tester') {
+        // Tester: Prioritize test files, test framework conventions, verification contracts, zero-test safeguards.
+        slicedFacts = base.facts.filter((f) => {
+            if (/^convention\.test/i.test(f.key) || ISSUE_KEY.test(f.key))
+                return true;
+            if (STACK_KEY.test(f.key) && /test/i.test(f.key + f.value))
+                return true;
+            const m = hit(`${f.key} ${f.value}`.toLowerCase());
+            return m.length > 0;
+        });
+        slicedChecks = base.checks;
+        slicedDocuments = base.documents.filter((d) => d.name === 'testing.md');
+        slicedDecisions = base.decisions.filter((d) => /test|verify|quality/i.test(d.title));
+        roleFindings.zeroTestSafeguards = [
+            'Zero-test pass detection active across Vitest, Jest, Pytest, Mocha, Go, and Cargo.',
+            'Commands exiting code 0 with 0 tests executed are classified as unverified false passes.',
+            'Record baseline before modifications: devworkspace task tests <id> --phase baseline --passed <n> --failed <n>.',
+            "Execute verification via 'devworkspace task run <id> <check>'.",
+        ];
+        roleGuidance = [
+            'Verify required contract commands for affected packages before claiming completion.',
+            'Write focused regression tests covering defect reproduction or feature acceptance criteria.',
+            'Never run destructive commands or test suites touching unmanaged databases without "testenv declare".',
+        ];
+    }
+    else if (role === 'reviewer') {
+        // Reviewer: Prioritize git diff/changed files, permanent safety rules, ADRs, potential regressions.
+        slicedFacts = base.facts.filter((f) => {
+            if (SECURITY_WORDS.test(`${f.key} ${f.value}`))
+                return true;
+            if (/^convention\./i.test(f.key))
+                return true;
+            const m = hit(`${f.key} ${f.value}`.toLowerCase());
+            return m.length > 0;
+        });
+        // Keep review-relevant checks (lint, typecheck, review, and test suites)
+        if (base.checks.length > 0) {
+            slicedChecks = base.checks.filter((c) => /lint|typecheck|review|test/i.test(c.id));
+        }
+        else {
+            try {
+                if (await pathExists(ws.commands)) {
+                    const contract = (await readVersioned(ws.commands, 'commands', SCHEMA_VERSION, validateCommands)).data.checks;
+                    const usable = contract.filter((c) => c.available && /lint|typecheck|review|test/i.test(c.id));
+                    slicedChecks = base.packages.length > 0
+                        ? usable.filter((c) => !c.cwd || c.cwd === '.' || base.packages.includes(c.cwd))
+                        : usable;
+                }
+            }
+            catch {
+                slicedChecks = [];
+            }
+        }
+        slicedDecisions = base.decisions;
+        slicedDocuments = base.documents.filter((d) => ['conventions.md', 'architecture.md'].includes(d.name));
+        try {
+            const dirty = await dirtyFiles(ws.root);
+            const dirtyList = dirty ? Object.keys(dirty.files) : [];
+            if (dirtyList.length > 0) {
+                const preview = dirtyList.slice(0, 5).join(', ') + (dirtyList.length > 5 ? ` (+${dirtyList.length - 5} more)` : '');
+                roleFindings.diffNotice = `${dirtyList.length} uncommitted file(s) detected: ${preview}. Inspect exact diff with "git diff".`;
+            }
+            else {
+                roleFindings.diffNotice = 'No uncommitted changes detected in working tree. When reviewing a branch or PR, the caller must supply the target diff or commit range.';
+            }
+        }
+        catch {
+            roleFindings.diffNotice = 'Could not inspect git working tree status. The caller must supply the diff or commit range.';
+        }
+        roleGuidance = [
+            'Audit diff against permanent SAFETY_RULES (no secrets in code/logs, no path traversals, untrusted commands).',
+            'Verify changes strictly comply with recorded decisions (ADRs) and feature contracts.',
+            'Ensure required verification checks have executed results before approving the completion gate.',
+        ];
+    }
+    const factKeys = new Set(slicedFacts.map((f) => f.key));
+    const checkIds = new Set(slicedChecks.map((c) => `${c.cwd ?? '.'}:${c.id}`));
+    const decIds = new Set(slicedDecisions.map((d) => String(d.number).padStart(4, '0')));
+    const docNames = new Set(slicedDocuments.map((d) => d.name));
+    const included = base.included.filter((item) => {
+        if (item.kind === 'rule')
+            return true;
+        if (item.kind === 'fact')
+            return factKeys.has(item.id);
+        if (item.kind === 'check')
+            return checkIds.has(item.id);
+        if (item.kind === 'decision')
+            return decIds.has(item.id);
+        if (item.kind === 'document')
+            return docNames.has(item.id);
+        return false;
+    });
+    included.push({
+        kind: 'rule',
+        id: `role:${role}`,
+        reason: `context tailored for ${role} role (Phase 1 role-based context slicing)`,
+    });
+    return {
+        ...base,
+        role,
+        facts: slicedFacts,
+        checks: slicedChecks,
+        decisions: slicedDecisions,
+        documents: slicedDocuments,
+        rules: SAFETY_RULES,
+        included,
+        counts: {
+            facts: [slicedFacts.length, base.counts.facts[1]],
+            checks: [slicedChecks.length, base.counts.checks[1]],
+            decisions: [slicedDecisions.length, base.counts.decisions[1]],
+            documents: [slicedDocuments.length, base.counts.documents[1]],
+        },
+        roleGuidance,
+        roleFindings,
+    };
+}
 //# sourceMappingURL=taskContext.js.map