xdrs-core 0.10.0 → 0.11.0

package/.xdrs/_core/adrs/principles/001-xdr-standards.md

@@ -52,7 +52,7 @@ Provides clear ownership by scope, predictable navigation, and reusable decision
   - Skills use `.xdrs/[scope]/[type]/[subject]/skills/[number]-[skill-name]/assets/`
 - **Scopes:** 
   - examples: `business-x`, `business-y`, `team-43`, `_core`
-  - `_local` is a reserved scope for XDRs created locally to a specific project or repository. XDRs in `_local` must not be shared with or propagated to other contexts. This scope must always be placed in the lowest position in `.xdrs/index.md` so that its decisions override or extend any decisions from all higher-positioned scopes.
+  - `_local` is a reserved scope for XDRs created locally to a specific project or repository. XDRs in `_local` must not be shared with or propagated to other contexts. This scope must always be placed in the lowest position in `.xdrs/index.md` so that its decisions override or extend any decisions from all higher-positioned scopes. Shared `.xdrs/index.md` files MUST NOT link `_local` canonical type indexes because `_local` stays workspace-local and is not distributed with shared packages. Readers, tools, and agents SHOULD still try to discover existing workspace-local `_local` canonical indexes by default, even when the shared root index does not link them.
   - **Types:** `adrs`, `bdrs`, `edrs`
   - there can exist sufixes to the standard scope names (e.g: `business-x-mobileapp`, `business-y-servicedesk`)
 - **Subjects:** MUST be one of the following depending on the type of the XDR:

package/.xdrs/_core/adrs/principles/skills/002-write-xdr/SKILL.md

@@ -10,7 +10,7 @@ metadata:
 
 ## Overview
 
-Guides the creation of a well-structured XDR by following the standards in `_core-adr-001`, researching existing records for conflicts, checking redundancy across related artifacts, and iterating until the document is concise, decision-focused, and clear about when the decision should be used.
+Guides the creation of a well-structured XDR by following the standards in `_core-adr-001`, consulting `xdr-standards` for every core element definition, researching existing records for conflicts, checking redundancy across related artifacts, and iterating until the document is concise, decision-focused, and clear about when the decision should be used.
 
 ## Instructions
 
