hadara 0.3.2 → 0.3.3-rc.0

package/dist/context/registry-extractors.js

@@ -0,0 +1,177 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractDocsRegistry = extractDocsRegistry;
+exports.extractCommandRegistry = extractCommandRegistry;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const extractor_contract_1 = require("./extractor-contract");
+const docs_registry_1 = require("../services/docs-registry");
+const capability_registry_1 = require("../services/capability-registry");
+const COMMAND_REGISTRY_SOURCE_PATH = 'src/services/capability-registry.ts';
+function extractDocsRegistry(projectRoot) {
+    const absolutePath = node_path_1.default.join(projectRoot, docs_registry_1.DOCS_REGISTRY_PATH);
+    const content = readOptionalText(absolutePath);
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractDocsRegistry', [{ path: docs_registry_1.DOCS_REGISTRY_PATH, content }]);
+    if (content == null) {
+        result.issues.push({
+            severity: 'warning',
+            code: 'CONTEXT_GRAPH_DOC_REGISTRY_MISSING',
+            path: docs_registry_1.DOCS_REGISTRY_PATH,
+            message: '.hadara/docs-registry.json is missing; Document nodes cannot be extracted from registry metadata.',
+            fixHint: 'Restore the docs registry artifact or run the scoped docs registry workflow before relying on document context routing.'
+        });
+        return result;
+    }
+    let registry;
+    try {
+        registry = JSON.parse(content);
+    }
+    catch (error) {
+        result.issues.push(parseFailedIssue(docs_registry_1.DOCS_REGISTRY_PATH, `.hadara/docs-registry.json could not be parsed: ${error instanceof Error ? error.message : String(error)}`));
+        return result;
+    }
+    const sourceHash = (0, extractor_contract_1.hashContextGraphText)(content);
+    const source = (0, extractor_contract_1.createContextGraphSourceRef)({
+        path: docs_registry_1.DOCS_REGISTRY_PATH,
+        extractor: 'extractDocsRegistry',
+        line: 1,
+        hash: sourceHash
+    });
+    const documents = Array.isArray(registry.documents) ? registry.documents : [];
+    result.nodes.push(...documents.map((doc) => documentNode(doc, source)));
+    result.edges.push(...documents.flatMap((doc) => documentEdges(doc, source)));
+    result.stateSources?.push(docsRegistryStateSource(documents, sourceHash));
+    return result;
+}
+function extractCommandRegistry(projectRoot) {
+    const absolutePath = node_path_1.default.join(projectRoot, COMMAND_REGISTRY_SOURCE_PATH);
+    const content = readOptionalText(absolutePath);
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractCommandRegistry', [{ path: COMMAND_REGISTRY_SOURCE_PATH, content }]);
+    const sourceHash = content == null ? undefined : (0, extractor_contract_1.hashContextGraphText)(content);
+    if (content == null) {
+        result.issues.push({
+            severity: 'warning',
+            code: 'CONTEXT_GRAPH_COMMAND_REGISTRY_MISSING',
+            path: COMMAND_REGISTRY_SOURCE_PATH,
+            message: 'Command registry source file is missing; command metadata is still available from the loaded runtime registry but source hash is unavailable.',
+            fixHint: 'Restore src/services/capability-registry.ts in source checkouts before relying on source-addressed command context.'
+        });
+    }
+    const source = (0, extractor_contract_1.createContextGraphSourceRef)({
+        path: COMMAND_REGISTRY_SOURCE_PATH,
+        extractor: 'extractCommandRegistry',
+        line: 1,
+        ...(sourceHash ? { hash: sourceHash } : {})
+    });
+    const commands = (0, capability_registry_1.listCommandRegistryEntries)();
+    result.nodes.push(...commands.map((entry) => commandNode(entry, source)));
+    result.edges.push(...commands.flatMap((entry) => commandDocEdges(entry, source)));
+    return result;
+}
+function documentNode(doc, source) {
+    return {
+        id: (0, extractor_contract_1.createDocumentNodeId)(doc.path),
+        type: 'Document',
+        label: doc.title || doc.path,
+        path: (0, extractor_contract_1.normalizeContextGraphPath)(doc.path),
+        status: doc.status,
+        kind: doc.kind,
+        owner: doc.owner,
+        metadata: {
+            requiredReading: doc.requiredReading,
+            readWhen: doc.readWhen,
+            scope: doc.scope,
+            updateOwner: doc.updateOwner,
+            closeSourceRole: doc.closeSourceRole,
+            supersedes: doc.supersedes,
+            supersededBy: doc.supersededBy ?? null
+        },
+        source
+    };
+}
+function documentEdges(doc, source) {
+    const from = (0, extractor_contract_1.createDocumentNodeId)(doc.path);
+    const edges = [];
+    for (const targetPath of doc.supersedes ?? []) {
+        const to = (0, extractor_contract_1.createDocumentNodeId)(targetPath);
+        edges.push(edge('SUPERSEDES', from, to, source, `${doc.path} supersedes ${targetPath}.`));
+    }
+    if (doc.supersededBy) {
+        const to = (0, extractor_contract_1.createDocumentNodeId)(doc.supersededBy);
+        edges.push(edge('SUPERSEDES', to, from, source, `${doc.supersededBy} supersedes ${doc.path}.`));
+    }
+    return edges;
+}
+function commandNode(entry, source) {
+    return {
+        id: (0, extractor_contract_1.createCommandNodeId)(entry.id),
+        type: 'Command',
+        label: entry.id,
+        status: entry.status,
+        kind: entry.family,
+        owner: entry.actor,
+        metadata: {
+            command: entry.command,
+            summary: entry.summary,
+            canonical: entry.canonical,
+            aliasFor: entry.aliasFor ?? null,
+            scope: entry.scope,
+            lifecycleStage: entry.lifecycleStage,
+            requiredness: entry.requiredness,
+            writeBoundary: entry.writeBoundary,
+            readOnly: entry.readOnly,
+            risk: entry.risk,
+            schemaVersion: entry.schemaVersion ?? null,
+            implementationFiles: entry.implementationFiles ?? [],
+            testFiles: entry.testFiles ?? [],
+            docs: entry.docs,
+            related: entry.related
+        },
+        source
+    };
+}
+function commandDocEdges(entry, source) {
+    return entry.docs.map((docPath) => edge('DESCRIBES_COMMAND', (0, extractor_contract_1.createDocumentNodeId)(docPath), (0, extractor_contract_1.createCommandNodeId)(entry.id), source, `${docPath} documents command ${entry.id}.`));
+}
+function docsRegistryStateSource(documents, sourceHash) {
+    return {
+        id: 'state-source:docs-registry',
+        path: docs_registry_1.DOCS_REGISTRY_PATH,
+        kind: 'docs-registry',
+        hash: sourceHash,
+        extracted: {
+            documents: documents.length,
+            requiredReading: documents.filter((doc) => doc.requiredReading).length,
+            statusCounts: documents.reduce((counts, doc) => {
+                counts[doc.status] = (counts[doc.status] ?? 0) + 1;
+                return counts;
+            }, {})
+        }
+    };
+}
+function edge(type, from, to, source, reason) {
+    return {
+        id: (0, extractor_contract_1.createContextGraphEdgeId)({ type, from, to, source, reason }),
+        from,
+        to,
+        type,
+        confidence: 'explicit',
+        reason,
+        source
+    };
+}
+function readOptionalText(absolutePath) {
+    return node_fs_1.default.existsSync(absolutePath) ? node_fs_1.default.readFileSync(absolutePath, 'utf8') : null;
+}
+function parseFailedIssue(relativePath, message) {
+    return {
+        severity: 'warning',
+        code: 'CONTEXT_GRAPH_PARSE_FAILED',
+        path: relativePath,
+        message,
+        fixHint: `Repair ${relativePath} before relying on context graph extraction for this source.`
+    };
+}

