hadara 0.3.3 → 0.3.4-rc.0

package/dist/handoff/handoff-stale-problems.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHandoffStaleProblemsReport = createHandoffStaleProblemsReport;
+exports.formatHandoffStaleProblemsReport = formatHandoffStaleProblemsReport;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const markdown_table_1 = require("../services/markdown-table");
+const task_capsule_1 = require("../task/task-capsule");
+const RELEASE_SOURCE_PATHS = ['docs/RELEASE_READINESS.md', 'docs/RELEASE_NOTES.md', 'docs/PROJECT_STATE.md', 'docs/AGENT_HANDOFF.md'];
+const TASK_STALE_REVIEW_LANGUAGE = /\b(not yet|needs closeout|needs publish|needs recycle|blocked|todo|awaiting|unresolved)\b|still needs (closeout|publish|recycle)/i;
+const RELEASE_STALE_REVIEW_LANGUAGE = /\b(pending|not yet|needs publish|needs recycle|blocked|todo|awaiting|unresolved)\b|publish\/recycle still pending|still needs (publish|recycle)/i;
+function createHandoffStaleProblemsReport(projectRoot) {
+    const handoffPath = node_path_1.default.join(projectRoot, 'docs', 'AGENT_HANDOFF.md');
+    const handoffExists = node_fs_1.default.existsSync(handoffPath);
+    const handoffContent = handoffExists ? node_fs_1.default.readFileSync(handoffPath, 'utf8') : '';
+    const issues = [];
+    if (!handoffExists) {
+        issues.push({ severity: 'error', code: 'AGENT_HANDOFF_MISSING', message: 'docs/AGENT_HANDOFF.md is missing.', path: 'docs/AGENT_HANDOFF.md' });
+    }
+    const rows = handoffExists ? knownProblemRows(handoffContent) : [];
+    const completedTasks = readCompletedTasks(projectRoot);
+    const releaseSources = readReleaseSources(projectRoot);
+    const candidates = rows.flatMap((cells, index) => analyzeKnownProblemRow(cells, index + 1, completedTasks, releaseSources));
+    return {
+        schemaVersion: 'hadara.handoff.staleProblems.v1',
+        command: 'handoff.stale-problems',
+        ok: !issues.some((issue) => issue.severity === 'error'),
+        readOnly: true,
+        generatedAt: new Date().toISOString(),
+        target: {
+            path: 'docs/AGENT_HANDOFF.md',
+            beforeHash: hashContent(handoffContent),
+            writeBoundary: 'read-only'
+        },
+        summary: {
+            knownProblemRows: rows.length,
+            candidates: candidates.length
+        },
+        candidates,
+        issues
+    };
+}
+function formatHandoffStaleProblemsReport(report) {
+    const lines = [`[HADARA] handoff stale-problems: ${report.ok ? 'ok' : 'issues'} candidates=${report.summary.candidates}`];
+    lines.push(`target=${report.target.path} beforeHash=${report.target.beforeHash}`);
+    for (const candidate of report.candidates) {
+        lines.push(`${candidate.confidence}\trow ${candidate.rowIndex}\t${candidate.reason}`);
+        lines.push(`  action: ${candidate.suggestedAction}`);
+    }
+    for (const issue of report.issues)
+        lines.push(`[${issue.severity}] ${issue.code}: ${issue.message}`);
+    return lines.join('\n');
+}
+function analyzeKnownProblemRow(cells, rowIndex, completedTasks, releaseSources) {
+    const rowText = cells.join(' · ');
+    const normalized = rowText.toLowerCase();
+    const candidates = [];
+    for (const taskId of unique([...rowText.matchAll(/\bT-\d{4}\b/g)].map((match) => match[0]))) {
+        const task = completedTasks.find((candidate) => candidate.taskId === taskId);
+        if (!task)
+            continue;
+        if (!TASK_STALE_REVIEW_LANGUAGE.test(rowText))
+            continue;
+        candidates.push({
+            id: `known-problem-${rowIndex}-${taskId.toLowerCase()}`,
+            rowIndex,
+            cells,
+            rowText,
+            confidence: 'high',
+            reason: `Known-problem row mentions ${taskId}, but that task capsule is marked ${task.status}.`,
+            matchedSources: [{ path: task.capsulePath, summary: `${task.taskId} ${task.title} is ${task.status}.` }],
+            suggestedAction: `Review this row and remove or rewrite it if ${taskId} resolved the problem.`
+        });
+    }
+    for (const version of unique([...rowText.matchAll(/\b\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?\b/g)].map((match) => match[0]))) {
+        const sourceMatches = releaseSources
+            .filter((source) => {
+            const sourceText = source.content.toLowerCase();
+            return source.content.includes(version) && /(published|verified|recycled|installed-package|npm view|dist-tag|latest)/i.test(source.content) && /published|verified|recycled|installed-package|npm view|dist-tag|latest/.test(sourceText);
+        })
+            .map((source) => ({ path: source.path, summary: `${version} appears in release/publish/recycle state text.` }));
+        if (sourceMatches.length === 0)
+            continue;
+        if (!RELEASE_STALE_REVIEW_LANGUAGE.test(normalized))
+            continue;
+        candidates.push({
+            id: `known-problem-${rowIndex}-version-${version.replace(/[^0-9a-z.-]/gi, '-')}`,
+            rowIndex,
+            cells,
+            rowText,
+            confidence: 'high',
+            reason: `Known-problem row mentions ${version}, and release state docs contain publish/recycle completion signals for that version.`,
+            matchedSources: sourceMatches,
+            suggestedAction: `Review this row and remove or rewrite it if ${version} publish/recycle work is complete.`
+        });
+    }
+    return dedupeCandidates(candidates);
+}
+function readCompletedTasks(projectRoot) {
+    return (0, task_capsule_1.listTaskCapsules)(projectRoot)
+        .map((task) => ({
+        taskId: task.id,
+        title: task.title,
+        status: readTaskStatus(task.dir) ?? 'unknown',
+        capsulePath: toPortablePath(node_path_1.default.relative(projectRoot, task.dir))
+    }))
+        .filter((task) => task.status === 'Done');
+}
+function knownProblemRows(handoffContent) {
+    return (0, markdown_table_1.parseMarkdownRowsUnderHeading)(handoffContent, '## Current Known Problems').filter((row) => {
+        const normalized = row.map((cell) => cell.toLowerCase());
+        return normalized.join('|') !== 'issue|impact|next step';
+    });
+}
+function readTaskStatus(taskDir) {
+    const taskPath = node_path_1.default.join(taskDir, 'TASK.md');
+    if (!node_fs_1.default.existsSync(taskPath))
+        return null;
+    const content = node_fs_1.default.readFileSync(taskPath, 'utf8');
+    return content.match(/^## Status\s*\n+([^\n]+)/m)?.[1]?.trim() ?? null;
+}
+function readReleaseSources(projectRoot) {
+    return RELEASE_SOURCE_PATHS.map((relativePath) => {
+        const absolutePath = node_path_1.default.join(projectRoot, relativePath);
+        return { path: relativePath, content: node_fs_1.default.existsSync(absolutePath) ? node_fs_1.default.readFileSync(absolutePath, 'utf8') : '' };
+    });
+}
+function dedupeCandidates(candidates) {
+    const seen = new Set();
+    return candidates.filter((candidate) => {
+        const key = `${candidate.rowIndex}:${candidate.reason}`;
+        if (seen.has(key))
+            return false;
+        seen.add(key);
+        return true;
+    });
+}
+function unique(values) {
+    return [...new Set(values)];
+}
+function hashContent(content) {
+    return `sha256:${node_crypto_1.default.createHash('sha256').update(content, 'utf8').digest('hex')}`;
+}
+function toPortablePath(value) {
+    return value.split(node_path_1.default.sep).join('/');
+}

package/dist/schemas/context-pack.schema.json

@@ -18,6 +18,7 @@
         "validateWith",
         "writeBoundaries",
         "sliceCandidates",
+        "agentActions",
         "knownProblems",
         "stateProjection",
         "sourceSummary",
@@ -38,6 +39,7 @@
         "validateWith": { "type": "array", "items": { "$ref": "#/$defs/validationSuggestion" } },
         "writeBoundaries": { "type": "array", "items": { "$ref": "#/$defs/writeBoundary" } },
         "sliceCandidates": { "type": "array", "items": { "$ref": "#/$defs/sliceCandidate" } },
+        "agentActions": { "type": "array", "items": { "$ref": "#/$defs/agentAction" } },
         "knownProblems": { "type": "array", "items": { "$ref": "#/$defs/item" } },
         "stateProjection": { "$ref": "#/$defs/stateProjection" },
         "sourceSummary": { "$ref": "#/$defs/sourceSummary" },
@@ -151,6 +153,27 @@
                 }
             }
         },