@@ -18,10 +18,13 @@ Guides the creation of a well-structured XDR by following the standards in `_cor
 
 1. Read `.xdrs/index.md` to discover all active scopes and their canonical indexes.
 2. Read `.xdrs/_core/adrs/principles/001-xdr-standards.md` in full to internalize structure rules, mandatory language, and the XDR template.
-3. Ask the user (or infer from context) the topic of the decision. Do NOT proceed to Phase 2 without a clear topic.
+3. Treat `.xdrs/_core/adrs/principles/001-xdr-standards.md` as the canonical source for all core XDR element definitions. Before choosing or writing any core element, consult it for the exact rules for type, scope, subject, ID, numbering, title, placement, and applicable folder structure instead of relying on memory or local convention.
+4. Ask the user (or infer from context) the topic of the decision. Do NOT proceed to Phase 2 without a clear topic.
 
 ### Phase 2: Select Type, Scope, and Subject
 
+Consult `001-xdr-standards` while making each choice in this phase. The summaries below are orientation only; when any detail matters, the standard decides.
+
 **Type** — choose exactly one based on the nature of the decision:
 - **BDR**: business process, product policy, strategic rule, operational procedure
 - **ADR**: system context, integration pattern, overarching architectural choice
@@ -133,6 +136,7 @@ If any check fails, revise and re-run this phase before proceeding.
 ### Constraints
 
 - MUST follow the XDR template from `001-xdr-standards` exactly.
+- MUST consult `001-xdr-standards` as the canonical source for every core element definition, especially type, scope, subject, ID, numbering, naming, and placement.
 - MUST NOT add personal opinions or general best-practice content not tied to a decision.
 - MUST NOT create an XDR that duplicates a decision already captured in another XDR — extend or reference instead.
 - MUST prefer links and short references over repeating the same decision content across related documents.

package/.xdrs/_core/adrs/principles/skills/003-write-skill/SKILL.md

@@ -11,17 +11,20 @@ metadata:
 
 ## Overview
 
-Guides the creation of a well-structured skill package by following `_core-adr-003` skill standards, checking existing skills to avoid duplication, and producing a complete SKILL.md ready to activate in VS Code.
+Guides the creation of a well-structured skill package by following `_core-adr-003` skill standards, consulting `xdr-standards` for every core element definition, checking existing skills to avoid duplication, and producing a complete SKILL.md ready to activate in VS Code.
 
 ## Instructions
 
 ### Phase 1: Understand the Skill Goal
 
 1. Read `.xdrs/_core/adrs/principles/003-skill-standards.md` in full to internalize the SKILL.md format, folder layout, and numbering rules.
-2. Identify what the skill must do, the concrete outcome it should produce, and the exact conditions under which an agent should activate it. Do NOT proceed without a clear goal, outcome, and activation trigger.
+2. Read `.xdrs/_core/adrs/principles/001-xdr-standards.md` in full before defining any core element for the skill package. Treat it as the canonical source for type, scope, subject, numbering expectations, naming constraints, and folder placement rules.
+3. Identify what the skill must do, the concrete outcome it should produce, and the exact conditions under which an agent should activate it. Do NOT proceed without a clear goal, outcome, and activation trigger.
 
 ### Phase 2: Select Type, Scope, Subject, and Number
 
+Consult `001-xdr-standards` while making each choice in this phase. The summaries below are orientation only; when there is any ambiguity or edge case, the standard decides.
+
 **Type** — choose one based on the skill's activity:
 - **EDR skill**: engineering workflows, tool usage, coding procedures, implementation how-tos
 - **ADR skill**: architectural evaluation, pattern compliance, technology selection guidance
@@ -122,6 +125,7 @@ If any check fails, revise before continuing.
 ### Constraints
 
 - MUST follow the agentskills SKILL.md format from `003-skill-standards` exactly.
+- MUST consult `001-xdr-standards` as the canonical source for every core element definition, especially type, scope, subject, numbering, naming, and placement.
 - MUST NOT create a skill that duplicates an existing one — extend or reference it instead.
 - MUST keep scope `_local` unless the user explicitly states otherwise.
 - MUST include a References section linking to `003-skill-standards`.

package/.xdrs/_core/adrs/principles/skills/004-write-article/SKILL.md

@@ -9,9 +9,7 @@ metadata:
 
 ## Overview
 
-Guides the creation of a well-structured article by following `_core-adr-004`, researching the XDRs,
-Research documents, and Skills to synthesize, and producing a concise document that serves as a navigable view without duplicating
-decision content.
+Guides the creation of a well-structured article by following `_core-adr-004`, consulting `xdr-standards` for every core element definition, researching the XDRs, Research documents, and Skills to synthesize, and producing a concise document that serves as a navigable view without duplicating decision content.
 
 ## Instructions
 
@@ -19,15 +17,21 @@ decision content.
 
 1. Read `.xdrs/_core/adrs/principles/004-article-standards.md` in full to internalize the template,
    placement rules, numbering rules, and the constraint that articles are views, not decisions.
-2. Identify the topic and intended audience from user input or context. Do NOT proceed without a clear
+2. Read `.xdrs/_core/adrs/principles/001-xdr-standards.md` in full before defining the article's core elements. Treat it as the canonical source for how to choose and write type, scope, subject, numbering, naming, and folder placement.
+3. Identify the topic and intended audience from user input or context. Do NOT proceed without a clear
    topic.
 
 ### Phase 2: Select Scope, Type, and Subject
 
+Consult `001-xdr-standards` while making each choice in this phase. The summaries below are orientation only; when any detail is unclear, the standard decides.
+
 **Scope** — use `_local` unless the user explicitly names another scope.
 
 **Type** — match the type of the XDRs the article primarily synthesizes (`adrs`, `bdrs`, or `edrs`).
-If the topic spans multiple types, use `adrs`.
+If the topic spans multiple types, use `adrs`. Use the same rules as `002-write-xdr` Phase 2:
+- **BDR**: business process, product policy, strategic rule, operational procedure
+- **ADR**: system context, integration pattern, overarching architectural choice
+- **EDR**: specific tool/library, coding practice, testing strategy, project structure, pipelines
 
 **Subject** — pick the subject that best matches the article's topic (see `004-article-standards`).
 If the article spans more than one subject, place it in `principles`.
@@ -111,6 +115,13 @@ Rules to apply while drafting:
 - **Conflicting information found** — note the conflict in the article and always defer to the XDR.
 - **Article would exceed 150 lines** — move detailed content to a new Research, Skill, or XDR and link back.
 
+## Constraints
+
+- MUST consult `001-xdr-standards` as the canonical source for every core element definition, especially type, scope, subject, numbering, naming, and placement.
+- MUST follow the article template and placement rules from `004-article-standards`.
+- MUST keep scope `_local` unless the user explicitly states otherwise.
+- MUST defer to active and applicable XDRs when article synthesis conflicts with them.
+
 ## References
 
 - [_core-adr-004 - Article standards](../../../.xdrs/_core/adrs/principles/004-article-standards.md)

package/.xdrs/_core/adrs/principles/skills/005-write-research/005-write-research.test.int.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const path = require('path');
+const { copilotCmd, testPrompt } = require('xdrs-core');
+
+const REPO_ROOT = path.resolve(__dirname, '..', '..', '..', '..', '..', '..');
+
+jest.setTimeout(60000);
+
+test.skip('check', () => {
+	const err = testPrompt(
+		{
+			workspaceRoot: REPO_ROOT,
+			workspaceMode: 'in-place',
+			promptCmd: copilotCmd(REPO_ROOT)
+		},
+		'Reply with READY and nothing else.',
+		'Verify that the final output is READY and nothing else.',
+		true
+	);
+
+	expect(err).toBe('');
+});
+
+test('005-write-research creates an IMRAD research document in copy mode', () => {
+	const err = testPrompt(
+		{
+			workspaceRoot: REPO_ROOT,
+			workspaceMode: 'copy',
+			promptCmd: copilotCmd(REPO_ROOT)
+		},
+		'Create a very small research document with the following data: We measured the installation time in our monorepo and pnpm is 3.5x faster than Yarn when installing dependencies. We recommend using PNPM in our monorepo to speed up our productivity as it seems very easy to use and have a better internal hoisting mechanism.',
+		'Verify that a research file was created under .xdrs/_local/edrs/devops/researches/, that it contains the sections Abstract, Introduction, Methods, Results, Discussion, Conclusion, and References, and that the content contains all the provided data in input prompt, and doesn\'t contain more than 20% of additional information.'
+	);
+
+	expect(err).toBe('');
+});

package/.xdrs/_core/adrs/principles/skills/005-write-research/SKILL.md

@@ -11,26 +11,32 @@ metadata:
 
 ## Overview
 
-Guides the creation of a well-structured research document by following `_core-adr-006`, checking related XDRs and existing research to avoid duplication, and producing an IMRAD-based study that reads as a standalone technical paper. Treat each section goal in the research template as an acceptance criterion, not as optional wording. Do not assume missing direction, evidence, or intended follow-up; ask the user explicitly before proceeding when those points are not already concrete.
+Guides the creation of a well-structured research document by following `_core-adr-006`, consulting `xdr-standards` for every core element definition, checking related XDRs and existing research to avoid duplication, and producing an IMRAD-based study that reads as a standalone technical paper. Treat each section goal in the research template as an acceptance criterion, not as optional wording. Do not assume missing direction, evidence, or intended follow-up; ask the user explicitly before proceeding when those points are not already concrete.
 
 ## Instructions
 
 ### Phase 1: Understand the Research Goal
 
 1. Read `.xdrs/_core/adrs/principles/006-research-standards.md` in full to internalize the folder layout, numbering rules, and mandatory template.
-2. Ask the user to confirm the intended direction of the research before planning the document: what decision, question, or option space the study should support, what boundaries or exclusions apply, and what kind of outcome they expect.
-3. Ask the user what evidence already exists and what evidence-gathering methods are acceptable if the current evidence is incomplete. Do not invent facts, sources, or confidence that the user did not provide.
-4. Ask the user what the proposed next step is after the research, such as writing a new XDR, updating an existing XDR, informing a discussion, or documenting trade-offs for later. Use that answer to shape the framing without turning the research into the final decision.
-5. Identify the problem or question being explored, the relevant system or domain context, the likely technical audience, and why the subject matters in practice.
-6. Internalize the goal of each required section before drafting: `Abstract` gives a quick technical reader the question, method, main result, and takeaway, `Introduction` frames the investigated problem and context, `Methods` makes the important parts reproducible, `Results` records raw findings with minimal interpretation, `Discussion` interprets the findings, `Conclusion` summarizes the practical takeaway and boundaries, and `References` makes sources traceable.
-7. Collect the main constraints, known facts, important experiences, gaps, and assumptions that belong in the introduction.
-8. Do NOT proceed without a clear problem statement, a central question, explicit user direction, an understood next step, and at least one credible source of evidence or a method for generating it. If any of these are ambiguous, stop and ask instead of assuming.
+2. Read `.xdrs/_core/adrs/principles/001-xdr-standards.md` in full before defining the research document's core elements. Treat it as the canonical source for how to choose and write type, scope, subject, numbering expectations, naming constraints, and folder placement.
+3. Ask the user to confirm the intended direction of the research before planning the document: what decision, question, or option space the study should support, what boundaries or exclusions apply, and what kind of outcome they expect.
+4. Ask the user what evidence already exists and what evidence-gathering methods are acceptable if the current evidence is incomplete. Do not invent facts, sources, or confidence that the user did not provide.
+5. Ask the user what the proposed next step is after the research, such as writing a new XDR, updating an existing XDR, informing a discussion, or documenting trade-offs for later. Use that answer to shape the framing without turning the research into the final decision.
+6. Identify the problem or question being explored, the relevant system or domain context, the likely technical audience, and why the subject matters in practice.
+7. Internalize the goal of each required section before drafting: `Abstract` gives a quick technical reader the question, method, main result, and takeaway, `Introduction` frames the investigated problem and context, `Methods` makes the important parts reproducible, `Results` records raw findings with minimal interpretation, `Discussion` interprets the findings, `Conclusion` summarizes the practical takeaway and boundaries, and `References` makes sources traceable.
+8. Collect the main constraints, known facts, important experiences, gaps, and assumptions that belong in the introduction.
+9. Do NOT proceed without a clear problem statement, a central question, explicit user direction, an understood next step, and at least one credible source of evidence or a method for generating it. If any of these are ambiguous, stop and ask instead of assuming.
 
 ### Phase 2: Select Scope, Type, Subject, and Number
 
+Consult `001-xdr-standards` while making each choice in this phase. The summaries below are orientation only; when any detail matters, the standard decides.
+
 **Scope** — use `_local` unless the user explicitly names another scope.
 
-**Type** — match the type of decision this research supports (`adrs`, `bdrs`, or `edrs`).
+**Type** — match the type of decision this research supports (`adrs`, `bdrs`, or `edrs`). Use the same rules as `002-write-xdr` Phase 2:
+- **BDR**: business process, product policy, strategic rule, operational procedure
+- **ADR**: system context, integration pattern, overarching architectural choice
+- **EDR**: specific tool/library, coding practice, testing strategy, project structure, pipelines
 
 **Subject** — pick the most specific subject that matches the problem domain.
 
@@ -253,4 +259,11 @@ If any check fails, revise before continuing.
 
 - [_core-adr-006 - Research standards](../../006-research-standards.md)
 - [_core-adr-001 - XDR standards](../../001-xdr-standards.md)
-- [002-write-xdr skill](../002-write-xdr/SKILL.md)
+- [002-write-xdr skill](../002-write-xdr/SKILL.md)
+
+## Constraints
+
+- MUST consult `001-xdr-standards` as the canonical source for every core element definition, especially type, scope, subject, numbering, naming, and placement.
+- MUST follow the research template and section-goal rules from `006-research-standards`.
+- MUST keep scope `_local` unless the user explicitly states otherwise.
+- MUST keep the document as research rather than turning it into a final decision.

package/.xdrs/index.md

@@ -19,6 +19,4 @@ Decisions about how XDRs work
 
 ### _local (reserved)
 
-Project-local XDRs that must not be shared with other contexts. Always keep this scope last so its decisions override or extend all scopes listed above. Add specific `_local` ADR/BDR/EDR index links here when present.
-
-
+Project-local XDRs that must not be shared with other contexts. Always keep this scope last so its decisions override or extend all scopes listed above. Keep `_local` canonical indexes in the workspace tree only; do not link them from this shared index. Readers and tools should still try to discover existing `_local` indexes in the current workspace by default.

package/README.md

@@ -68,6 +68,46 @@ npx -y xdrs-core lint ./some-project
 pnpm exec xdrs-core lint .
 ```
 
