@bvdm/delano 0.1.5 → 0.1.8

package/assets/payload/.agents/schemas/sync/drift-report.schema.json

@@ -0,0 +1,25 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://delano.local/schemas/sync/drift-report.schema.json",
+  "title": "Delano dry-run drift report",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "mode", "generated_at", "summary", "drift", "repair_recommendations"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "mode": { "const": "dry-run" },
+    "generated_at": { "type": "string" },
+    "summary": {
+      "type": "object",
+      "required": ["projects", "tasks", "drift_count", "repair_count"],
+      "properties": {
+        "projects": { "type": "integer", "minimum": 0 },
+        "tasks": { "type": "integer", "minimum": 0 },
+        "drift_count": { "type": "integer", "minimum": 0 },
+        "repair_count": { "type": "integer", "minimum": 0 }
+      }
+    },
+    "drift": { "type": "array" },
+    "repair_recommendations": { "type": "array" }
+  }
+}

package/assets/payload/.agents/schemas/sync/drift-taxonomy.json

@@ -0,0 +1,38 @@
+{
+  "schema_version": 1,
+  "status": "draft",
+  "purpose": "Typed local-first taxonomy for Delano operational sync drift and repair recommendations.",
+  "drift_types": [
+    {
+      "id": "mapping-drift",
+      "description": "A local project/task/workstream mapping disagrees with the registry or external identifiers.",
+      "severity": ["info", "warning", "error"],
+      "repair_posture": "dry-run-plan-first"
+    },
+    {
+      "id": "status-drift",
+      "description": "Local status and inspected external status differ.",
+      "severity": ["warning", "error"],
+      "repair_posture": "dry-run-plan-first"
+    },
+    {
+      "id": "dependency-drift",
+      "description": "Local dependencies and inspected external dependency links differ.",
+      "severity": ["warning", "error"],
+      "repair_posture": "dry-run-plan-first"
+    },
+    {
+      "id": "orphan-drift",
+      "description": "A local or external record lacks its expected counterpart.",
+      "severity": ["info", "warning", "error"],
+      "repair_posture": "manual-review-before-apply"
+    },
+    {
+      "id": "repair-recommendation",
+      "description": "A proposed local or external repair action generated from drift inspection.",
+      "severity": ["info", "warning", "error"],
+      "repair_posture": "never-apply-without-explicit-approval"
+    }
+  ],
+  "repair_recommendation_fields": ["drift_type", "target", "summary", "proposed_action", "apply_posture", "evidence"]
+}