+        "agentAction": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["id", "kind", "priority", "reason", "command", "writeBoundary"],
+            "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "kind": { "enum": ["read-first", "slice", "validate"] },
+                "priority": { "type": "number" },
+                "reason": { "type": "string", "minLength": 1 },
+                "command": { "type": "string", "minLength": 1 },
+                "commandArgs": {
+                    "type": "array",
+                    "minItems": 1,
+                    "items": { "type": "string", "minLength": 1 }
+                },
+                "sourceItemId": { "type": "string" },
+                "sliceCandidateId": { "type": "string" },
+                "path": { "type": "string" },
+                "writeBoundary": { "const": "read-only" }
+            }
+        },
         "stateProjection": {
             "type": "object",
             "additionalProperties": true,

package/dist/schemas/evidence-summary.schema.json

@@ -0,0 +1,73 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "hadara.evidence.summary.v1",
+    "x-hadara-schema-id": "hadara.evidence.summary.v1",
+    "title": "HADARA Evidence Summary Report",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schemaVersion", "command", "ok", "readOnly", "taskId", "summary", "records", "latest", "latestCloseEvidence", "copyHints", "issues"],
+    "properties": {
+        "schemaVersion": { "const": "hadara.evidence.summary.v1" },
+        "command": { "const": "evidence.summary" },
+        "ok": { "type": "boolean" },
+        "readOnly": { "const": true },
+        "taskId": { "type": "string", "pattern": "^T-[0-9]{4}$" },
+        "summary": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["count", "durableCount", "unstableCount", "privateIncluded", "latestId", "latestCloseEvidenceId"],
+            "properties": {
+                "count": { "type": "integer", "minimum": 0 },
+                "durableCount": { "type": "integer", "minimum": 0 },
+                "unstableCount": { "type": "integer", "minimum": 0 },
+                "privateIncluded": { "type": "boolean" },
+                "latestId": { "type": ["string", "null"] },
+                "latestCloseEvidenceId": { "type": ["string", "null"] }
+            }
+        },
+        "records": { "type": "array", "items": { "$ref": "#/$defs/summaryRecord" } },
+        "latest": { "oneOf": [{ "$ref": "#/$defs/summaryRecord" }, { "type": "null" }] },
+        "latestCloseEvidence": { "oneOf": [{ "$ref": "#/$defs/summaryRecord" }, { "type": "null" }] },
+        "copyHints": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["latestId", "latestCloseEvidenceId", "durableIds"],
+            "properties": {
+                "latestId": { "type": ["string", "null"] },
+                "latestCloseEvidenceId": { "type": ["string", "null"] },
+                "durableIds": { "type": "array", "items": { "type": "string", "minLength": 1 } }
+            }
+        },
+        "issues": { "type": "array", "items": { "$ref": "#/$defs/issue" } }
+    },
+    "$defs": {
+        "summaryRecord": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["id", "time", "category", "outcome", "visibility", "summary", "tags", "sourceLine", "idSource", "idStability", "persistedSchemaVersion"],
+            "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "time": { "type": "string", "minLength": 1 },
+                "category": { "type": "string", "enum": ["validation", "implementation", "release", "security", "policy", "operation", "decision", "handoff", "audit", "note", "observation"] },
+                "outcome": { "type": "string", "enum": ["passed", "failed", "blocked", "unknown", "recorded", "not-applicable"] },
+                "visibility": { "type": "string", "enum": ["public", "private"] },
+                "summary": { "type": "string", "minLength": 1 },
+                "tags": { "type": "array", "items": { "type": "string" } },
+                "sourceLine": { "type": "integer", "minimum": 1 },
+                "idSource": { "type": "string", "enum": ["persisted", "line-fallback"] },
+                "idStability": { "type": "string", "enum": ["durable", "unstable-on-reorder"] },
+                "persistedSchemaVersion": { "type": "string", "enum": ["hadara.evidence.v1", "hadara.evidence.v2"] }
+            }
+        },
+        "issue": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["severity", "code", "message"],
+            "properties": {
+                "severity": { "type": "string", "enum": ["warning", "error"] },
+                "code": { "type": "string", "minLength": 1 },
+                "message": { "type": "string", "minLength": 1 }
+            }
+        }
+    }
+}