+## Library Testing
+
+The package also exposes a reusable behavior-test library for Jest or any other JavaScript test runner.
+
+Main exports:
+
+- `testPrompt(config, inputPrompt, judgePrompt)` runs the task prompt, evaluates the result in a fresh judge session, and returns an empty string on success or a markdown bullet list on failure.
+- `runPromptTest(config, inputPrompt, judgePrompt)` returns the structured result object when you need access to captured output and the agent-reported changed file list.
+- `copilotCmd(workspaceRoot)` returns a ready-to-use `promptCmd` template for the Copilot CLI. The library uses that same command template for both the task and judge phases. If `workspaceRoot` is omitted it defaults to the current git repository root.
+- `config.workspaceRoot`, when set, is the authoritative workspace under test. If omitted, the library uses the current git repository root.
+
+Execution model:
+
+- phase 1 runs the task prompt and captures final output text plus the files the agent says it changed
+- phase 2 runs an independent judge prompt in a fresh invocation of `promptCmd` against the original task prompt, task output, the agent-reported changed file list, and the current workspace state
+- the judge trusts that reported file list as the authoritative change report and reads file contents from the workspace directly when needed
+- when `workspaceMode: 'copy'` is used, the temporary workspace honors nested `.gitignore` rules and skips git metadata files during the copy
+
+`promptCmd` accepts either a string array or a JSON array string and must include a `{PROMPT}` placeholder.
+
+Example with Jest:
+
+```js
+const { copilotCmd, testPrompt } = require('xdrs-core');
+
+test('creates hello.md', () => {
+  const err = testPrompt(
+    {
+      workspaceRoot: process.cwd(),
+      promptCmd: copilotCmd(process.cwd()),
+      workspaceMode: 'copy'
+    },
+    "Create a nice markdown file at hello.md saying 'hello!'",
+    'The resulting file should be created at hello.md and have hello as part of its contents, without too much extra info (should be <100 chars)'
+  );
+
+  expect(err).toBe('');
+});
+```
+
 ## Requirements
 
 ### Multi-scope support

package/lib/index.js

