hadara 0.1.0-rc.0

package/dist/harness/validate.js

@@ -0,0 +1,465 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTaskCapsule = validateTaskCapsule;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const task_capsule_1 = require("../task/task-capsule");
+const REQUIRED_TASK_FILES = [
+    'TASK.md',
+    'PLAN.md',
+    'CONTEXT.md',
+    'FILES.md',
+    'ACCEPTANCE.md',
+    'TESTS.md',
+    'RISKS.md',
+    'DECISIONS.md',
+    'EVIDENCE.md',
+    'evidence.jsonl',
+    'HANDOFF.md'
+];
+const EVIDENCE_KINDS = new Set(['test-log', 'command-log', 'diff-summary', 'screenshot', 'note']);
+const EVIDENCE_RESULTS = new Set(['passed', 'failed', 'blocked', 'unknown']);
+const EVIDENCE_VISIBILITIES = new Set(['public', 'private']);
+function validateTaskCapsule(projectRoot, taskId, options = {}) {
+    const level = options.level ?? 'draft';
+    const task = findTask(projectRoot, taskId);
+    if (!task) {
+        return {
+            schemaVersion: 'hadara.harness.validate.v1',
+            command: 'harness.validate',
+            ok: false,
+            level,
+            task: { id: taskId, title: '', capsule: '' },
+            checkedFiles: [],
+            issues: [
+                {
+                    severity: 'error',
+                    code: 'TASK_NOT_FOUND',
+                    message: `Task Capsule not found: ${taskId}`
+                }
+            ]
+        };
+    }
+    const issues = [];
+    const checkedFiles = [];
+    for (const fileName of REQUIRED_TASK_FILES) {
+        const filePath = node_path_1.default.join(task.dir, fileName);
+        const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, filePath));
+        checkedFiles.push(relativePath);
+        if (!node_fs_1.default.existsSync(filePath)) {
+            issues.push({
+                severity: 'error',
+                code: 'MISSING_TASK_FILE',
+                message: `Required Task Capsule file is missing: ${fileName}`,
+                path: relativePath
+            });
+        }
+    }
+    validateTaskMarkdown(projectRoot, task, issues);
+    validateCapsuleFormatMarkdown(projectRoot, task, issues);
+    validateEvidenceMarkdown(projectRoot, task, issues);
+    validateEvidenceIndex(projectRoot, task, issues);
+    if (level === 'done') {
+        validateDoneLevel(projectRoot, task, issues, checkedFiles);
+    }
+    return {
+        schemaVersion: 'hadara.harness.validate.v1',
+        command: 'harness.validate',
+        ok: !issues.some((issue) => issue.severity === 'error'),
+        level,
+        task: {
+            id: task.id,
+            title: task.title,
+            capsule: toPortablePath(node_path_1.default.relative(projectRoot, task.dir))
+        },
+        checkedFiles,
+        issues
+    };
+}
+function findTask(projectRoot, taskId) {
+    return (0, task_capsule_1.listTaskCapsules)(projectRoot).find((task) => task.id === taskId);
+}
+function validateTaskMarkdown(projectRoot, task, issues) {
+    const taskPath = node_path_1.default.join(task.dir, 'TASK.md');
+    if (!node_fs_1.default.existsSync(taskPath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, taskPath));
+    const content = node_fs_1.default.readFileSync(taskPath, 'utf8');
+    for (const heading of ['## Goal', '## Scope', '## Out of Scope', '## Status']) {
+        if (!content.includes(heading)) {
+            issues.push({
+                severity: 'error',
+                code: 'TASK_SECTION_MISSING',
+                message: `TASK.md is missing required section: ${heading}`,
+                path: relativePath
+            });
+        }
+    }
+}
+function validateCapsuleFormatMarkdown(projectRoot, task, issues) {
+    validateMarkdownFile(projectRoot, task, issues, 'ACCEPTANCE.md', [
+        { code: 'ACCEPTANCE_HEADING_INVALID', anyText: ['# Acceptance Criteria'] },
+        { code: 'ACCEPTANCE_CHECKLIST_MISSING', anyText: ['- [ ]', '- [x]'] }
+    ]);
+    validateMarkdownFile(projectRoot, task, issues, 'FILES.md', [
+        { code: 'FILES_TABLE_INVALID', anyText: ['| Path | Action | Reason |'] },
+        { code: 'FILES_TABLE_INVALID', anyText: ['|---|---|---|'] }
+    ]);
+    validateMarkdownFile(projectRoot, task, issues, 'TESTS.md', [
+        { code: 'TESTS_SECTION_MISSING', anyText: ['## Required'] },
+        { code: 'TESTS_SECTION_MISSING', anyText: ['## Optional'] }
+    ]);
+    validateMarkdownFile(projectRoot, task, issues, 'RISKS.md', [
+        { code: 'RISKS_TABLE_INVALID', anyText: ['| Risk | Mitigation |'] },
+        { code: 'RISKS_TABLE_INVALID', anyText: ['|---|---|'] }
+    ]);
+    validateMarkdownFile(projectRoot, task, issues, 'HANDOFF.md', [
+        { code: 'HANDOFF_SECTION_MISSING', anyText: ['## Last Completed'] },
+        { code: 'HANDOFF_SECTION_MISSING', anyText: ['## Next Recommended Step'] }
+    ]);
+}
+function validateMarkdownFile(projectRoot, task, issues, fileName, checks) {
+    const filePath = node_path_1.default.join(task.dir, fileName);
+    if (!node_fs_1.default.existsSync(filePath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, filePath));
+    const content = node_fs_1.default.readFileSync(filePath, 'utf8');
+    for (const check of checks) {
+        if (!check.anyText.some((text) => content.includes(text))) {
+            issues.push({
+                severity: 'error',
+                code: check.code,
+                message: `${fileName} is missing standard Task Capsule format marker: ${check.anyText.join(' or ')}`,
+                path: relativePath
+            });
+        }
+    }
+}
+function validateEvidenceMarkdown(projectRoot, task, issues) {
+    const evidencePath = node_path_1.default.join(task.dir, 'EVIDENCE.md');
+    if (!node_fs_1.default.existsSync(evidencePath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, evidencePath));
+    const lines = node_fs_1.default.readFileSync(evidencePath, 'utf8').split(/\r?\n/);
+    const headerIndex = lines.findIndex((line) => line.trim() === '| Time | Kind | Summary | Result |');
+    if (headerIndex < 0 || lines[headerIndex + 1]?.trim() !== '|---|---|---|---|') {
+        issues.push({
+            severity: 'error',
+            code: 'EVIDENCE_TABLE_INVALID',
+            message: 'EVIDENCE.md must contain the standard evidence table header.',
+            path: relativePath
+        });
+    }
+}
+function validateEvidenceIndex(projectRoot, task, issues) {
+    const indexPath = node_path_1.default.join(task.dir, 'evidence.jsonl');
+    if (!node_fs_1.default.existsSync(indexPath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, indexPath));
+    const content = node_fs_1.default.readFileSync(indexPath, 'utf8').trim();
+    if (!content)
+        return;
+    content.split(/\r?\n/).forEach((line, index) => {
+        try {
+            const record = JSON.parse(line);
+            if (record.schemaVersion !== 'hadara.evidence.v1') {
+                issues.push({
+                    severity: 'error',
+                    code: 'EVIDENCE_INDEX_SCHEMA_INVALID',
+                    message: `evidence.jsonl line ${index + 1} has an unsupported schemaVersion.`,
+                    path: relativePath
+                });
+            }
+            if (record.taskId !== task.id || typeof record.kind !== 'string' || typeof record.result !== 'string') {
+                issues.push({
+                    severity: 'error',
+                    code: 'EVIDENCE_INDEX_RECORD_INVALID',
+                    message: `evidence.jsonl line ${index + 1} is missing required evidence fields.`,
+                    path: relativePath
+                });
+            }
+            if (typeof record.time !== 'string' || !record.time.trim()) {
+                issues.push({
+                    severity: 'error',
+                    code: 'EVIDENCE_INDEX_TIME_MISSING',
+                    message: `evidence.jsonl line ${index + 1} is missing required time.`,
+                    path: relativePath
+                });
+            }
+            if (typeof record.summary !== 'string' || !record.summary.trim()) {
+                issues.push({
+                    severity: 'error',
+                    code: 'EVIDENCE_INDEX_SUMMARY_MISSING',
+                    message: `evidence.jsonl line ${index + 1} is missing required summary.`,
+                    path: relativePath
+                });
+            }
+            if (typeof record.visibility !== 'string') {
+                issues.push({
+                    severity: 'error',
+                    code: 'EVIDENCE_INDEX_VISIBILITY_MISSING',
+                    message: `evidence.jsonl line ${index + 1} is missing required visibility.`,
+                    path: relativePath
+                });
+            }
+            if ((typeof record.kind === 'string' && !EVIDENCE_KINDS.has(record.kind)) ||
+                (typeof record.result === 'string' && !EVIDENCE_RESULTS.has(record.result)) ||
+                (typeof record.visibility === 'string' && !EVIDENCE_VISIBILITIES.has(record.visibility))) {
+                issues.push({
+                    severity: 'error',
+                    code: 'EVIDENCE_INDEX_ENUM_INVALID',
+                    message: `evidence.jsonl line ${index + 1} has an unsupported evidence enum value.`,
+                    path: relativePath
+                });
+            }
+        }
+        catch {
+            issues.push({
+                severity: 'error',
+                code: 'EVIDENCE_INDEX_JSON_INVALID',
+                message: `evidence.jsonl line ${index + 1} is not valid JSON.`,
+                path: relativePath
+            });
+        }
+    });
+}
+function validateDoneLevel(projectRoot, task, issues, checkedFiles) {
+    validateTaskStatusDone(projectRoot, task, issues);
+    validateDoneLevelScaffoldContent(projectRoot, task, issues);
+    validateAcceptanceDone(projectRoot, task, issues);
+    validateEvidenceMarkdownSingleTable(projectRoot, task, issues);
+    validateEvidenceIndexHasRecords(projectRoot, task, issues);
+    validateHandoffDone(projectRoot, task, issues);
+    validateTaskBoardDone(projectRoot, task, issues, checkedFiles);
+}
+function validateTaskStatusDone(projectRoot, task, issues) {
+    const taskPath = node_path_1.default.join(task.dir, 'TASK.md');
+    if (!node_fs_1.default.existsSync(taskPath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, taskPath));
+    const status = readSectionBody(taskPath, '## Status');
+    if (!/^Done\b/i.test(status.trim())) {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_STATUS_NOT_DONE',
+            message: 'Done-level validation requires TASK.md status to be Done.',
+            path: relativePath
+        });
+    }
+}
+function validateAcceptanceDone(projectRoot, task, issues) {
+    const acceptancePath = node_path_1.default.join(task.dir, 'ACCEPTANCE.md');
+    if (!node_fs_1.default.existsSync(acceptancePath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, acceptancePath));
+    const checklistLines = node_fs_1.default
+        .readFileSync(acceptancePath, 'utf8')
+        .split(/\r?\n/)
+        .filter((line) => /^-\s+\[[ xX]\]/.test(line.trim()));
+    if (checklistLines.length === 0 || checklistLines.some((line) => /^-\s+\[\s\]/.test(line.trim()))) {
+        issues.push({
+            severity: 'error',
+            code: 'ACCEPTANCE_INCOMPLETE',
+            message: 'Done-level validation requires all acceptance checkboxes to be checked.',
+            path: relativePath
+        });
+    }
+}
+function validateDoneLevelScaffoldContent(projectRoot, task, issues) {
+    const checks = [
+        {
+            fileName: 'TASK.md',
+            code: 'TASK_SCAFFOLD_PLACEHOLDER',
+            message: 'Done-level validation requires TASK.md Goal, Scope, and Out of Scope to replace scaffold placeholders.'
+        },
+        {
+            fileName: 'PLAN.md',
+            code: 'PLAN_SCAFFOLD_UNCHANGED',
+            message: 'Done-level validation requires PLAN.md to replace the default scaffold plan.'
+        },
+        {
+            fileName: 'CONTEXT.md',
+            code: 'CONTEXT_SCAFFOLD_UNCHANGED',
+            message: 'Done-level validation requires CONTEXT.md to contain task-specific context.'
+        },
+        {
+            fileName: 'FILES.md',
+            code: 'FILES_SCAFFOLD_UNCHANGED',
+            message: 'Done-level validation requires FILES.md to list touched files or explain that no files changed.'
+        },
+        {
+            fileName: 'ACCEPTANCE.md',
+            code: 'ACCEPTANCE_SCAFFOLD_UNCHANGED',
+            message: 'Done-level validation requires ACCEPTANCE.md to replace the default checklist items.'
+        },
+        {
+            fileName: 'TESTS.md',
+            code: 'TESTS_SCAFFOLD_UNCHANGED',
+            message: 'Done-level validation requires TESTS.md to replace the default npm test/npm run check scaffold.'
+        },
+        {
+            fileName: 'RISKS.md',
+            code: 'RISKS_SCAFFOLD_UNCHANGED',
+            message: 'Done-level validation requires RISKS.md to list risks or record why no material risks remain.'
+        },
+        {
+            fileName: 'DECISIONS.md',
+            code: 'DECISIONS_SCAFFOLD_UNCHANGED',
+            message: 'Done-level validation requires DECISIONS.md to replace the default scaffold note.'
+        },
+        {
+            fileName: 'EVIDENCE.md',
+            code: 'EVIDENCE_SCAFFOLD_UNCHANGED',
+            message: 'Done-level validation requires EVIDENCE.md to contain at least one evidence table row.'
+        }
+    ];
+    for (const check of checks) {
+        const filePath = node_path_1.default.join(task.dir, check.fileName);
+        if (!node_fs_1.default.existsSync(filePath))
+            continue;
+        const content = node_fs_1.default.readFileSync(filePath, 'utf8');
+        if ((0, task_capsule_1.isTaskCapsuleScaffoldContent)(task, check.fileName, content)) {
+            issues.push({
+                severity: 'error',
+                code: check.code,
+                message: check.message,
+                path: toPortablePath(node_path_1.default.relative(projectRoot, filePath))
+            });
+        }
+    }
+}
+function validateEvidenceIndexHasRecords(projectRoot, task, issues) {
+    const indexPath = node_path_1.default.join(task.dir, 'evidence.jsonl');
+    if (!node_fs_1.default.existsSync(indexPath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, indexPath));
+    if (!node_fs_1.default.readFileSync(indexPath, 'utf8').trim()) {
+        issues.push({
+            severity: 'error',
+            code: 'EVIDENCE_REQUIRED',
+            message: 'Done-level validation requires at least one evidence.jsonl record.',
+            path: relativePath
+        });
+    }
+}
+function validateEvidenceMarkdownSingleTable(projectRoot, task, issues) {
+    const evidencePath = node_path_1.default.join(task.dir, 'EVIDENCE.md');
+    if (!node_fs_1.default.existsSync(evidencePath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, evidencePath));
+    const lines = node_fs_1.default.readFileSync(evidencePath, 'utf8').split(/\r?\n/);
+    const tableHeaderCount = lines.filter((line, index) => line.trim() === '| Time | Kind | Summary | Result |' && lines[index + 1]?.trim() === '|---|---|---|---|').length;
+    if (tableHeaderCount > 1) {
+        issues.push({
+            severity: 'error',
+            code: 'EVIDENCE_TABLE_DUPLICATE_HEADER',
+            message: `Done-level validation requires EVIDENCE.md to contain exactly one evidence table header; found ${tableHeaderCount}.`,
+            path: relativePath
+        });
+    }
+}
+function validateHandoffDone(projectRoot, task, issues) {
+    const handoffPath = node_path_1.default.join(task.dir, 'HANDOFF.md');
+    if (!node_fs_1.default.existsSync(handoffPath))
+        return;
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, handoffPath));
+    const lastCompleted = readSectionBody(handoffPath, '## Last Completed').trim();
+    const nextStep = readSectionBody(handoffPath, '## Next Recommended Step').trim();
+    if (isPlaceholderSection(lastCompleted) || isPlaceholderSection(nextStep)) {
+        issues.push({
+            severity: 'error',
+            code: 'HANDOFF_PLACEHOLDER',
+            message: 'Done-level validation requires non-placeholder handoff sections.',
+            path: relativePath
+        });
+    }
+}
+function validateTaskBoardDone(projectRoot, task, issues, checkedFiles) {
+    const taskBoardPath = node_path_1.default.join(projectRoot, 'docs', 'TASK_BOARD.md');
+    const relativePath = toPortablePath(node_path_1.default.relative(projectRoot, taskBoardPath));
+    checkedFiles.push(relativePath);
+    if (!node_fs_1.default.existsSync(taskBoardPath)) {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_BOARD_MISSING',
+            message: 'Done-level validation requires docs/TASK_BOARD.md to contain the completed task row.',
+            path: relativePath
+        });
+        return;
+    }
+    const rows = parseTaskBoardRows(node_fs_1.default.readFileSync(taskBoardPath, 'utf8')).filter((row) => row.id === task.id);
+    if (rows.length === 0) {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_BOARD_ROW_MISSING',
+            message: `Done-level validation requires docs/TASK_BOARD.md to contain exactly one row for ${task.id}.`,
+            path: relativePath
+        });
+        return;
+    }
+    if (rows.length > 1) {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_BOARD_ROW_DUPLICATE',
+            message: `docs/TASK_BOARD.md contains ${rows.length} rows for ${task.id}; expected exactly one.`,
+            path: relativePath
+        });
+        return;
+    }
+    const row = rows[0];
+    const expectedCapsule = toPortablePath(node_path_1.default.relative(projectRoot, task.dir));
+    if (row.status !== 'Done') {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_BOARD_STATUS_NOT_DONE',
+            message: `Done-level validation requires docs/TASK_BOARD.md status for ${task.id} to be Done.`,
+            path: relativePath
+        });
+    }
+    if (row.capsule !== expectedCapsule) {
+        issues.push({
+            severity: 'error',
+            code: 'TASK_BOARD_CAPSULE_MISMATCH',
+            message: `docs/TASK_BOARD.md capsule for ${task.id} is ${row.capsule || '(empty)'}, expected ${expectedCapsule}.`,
+            path: relativePath
+        });
+    }
+}
+function parseTaskBoardRows(content) {
+    return content
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => /^\|\s*T-\d{4}\s*\|/.test(line))
+        .map((line) => {
+        const cells = line
+            .slice(1, line.endsWith('|') ? -1 : undefined)
+            .split('|')
+            .map((cell) => cell.trim());
+        return {
+            id: cells[0] ?? '',
+            title: cells[1] ?? '',
+            status: cells[2] ?? '',
+            capsule: cells[3] ?? '',
+            notes: cells[4] ?? ''
+        };
+    });
+}
+function readSectionBody(filePath, heading) {
+    const content = node_fs_1.default.readFileSync(filePath, 'utf8');
+    const start = content.indexOf(heading);
+    if (start < 0)
+        return '';
+    const afterHeading = content.slice(start + heading.length);
+    const nextHeading = afterHeading.search(/\n##\s+/);
+    return nextHeading >= 0 ? afterHeading.slice(0, nextHeading) : afterHeading;
+}
+function isPlaceholderSection(value) {
+    const normalized = value.trim();
+    return normalized.length === 0 || /^TBD\.?$/i.test(normalized);
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/hermes/context-export.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectHermesContext = detectHermesContext;
+exports.buildHadaraContextContent = buildHadaraContextContent;
+exports.createContextExportReport = createContextExportReport;
+exports.exportHadaraContext = exportHadaraContext;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("../core/fs");
+const HERMES_CONTEXT_FILES = ['AGENTS.md', '.hermes.md', 'HERMES.md', 'CLAUDE.md', '.cursorrules'];
+const CONTEXT_OUTPUT_PATH = '.hadara/context/HADARA_CONTEXT.md';
+function detectHermesContext(projectRoot) {
+    const found = [];
+    const missing = [];
+    for (const file of HERMES_CONTEXT_FILES) {
+        const filePath = node_path_1.default.join(projectRoot, file);
+        if (node_fs_1.default.existsSync(filePath))
+            found.push(file);
+        else
+            missing.push(file);
+    }
+    return { found, missing };
+}
+function buildHadaraContextContent(projectRoot) {
+    const sourceFiles = [
+        'docs/PROJECT_STATE.md',
+        'docs/AGENT_HANDOFF.md',
+        'docs/IMPLEMENTATION_SOP.md',
+        'docs/TASK_BOARD.md',
+        'docs/ROADMAP.md',
+        'docs/DEVELOPMENT_SLICES.md',
+        'docs/CLI_JSON_CONTRACT.md',
+        'docs/MCP_BRIDGE_CONTRACT.md',
+        'docs/MCP_EVIDENCE_ATTACH_CONTRACT.md',
+        'docs/ARCHITECTURE.md',
+        'docs/SECURITY_MODEL.md',
+        'docs/TEST_STRATEGY.md'
+    ];
+    const sections = sourceFiles.map((relativePath) => {
+        const content = (0, fs_1.readTextIfExists)(node_path_1.default.join(projectRoot, relativePath)) ?? '_Missing._';
+        return `## ${relativePath}\n\n${content}`;
+    });
+    const output = `# HADARA_CONTEXT
+
+This file is generated by HADARA for Hermes Agent and external agent-harness compatibility.
+Do not treat this file as the source of truth; prefer HADARA CLI JSON, MCP read tools, and the referenced docs.
+Follow docs/IMPLEMENTATION_SOP.md for implementation, validation, and session-end procedure.
+
+Agents must:
+1. Preserve the portable/project store boundary.
+2. Work inside the active Task Capsule.
+3. Attach evidence before marking work complete.
+4. Update AGENT_HANDOFF.md before stopping.
+5. Respect policy decisions for shell/file/git operations.
+6. Treat AGENT_HANDOFF.md as compact current state and follow its Historical Index for older history.
+7. Prefer stable HADARA read surfaces before scraping raw files: use hadara.project.state.read or hadara status --json for project state.
+8. Use hadara.task.list and hadara.task.read, or hadara task list --json and hadara task show <task-id> --json, for task state.
+9. Use hadara.handoff.read, hadara.policy.evaluate, and hadara.harness.validate, or their CLI JSON equivalents, for handoff, policy, and validation state.
+10. Use hadara.context.export for in-memory MCP context export; only hadara hermes export-context writes .hadara/context/HADARA_CONTEXT.md.
+11. Treat MCP default mode as read-only; do not assume MCP task mutation, file writes, shell execution, or release/package execution exists.
+12. If MCP is unavailable, fall back to CLI JSON commands and then to repository documents.
+13. Respect the single active agent/session model; do not assume queues, worker lanes, or multi-agent concurrent execution.
+14. Treat policy.evaluate as policy evaluation only, not MCP execution authorization.
+15. Treat MCP evidence attachment as disabled by default; it requires explicit server opt-in, per-call approval metadata, and private audit logging.
+
+${sections.join('\n\n---\n\n')}
+`;
+    return output;
+}
+function createContextExportReport(projectRoot, options = {}) {
+    const format = options.format ?? 'markdown';
+    const markdown = buildHadaraContextContent(projectRoot);
+    const content = format === 'json' ? JSON.stringify({ schemaVersion: 'hadara.context.content.v1', summaryOnly: options.summaryOnly === true, markdown }) : markdown;
+    const issues = options.summaryOnly === true
+        ? [
+            {
+                severity: 'warning',
+                code: 'SUMMARY_ONLY_NOT_IMPLEMENTED',
+                message: 'summaryOnly is accepted for forward compatibility but currently returns the full context.'
+            }
+        ]
+        : [];
+    return {
+        schemaVersion: 'hadara.context.export.v1',
+        command: 'context.export',
+        ok: true,
+        format,
+        mode: 'memory',
+        content,
+        contextPath: null,
+        wouldWritePath: CONTEXT_OUTPUT_PATH,
+        issues
+    };
+}
+function exportHadaraContext(projectRoot) {
+    const contextDir = node_path_1.default.join(projectRoot, '.hadara', 'context');
+    (0, fs_1.ensureDir)(contextDir);
+    const outputPath = node_path_1.default.join(projectRoot, CONTEXT_OUTPUT_PATH);
+    node_fs_1.default.writeFileSync(outputPath, buildHadaraContextContent(projectRoot), 'utf8');
+    return outputPath;
+}

package/dist/index.js

@@ -0,0 +1,29 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./core/paths"), exports);
+__exportStar(require("./core/redaction"), exports);
+__exportStar(require("./core/workspace"), exports);
+__exportStar(require("./cli/args"), exports);
+__exportStar(require("./providers/provider-contract"), exports);
+__exportStar(require("./providers/mock-provider"), exports);
+__exportStar(require("./providers/provider-preparation"), exports);
+__exportStar(require("./task/task-capsule"), exports);
+__exportStar(require("./evidence/evidence"), exports);
+__exportStar(require("./handoff/handoff"), exports);
+__exportStar(require("./tools/fake-shell"), exports);
+__exportStar(require("./agent/loop"), exports);
+__exportStar(require("./agent/evidence"), exports);