package/assets/payload/.agents/schemas/sync/sync-map.schema.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "https://delano.local/schemas/sync/sync-map.schema.json",
+  "title": "Delano operational sync map",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "projects"],
+  "properties": {
+    "schema_version": { "const": 1 },
+    "projects": {
+      "type": "array",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["slug", "local_path"],
+        "properties": {
+          "slug": { "type": "string", "pattern": "^[a-z0-9]+(?:-[a-z0-9]+)*$" },
+          "local_path": { "type": "string", "pattern": "^\\.project/projects/[^/]+$" },
+          "linear_project_id": { "type": "string" },
+          "github_repo": { "type": "string" },
+          "tasks": {
+            "type": "array",
+            "items": {
+              "type": "object",
+              "additionalProperties": false,
+              "required": ["local_id"],
+              "properties": {
+                "local_id": { "type": "string", "pattern": "^T-[0-9]{3}$" },
+                "linear_issue_id": { "type": "string" },
+                "github_issue": { "type": "string" },
+                "github_pr": { "type": "string" }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/assets/payload/.agents/scripts/README.md

@@ -27,5 +27,6 @@ Operational:
 - `query-log.sh`
 - `test-and-log.sh`
 - `check-path-standards.sh`
+- `check-text-safety.mjs`
 - `fix-path-standards.sh`
 - `git-sparse-download.sh`

package/assets/payload/.agents/scripts/audit-context-files.mjs

@@ -0,0 +1,54 @@
+import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const contextDir = path.join(repoRoot, ".project", "context");
+const staleDays = Number(readOption("--stale-days") || 180);
+const now = Date.now();
+const requiredCommandDocs = new Map([
+  ["tech-context.md", ["npm test", "validate.sh"]],
+  ["progress.md", ["validate.sh"]]
+]);
+
+const files = existsSync(contextDir) ? readdirSync(contextDir).filter((file) => file.endsWith(".md")).sort() : [];
+const entries = files.map((file) => auditFile(file));
+const summary = entries.reduce((acc, entry) => {
+  acc[entry.classification] = (acc[entry.classification] || 0) + 1;
+  return acc;
+}, {});
+const result = {
+  schema_version: 1,
+  context_dir: ".project/context",
+  stale_days: staleDays,
+  file_count: entries.length,
+  summary,
+  files: entries
+};
+
+if (process.argv.includes("--json")) console.log(JSON.stringify(result, null, 2));
+else console.log(`Context audit scored ${entries.length} file(s): ${Object.entries(summary).map(([k,v])=>`${k}=${v}`).join(", ")}.`);
+
+function auditFile(file) {
+  const repoPath = [".project", "context", file].join("/");
+  const abs = path.join(repoRoot, ".project", "context", file);
+  const text = readFileSync(abs, "utf8");
+  const requiredCommands = requiredCommandDocs.get(file) || [];
+  const missingCommands = requiredCommands.filter((command) => !text.includes(command));
+  const ageDays = Math.floor((now - statSync(abs).mtimeMs) / 86_400_000);
+  const lineCount = text.split(/\r?\n/).length;
+  const wordCount = (text.match(/\b\w+\b/g) || []).length;
+  const placeholderSignals = countSignals(text, [/\bTODO\b/i, /\bTBD\b/i, /placeholder/i, /fill this/i, /coming soon/i]);
+  let classification = "real";
+  if (file === "README.md") classification = "not_applicable";
+  else if (wordCount < 40 || placeholderSignals >= 2) classification = "placeholder";
+  else if (missingCommands.length) classification = "missing_required_commands";
+  else if (ageDays > staleDays) classification = "stale";
+  const score = classification === "real" ? 100 : classification === "stale" ? 65 : classification === "missing_required_commands" ? 55 : classification === "placeholder" ? 25 : 0;
+  return { path: repoPath, classification, score, age_days: ageDays, line_count: lineCount, word_count: wordCount, missing_required_commands: missingCommands };
+}
+function countSignals(text, patterns) { return patterns.reduce((sum, pattern) => sum + (pattern.test(text) ? 1 : 0), 0); }
+function readOption(name) { const i = process.argv.indexOf(name); return i === -1 ? "" : process.argv[i + 1]; }
+function resolveRepoRoot(startDir) { for (const c of [path.resolve(startDir,".."),path.resolve(startDir,"..","..")]) if (existsSync(path.join(c,".project"))) return c; return path.resolve(startDir,".."); }

package/assets/payload/.agents/scripts/audit-context-scoring.mjs

@@ -0,0 +1,14 @@
+import { existsSync, readFileSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const targets = ["AGENTS.md", ".project/context", ".project/registry/linear-map.json", ".agents/scripts/pm/validate.sh"];
+const findings = targets.map(scoreTarget);
+const summary = { real:0, placeholder:0, stale:0, missing:0, not_applicable:0 };
+for (const f of findings) summary[f.classification]++;
+const result = { schema_version: 1, score: findings.filter(f=>f.classification === "real").length, max_score: findings.length, summary, findings };
+if (process.argv.includes("--json")) console.log(JSON.stringify(result,null,2)); else console.log(`Context audit score ${result.score}/${result.max_score}; missing=${summary.missing}; placeholder=${summary.placeholder}.`);
+if (summary.missing || summary.placeholder) process.exit(1);
+function scoreTarget(rel){ const abs=path.join(repoRoot, rel); if(!existsSync(abs)) return { path: rel, classification: "missing", reason: "required context path is absent" }; const st=statSync(abs); if(st.isDirectory()) return { path: rel, classification: "real", reason: "directory present" }; const text=readFileSync(abs,"utf8"); if(/TODO|placeholder|coming soon/i.test(text) && text.length < 200) return { path: rel, classification: "placeholder", reason: "short placeholder text" }; if(rel.endsWith('validate.sh') && !text.includes('Summary')) return { path: rel, classification: "stale", reason: "validation script lacks summary section" }; return { path: rel, classification: "real", reason: "required context content present" }; }
+function resolveRepoRoot(startDir){ for(const c of [path.resolve(startDir,".."),path.resolve(startDir,"..","..")]) if(existsSync(path.join(c,".project"))) return c; return path.resolve(startDir,".."); }

package/assets/payload/.agents/scripts/build-drift-report.mjs

@@ -0,0 +1,133 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { readLocalSyncMap } from "./read-local-sync-map.mjs";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const jsonMode = process.argv.includes("--json");
+const localOnlyMode = process.argv.includes("--local-only") || (!process.argv.includes("--github-snapshot") && !process.argv.includes("--linear-snapshot"));
+const githubSnapshotPath = readOption("--github-snapshot") || path.join(repoRoot, ".agents", "fixtures", "github", "status-snapshot.json");
+const linearSnapshotPath = readOption("--linear-snapshot") || path.join(repoRoot, ".agents", "fixtures", "linear", "issue-snapshot.json");
+
+if (isDirectRun()) {
+  const syncMap = readLocalSyncMap(repoRoot);
+  const githubSnapshot = localOnlyMode ? { repositories: [] } : readJson(githubSnapshotPath, { repositories: [] });
+  const linearSnapshot = localOnlyMode ? { issues: [] } : readJson(linearSnapshotPath, { issues: [] });
+  const report = buildDriftReport(syncMap, githubSnapshot, linearSnapshot, { localOnlyMode });
+
+  if (jsonMode) {
+    console.log(JSON.stringify(report, null, 2));
+  } else {
+    console.log(`Dry-run drift report produced ${report.summary.drift_count} drift item(s) from ${report.summary.tasks} task(s).`);
+    console.log(`Mode: ${report.mode}; apply posture: ${report.apply_posture}.`);
+    for (const drift of report.drift) console.log(`- ${drift.severity}: ${drift.target} ${drift.summary}`);
+  }
+}
+export function buildDriftReport(syncMap, githubSnapshot = {}, linearSnapshot = {}, options = {}) {
+  const githubIndex = indexGithubSnapshot(githubSnapshot);
+  const linearIndex = new Map((linearSnapshot.issues || []).map((issue) => [String(issue.id), issue]));
+  const drift = [];
+  let taskCount = 0;
+  let inspectedRefs = 0;
+
+  for (const project of syncMap.projects || []) {
+    for (const task of project.tasks || []) {
+      taskCount += 1;
+      const taskKey = `${project.slug}/${task.local_id}`;
+
+      for (const [field, expectedKind] of [["github_issue", "issue"], ["github_pr", "pull_request"]]) {
+        if (!task[field]) continue;
+        inspectedRefs += 1;
+        const parsed = parseGitHubRef(task[field], project.github_repo, expectedKind);
+        if (!parsed) {
+          drift.push(driftItem("mapping-drift", "error", taskKey, `invalid ${field}: ${task[field]}`, "Correct or remove the malformed GitHub reference.", { field, value: task[field] }));
+          continue;
+        }
+        const remote = githubIndex.get(`${parsed.owner}/${parsed.repo}#${parsed.number}:${parsed.kind}`);
+        if (!remote) {
+          drift.push(driftItem("orphan-drift", "warning", taskKey, `${field} has no inspected GitHub counterpart`, "Review the reference or refresh the GitHub snapshot before applying changes.", { field, ref: task[field], expected_kind: expectedKind }));
+        } else if (remote.kind && remote.kind !== expectedKind) {
+          drift.push(driftItem("mapping-drift", "error", taskKey, `${field} points to ${remote.kind}, expected ${expectedKind}`, "Move the reference to the correct local field or repair the remote mapping.", { field, ref: task[field], external_kind: remote.kind }));
+        }
+      }
+
+      if (task.linear_issue_id) {
+        inspectedRefs += 1;
+        const issue = linearIndex.get(String(task.linear_issue_id));
+        if (!issue) {
+          drift.push(driftItem("orphan-drift", "warning", taskKey, "linear_issue_id has no inspected Linear counterpart", "Review the reference or refresh the Linear snapshot before applying changes.", { linear_issue_id: task.linear_issue_id }));
+        } else if (issue.project_id && project.linear_project_id && issue.project_id !== project.linear_project_id) {
+          drift.push(driftItem("mapping-drift", "error", taskKey, `Linear project mismatch: ${issue.project_id} != ${project.linear_project_id}`, "Plan a project mapping repair before sync apply.", { linear_issue_id: task.linear_issue_id, external_project_id: issue.project_id, local_project_id: project.linear_project_id }));
+        }
+      }
+    }
+  }
+
+  const repairRecommendations = drift.map((item, index) => ({
+    id: `RR-${String(index + 1).padStart(3, "0")}`,
+    drift_type: item.drift_type,
+    target: item.target,
+    summary: item.summary,
+    proposed_action: item.proposed_action,
+    apply_posture: item.apply_posture,
+    evidence: item.evidence
+  }));
+
+  return {
+    schema_version: 1,
+    mode: "dry-run",
+    generated_at: new Date().toISOString(),
+    source: options.localOnlyMode ? "local-sync-map-only" : "local-sync-map-and-fixtures",
+    apply_posture: "never-apply-without-explicit-approval",
+    summary: {
+      projects: (syncMap.projects || []).length,
+      tasks: taskCount,
+      inspected_refs: inspectedRefs,
+      drift_count: drift.length,
+      repair_count: repairRecommendations.length
+    },
+    drift,
+    repair_recommendations: repairRecommendations
+  };
+}
+
+function driftItem(driftType, severity, target, summary, proposedAction, evidence) {
+  return { drift_type: driftType, severity, target, summary, proposed_action: proposedAction, apply_posture: "dry-run-plan-first", evidence };
+}
+function parseGitHubRef(value, fallbackRepo, expectedKind) {
+  const raw = String(value || "").trim();
+  const url = raw.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)\/(issues|pull)\/([0-9]+)\/?$/);
+  if (url) return { owner: url[1], repo: url[2], kind: url[3] === "pull" ? "pull_request" : "issue", number: Number(url[4]) };
+  const short = raw.match(/^#?([0-9]+)$/);
+  if (short && fallbackRepo?.includes("/")) {
+    const [owner, repo] = fallbackRepo.split("/");
+    return { owner, repo, kind: expectedKind, number: Number(short[1]) };
+  }
+  return null;
+}
+function indexGithubSnapshot(snapshot) {
+  const index = new Map();
+  for (const repo of snapshot.repositories || []) {
+    for (const issue of repo.issues || []) index.set(`${repo.owner}/${repo.name}#${issue.number}:issue`, { ...issue, kind: "issue" });
+    for (const pr of repo.pull_requests || []) index.set(`${repo.owner}/${repo.name}#${pr.number}:pull_request`, { ...pr, kind: "pull_request" });
+  }
+  return index;
+}
+function readOption(name) {
+  const index = process.argv.indexOf(name);
+  return index === -1 ? "" : process.argv[index + 1];
+}
+function readJson(filePath, fallback) {
+  if (!existsSync(filePath)) return fallback;
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function isDirectRun() {
+  return process.argv[1] && path.resolve(process.argv[1]) === __filename;
+}
+function resolveRepoRoot(startDir) {
+  const candidates = [path.resolve(startDir, ".."), path.resolve(startDir, "..", "..")];
+  for (const candidate of candidates) if (existsSync(path.join(candidate, ".project")) && existsSync(path.join(candidate, ".agents"))) return candidate;
+  return path.resolve(startDir, "..");
+}

package/assets/payload/.agents/scripts/check-artifact-schemas.mjs

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const scopePath = path.join(repoRoot, ".agents", "schemas", "artifact-scope.json");
+const errors = [];
+
+const scope = readJson(scopePath, "artifact scope");
+const artifactTypes = scope.artifact_types || {};
+
+for (const [artifactType, contract] of Object.entries(artifactTypes)) {
+  const schemaPath = contract.schema_path;
+  if (typeof schemaPath !== "string" || schemaPath.trim() === "") {
+    errors.push(`${artifactType} must declare schema_path in artifact-scope.json.`);
+    continue;
+  }
+
+  const absoluteSchemaPath = path.join(repoRoot, schemaPath);
+  const schema = readJson(absoluteSchemaPath, `${artifactType} schema`);
+  if (!existsSync(absoluteSchemaPath)) {
+    continue;
+  }
+
+  checkSchemaBasics(artifactType, schemaPath, schema);
+  checkRequiredFields(artifactType, contract, schema);
+  checkEnumFields(artifactType, contract, schema);
+}
+
+if (errors.length > 0) {
+  console.error("Artifact schema check failed:");
+  for (const error of errors) {
+    console.error(`- ${error}`);
+  }
+  process.exit(1);
+}
+
+console.log(`Artifact schema check passed for ${Object.keys(artifactTypes).length} artifact schemas.`);
+
+function readJson(filePath, label) {
+  try {
+    return JSON.parse(readFileSync(filePath, "utf8"));
+  } catch (error) {
+    errors.push(`Could not read ${label} at ${toRepoPath(filePath)}: ${error.message}`);
+    return {};
+  }
+}
+
+function checkSchemaBasics(artifactType, schemaPath, schema) {
+  if (!schema.$schema) {
+    errors.push(`${schemaPath} must declare $schema.`);
+  }
+  if (!schema.$id) {
+    errors.push(`${schemaPath} must declare $id.`);
+  }
+  if (schema.type !== "object") {
+    errors.push(`${schemaPath} must describe an object schema.`);
+  }
+  if (!schema.title || !schema.title.toLowerCase().includes("delano")) {
+    errors.push(`${schemaPath} must include a Delano-specific title.`);
+  }
+  if (artifactType !== path.basename(schemaPath, ".schema.json")) {
+    errors.push(`${schemaPath} file name must match artifact type ${artifactType}.`);
+  }
+}
+
+function checkRequiredFields(artifactType, contract, schema) {
+  const expected = contract.required_fields || [];
+  const actual = schema.required || [];
+  for (const field of expected) {
+    if (!actual.includes(field)) {
+      errors.push(`${artifactType} schema must require canonical field: ${field}`);
+    }
+    if (!schema.properties || !schema.properties[field]) {
+      errors.push(`${artifactType} schema must define canonical property: ${field}`);
+    }
+  }
+}
+
+function checkEnumFields(artifactType, contract, schema) {
+  for (const [field, expectedValues] of Object.entries(contract.enum_fields || {})) {
+    const property = schema.properties && schema.properties[field];
+    if (!property) {
+      errors.push(`${artifactType} schema must define enum property: ${field}`);
+      continue;
+    }
+
+    const actualValues = property.enum || [];
+    for (const value of expectedValues) {
+      if (!actualValues.includes(value)) {
+        errors.push(`${artifactType}.${field} schema enum missing value: ${value}`);
+      }
+    }
+  }
+}
+
+function resolveRepoRoot(startDir) {
+  const candidates = [
+    path.resolve(startDir, ".."),
+    path.resolve(startDir, "..", "..")
+  ];
+
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, ".agents", "schemas", "artifact-scope.json"))) {
+      return candidate;
+    }
+  }
+
+  return path.resolve(startDir, "..");
+}
+
+function toRepoPath(filePath) {
+  return path.relative(repoRoot, filePath).split(path.sep).join("/");
+}

package/assets/payload/.agents/scripts/check-closeout-learning-proposals.mjs

@@ -0,0 +1,23 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+const __filename = fileURLToPath(import.meta.url); const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const errors = [];
+const schema = readJson(path.join(repoRoot, ".agents", "schemas", "learning", "closeout-learning-proposal.schema.json"));
+const skill = readText(path.join(repoRoot, ".agents", "skills", "closeout-skill", "SKILL.md"));
+const runbook = readText(path.join(repoRoot, ".agents", "skills", "closeout-skill", "references", "runbook.md"));
+const checklist = readText(path.join(repoRoot, ".agents", "skills", "closeout-skill", "templates", "closure-checklist.md"));
+const template = readText(path.join(repoRoot, ".agents", "skills", "closeout-skill", "templates", "learning-proposal.md"));
+for (const field of ["schema_version", "project", "task_ids", "proposal_type", "title", "rationale", "target_paths", "review_gate", "adoption_status"]) if (!schema.required?.includes(field)) errors.push(`proposal schema missing required field: ${field}`);
+for (const type of ["rule", "skill", "schema", "fixture"]) if (!schema.properties?.proposal_type?.enum?.includes(type)) errors.push(`proposal schema missing proposal type: ${type}`);
+if (!schema.properties?.review_gate?.enum?.includes("required-before-adoption")) errors.push("proposal schema must require review before adoption");
+if (schema.properties?.target_paths?.items?.not?.pattern !== "^/") errors.push("proposal target paths must reject absolute paths");
+for (const text of [skill, runbook, checklist, template]) {
+  if (!/review/i.test(text) || !/adoption/i.test(text)) errors.push("closeout learning workflow must mention review before adoption in skill assets");
+}
+if (errors.length) { console.error("Closeout learning proposal check failed:"); for (const error of errors) console.error(`- ${error}`); process.exit(1); }
+console.log("Closeout learning proposal workflow check passed.");
+function readJson(filePath){ if(!existsSync(filePath)){ errors.push(`missing file: ${path.relative(repoRoot,filePath)}`); return {}; } return JSON.parse(readFileSync(filePath,"utf8")); }
+function readText(filePath){ if(!existsSync(filePath)){ errors.push(`missing file: ${path.relative(repoRoot,filePath)}`); return ""; } return readFileSync(filePath,"utf8"); }
+function resolveRepoRoot(startDir){ for(const c of [path.resolve(startDir,".."),path.resolve(startDir,"..","..")]) if(existsSync(path.join(c,".agents"))) return c; return path.resolve(startDir,".."); }

package/assets/payload/.agents/scripts/check-context-audit.mjs

@@ -0,0 +1,61 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const contextDir = readOption("--context") || path.join(repoRoot, ".project", "context");
+const requiredFiles = [
+  "project-overview.md",
+  "project-brief.md",
+  "tech-context.md",
+  "project-structure.md",
+  "system-patterns.md",
+  "product-context.md",
+  "project-style-guide.md",
+  "progress.md",
+  "gui-testing.md"
+];
+const commandFiles = new Map([
+  ["project-style-guide.md", ["bash .agents/scripts/pm/validate.sh"]],
+  ["tech-context.md", ["validate.sh"]]
+]);
+const results = requiredFiles.map(auditFile);
+const summary = results.reduce((acc, item) => {
+  acc[item.classification] = (acc[item.classification] || 0) + 1;
+  return acc;
+}, {});
+const blocking = results.filter((item) => ["missing", "placeholder", "missing_required_commands"].includes(item.classification));
+const report = { schema_version: 1, context_dir: path.relative(repoRoot, contextDir) || ".", file_count: results.length, summary, results, blocking_count: blocking.length };
+
+if (process.argv.includes("--json")) console.log(JSON.stringify(report, null, 2));
+else console.log(`Context audit scored ${results.length} file(s): ${Object.entries(summary).map(([k,v])=>`${k}=${v}`).join(", ")}.`);
+if (blocking.length) process.exit(1);
+
+function auditFile(file) {
+  const filePath = path.join(contextDir, file);
+  if (!existsSync(filePath)) return { file, classification: "missing", score: 0, reasons: ["required context file is absent"] };
+  const text = readFileSync(filePath, "utf8");
+  const reasons = [];
+  if (isPlaceholder(text)) return { file, classification: "placeholder", score: 10, reasons: ["contains placeholder language or too little repo-specific content"] };
+  const requiredCommands = commandFiles.get(file) || [];
+  const missingCommands = requiredCommands.filter((command) => !text.includes(command));
+  if (missingCommands.length) return { file, classification: "missing_required_commands", score: 50, reasons: missingCommands.map((command)=>`missing command reference: ${command}`) };
+  if (file === "gui-testing.md") return { file, classification: "not_applicable", score: 100, reasons: ["advisory-only GUI policy file"] };
+  if (isStale(text)) reasons.push("frontmatter updated date is older than the current delivery cycle");
+  return { file, classification: reasons.length ? "stale" : "real", score: reasons.length ? 70 : 100, reasons };
+}
+function isPlaceholder(text) {
+  const compact = text.replace(/---[\s\S]*?---/, "").trim();
+  if (compact.length < 80) return true;
+  if (/TODO|TBD/i.test(compact)) return true;
+  const repoSpecific = /Delano|\.agents|\.project|HANDBOOK|npm|CLI|runtime/i.test(compact);
+  return !repoSpecific && /Capture architecture|Document major repository boundaries/i.test(compact);
+}
+function isStale(text) {
+  const match = text.match(/^updated:\s*(\d{4}-\d{2}-\d{2})/m);
+  return Boolean(match && match[1] < "2026-04-29");
+}
+function readOption(name) { const i = process.argv.indexOf(name); return i === -1 ? "" : process.argv[i + 1]; }
+function resolveRepoRoot(startDir) { for (const c of [path.resolve(startDir,".."),path.resolve(startDir,"..","..")]) if (existsSync(path.join(c,".project"))) return c; return path.resolve(startDir,".."); }

package/assets/payload/.agents/scripts/check-delivery-metric-events.mjs

@@ -0,0 +1,35 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const schemaPath = path.join(repoRoot, ".agents", "schemas", "metrics", "delivery-event.schema.json");
+const errors = [];
+const schema = readJson(schemaPath);
+
+const requiredFields = ["schema_version", "event_id", "event_type", "project", "created_at", "source", "privacy", "summary"];
+const eventTypes = ["task-status-change", "validation-run", "sync-drift", "evidence-gap", "blocked-time", "closeout-learning"];
+for (const field of requiredFields) if (!schema.required?.includes(field)) errors.push(`delivery metric event schema must require ${field}`);
+for (const eventType of eventTypes) if (!schema.properties?.event_type?.enum?.includes(eventType)) errors.push(`delivery metric event type missing ${eventType}`);
+if (schema.properties?.privacy?.properties?.raw_text_allowed?.const !== false) errors.push("delivery metric events must disallow raw text by default");
+if (schema.properties?.privacy?.properties?.summary_only?.const !== true) errors.push("delivery metric events must be summary-only");
+if (!schema.properties?.summary?.minLength) errors.push("delivery metric events must include a non-empty privacy-safe summary");
+
+if (errors.length) {
+  console.error("Delivery metric event contract check failed:");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+console.log(`Delivery metric event schema check passed for ${eventTypes.length} event type(s).`);
+console.log(`Delivery metric event contract check passed for ${eventTypes.length} event type(s).`);
+
+function readJson(filePath) {
+  if (!existsSync(filePath)) {
+    errors.push(`missing file: ${path.relative(repoRoot, filePath)}`);
+    return {};
+  }
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function resolveRepoRoot(startDir) { for (const c of [path.resolve(startDir,".."),path.resolve(startDir,"..","..")]) if (existsSync(path.join(c,".agents"))) return c; return path.resolve(startDir,".."); }

package/assets/payload/.agents/scripts/check-delivery-metrics.mjs

@@ -0,0 +1,52 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const errors = [];
+const schema = readJson(path.join(repoRoot, ".agents", "schemas", "metrics", "delivery-events.schema.json"));
+const docs = readText(path.join(repoRoot, ".agents", "logs", "delivery-metrics.md"));
+
+for (const field of ["schema_version", "event_id", "event_type", "timestamp", "project", "actor", "summary"]) {
+  if (!schema.required?.includes(field)) errors.push(`delivery metric schema missing required field: ${field}`);
+}
+const eventTypes = schema.properties?.event_type?.enum || [];
+for (const eventType of ["task_status_changed", "validation_run", "lease_acquired", "lease_released", "drift_report_generated", "repair_plan_created", "closeout_recorded"]) {
+  if (!eventTypes.includes(eventType)) errors.push(`delivery metric schema missing event type: ${eventType}`);
+  if (!docs.includes(eventType)) errors.push(`delivery metrics docs missing event type: ${eventType}`);
+}
+if (schema.properties?.summary?.properties?.privacy?.const !== "metadata-only") errors.push("delivery metric summaries must be metadata-only.");
+const repoPathPattern = schema.properties?.evidence?.properties?.repo_paths?.items?.not?.pattern;
+if (repoPathPattern !== "^/") errors.push("delivery metric evidence must reject absolute repo paths.");
+for (const forbidden of ["prompt_raw", "prompt_redacted", "transcript", "customer_data"]) {
+  if (JSON.stringify(schema).includes(forbidden) || docs.includes(forbidden)) errors.push(`delivery metrics contract mentions forbidden raw field: ${forbidden}`);
+}
+
+if (errors.length > 0) {
+  console.error("Delivery metric event check failed:");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+console.log(`Delivery metric event check passed for ${eventTypes.length} event type(s).`);
+
+function readJson(filePath) {
+  if (!existsSync(filePath)) {
+    errors.push(`missing file: ${path.relative(repoRoot, filePath)}`);
+    return {};
+  }
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function readText(filePath) {
+  if (!existsSync(filePath)) {
+    errors.push(`missing file: ${path.relative(repoRoot, filePath)}`);
+    return "";
+  }
+  return readFileSync(filePath, "utf8");
+}
+function resolveRepoRoot(startDir) {
+  const candidates = [path.resolve(startDir, ".."), path.resolve(startDir, "..", "..")];
+  for (const candidate of candidates) if (existsSync(path.join(candidate, ".project")) && existsSync(path.join(candidate, ".agents"))) return candidate;
+  return path.resolve(startDir, "..");
+}