package/dist/schemas/handoff-stale-problems.schema.json

@@ -0,0 +1,64 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "hadara.handoff.staleProblems.v1",
+    "x-hadara-schema-id": "hadara.handoff.staleProblems.v1",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schemaVersion", "command", "ok", "readOnly", "generatedAt", "target", "summary", "candidates", "issues"],
+    "properties": {
+        "schemaVersion": { "const": "hadara.handoff.staleProblems.v1" },
+        "command": { "const": "handoff.stale-problems" },
+        "ok": { "type": "boolean" },
+        "readOnly": { "const": true },
+        "generatedAt": { "type": "string" },
+        "target": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["path", "beforeHash", "writeBoundary"],
+            "properties": {
+                "path": { "const": "docs/AGENT_HANDOFF.md" },
+                "beforeHash": { "type": "string", "pattern": "^sha256:[a-f0-9]{64}$" },
+                "writeBoundary": { "const": "read-only" }
+            }
+        },
+        "summary": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["knownProblemRows", "candidates"],
+            "properties": {
+                "knownProblemRows": { "type": "integer", "minimum": 0 },
+                "candidates": { "type": "integer", "minimum": 0 }
+            }
+        },
+        "candidates": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "additionalProperties": true,
+                "required": ["id", "rowIndex", "cells", "rowText", "confidence", "reason", "matchedSources", "suggestedAction"],
+                "properties": {
+                    "id": { "type": "string" },
+                    "rowIndex": { "type": "integer", "minimum": 1 },
+                    "cells": { "type": "array", "items": { "type": "string" } },
+                    "rowText": { "type": "string" },
+                    "confidence": { "enum": ["medium", "high"] },
+                    "reason": { "type": "string" },
+                    "matchedSources": {
+                        "type": "array",
+                        "items": {
+                            "type": "object",
+                            "additionalProperties": true,
+                            "required": ["path", "summary"],
+                            "properties": {
+                                "path": { "type": "string" },
+                                "summary": { "type": "string" }
+                            }
+                        }
+                    },
+                    "suggestedAction": { "type": "string" }
+                }
+            }
+        },
+        "issues": { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+    }
+}