@@ -0,0 +1,3 @@
+'use strict';
+
+module.exports = require('./testPrompt');

package/lib/lint.js

@@ -96,32 +96,30 @@ function lintRootIndex(rootIndexPath, xdrsRoot, actualTypeIndexes, errors) {
     errors.push(`Root index is missing required override text: ${toDisplayPath(rootIndexPath)}`);
   }
 
-  const localLinks = parseLocalLinks(content, path.dirname(rootIndexPath));
-  for (const linkPath of localLinks) {
+  const links = parseLocalLinks(content, path.dirname(rootIndexPath));
+  for (const linkPath of links) {
     if (!fs.existsSync(linkPath)) {
       errors.push(`Broken link in root index: ${displayPath(rootIndexPath, linkPath)}`);
     }
   }
 
-  const linkedTypeIndexes = localLinks.filter((linkPath) => isCanonicalTypeIndex(linkPath, xdrsRoot));
+  const linkedTypeIndexes = links.filter((linkPath) => isCanonicalTypeIndex(linkPath, xdrsRoot));
   const linkedSet = new Set(linkedTypeIndexes.map(normalizePath));
 
-  for (const indexPath of actualTypeIndexes) {
-    if (!linkedSet.has(normalizePath(indexPath))) {
-      errors.push(`Root index is missing canonical index link: ${toDisplayPath(indexPath)}`);
+  for (const indexPath of linkedTypeIndexes) {
+    const scopeName = path.basename(path.dirname(path.dirname(indexPath)));
+    if (scopeName === '_local') {
+      errors.push(`Root index must not link _local canonical index: ${displayPath(rootIndexPath, indexPath)}`);
     }
   }
 
-  let seenLocal = false;
-  for (const indexPath of linkedTypeIndexes) {
+  for (const indexPath of actualTypeIndexes) {
     const scopeName = path.basename(path.dirname(path.dirname(indexPath)));
     if (scopeName === '_local') {
-      seenLocal = true;
       continue;
     }
-    if (seenLocal) {
-      errors.push('Root index must keep all _local scope links after every non-_local scope link');
-      break;
+    if (!linkedSet.has(normalizePath(indexPath))) {
+      errors.push(`Root index is missing canonical index link: ${toDisplayPath(indexPath)}`);
     }
   }
 }

package/lib/testPrompt.js

@@ -0,0 +1,660 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const ignore = require('ignore');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const MAX_TASK_OUTPUT_CHARS = 12 * 1024;
+
+function testPrompt(config, inputPrompt, judgePrompt, verbose) {
+	const result = runPromptTest(config, inputPrompt, judgePrompt, verbose);
+	return result.passed ? '' : formatFailureMarkdown(result.findings);
+}
+
+function runPromptTest(config, inputPrompt, judgePrompt, verbose) {
+	if(verbose) {
+		console.log('Running prompt test with config:', JSON.stringify(config, null, 2));
+		console.log('Input Prompt:', inputPrompt);
+		console.log('Judge Prompt:', judgePrompt);
+	}
+	const options = normalizeConfig(config);
+	const originalWorkspace = resolveWorkspaceRoot(options);
+	let tempRoot = null;
+	let effectiveWorkspace = originalWorkspace;
+
+	try {
+		if (options.workspaceMode === 'copy') {
+			tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'xdrs-core-test-'));
+			effectiveWorkspace = copyWorkspace(originalWorkspace, path.join(tempRoot, 'workspace'), verbose);
+		}
+
+		if(verbose) {
+			console.log(`Running prompt test in workspace: ${effectiveWorkspace} (mode: ${options.workspaceMode})`);
+		}
+		const task = runTaskPhase({
+			prompt: ensureNonEmptyString(inputPrompt, 'inputPrompt'),
+			commandTemplate: options.promptCmd,
+			workspacePath: effectiveWorkspace,
+			authoritativeWorkspacePath: originalWorkspace,
+			timeoutMs: options.taskTimeoutMs,
+			env: options.env,
+			verbose
+		});
+
+		if(verbose) {
+			console.log('Task phase completed. Summary:', task.summary);
+			console.log('Agent reported changed files:', task.changedFiles);
+		}
+
+		if(verbose) {
+			console.log('Running judge phase to evaluate the task output against the judge prompt.');
+		}
+		const evaluation = runJudgePhase({
+			originalPrompt: ensureNonEmptyString(inputPrompt, 'inputPrompt'),
+			judgePrompt: ensureNonEmptyString(judgePrompt, 'judgePrompt'),
+			taskOutput: task.summary,
+			agentReportedChanges: task.changedFiles,
+			commandTemplate: options.promptCmd,
+			workspacePath: effectiveWorkspace,
+			authoritativeWorkspacePath: originalWorkspace,
+			timeoutMs: options.judgeTimeoutMs,
+			env: options.env,
+			verbose
+		});
+
+		return {
+			passed: evaluation.pass,
+			findings: evaluation.findings,
+			taskOutput: task.summary,
+			agentReportedChanges: task.changedFiles,
+			judge: evaluation.raw,
+			workspace: {
+				original: originalWorkspace,
+				effective: effectiveWorkspace,
+				mode: options.workspaceMode
+			}
+		};
+	} finally {
+		if (tempRoot && options.workspaceMode === 'copy') {
+			fs.rmSync(tempRoot, { recursive: true, force: true });
+		}
+	}
+}
+
+function copilotCmd(workspaceRoot = findGitRoot(process.cwd())) {
+	return [
+		'copilot',
+		`--add-dir=${path.resolve(workspaceRoot)}`,
+		'--allow-all',
+		'-p',
+		'{PROMPT}'
+	];
+}
+
+function ensureNonEmptyString(value, label) {
+	if (typeof value !== 'string' || !value.trim()) {
+		throw new Error(`Expected non-empty ${label}`);
+	}
+	return value.trim();
+}
+
+function normalizeConfig(config) {
+	if (!config || typeof config !== 'object' || Array.isArray(config)) {
+		throw new Error('Expected config to be an object.');
+	}
+
+	const workspaceMode = config.workspaceMode || 'copy';
+	if (workspaceMode !== 'copy' && workspaceMode !== 'in-place') {
+		throw new Error(`Invalid workspaceMode value: ${workspaceMode}`);
+	}
+
+	return {
+		promptCmd: parseCommandTemplate(config.promptCmd, 'promptCmd'),
+		workspaceRoot: config.workspaceRoot ? path.resolve(config.workspaceRoot) : null,
+		workspaceMode,
+		env: normalizeEnv(config.env),
+		taskTimeoutMs: readTimeout(config.taskTimeoutMs, 'taskTimeoutMs'),
+		judgeTimeoutMs: readTimeout(config.judgeTimeoutMs, 'judgeTimeoutMs')
+	};
+}
+
+function resolveWorkspaceRoot(options) {
+	const resolvedWorkspace = options.workspaceRoot || findGitRoot(process.cwd());
+
+	if (!fs.existsSync(resolvedWorkspace) || !fs.statSync(resolvedWorkspace).isDirectory()) {
+		throw new Error(`Workspace directory not found: ${resolvedWorkspace}`);
+	}
+
+	return resolvedWorkspace;
+}
+
+function runTaskPhase({ prompt, commandTemplate, workspacePath, authoritativeWorkspacePath, timeoutMs, env }, verbose) {
+	const wrappedPrompt = [
+		'XDRS-CORE TEST PHASE: TASK',
+		'',
+		'Execute the following task in the current workspace.',
+		'Keep all changes inside the workspace.',
+		'Respond with JSON only and no code fences.',
+		'Use exactly this schema: {"summary":"plain text summary","changedFiles":["relative/path.ext"]}.',
+		'The summary must describe the final result only, not hidden reasoning.',
+		'',
+		'BEGIN TASK PROMPT',
+		prompt,
+		'END TASK PROMPT'
+	].join('\n');
+
+	const result = runPromptCommand({
+		commandTemplate,
+		workspacePath,
+		authoritativeWorkspacePath,
+		prompt: wrappedPrompt,
+		timeoutMs,
+		env,
+		verbose
+	});
+
+	return parseTaskResponse(result.output);
+}
+
+function runJudgePhase({ originalPrompt, judgePrompt, taskOutput, agentReportedChanges, commandTemplate, workspacePath, authoritativeWorkspacePath, timeoutMs, env }, verbose) {
+	const wrappedPrompt = [
+		'XDRS-CORE TEST PHASE: ASSERTION_EVALUATION',
+		'',
+		'You are evaluating the result of a separate agent task run.',
+		'Treat this as a fresh session. Do not assume any hidden history.',
+		'Use the original task prompt, the judge prompt, the final task output, the reported changed file paths, and the current workspace state to decide whether the result passes.',
+		'Trust the reported changed file path list as the authoritative change report for this task run.',
+		'Read files from the workspace directly when you need their contents.',
+		'Inspect files in the workspace directly when needed.',
+		'Respond with JSON only and no code fences.',
+		'Use exactly this schema: {"pass":true,"findings":[]} or {"pass":false,"findings":[{"target":"file","path":"relative/path.ext","line":1,"message":"explanation","assertionRef":"exact relevant phrase from the judge prompt"}]}.',
+		'Use target="output" when the issue is in the final task output and target="workspace" when it is not tied to a specific file.',
+		'Include 1-based line numbers when you cite a file or the output text. Include the exact judge-prompt phrase that triggered each finding in assertionRef.',
+		'',
+		'BEGIN ORIGINAL TASK PROMPT',
+		originalPrompt,
+		'END ORIGINAL TASK PROMPT',
+		'',
+		'BEGIN JUDGE PROMPT',
+		judgePrompt,
+		'END JUDGE PROMPT',
+		'',
+		'BEGIN TASK OUTPUT',
+		truncateText(taskOutput || '(empty)', MAX_TASK_OUTPUT_CHARS),
+		'END TASK OUTPUT',
+		'',
+		'BEGIN AGENT REPORTED CHANGES JSON',
+		JSON.stringify(agentReportedChanges, null, 2),
+		'END AGENT REPORTED CHANGES JSON'
+	].join('\n');
+
+	const result = runPromptCommand({
+		commandTemplate,
+		workspacePath,
+		authoritativeWorkspacePath,
+		prompt: wrappedPrompt,
+		timeoutMs,
+		env,
+		verbose
+	});
+
+	return normalizeJudgeResponse(result.output);
+}
+
+function parseTaskResponse(output) {
+	const trimmed = String(output || '').trim();
+	if (!trimmed) {
+		throw new Error('The task command returned empty output.');
+	}
+
+	try {
+		const parsed = parseJsonObject(trimmed);
+		return {
+			summary: typeof parsed.summary === 'string' && parsed.summary.trim()
+				? parsed.summary.trim()
+				: trimmed,
+			changedFiles: normalizeStringArray(parsed.changedFiles)
+		};
+	} catch (error) {
+		return {
+			summary: trimmed,
+			changedFiles: []
+		};
+	}
+}
+
+function normalizeJudgeResponse(output) {
+	let parsed;
+
+	try {
+		parsed = parseJsonObject(output);
+	} catch (error) {
+		throw new Error(`Judge returned invalid JSON: ${truncateText(String(output || '').trim(), 1000)}`);
+	}
+
+	if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+		throw new Error('Judge response must be a JSON object.');
+	}
+
+	if (typeof parsed.pass !== 'boolean') {
+		throw new Error('Judge response must include a boolean pass field.');
+	}
+
+	let findings = [];
+	if (Array.isArray(parsed.findings)) {
+		findings = parsed.findings.map(normalizeFinding).filter(Boolean);
+	} else if (Array.isArray(parsed.reasons)) {
+		findings = parsed.reasons
+			.filter((reason) => typeof reason === 'string' && reason.trim())
+			.map((reason) => ({
+				target: 'workspace',
+				message: reason.trim(),
+				path: null,
+				line: null,
+				assertionRef: ''
+			}));
+	}
+
+	if (!parsed.pass && findings.length === 0) {
+		findings = [{
+			target: 'workspace',
+			message: 'Judge reported failure without detailed findings.',
+			path: null,
+			line: null,
+			assertionRef: ''
+		}];
+	}
+
+	return {
+		pass: parsed.pass,
+		findings,
+		raw: parsed
+	};
+}
+
+function normalizeFinding(finding) {
+	if (!finding) {
+		return null;
+	}
+
+	if (typeof finding === 'string') {
+		const message = finding.trim();
+		return message ? {
+			target: 'workspace',
+			message,
+			path: null,
+			line: null,
+			assertionRef: ''
+		} : null;
+	}
+
+	if (typeof finding !== 'object' || Array.isArray(finding)) {
+		return null;
+	}
+
+	const message = typeof finding.message === 'string' ? finding.message.trim() : '';
+	if (!message) {
+		return null;
+	}
+
+	const pathValue = typeof finding.path === 'string' && finding.path.trim() ? finding.path.trim() : null;
+	const lineValue = normalizeLineNumber(finding.line);
+	const target = finding.target === 'file' || finding.target === 'output' || finding.target === 'workspace'
+		? finding.target
+		: (pathValue ? 'file' : 'workspace');
+
+	return {
+		target,
+		path: pathValue,
+		line: lineValue,
+		message,
+		assertionRef: typeof finding.assertionRef === 'string' ? finding.assertionRef.trim() : ''
+	};
+}
+
+function runPromptCommand({ commandTemplate, workspacePath, authoritativeWorkspacePath, prompt, timeoutMs, env }, verbose) {
+	const command = rewriteWorkspaceCommand(commandTemplate.map((entry) => entry
+		.replace('{PROMPT}', prompt)
+		.replace('{WORKSPACE_ROOT}', workspacePath)), workspacePath, authoritativeWorkspacePath);
+
+	const [file, ...args] = command;
+
+	if(verbose) {
+		console.log(`Running prompt cmd: ${file} ${args.join(' ')} in workspace: ${workspacePath}`);
+	}
+
+	const result = spawnSync(file, args, {
+		encoding: 'utf8',
+		cwd: workspacePath,
+		timeout: timeoutMs || undefined,
+		maxBuffer: 10 * 1024 * 1024,
+		env: {
+			...process.env,
+			...env
+		}
+	});
+
+	if(verbose) {
+		console.log(`Prompt command output: ${result.stdout || result.stderr}`);
+	}
+
+
+	if (result.error) {
+		if (result.error.code === 'ENOENT') {
+			throw new Error(`Command not found: ${file}`);
+		}
+		throw new Error(`Failed to execute ${file}: ${result.error.message}`);
+	}
+
+	if (result.status !== 0) {
+		const details = truncateText((result.stderr || result.stdout || '').trim(), 2000);
+		throw new Error(`${file} exited with status ${result.status}${details ? `: ${details}` : ''}`);
+	}
+
+	const output = (result.stdout || '').trim() || (result.stderr || '').trim();
+	if (!output) {
+		throw new Error(`${file} returned empty output.`);
+	}
+
+	if(verbose) {
+		console.log(`Prompt command output: ${output}`);
+	}
+
+	return { output };
+}
+
+function rewriteWorkspaceCommand(command, workspacePath, authoritativeWorkspacePath) {
+	if (!authoritativeWorkspacePath || path.resolve(workspacePath) === path.resolve(authoritativeWorkspacePath)) {
+		return command;
+	}
+
+	const normalizedAuthoritativeWorkspacePath = path.resolve(authoritativeWorkspacePath);
+	return command.map((entry, index, allEntries) => {
+		if (entry === '--add-dir' && typeof allEntries[index + 1] === 'string') {
+			return entry;
+		}
+
+		if (index > 0 && allEntries[index - 1] === '--add-dir' && path.resolve(entry) === normalizedAuthoritativeWorkspacePath) {
+			return workspacePath;
+		}
+
+		if (!entry.startsWith('--add-dir=')) {
+			return entry;
+		}
+
+		const addDirPath = entry.slice('--add-dir='.length);
+		if (path.resolve(addDirPath) !== normalizedAuthoritativeWorkspacePath) {
+			return entry;
+		}
+
+		return `--add-dir=${workspacePath}`;
+	});
+}
+
+function parseCommandTemplate(value, label) {
+	if (Array.isArray(value)) {
+		return normalizeCommandArray(value, label);
+	}
+
+	if (typeof value !== 'string' || !value.trim()) {
+		throw new Error(`Expected ${label} to be a non-empty JSON array string or string array.`);
+	}
+
+	let parsed;
+	try {
+		parsed = JSON.parse(value);
+	} catch (error) {
+		throw new Error(`${label} must be a JSON array string or a string array.`);
+	}
+
+	return normalizeCommandArray(parsed, label);
+}
+
+function normalizeCommandArray(value, label) {
+	if (!Array.isArray(value) || value.length === 0 || value.some((entry) => typeof entry !== 'string' || !entry)) {
+		throw new Error(`${label} must be a non-empty array of strings.`);
+	}
+
+	if (!value.some((entry) => entry.includes('{PROMPT}'))) {
+		throw new Error(`${label} must include a {PROMPT} placeholder.`);
+	}
+
+	return [...value];
+}
+
+function normalizeEnv(env) {
+	if (env == null) {
+		return {};
+	}
+
+	if (!env || typeof env !== 'object' || Array.isArray(env)) {
+		throw new Error('Expected env to be an object when provided.');
+	}
+
+	return { ...env };
+}
+
+function readTimeout(value, label) {
+	if (value == null) {
+		return 0;
+	}
+
+	const parsed = Number.parseInt(value, 10);
+	if (!Number.isFinite(parsed) || parsed < 0) {
+		throw new Error(`Invalid ${label} value: ${value}`);
+	}
+	return parsed;
+}
+
+function parseJsonObject(value) {
+	const trimmed = String(value || '').trim();
+	try {
+		return JSON.parse(trimmed);
+	} catch (error) {
+		const firstBrace = trimmed.indexOf('{');
+		const lastBrace = trimmed.lastIndexOf('}');
+		if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+			return JSON.parse(trimmed.slice(firstBrace, lastBrace + 1));
+		}
+		throw error;
+	}
+}
+
+function normalizeStringArray(values) {
+	if (!Array.isArray(values)) {
+		return [];
+	}
+
+	return [...new Set(values
+		.filter((value) => typeof value === 'string' && value.trim())
+		.map((value) => value.trim()))].sort((left, right) => left.localeCompare(right));
+}
+
+function normalizeLineNumber(value) {
+	const parsed = Number.parseInt(value, 10);
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : null;
+}
+
+function formatFailureMarkdown(findings) {
+	const normalizedFindings = Array.isArray(findings) && findings.length > 0
+		? findings
+		: [{ target: 'workspace', message: 'The prompt test failed without detailed findings.' }];
+
+	return normalizedFindings.map((finding) => {
+		const location = formatFindingLocation(finding);
+		const assertion = finding.assertionRef ? ` Assertion: "${finding.assertionRef}".` : '';
+		return `- [${location}] ${finding.message}${assertion}`;
+	}).join('\n');
+}
+
+function formatFindingLocation(finding) {
+	if (finding.target === 'output') {
+		return finding.line ? `output:${finding.line}` : 'output';
+	}
+
+	if (finding.path) {
+		return finding.line ? `${finding.path}:${finding.line}` : finding.path;
+	}
+
+	return 'workspace';
+}
+
+function findGitRoot(startPath) {
+	let currentPath = path.resolve(startPath);
+
+	while (true) {
+		if (fs.existsSync(path.join(currentPath, '.git'))) {
+			return currentPath;
+		}
+
+		const parentPath = path.dirname(currentPath);
+		if (parentPath === currentPath) {
+			return path.resolve(startPath);
+		}
+
+		currentPath = parentPath;
+	}
+}
+
+function copyWorkspace(sourcePath, targetPath, verbose) {
+	if(verbose) {
+		console.log(`Copying workspace from ${sourcePath} to ${targetPath}`);
+	}
+	fs.mkdirSync(targetPath, { recursive: true });
+	copyWorkspaceDirectory({
+		sourceDir: sourcePath,
+		targetDir: targetPath,
+		rootPath: sourcePath,
+		ignoreContexts: [],
+		activeRealDirectories: new Set()
+	});
+	return targetPath;
+}
+
+function copyWorkspaceDirectory({ sourceDir, targetDir, rootPath, ignoreContexts, activeRealDirectories }) {
+	const realSourceDir = fs.realpathSync(sourceDir);
+	if (activeRealDirectories.has(realSourceDir)) {
+		return;
+	}
+	activeRealDirectories.add(realSourceDir);
+
+	try {
+		const currentRelativeDir = toWorkspaceRelativePath(path.relative(rootPath, sourceDir));
+		const nextIgnoreContexts = loadGitignoreContext(sourceDir, currentRelativeDir, ignoreContexts);
+		const entries = fs.readdirSync(sourceDir, { withFileTypes: true });
+
+		for (const entry of entries) {
+			if (!shouldCopyWorkspaceEntry(entry.name)) {
+				continue;
+			}
+
+			const sourceEntryPath = path.join(sourceDir, entry.name);
+			const entryStats = entry.isSymbolicLink() ? fs.statSync(sourceEntryPath) : null;
+			const isDirectory = entry.isDirectory() || (entryStats && entryStats.isDirectory());
+			const isFile = entry.isFile() || (entryStats && entryStats.isFile());
+
+			if (!isDirectory && !isFile) {
+				continue;
+			}
+
+			const entryRelativePath = toWorkspaceRelativePath(path.relative(rootPath, sourceEntryPath));
+			const matchPath = isDirectory ? `${entryRelativePath}/` : entryRelativePath;
+			if (isGitignoredPath(matchPath, nextIgnoreContexts)) {
+				continue;
+			}
+
+			const targetEntryPath = path.join(targetDir, entry.name);
+			if (isDirectory) {
+				fs.mkdirSync(targetEntryPath, { recursive: true });
+				copyWorkspaceDirectory({
+					sourceDir: sourceEntryPath,
+					targetDir: targetEntryPath,
+					rootPath,
+					ignoreContexts: nextIgnoreContexts,
+					activeRealDirectories
+				});
+				continue;
+			}
+
+			fs.copyFileSync(sourceEntryPath, targetEntryPath);
+			fs.chmodSync(targetEntryPath, (entryStats || fs.statSync(sourceEntryPath)).mode);
+		}
+	} finally {
+		activeRealDirectories.delete(realSourceDir);
+	}
+}
+
+function loadGitignoreContext(sourceDir, currentRelativeDir, ignoreContexts) {
+	const gitignorePath = path.join(sourceDir, '.gitignore');
+	if (!fs.existsSync(gitignorePath) || !fs.statSync(gitignorePath).isFile()) {
+		return ignoreContexts;
+	}
+
+	const matcher = ignore();
+	matcher.add(fs.readFileSync(gitignorePath, 'utf8'));
+	return [...ignoreContexts, { basePath: currentRelativeDir, matcher }];
+}
+
+function isGitignoredPath(matchPath, ignoreContexts) {
+	let ignored = false;
+
+	for (const context of ignoreContexts) {
+		const relativeToContext = toContextRelativePath(matchPath, context.basePath);
+		if (relativeToContext == null) {
+			continue;
+		}
+
+		const result = context.matcher.checkIgnore(relativeToContext);
+		if (result.unignored) {
+			ignored = false;
+		}
+		if (result.ignored) {
+			ignored = true;
+		}
+	}
+
+	return ignored;
+}
+
+function toContextRelativePath(matchPath, basePath) {
+	const isDirectory = matchPath.endsWith('/');
+	const barePath = isDirectory ? matchPath.slice(0, -1) : matchPath;
+	const relativePath = basePath ? path.posix.relative(basePath, barePath) : barePath;
+
+	if (!relativePath || relativePath === '.' || relativePath === '..' || relativePath.startsWith('../')) {
+		return null;
+	}
+
+	return isDirectory ? `${relativePath}/` : relativePath;
+}
+
+function toWorkspaceRelativePath(relativePath) {
+	return relativePath ? relativePath.split(path.sep).join(path.posix.sep) : '';
+}
+
+function shouldCopyWorkspaceEntry(entryName) {
+	return !COPY_WORKSPACE_EXCLUDES.has(entryName);
+}
+
+const COPY_WORKSPACE_EXCLUDES = new Set([
+	'.git',
+	'.gitattributes',
+	'.gitignore',
+	'.gitmodules'
+]);
+
+function truncateText(value, maxLength) {
+	if (value.length <= maxLength) {
+		return value;
+	}
+	return `${value.slice(0, maxLength)}...`;
+}
+
+module.exports = {
+	testPrompt,
+	runPromptTest,
+	copilotCmd
+};