package/dist/context/release-extractors.js

@@ -0,0 +1,175 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractReleaseReadiness = extractReleaseReadiness;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const extractor_contract_1 = require("./extractor-contract");
+const capability_registry_1 = require("../services/capability-registry");
+const RELEASE_READINESS_PATH = 'docs/RELEASE_READINESS.md';
+const EVIDENCE_ID_PATTERN = /\bev:T-\d{4}:[a-f0-9]{24,64}\b/g;
+function extractReleaseReadiness(projectRoot) {
+    const content = readOptionalText(node_path_1.default.join(projectRoot, RELEASE_READINESS_PATH));
+    const result = (0, extractor_contract_1.createEmptyExtractionResult)('extractReleaseReadiness', [{ path: RELEASE_READINESS_PATH, content }]);
+    if (content == null) {
+        result.issues.push({
+            severity: 'warning',
+            code: 'CONTEXT_GRAPH_SOURCE_MISSING',
+            path: RELEASE_READINESS_PATH,
+            message: 'docs/RELEASE_READINESS.md is missing; ReleaseCheck nodes cannot be extracted.',
+            fixHint: 'Restore docs/RELEASE_READINESS.md before relying on release-readiness context routing.'
+        });
+        return result;
+    }
+    const sourceHash = (0, extractor_contract_1.hashContextGraphText)(content);
+    const commandEntries = (0, capability_registry_1.listCommandRegistryEntries)();
+    const sections = parseReleaseReadinessSections(content);
+    for (const section of sections) {
+        const source = (0, extractor_contract_1.createContextGraphSourceRef)({
+            path: RELEASE_READINESS_PATH,
+            extractor: 'extractReleaseReadiness',
+            line: section.startLine,
+            hash: sourceHash
+        });
+        const checkNodeId = (0, extractor_contract_1.createReleaseCheckNodeId)(section.title);
+        const commandMentions = findCommandMentions(section.text, commandEntries);
+        const evidenceIds = findEvidenceIds(section.text);
+        result.nodes.push(releaseCheckNode(section, source, commandMentions, evidenceIds));
+        result.edges.push(edge('BELONGS_TO_DOCUMENT', checkNodeId, (0, extractor_contract_1.createDocumentNodeId)(RELEASE_READINESS_PATH), source, `${section.title} is defined in ${RELEASE_READINESS_PATH}.`));
+        for (const mention of commandMentions) {
+            result.edges.push(edge('CHECKS_COMMAND', checkNodeId, (0, extractor_contract_1.createCommandNodeId)(mention.commandId), source, `${section.title} explicitly references command ${mention.commandId}.`));
+        }
+        for (const evidenceId of evidenceIds) {
+            result.edges.push(edge('DEPENDS_ON_EVIDENCE', checkNodeId, (0, extractor_contract_1.createEvidenceNodeId)(evidenceId), source, `${section.title} explicitly references evidence ${evidenceId}.`));
+        }
+    }
+    result.stateSources?.push(releaseReadinessStateSource(sourceHash, sections, result.nodes, result.edges));
+    return result;
+}
+function releaseCheckNode(section, source, commandMentions, evidenceIds) {
+    const status = deriveSectionStatus(section.text);
+    return {
+        id: (0, extractor_contract_1.createReleaseCheckNodeId)(section.title),
+        type: 'ReleaseCheck',
+        label: section.title,
+        path: (0, extractor_contract_1.normalizeContextGraphPath)(RELEASE_READINESS_PATH),
+        status,
+        kind: 'release-readiness-section',
+        metadata: {
+            startLine: section.startLine,
+            endLine: section.endLine,
+            commandIds: commandMentions.map((mention) => mention.commandId),
+            commandMentions: commandMentions.map((mention) => mention.mention),
+            evidenceIds,
+            summary: firstMeaningfulLine(section.text)
+        },
+        source
+    };
+}
+function parseReleaseReadinessSections(content) {
+    const lines = content.split(/\r?\n/);
+    const headingIndexes = [];
+    lines.forEach((line, index) => {
+        const match = line.match(/^##\s+(.+?)\s*#*\s*$/);
+        if (match?.[1])
+            headingIndexes.push({ index, title: match[1].trim() });
+    });
+    return headingIndexes.map((heading, position) => {
+        const nextHeading = headingIndexes[position + 1]?.index ?? lines.length;
+        const bodyLines = lines.slice(heading.index + 1, nextHeading);
+        return {
+            title: heading.title,
+            startLine: heading.index + 1,
+            endLine: nextHeading,
+            text: bodyLines.join('\n').trim()
+        };
+    });
+}
+function findCommandMentions(text, entries) {
+    const spans = codeSpans(text).filter((span) => /\bhadara\b/.test(span));
+    const mentions = new Map();
+    for (const span of spans) {
+        const normalizedSpan = normalizeCommandText(span);
+        for (const entry of entries) {
+            const prefix = commandPrefix(entry.command);
+            if (!prefix || !normalizedSpan.startsWith(prefix))
+                continue;
+            mentions.set(entry.id, {
+                commandId: entry.id,
+                command: entry.command,
+                mention: span
+            });
+        }
+    }
+    return Array.from(mentions.values()).sort((a, b) => a.commandId.localeCompare(b.commandId));
+}
+function findEvidenceIds(text) {
+    return Array.from(new Set(text.match(EVIDENCE_ID_PATTERN) ?? [])).sort();
+}
+function codeSpans(text) {
+    const spans = [];
+    for (const match of text.matchAll(/`([^`]+)`/g)) {
+        if (match[1])
+            spans.push(match[1].trim());
+    }
+    return spans;
+}
+function commandPrefix(command) {
+    return normalizeCommandText(command)
+        .replace(/\s*\[[^\]]+\]/g, '')
+        .replace(/\s*<[^>]+>/g, '')
+        .trim();
+}
+function normalizeCommandText(command) {
+    return command.replace(/\s+/g, ' ').trim();
+}
+function deriveSectionStatus(text) {
+    const lowered = text.toLowerCase();
+    if (/\b(deferred|reserved)\b/.test(lowered))
+        return 'deferred';
+    if (/\b(blocked|blocking)\b/.test(lowered))
+        return 'blocked';
+    if (/\b(complete|completed|passed|published)\b/.test(lowered))
+        return 'current';
+    return 'documented';
+}
+function firstMeaningfulLine(text) {
+    return text.split(/\r?\n/)
+        .map((line) => line.trim().replace(/^-\s+/, ''))
+        .find((line) => line.length > 0) ?? null;
+}
+function releaseReadinessStateSource(sourceHash, sections, nodes, edges) {
+    return {
+        id: 'state-source:release-readiness',
+        path: RELEASE_READINESS_PATH,
+        kind: 'release-readiness',
+        hash: sourceHash,
+        extracted: {
+            checks: sections.length,
+            headings: sections.map((section) => section.title),
+            statusCounts: nodes.reduce((counts, node) => {
+                const status = node.status ?? 'unknown';
+                counts[status] = (counts[status] ?? 0) + 1;
+                return counts;
+            }, {}),
+            commandReferences: edges.filter((edgeItem) => edgeItem.type === 'CHECKS_COMMAND').length,
+            evidenceReferences: edges.filter((edgeItem) => edgeItem.type === 'DEPENDS_ON_EVIDENCE').length
+        }
+    };
+}
+function edge(type, from, to, source, reason) {
+    return {
+        id: (0, extractor_contract_1.createContextGraphEdgeId)({ type, from, to, source, reason }),
+        from,
+        to,
+        type,
+        confidence: 'explicit',
+        reason,
+        source
+    };
+}
+function readOptionalText(absolutePath) {
+    return node_fs_1.default.existsSync(absolutePath) ? node_fs_1.default.readFileSync(absolutePath, 'utf8') : null;
+}

package/dist/context/session-start.js

@@ -0,0 +1,297 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_START_COMMAND = exports.SESSION_START_SCHEMA_ID = void 0;
+exports.buildSessionStartReport = buildSessionStartReport;
+const context_pack_1 = require("./context-pack");
+const context_graph_builder_1 = require("./context-graph-builder");
+const context_cache_store_1 = require("./context-cache-store");
+const source_manifest_1 = require("./source-manifest");
+const code_graph_extractor_1 = require("./code-graph-extractor");
+exports.SESSION_START_SCHEMA_ID = 'hadara.sessionStart.v1';
+exports.SESSION_START_COMMAND = 'session.start';
+function buildSessionStartReport(input) {
+    const generatedAt = input.generatedAt ?? new Date().toISOString();
+    const contextPack = input.contextPack ?? (input.allowLiveContextPack
+        ? (0, context_pack_1.buildContextPackReport)({
+            projectRoot: input.projectRoot,
+            generatedAt,
+            includeCode: input.includeCode,
+            ...(input.taskId ? { taskId: input.taskId } : {}),
+            ...(input.budget ? { budget: input.budget } : {})
+        })
+        : buildWarmCachedContextPackReport({
+            projectRoot: input.projectRoot,
+            generatedAt,
+            taskId: input.taskId,
+            includeCode: input.includeCode,
+            budget: input.budget
+        }) ?? buildBoundedContextPackReport({
+            projectRoot: input.projectRoot,
+            generatedAt,
+            taskId: input.taskId,
+            budget: input.budget
+        }));
+    const stateProjection = contextPack.stateProjection;
+    const taskId = contextPack.taskId ?? input.taskId ?? stateProjection.activeTask;
+    const issues = [...contextPack.issues];
+    const lifecycle = lifecycleForSessionStart(taskId, contextPack);
+    const guidance = guidanceForSessionStart({
+        taskId,
+        contextPack,
+        lifecycle,
+        allowLiveContextPack: Boolean(input.allowLiveContextPack)
+    });
+    return {
+        schemaVersion: exports.SESSION_START_SCHEMA_ID,
+        command: exports.SESSION_START_COMMAND,
+        ok: contextPack.ok && issues.every((issue) => issue.severity !== 'error'),
+        generatedAt,
+        projectRoot: input.projectRoot,
+        currentState: {
+            ...(stateProjection.activeTask ? { activeTask: stateProjection.activeTask } : {}),
+            ...(stateProjection.latestCompletedTask ? { latestCompletedTask: stateProjection.latestCompletedTask } : {}),
+            ...(taskId ? { recommendedNextTask: taskId } : {}),
+            ...(stateProjection.releaseState ? { releaseState: stateProjection.releaseState } : {})
+        },
+        contextPack,
+        lifecycle,
+        guidance,
+        knownProblems: contextPack.knownProblems,
+        sourceSummary: contextPack.sourceSummary,
+        cache: contextPack.cache,
+        summary: {
+            degraded: contextPack.sourceSummary.degraded || issues.some((issue) => issue.severity !== 'info'),
+            readFirstCount: contextPack.readFirst.length,
+            readIfNeededCount: contextPack.readIfNeeded.length,
+            sliceCandidateCount: contextPack.sliceCandidates.length,
+            knownProblemCount: contextPack.knownProblems.length,
+            issueCount: issues.length
+        },
+        issues
+    };
+}
+function buildWarmCachedContextPackReport(input) {
+    const cachedManifest = (0, context_cache_store_1.readContextSourceManifestCache)(input.projectRoot);
+    if (cachedManifest.status !== 'valid' || !cachedManifest.manifest)
+        return undefined;
+    const fastFreshness = (0, source_manifest_1.checkContextSourceManifestFastFreshness)(input.projectRoot, cachedManifest.manifest);
+    if (!fastFreshness.ok)
+        return undefined;
+    const graphCore = (0, context_cache_store_1.readContextGraphCoreShard)({
+        projectRoot: input.projectRoot,
+        manifest: cachedManifest.manifest
+    });
+    if (!graphCore.hit || !graphCore.result)
+        return undefined;
+    const extractionResults = [graphCore.result];
+    const code = input.includeCode
+        ? (0, context_cache_store_1.readContextCodeIndexShard)({
+            projectRoot: input.projectRoot,
+            manifest: cachedManifest.manifest
+        })
+        : undefined;
+    if (code?.hit && code.result) {
+        extractionResults.push((0, code_graph_extractor_1.codeIndexReportToGraphExtraction)(code.result));
+    }
+    const cache = {
+        used: true,
+        hit: !input.includeCode || Boolean(code?.hit),
+        mode: input.includeCode
+            ? code?.hit ? 'graph-core+code-index' : `graph-core+code-index-${code?.status ?? 'missing'}`
+            : 'graph-core',
+        manifestHash: cachedManifest.manifest.manifestHash,
+        readShardCount: 1 + (input.includeCode ? 1 : 0),
+        hitShardCount: 1 + (code?.hit ? 1 : 0),
+        missShardCount: code?.status === 'missing' ? 1 : 0,
+        staleShardCount: code?.status === 'stale' ? 1 : 0,
+        corruptShardCount: code?.status === 'corrupt' ? 1 : 0,
+        schemaMismatchShardCount: code?.status === 'schema-mismatch' ? 1 : 0,
+        shardPaths: [graphCore.path, ...(code ? [code.path] : [])].sort(),
+        staleExtractorKeys: code?.status === 'stale' ? ['codeIndex'] : [],
+        ...(graphCore.record ? { createdAt: graphCore.record.createdAt, cachePath: graphCore.path } : {}),
+        sourceManifestCacheFresh: true,
+        sourceManifestFastPath: 'hit',
+        sourceManifestFastPathReason: fastFreshness.reason,
+        ...(fastFreshness.strategy ? { sourceManifestFastPathStrategy: fastFreshness.strategy } : {})
+    };
+    const graphReport = (0, context_graph_builder_1.buildContextGraphReport)({
+        projectRoot: input.projectRoot,
+        generatedAt: input.generatedAt,
+        ...(input.taskId ? { taskId: input.taskId, mode: 'task' } : { mode: 'full' }),
+        extractionResults,
+        cache
+    });
+    return (0, context_pack_1.buildContextPackReport)({
+        projectRoot: input.projectRoot,
+        generatedAt: input.generatedAt,
+        ...(input.taskId ? { taskId: input.taskId } : {}),
+        ...(input.budget ? { budget: input.budget } : {}),
+        includeCode: input.includeCode,
+        graphReport,
+        cache
+    });
+}
+function lifecycleForSessionStart(taskId, contextPack) {
+    const primaryNextCommands = taskId
+        ? [
+            `node dist/cli/main.js task status --task ${taskId} --json`,
+            `node dist/cli/main.js context pack --task ${taskId} --json`
+        ]
+        : ['node dist/cli/main.js task next --json'];
+    for (const suggestion of contextPack.validateWith) {
+        if (suggestion.requiredForClose && !primaryNextCommands.includes(suggestion.command)) {
+            primaryNextCommands.push(suggestion.command);
+        }
+    }
+    const diagnosticCommands = [
+        'node dist/cli/main.js context cache status --json',
+        taskId
+            ? `node dist/cli/main.js context graph --task ${taskId} --json`
+            : 'node dist/cli/main.js context graph --json',
+        taskId
+            ? `node dist/cli/main.js session start --task ${taskId} --live --json`
+            : 'node dist/cli/main.js session start --live --json',
+        'node dist/cli/main.js state verify --json'
+    ];
+    return {
+        primaryNextCommands,
+        diagnosticCommands
+    };
+}
+function guidanceForSessionStart(input) {
+    const mode = input.allowLiveContextPack
+        ? 'live-context-pack'
+        : input.contextPack.cache.used
+            ? 'warm-cache'
+            : 'bounded-no-live';
+    const taskId = input.taskId;
+    const taskRequired = !taskId;
+    const primaryNextAction = taskRequired ? 'select-task' : 'inspect-task';
+    const reason = taskRequired
+        ? 'No task id was supplied, so bounded Session Start returned task-selection guidance without running live graph discovery.'
+        : mode === 'warm-cache'
+            ? 'Session Start used proven-fresh warm cache and preserved read-only behavior.'
+            : mode === 'live-context-pack'
+                ? 'Session Start used explicit live context-pack discovery because --live was supplied.'
+                : 'Session Start used the bounded no-live packet and avoided broad live graph discovery.';
+    const commands = [];
+    if (!taskId) {
+        commands.push({
+            id: 'task-next',
+            command: 'node dist/cli/main.js task next --json',
+            args: ['task', 'next', '--json'],
+            reason: 'Choose the next task before requesting task-scoped context.'
+        });
+    }
+    else {
+        commands.push({
+            id: 'task-status',
+            command: `node dist/cli/main.js task status --task ${taskId} --json`,
+            args: ['task', 'status', '--task', taskId, '--json'],
+            reason: 'Inspect task readiness, evidence, and lifecycle state.'
+        });
+        commands.push({
+            id: 'context-pack',
+            command: `node dist/cli/main.js context pack --task ${taskId} --json`,
+            args: ['context', 'pack', '--task', taskId, '--json'],
+            reason: 'Inspect the bounded task read plan without slicing raw source text.'
+        });
+    }
+    commands.push({
+        id: 'cache-warm',
+        command: 'node dist/cli/main.js context cache warm --json',
+        args: ['context', 'cache', 'warm', '--json'],
+        reason: 'Preview stale cache shards without writing cache.'
+    });
+    commands.push({
+        id: 'session-start-live',
+        command: taskId
+            ? `node dist/cli/main.js session start --task ${taskId} --live --json`
+            : 'node dist/cli/main.js session start --live --json',
+        args: taskId
+            ? ['session', 'start', '--task', taskId, '--live', '--json']
+            : ['session', 'start', '--live', '--json'],
+        reason: 'Opt into slower live context-pack discovery only when broad graph reads are acceptable.'
+    });
+    return {
+        mode,
+        primaryNextAction,
+        reason,
+        taskRequired,
+        liveContextPackAvailable: true,
+        commands
+    };
+}
+function buildBoundedContextPackReport(input) {
+    const budget = {
+        ...(input.budget?.targetTokens !== undefined ? { targetTokens: input.budget.targetTokens } : {}),
+        ...(input.budget?.maxItems !== undefined ? { maxItems: input.budget.maxItems } : {}),
+        maxReadFirstItems: input.budget?.maxReadFirstItems ?? 7,
+        mode: input.budget?.mode ?? 'bounded'
+    };
+    const issues = input.taskId
+        ? [{
+                severity: 'warning',
+                code: 'CONTEXT_PACK_DEGRADED',
+                message: 'Session start used the bounded no-live context pack envelope. Run session start --live or context pack explicitly when a full graph read is acceptable.',
+                fixHint: 'Run hadara context cache warm --execute --json before relying on broad graph-backed session context.'
+            }]
+        : [{
+                severity: 'warning',
+                code: 'CONTEXT_PACK_TASK_NOT_FOUND',
+                message: 'No task id was supplied. Bounded session start returned task-selection guidance without running live project discovery.',
+                fixHint: 'Run hadara task next --json, then rerun hadara session start --task <task-id> --json.'
+            }];
+    const readFirst = input.taskId
+        ? [{
+                id: `task:${input.taskId}`,
+                type: 'Task',
+                title: input.taskId,
+                reason: 'Explicit task id supplied to bounded session start.',
+                confidence: 'explicit',
+                required: true
+            }]
+        : [];
+    return {
+        schemaVersion: context_pack_1.CONTEXT_PACK_SCHEMA_ID,
+        command: context_pack_1.CONTEXT_PACK_COMMAND,
+        ok: issues.every((issue) => issue.severity !== 'error'),
+        generatedAt: input.generatedAt,
+        ...(input.taskId ? { taskId: input.taskId } : {}),
+        projectRoot: input.projectRoot,
+        budget,
+        readFirst: readFirst.slice(0, budget.maxReadFirstItems),
+        readIfNeeded: [],
+        doNotReadByDefault: [],
+        validateWith: input.taskId
+            ? [{
+                    command: `node dist/cli/main.js task ready --task ${input.taskId} --level done --json`,
+                    reason: 'Done-level readiness is required before closing this task.',
+                    requiredForClose: true,
+                    source: 'evidence-history'
+                }]
+            : [],
+        writeBoundaries: [],
+        sliceCandidates: [],
+        knownProblems: [],
+        stateProjection: {
+            ...(input.taskId ? { activeTask: input.taskId } : {}),
+            stateConsistency: 'unknown',
+            issues: []
+        },
+        sourceSummary: {
+            graphAvailable: false,
+            codeIndexAvailable: false,
+            stateProjectionAvailable: false,
+            docsRegistryAvailable: false,
+            commandRegistryAvailable: false,
+            degraded: true
+        },
+        cache: {
+            used: false,
+            hit: false,
+            mode: 'session-start-bounded-no-live'
+        },
+        issues
+    };
+}