package/dist/schemas/package-recycle.schema.json

@@ -0,0 +1,150 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "hadara.packageRecycle.v1",
+    "x-hadara-schema-id": "hadara.packageRecycle.v1",
+    "title": "HADARA Installed Package Recycle Report",
+    "type": "object",
+    "additionalProperties": true,
+    "required": [
+        "schemaVersion",
+        "command",
+        "ok",
+        "mode",
+        "readOnly",
+        "package",
+        "networkPolicy",
+        "execution",
+        "workspace",
+        "steps",
+        "artifacts",
+        "privacy",
+        "issues"
+    ],
+    "properties": {
+        "schemaVersion": { "const": "hadara.packageRecycle.v1" },
+        "command": { "const": "package.recycle" },
+        "ok": { "type": "boolean" },
+        "mode": { "type": "string", "enum": ["dry-run", "execute"] },
+        "readOnly": { "type": "boolean" },
+        "package": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["specifier", "name", "expectedVersion", "observedVersion", "latestVersion", "distTags"],
+            "properties": {
+                "specifier": { "type": "string", "minLength": 1 },
+                "name": { "type": "string", "minLength": 1 },
+                "expectedVersion": { "type": ["string", "null"] },
+                "observedVersion": { "type": ["string", "null"] },
+                "latestVersion": { "type": ["string", "null"] },
+                "distTags": {
+                    "type": "object",
+                    "additionalProperties": { "type": "string" }
+                }
+            }
+        },
+        "networkPolicy": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["mode", "enforced", "notes"],
+            "properties": {
+                "mode": { "const": "environment-inherited" },
+                "enforced": { "const": false },
+                "notes": { "type": "array", "items": { "type": "string", "minLength": 1 } }
+            }
+        },
+        "execution": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": [
+                "npmViewExecuted",
+                "npmDistTagExecuted",
+                "packageInstallExecuted",
+                "installedVersionExecuted",
+                "lifecycleHelpExecuted",
+                "initExecuted",
+                "taskLifecycleExecuted",
+                "contextSmokeExecuted",
+                "releaseMutationExecuted",
+                "publishExecuted"
+            ],
+            "properties": {
+                "npmViewExecuted": { "type": "boolean" },
+                "npmDistTagExecuted": { "type": "boolean" },
+                "packageInstallExecuted": { "type": "boolean" },
+                "installedVersionExecuted": { "type": "boolean" },
+                "lifecycleHelpExecuted": { "type": "boolean" },
+                "initExecuted": { "type": "boolean" },
+                "taskLifecycleExecuted": { "type": "boolean" },
+                "contextSmokeExecuted": { "type": "boolean" },
+                "releaseMutationExecuted": { "const": false },
+                "publishExecuted": { "const": false }
+            }
+        },
+        "workspace": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["kind", "displayPath", "pathRedacted", "retention"],
+            "properties": {
+                "kind": { "const": "disposable" },
+                "displayPath": { "type": "string", "minLength": 1 },
+                "pathRedacted": { "const": true },
+                "retention": { "type": "string", "enum": ["deleted", "kept-temporary"] }
+            }
+        },
+        "steps": { "type": "array", "items": { "$ref": "#/$defs/step" } },
+        "artifacts": { "type": "array", "items": { "$ref": "#/$defs/artifact" } },
+        "privacy": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["rawLogsIncluded", "rawPackageContentsIncluded", "privatePathsIncluded", "environmentSecretsIncluded", "privateStorePathsIncluded"],
+            "properties": {
+                "rawLogsIncluded": { "const": false },
+                "rawPackageContentsIncluded": { "const": false },
+                "privatePathsIncluded": { "const": false },
+                "environmentSecretsIncluded": { "const": false },
+                "privateStorePathsIncluded": { "const": false }
+            }
+        },
+        "issues": { "type": "array", "items": { "$ref": "#/$defs/issue" } }
+    },
+    "$defs": {
+        "step": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["id", "label", "status", "summary"],
+            "properties": {
+                "id": { "type": "string", "minLength": 1 },
+                "label": { "type": "string", "minLength": 1 },
+                "status": { "type": "string", "enum": ["planned", "passed", "failed", "skipped"] },
+                "command": { "type": "string", "minLength": 1 },
+                "exitCode": { "type": ["integer", "null"] },
+                "elapsedMs": { "type": "integer" },
+                "summary": { "type": "string", "minLength": 1 }
+            }
+        },
+        "artifact": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["kind", "visibility", "rawContentIncluded"],
+            "properties": {
+                "kind": { "type": "string", "enum": ["summary", "command-log", "install-tree"] },
+                "visibility": { "type": "string", "enum": ["public", "private", "temporary"] },
+                "evidencePath": { "type": "string", "pattern": "^tasks/T-[0-9]{4}-.+/artifacts/package-recycle/.+" },
+                "relativePath": { "type": "string", "minLength": 1 },
+                "pathRedacted": { "const": true },
+                "rawContentIncluded": { "const": false }
+            }
+        },
+        "issue": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["severity", "code", "message"],
+            "properties": {
+                "severity": { "type": "string", "enum": ["warning", "error"] },
+                "code": { "type": "string", "minLength": 1 },
+                "message": { "type": "string", "minLength": 1 },
+                "stepId": { "type": "string", "minLength": 1 }
+            }
+        }
+    }
+}