package/lib/testPrompt.test.js

@@ -0,0 +1,133 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const { copilotCmd, testPrompt } = require('./testPrompt');
+
+let TMP_ROOT;
+const COPILOT_DIR = path.join(__dirname, 'tests');
+
+beforeAll(() => {
+	TMP_ROOT = fs.mkdtempSync(path.join(os.tmpdir(), 'xdrs-core-fixtures-'));
+});
+
+afterAll(() => {
+	fs.rmSync(TMP_ROOT, { recursive: true, force: true });
+});
+
+test('passes a prompt test with copied workspace isolation', () => {
+	const workspaceRoot = createWorkspace('customer-pass');
+	const err = testPrompt(
+		createConfig(workspaceRoot),
+		'create a research about our customer base. We have 30% of customer > 50 years; 90% > 20',
+		'The resulting file should be created at customer-research.md and should not generate facts that are not present in the original prompt'
+	);
+
+	expect(err).toBe('');
+	expect(fs.existsSync(path.join(workspaceRoot, 'customer-research.md'))).toBe(false);
+});
+
+test('passes when ignored files and git metadata stay out of the copied workspace', () => {
+	const workspaceRoot = createWorkspace('ignore-pass', { withIgnoredEntries: true });
+	const err = testPrompt(
+		createConfig(workspaceRoot),
+		'create a note named summary.txt saying behavior ok',
+		'Verify if ignored/seed.txt, .git/config, and nested/.git/config are not available in the copied workspace and are not reported as changes'
+	);
+
+	expect(err).toBe('');
+	expect(fs.existsSync(path.join(workspaceRoot, 'summary.txt'))).toBe(false);
+	assertFileExists(path.join(workspaceRoot, 'ignored', 'seed.txt'));
+	assertFileExists(path.join(workspaceRoot, '.git', 'config'));
+	assertFileExists(path.join(workspaceRoot, 'nested', '.git', 'config'));
+});
+
+test('returns markdown findings when the judge rejects the result', () => {
+	const workspaceRoot = createWorkspace('failure-case');
+	const err = testPrompt(
+		createConfig(workspaceRoot),
+		'create a research about our customer base. We have 30% of customer > 50 years; 90% > 20',
+		'Verify if summary.txt exists and the final output mentions summary.txt'
+	);
+
+	expect(err).toContain('- [summary.txt] summary.txt should exist.');
+	expect(err).toContain('Assertion: "summary.txt exists".');
+	expect(err).toContain('- [output:1] The final output should mention summary.txt.');
+});
+
+test('does not create a temp workspace in in-place mode', () => {
+	const workspaceRoot = createWorkspace('in-place');
+	const mkdtempSpy = jest.spyOn(fs, 'mkdtempSync');
+
+	try {
+		const err = testPrompt(
+			createConfig(workspaceRoot, { workspaceMode: 'in-place' }),
+			'create a note named summary.txt saying behavior ok',
+			'Verify if summary.txt exists and the final output mentions summary.txt'
+		);
+
+		expect(err).toBe('');
+		expect(mkdtempSpy).not.toHaveBeenCalled();
+		expect(fs.existsSync(path.join(workspaceRoot, 'summary.txt'))).toBe(true);
+	} finally {
+		mkdtempSpy.mockRestore();
+	}
+});
+
+test('copilotCmd defaults to the git repository root', () => {
+	const command = copilotCmd();
+	const addDirArgument = command.find((entry) => entry.startsWith('--add-dir='));
+
+	expect(addDirArgument).toBe(`--add-dir=${path.resolve(__dirname, '..')}`);
+	const promptIndex = command.indexOf('-p');
+	expect(command[promptIndex + 1]).toBe('{PROMPT}');
+});
+
+test('judge phase reuses promptCmd even when judgeCmd is provided', () => {
+	const workspaceRoot = createWorkspace('judge-cmd-ignored');
+	const err = testPrompt(
+		createConfig(workspaceRoot, {
+			judgeCmd: ['missing-command', '{PROMPT}']
+		}),
+		'create a note named summary.txt saying behavior ok',
+		'Verify if summary.txt exists and the final output mentions summary.txt'
+	);
+
+	expect(err).toBe('');
+});
+
+	function createConfig(workspaceRoot, overrides = {}) {
+	return {
+		promptCmd: copilotCmd(workspaceRoot),
+		workspaceRoot,
+		workspaceMode: 'copy',
+		env: {
+			PATH: `${COPILOT_DIR}:${process.env.PATH}`
+		},
+		...overrides
+	};
+}
+
+function createWorkspace(name, options = {}) {
+	const workspaceRoot = path.join(TMP_ROOT, name);
+	fs.mkdirSync(workspaceRoot, { recursive: true });
+	fs.writeFileSync(path.join(workspaceRoot, 'seed.txt'), 'seed\n', 'utf8');
+
+	if (options.withIgnoredEntries) {
+		fs.writeFileSync(path.join(workspaceRoot, '.gitignore'), 'ignored/\n', 'utf8');
+		fs.mkdirSync(path.join(workspaceRoot, 'ignored'), { recursive: true });
+		fs.writeFileSync(path.join(workspaceRoot, 'ignored', 'seed.txt'), 'ignored seed\n', 'utf8');
+		fs.mkdirSync(path.join(workspaceRoot, '.git'), { recursive: true });
+		fs.writeFileSync(path.join(workspaceRoot, '.git', 'config'), 'git config\n', 'utf8');
+		fs.mkdirSync(path.join(workspaceRoot, 'nested', '.git'), { recursive: true });
+		fs.writeFileSync(path.join(workspaceRoot, 'nested', '.git', 'config'), 'nested git config\n', 'utf8');
+	}
+
+	return workspaceRoot;
+}
+
+function assertFileExists(filePath) {
+	expect(fs.existsSync(filePath)).toBe(true);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "xdrs-core",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "A standard way to organize Decision Records (XDRs) across scopes, subjects, and teams so that AI agents can reliably query and follow them.",
   "repository": {
     "type": "git",
@@ -13,16 +13,26 @@
     "ai-agents"
   ],
   "license": "MIT",
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "exports": {
+    ".": "./lib/index.js"
+  },
   "files": [
     ".xdrs/_core/**",
     ".xdrs/index.md",
     "package.json",
     "AGENTS.md",
     "bin/filedist.js",
-    "lib/**/*.js"
+	  "lib/**/*.js"
   ],
+  "devDependencies": {
+    "jest": "^29.7.0"
+  },
   "dependencies": {
-    "filedist": "^0.26.0"
+    "filedist": "^0.26.0",
+    "ignore": "^7.0.5",
+    "minimatch": "^10.2.5"
   },
   "filedist": {
     "sets": [
@@ -31,6 +41,10 @@
           "files": [
             "AGENTS.md",
             ".xdrs/_core/**"
+          ],
+          "exclude": [
+            "**/*.test.js",
+            "**/*.test.int.js"
           ]
         },
         "output": {