package/dist/schemas/release-closeout.schema.json

@@ -0,0 +1,39 @@
+{
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "$id": "hadara.releaseCloseout.v1",
+    "x-hadara-schema-id": "hadara.releaseCloseout.v1",
+    "type": "object",
+    "additionalProperties": true,
+    "required": ["schemaVersion", "command", "ok", "readOnly", "generatedAt", "input", "summary", "surfaces", "suggestedFragments", "issues"],
+    "properties": {
+        "schemaVersion": { "const": "hadara.releaseCloseout.v1" },
+        "command": { "const": "release.closeout" },
+        "ok": { "type": "boolean" },
+        "readOnly": { "const": true },
+        "generatedAt": { "type": "string" },
+        "input": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["version", "taskId"],
+            "properties": {
+                "version": { "type": ["string", "null"] },
+                "taskId": { "type": ["string", "null"] }
+            }
+        },
+        "summary": {
+            "type": "object",
+            "additionalProperties": true,
+            "required": ["files", "current", "stale", "missing", "suggestedFragments"],
+            "properties": {
+                "files": { "type": "integer", "minimum": 0 },
+                "current": { "type": "integer", "minimum": 0 },
+                "stale": { "type": "integer", "minimum": 0 },
+                "missing": { "type": "integer", "minimum": 0 },
+                "suggestedFragments": { "type": "integer", "minimum": 0 }
+            }
+        },
+        "surfaces": { "type": "array", "items": { "type": "object", "additionalProperties": true } },
+        "suggestedFragments": { "type": "array", "items": { "type": "object", "additionalProperties": true } },
+        "issues": { "type": "array", "items": { "type": "object", "additionalProperties": true } }
+    }
+}

package/dist/schemas/schema-index.json

@@ -43,6 +43,13 @@
             "owner": "services/evidence-list",
             "notes": "Shared by CLI evidence list and read-only MCP hadara.evidence.list."
         },
+        {
+            "id": "hadara.evidence.summary.v1",
+            "path": "src/schemas/evidence-summary.schema.json",
+            "status": "fixture",
+            "owner": "services/evidence-summary",
+            "notes": "Compact read-only evidence id summary for agent copy/paste and close-proof discovery."
+        },
         {
             "id": "hadara.evidence.lint.v1",
             "path": "src/schemas/evidence-lint.schema.json",
@@ -218,6 +225,13 @@
             "owner": "handoff/suggestion",
             "notes": "Documents read-only Agent Handoff section-fragment suggestions with shared-doc before-hash metadata."
         },
+        {
+            "id": "hadara.handoff.staleProblems.v1",
+            "path": "src/schemas/handoff-stale-problems.schema.json",
+            "status": "fixture",
+            "owner": "handoff/stale-problems",
+            "notes": "Documents read-only Agent Handoff stale known-problem candidate detection."
+        },
         {
             "id": "hadara.dev.docker_check.v1",
             "path": "src/schemas/dev-docker-check.schema.json",
@@ -428,6 +442,13 @@
             "owner": "package-smoke/report",
             "notes": "Documents reduced package-smoke reports before dry-run or executable package-smoke command implementation."
         },
+        {
+            "id": "hadara.packageRecycle.v1",
+            "path": "src/schemas/package-recycle.schema.json",
+            "status": "fixture",
+            "owner": "package-recycle/report",
+            "notes": "Documents reduced installed-package recycle reports for npm registry/package consumer smoke validation."
+        },
         {
             "id": "hadara.plan_context.v1",
             "path": "src/schemas/plan-context.schema.json",
@@ -470,6 +491,13 @@
             "owner": "release/dry-run",
             "notes": "Documents read-only final release dry-run reports that cross-check public evidence artifacts and planned release targets without publish or GitHub Release mutation."
         },
+        {
+            "id": "hadara.releaseCloseout.v1",
+            "path": "src/schemas/release-closeout.schema.json",
+            "status": "fixture",
+            "owner": "release/closeout",
+            "notes": "Documents read-only release closeout planning across release docs, shared state docs, and active release capsule files."
+        },
         {
             "id": "hadara.releasePublish.v1",
             "path": "src/schemas/release-publish.schema.json",

package/dist/schemas/session-start.schema.json

@@ -71,6 +71,10 @@
             "required": [
                 "mode",
                 "primaryNextAction",
+                "primaryAction",
+                "whyThisNow",
+                "avoidForNow",
+                "nextCommandArgs",
                 "reason",
                 "taskRequired",
                 "liveContextPackAvailable",
@@ -79,6 +83,32 @@
             "properties": {
                 "mode": { "enum": ["live-context-pack", "warm-cache", "bounded-no-live"] },
                 "primaryNextAction": { "enum": ["select-task", "inspect-task"] },
+                "primaryAction": {
+                    "type": "object",
+                    "additionalProperties": true,
+                    "required": ["id", "label", "command", "args", "reason", "writeBoundary", "recommendedActorRole"],
+                    "properties": {
+                        "id": { "type": "string", "minLength": 1 },
+                        "label": { "type": "string", "minLength": 1 },
+                        "command": { "type": "string", "minLength": 1 },
+                        "args": {
+                            "type": "array",
+                            "items": { "type": "string" }
+                        },
+                        "reason": { "type": "string", "minLength": 1 },
+                        "writeBoundary": { "const": "read-only" },
+                        "recommendedActorRole": { "const": "agent-worker" }
+                    }
+                },
+                "whyThisNow": { "type": "string", "minLength": 1 },
+                "avoidForNow": {
+                    "type": "array",
+                    "items": { "type": "string", "minLength": 1 }
+                },
+                "nextCommandArgs": {
+                    "type": "array",
+                    "items": { "type": "string" }
+                },
                 "reason": { "type": "string", "minLength": 1 },
                 "taskRequired": { "type": "boolean" },
                 "liveContextPackAvailable": { "type": "boolean" },

package/dist/schemas/smoke-evidence-summary.schema.json

@@ -23,7 +23,7 @@
         "schemaVersion": { "const": "hadara.smokeEvidenceSummary.v1" },
         "time": { "type": "string", "minLength": 1 },
         "taskId": { "type": "string", "pattern": "^T-[0-9]{4}$" },
-        "category": { "type": "string", "enum": ["package-smoke", "clean-checkout-smoke"] },
+        "category": { "type": "string", "enum": ["package-smoke", "package-recycle", "clean-checkout-smoke"] },
         "sourceReport": {
             "type": "object",
             "additionalProperties": true,