@bvdm/delano 0.1.5 → 0.1.8

package/assets/payload/.agents/scripts/check-evidence-map.mjs

@@ -0,0 +1,143 @@
+import { existsSync, readdirSync, 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 contractPath = path.join(repoRoot, ".agents", "schemas", "evidence-map.json");
+const projectsRoot = path.join(repoRoot, ".project", "projects");
+const errors = [];
+const warnings = [];
+
+const contract = readJson(contractPath, "evidence map contract");
+const strictSince = Date.parse(contract.strict_since || "2026-04-29T00:00:00Z");
+const proofRules = Array.isArray(contract.done_task_rules) ? contract.done_task_rules : [];
+if (contract.schema_version !== 1) errors.push("evidence-map.json schema_version must be 1.");
+for (const requiredRule of ["acceptance-criteria-checked", "evidence-log-present", "validation-proof"]) {
+  if (!proofRules.some((rule) => rule.id === requiredRule)) errors.push(`evidence map contract missing rule: ${requiredRule}`);
+}
+
+for (const taskFile of listTaskFiles(projectsRoot)) {
+  const text = readFileSync(taskFile, "utf8");
+  const frontmatter = parseFrontmatter(taskFile, text);
+  if (frontmatter.status !== "done") continue;
+
+  const strict = isStrictTask(frontmatter, strictSince);
+  const taskErrors = validateDoneTask(taskFile, text, proofRules);
+  if (strict) errors.push(...taskErrors);
+  else warnings.push(...taskErrors);
+}
+
+if (errors.length > 0) {
+  console.error("Evidence map check failed:");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+if (warnings.length > 0) {
+  console.warn(`Evidence map check warnings: ${warnings.length} legacy evidence warning(s).`);
+}
+console.log("Evidence map check passed for done task acceptance criteria.");
+
+function validateDoneTask(taskFile, text, proofRules) {
+  const localErrors = [];
+  const acceptanceSection = section(text, "Acceptance Criteria");
+  const evidenceSection = section(text, "Evidence Log");
+  const evidenceText = evidenceSection || "";
+  const fullEvidenceContext = `${evidenceText}\n${text}`;
+  const criteria = acceptanceSection.split("\n").filter((line) => /^- \[[ xX]\]/.test(line.trim()));
+
+  for (const criterion of criteria) {
+    if (!/^- \[[xX]\]/.test(criterion.trim())) {
+      localErrors.push(`${toRepoPath(taskFile)} is done but has unchecked acceptance criterion: ${criterion.trim()}`);
+    }
+  }
+
+  const implementationEvidence = evidenceSection
+    .split("\n")
+    .filter((line) => /^- \d{4}-\d{2}-\d{2}/.test(line.trim()) && !line.toLowerCase().includes("implementation evidence pending"));
+  if (implementationEvidence.length === 0) {
+    localErrors.push(`${toRepoPath(taskFile)} is done but lacks implementation evidence in Evidence Log.`);
+  }
+
+  for (const rule of proofRules) {
+    if (!rule.acceptance_criterion_contains) continue;
+    const matchingCriterion = criteria.find((criterion) => criterion.toLowerCase().includes(rule.acceptance_criterion_contains.toLowerCase()));
+    if (!matchingCriterion) continue;
+    const proofTerms = Array.isArray(rule.proof_terms) ? rule.proof_terms : [];
+    if (proofTerms.length === 0) continue;
+    const hasProof = proofTerms.some((term) => fullEvidenceContext.toLowerCase().includes(term.toLowerCase()));
+    if (!hasProof) {
+      localErrors.push(`${toRepoPath(taskFile)} criterion lacks mapped evidence proof for rule ${rule.id}: ${matchingCriterion.trim()}`);
+    }
+  }
+
+  return localErrors;
+}
+
+function isStrictTask(frontmatter, strictSince) {
+  const updated = Date.parse(frontmatter.updated || "");
+  if (!Number.isNaN(updated) && updated >= strictSince) return true;
+  const created = Date.parse(frontmatter.created || "");
+  return !Number.isNaN(created) && created >= strictSince;
+}
+
+function section(text, heading) {
+  const lines = text.split("\n");
+  const start = lines.findIndex((line) => line.trim() === `## ${heading}`);
+  if (start === -1) return "";
+  const collected = [];
+  for (const line of lines.slice(start + 1)) {
+    if (line.startsWith("## ")) break;
+    collected.push(line);
+  }
+  return collected.join("\n").trim();
+}
+
+function parseFrontmatter(filePath, text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---\n/);
+  if (!match) { errors.push(`${toRepoPath(filePath)} is missing frontmatter.`); return {}; }
+  const result = {};
+  for (const line of match[1].split("\n")) {
+    const index = line.indexOf(":");
+    if (index === -1) continue;
+    result[line.slice(0, index).trim()] = line.slice(index + 1).trim();
+  }
+  return result;
+}
+
+function listTaskFiles(root) {
+  if (!existsSync(root)) return [];
+  const files = [];
+  for (const project of readdirSync(root, { withFileTypes: true })) {
+    if (!project.isDirectory()) continue;
+    const tasksDir = path.join(root, project.name, "tasks");
+    if (!existsSync(tasksDir)) continue;
+    for (const task of readdirSync(tasksDir, { withFileTypes: true })) {
+      if (task.isFile() && task.name.endsWith(".md")) files.push(path.join(tasksDir, task.name));
+    }
+  }
+  return files;
+}
+
+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 resolveRepoRoot(startDir) {
+  const candidates = [path.resolve(startDir, ".."), path.resolve(startDir, "..", "..")];
+  for (const candidate of candidates) {
+    if (existsSync(path.join(candidate, ".project", "projects")) && existsSync(path.join(candidate, ".agents"))) return candidate;
+  }
+  return path.resolve(startDir, "..");
+}
+
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function toRepoPath(filePath) {
+  return path.relative(repoRoot, filePath).split(path.sep).join("/");
+}

package/assets/payload/.agents/scripts/check-github-status-inspection.mjs

@@ -0,0 +1,93 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const errors = [];
+const warnings = [];
+const snapshotPath = path.join(repoRoot, ".agents", "fixtures", "github", "status-snapshot.json");
+const syncMap = readLocalSyncMap();
+const snapshot = readJson(snapshotPath, "GitHub status snapshot", { repositories: [] });
+const snapshotIndex = indexSnapshot(snapshot);
+
+if (snapshot.schema_version !== 1) errors.push("GitHub status snapshot schema_version must be 1.");
+
+for (const project of syncMap.projects || []) {
+  for (const task of project.tasks || []) {
+    inspectRef(project, task, "github_issue", "issue");
+    inspectRef(project, task, "github_pr", "pull_request");
+  }
+}
+
+if (errors.length > 0) {
+  console.error("GitHub status inspection failed:");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+console.log(`GitHub status inspection passed with ${warnings.length} local-only warning(s).`);
+if (process.argv.includes("--verbose")) for (const warning of warnings) console.warn(`Warning: ${warning}`);
+
+function inspectRef(project, task, field, kind) {
+  const value = task[field];
+  if (!value) return;
+  const parsed = parseGitHubRef(value, project.github_repo);
+  if (!parsed) {
+    errors.push(`${project.slug}/${task.local_id} has invalid ${field}: ${value}`);
+    return;
+  }
+  if (parsed.kind !== kind) errors.push(`${project.slug}/${task.local_id} expected ${kind} but got ${parsed.kind}: ${value}`);
+  const key = `${parsed.owner}/${parsed.repo}#${parsed.number}:${parsed.kind}`;
+  const remote = snapshotIndex.get(key);
+  if (!remote) {
+    warnings.push(`${project.slug}/${task.local_id} ${field} ${key} has no mock snapshot; treated as local-only.`);
+    return;
+  }
+  if (!remote.state) errors.push(`${project.slug}/${task.local_id} ${field} ${key} snapshot lacks state.`);
+  if (kind === "pull_request" && remote.mergeable === "unknown") warnings.push(`${project.slug}/${task.local_id} PR ${key} has unknown mergeability.`);
+}
+
+function parseGitHubRef(value, fallbackRepo) {
+  const raw = String(value || "").trim();
+  if (!raw) return null;
+  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 && fallbackRepo.includes("/")) {
+    const [owner, repo] = fallbackRepo.split("/");
+    return { owner, repo, kind: "issue", number: Number(short[1]) };
+  }
+  return null;
+}
+
+function indexSnapshot(snapshot) {
+  const index = new Map();
+  for (const repo of snapshot.repositories || []) {
+    const owner = repo.owner;
+    const name = repo.name;
+    for (const issue of repo.issues || []) index.set(`${owner}/${name}#${issue.number}:issue`, issue);
+    for (const pr of repo.pull_requests || []) index.set(`${owner}/${name}#${pr.number}:pull_request`, pr);
+  }
+  return index;
+}
+
+function readLocalSyncMap() {
+  const result = spawnSync(process.execPath, [path.join(repoRoot, "scripts", "check-local-sync-map.mjs"), "--json"], { cwd: repoRoot, encoding: "utf8" });
+  if (result.status !== 0) {
+    errors.push(`local sync map reader failed: ${result.stderr || result.stdout}`);
+    return { projects: [] };
+  }
+  const parsed = JSON.parse(result.stdout);
+  return parsed.sync_map || parsed;
+}
+function readJson(filePath, label, fallback) {
+  try { return JSON.parse(readFileSync(filePath, "utf8")); }
+  catch (error) { errors.push(`Could not read ${label}: ${error.message}`); return fallback; }
+}
+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-github-sync.mjs

@@ -0,0 +1,159 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+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 args = new Set(process.argv.slice(2));
+const jsonMode = args.has("--json");
+const allowNetwork = args.has("--fetch");
+const syncMapPath = readOption("--sync-map");
+const statePath = readOption("--github-state") || readOption("--fixture");
+
+const syncMap = syncMapPath ? readJson(syncMapPath) : readLocalSyncMap(repoRoot);
+const githubState = statePath ? readJson(statePath) : (allowNetwork ? fetchGithubState(syncMap) : { repositories: {}, source: "none" });
+const report = inspectGithubSync(syncMap, githubState, { fetched: allowNetwork && !statePath });
+
+if (jsonMode) {
+  console.log(JSON.stringify(report, null, 2));
+} else {
+  console.log(`GitHub sync inspection checked ${report.summary.checked_refs} refs; ${report.summary.drift_count} drift item(s).`);
+  if (!allowNetwork && !statePath) console.log("No GitHub state supplied; use --github-state <file> for deterministic dry-run inspection or --fetch to query gh.");
+  for (const drift of report.drift) console.log(`- ${drift.severity}: ${drift.task} ${drift.summary}`);
+}
+
+if (report.errors.length > 0) {
+  if (!jsonMode) {
+    console.error("GitHub sync inspection failed:");
+    for (const error of report.errors) console.error(`- ${error}`);
+  }
+  process.exit(1);
+}
+
+export function inspectGithubSync(syncMap, githubState = {}, options = {}) {
+  const errors = [];
+  const inspections = [];
+  const drift = [];
+  for (const project of syncMap.projects || []) {
+    const repo = project.github_repo || githubState.default_repository || "";
+    for (const task of project.tasks || []) {
+      for (const field of ["github_issue", "github_pr"]) {
+        const localRef = task[field];
+        if (!localRef) continue;
+        const type = field === "github_pr" ? "pull_request" : "issue";
+        const parsed = parseGithubRef(localRef, repo, type);
+        const taskKey = `${project.slug}:${task.local_id}`;
+        if (!parsed) {
+          errors.push(`${taskKey} has unsupported ${field}: ${localRef}`);
+          continue;
+        }
+        const external = lookupGithubState(githubState, parsed);
+        const inspection = {
+          task: taskKey,
+          field,
+          local_ref: localRef,
+          repository: parsed.repository,
+          number: parsed.number,
+          type,
+          external_state: external?.state || "unknown",
+          external_url: external?.url || parsed.url || "",
+          source: external?.source || githubState.source || (options.fetched ? "gh" : "fixture-or-none")
+        };
+        inspections.push(inspection);
+        if (!external) {
+          drift.push({
+            drift_type: "orphan-drift",
+            severity: "warning",
+            task: taskKey,
+            target: `${parsed.repository}#${parsed.number}`,
+            summary: `references ${field} without inspected GitHub state`,
+            evidence: { local_ref: localRef }
+          });
+        } else if (external.kind && external.kind !== type) {
+          drift.push({
+            drift_type: "mapping-drift",
+            severity: "error",
+            task: taskKey,
+            target: `${parsed.repository}#${parsed.number}`,
+            summary: `local ${field} points at inspected ${external.kind}`,
+            evidence: { local_ref: localRef, external_kind: external.kind }
+          });
+        }
+      }
+    }
+  }
+  return {
+    schema_version: 1,
+    source: githubState.source || (options.fetched ? "gh" : "local-dry-run"),
+    summary: { checked_refs: inspections.length, drift_count: drift.length },
+    inspections,
+    drift,
+    errors
+  };
+}
+
+function parseGithubRef(ref, projectRepo, type) {
+  const value = String(ref || "").trim();
+  if (!value) return null;
+  const urlMatch = value.match(/^https:\/\/github\.com\/([^/]+\/[^/]+)\/(issues|pull)\/(\d+)/);
+  if (urlMatch) return { repository: urlMatch[1], number: urlMatch[3], url: value };
+  const shorthand = value.match(/^([^/\s]+\/[^#\s]+)#(\d+)$/);
+  if (shorthand) return { repository: shorthand[1], number: shorthand[2] };
+  const number = value.match(/^#?(\d+)$/);
+  if (number && projectRepo) return { repository: projectRepo, number: number[1] };
+  return null;
+}
+
+function lookupGithubState(state, parsed) {
+  const repo = state.repositories?.[parsed.repository] || state.repos?.[parsed.repository];
+  if (!repo) return null;
+  const pr = repo.pull_requests?.[parsed.number] || repo.prs?.[parsed.number];
+  if (pr) return { ...pr, kind: "pull_request", source: state.source || "fixture" };
+  const issue = repo.issues?.[parsed.number];
+  if (issue) return { ...issue, kind: "issue", source: state.source || "fixture" };
+  return null;
+}
+
+function fetchGithubState(syncMap) {
+  const repositories = {};
+  if (!commandExists("gh")) return { repositories, source: "gh-unavailable" };
+  for (const project of syncMap.projects || []) {
+    const repo = project.github_repo;
+    if (!repo) continue;
+    repositories[repo] ||= { issues: {}, pull_requests: {} };
+    for (const task of project.tasks || []) {
+      const refs = [task.github_issue, task.github_pr].filter(Boolean);
+      for (const ref of refs) {
+        const parsed = parseGithubRef(ref, repo);
+        if (!parsed) continue;
+        const result = spawnSync("gh", ["issue", "view", parsed.number, "--repo", parsed.repository, "--json", "number,state,url"], { encoding: "utf8" });
+        if (result.status === 0) {
+          const issue = JSON.parse(result.stdout);
+          repositories[parsed.repository] ||= { issues: {}, pull_requests: {} };
+          repositories[parsed.repository].issues[String(issue.number)] = { state: issue.state, url: issue.url };
+        }
+      }
+    }
+  }
+  return { repositories, source: "gh" };
+}
+
+function readOption(name) {
+  const index = process.argv.indexOf(name);
+  return index === -1 ? "" : process.argv[index + 1];
+}
+function readJson(filePath) {
+  return JSON.parse(readFileSync(filePath, "utf8"));
+}
+function commandExists(name) {
+  const result = spawnSync(process.platform === "win32" ? "where" : "command", process.platform === "win32" ? [name] : ["-v", name], { shell: process.platform !== "win32", stdio: "ignore" });
+  return result.status === 0;
+}
+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-handoff-summaries.mjs

@@ -0,0 +1,57 @@
+import { existsSync, mkdirSync, readFileSync, rmSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const statePath = readOption("--state") || path.join(repoRoot, ".agents", "leases", "active-leases.json");
+const selfTest = process.argv.includes("--self-test") || !existsSync(statePath);
+const errors = [];
+
+if (selfTest) runSelfTest();
+else validateState(statePath);
+
+if (process.argv.includes("--json")) console.log(JSON.stringify({ schema_version: 1, ok: errors.length === 0, error_count: errors.length, errors }, null, 2));
+else console.log(`Handoff summary check ${errors.length ? "failed" : "passed"} with ${errors.length} error(s).`);
+
+if (errors.length) {
+  if (!process.argv.includes("--json")) for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+
+function validateState(filePath) {
+  const state = JSON.parse(readFileSync(filePath, "utf8"));
+  for (const lease of state.leases || []) {
+    if (lease.status !== "released") continue;
+    validateSummary(lease.handoff_summary || "", `${lease.project}/${lease.task_id}`);
+  }
+}
+
+function runSelfTest() {
+  const dir = path.join(os.tmpdir(), `delano-handoff-${process.pid}`);
+  const state = path.join(dir, "leases.json");
+  mkdirSync(dir, { recursive: true });
+  try {
+    const acquire = spawnSync(process.execPath, ["scripts/lease-manager.mjs", "acquire", "--state", state, "--owner", "handoff-test", "--project", "delano-multi-agent-execution", "--task", "T-006", "--zone", "scripts/lease-manager.mjs"], { cwd: repoRoot, encoding: "utf8" });
+    if (acquire.status !== 0) { errors.push(`self-test acquire failed: ${acquire.stderr || acquire.stdout}`); return; }
+    const lease = JSON.parse(readFileSync(state, "utf8")).leases[0];
+    const missing = spawnSync(process.execPath, ["scripts/lease-manager.mjs", "release", "--state", state, "--lease-id", lease.lease_id], { cwd: repoRoot, encoding: "utf8" });
+    if (missing.status === 0) errors.push("release without --handoff should be rejected for active stream closeout");
+    const summary = "Changed: validated handoff requirement\nEvidence: self-test release gate\nBlockers: none\nLease state: released\nNext safe action: continue";
+    const release = spawnSync(process.execPath, ["scripts/lease-manager.mjs", "release", "--state", state, "--lease-id", lease.lease_id, "--handoff", summary], { cwd: repoRoot, encoding: "utf8" });
+    if (release.status !== 0) errors.push(`self-test release with handoff failed: ${release.stderr || release.stdout}`);
+    validateState(state);
+  } finally {
+    rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+function validateSummary(summary, target) {
+  const required = ["Changed:", "Evidence:", "Blockers:", "Lease state:", "Next safe action:"];
+  for (const heading of required) if (!summary.includes(heading)) errors.push(`${target} handoff_summary missing ${heading}`);
+}
+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,".agents"))) return c; return path.resolve(startDir,".."); }

package/assets/payload/.agents/scripts/check-lease-conflicts.mjs

@@ -0,0 +1,24 @@
+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 statePath = readOption("--state") || path.join(repoRoot, ".agents", "leases", "active-leases.json");
+const requestedZones = readList("--zone");
+const requestedMode = readOption("--mode") || "shared";
+const state = readState(statePath);
+const active = (state.leases || []).filter((lease) => lease.status === "active" && new Date(lease.expires_at).getTime() > Date.now());
+const conflicts = [];
+for (const lease of active) {
+  const overlap = requestedZones.length ? lease.conflict_zones.filter((zone) => requestedZones.includes(zone)) : [];
+  if (!requestedZones.length) continue;
+  if (overlap.length && (lease.mode === "exclusive" || requestedMode === "exclusive")) conflicts.push({ lease_id: lease.lease_id, owner: lease.owner, zones: overlap, mode: lease.mode });
+}
+if (process.argv.includes("--json")) console.log(JSON.stringify({ schema_version: 1, conflict_count: conflicts.length, conflicts }, null, 2));
+else console.log(`Lease conflict check found ${conflicts.length} conflict(s).`);
+if (conflicts.length) process.exit(2);
+function readState(filePath) { if (!existsSync(filePath)) return { schema_version: 1, leases: [] }; return JSON.parse(readFileSync(filePath, "utf8")); }
+function readOption(name) { const i = process.argv.indexOf(name); return i === -1 ? "" : process.argv[i + 1]; }
+function readList(name) { const out=[]; process.argv.forEach((arg,i)=>{ if(arg===name && process.argv[i+1]) out.push(process.argv[i+1]); }); return out; }
+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-lease-contracts.mjs

@@ -0,0 +1,17 @@
+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 schema = JSON.parse(readFileSync(path.join(repoRoot, ".agents", "schemas", "leases", "lease.schema.json"), "utf8"));
+const errors = [];
+for (const field of ["schema_version", "lease_id", "owner", "project", "task_id", "status", "mode", "conflict_zones", "acquired_at", "expires_at"]) {
+  if (!schema.required?.includes(field)) errors.push(`lease schema must require ${field}`);
+}
+for (const status of ["active", "released", "expired"]) if (!schema.properties?.status?.enum?.includes(status)) errors.push(`lease status missing ${status}`);
+for (const mode of ["shared", "exclusive"]) if (!schema.properties?.mode?.enum?.includes(mode)) errors.push(`lease mode missing ${mode}`);
+if (!schema.properties?.handoff_summary) errors.push("lease schema must reserve handoff_summary for release closeout");
+if (errors.length) { console.error("Lease contract check failed:"); for (const e of errors) console.error(`- ${e}`); process.exit(1); }
+console.log("Lease contract check passed for lifecycle fields and modes.");
+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-linear-issue-inspection.mjs

@@ -0,0 +1,63 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { spawnSync } from "node:child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const repoRoot = resolveRepoRoot(__dirname);
+const errors = [];
+const warnings = [];
+const snapshotPath = path.join(repoRoot, ".agents", "fixtures", "linear", "issue-snapshot.json");
+const syncMap = readLocalSyncMap();
+const snapshot = readJson(snapshotPath, "Linear issue snapshot", { issues: [] });
+const issueIndex = new Map((snapshot.issues || []).map((issue) => [issue.id, issue]));
+
+if (snapshot.schema_version !== 1) errors.push("Linear issue snapshot schema_version must be 1.");
+
+for (const project of syncMap.projects || []) {
+  for (const task of project.tasks || []) {
+    if (!task.linear_issue_id) continue;
+    if (!/^[-_A-Za-z0-9]+$/.test(task.linear_issue_id)) {
+      errors.push(`${project.slug}/${task.local_id} has invalid linear_issue_id: ${task.linear_issue_id}`);
+      continue;
+    }
+    const issue = issueIndex.get(task.linear_issue_id);
+    if (!issue) {
+      warnings.push(`${project.slug}/${task.local_id} Linear issue ${task.linear_issue_id} has no mock snapshot; treated as local-only.`);
+      continue;
+    }
+    if (!issue.state) errors.push(`${task.linear_issue_id} snapshot lacks state.`);
+    if (issue.project_id && project.linear_project_id && issue.project_id !== project.linear_project_id) errors.push(`${project.slug}/${task.local_id} Linear project drift: ${issue.project_id} != ${project.linear_project_id}`);
+    for (const dependency of issue.depends_on || []) {
+      if (!task.depends_on?.includes(dependency.local_id || dependency)) warnings.push(`${project.slug}/${task.local_id} remote dependency not present locally: ${dependency.local_id || dependency}`);
+    }
+  }
+}
+
+if (errors.length > 0) {
+  console.error("Linear issue inspection failed:");
+  for (const error of errors) console.error(`- ${error}`);
+  process.exit(1);
+}
+console.log(`Linear issue inspection passed with ${warnings.length} local-only warning(s).`);
+if (process.argv.includes("--verbose")) for (const warning of warnings) console.warn(`Warning: ${warning}`);
+
+function readLocalSyncMap() {
+  const result = spawnSync(process.execPath, [path.join(repoRoot, "scripts", "check-local-sync-map.mjs"), "--json"], { cwd: repoRoot, encoding: "utf8" });
+  if (result.status !== 0) {
+    errors.push(`local sync map reader failed: ${result.stderr || result.stdout}`);
+    return { projects: [] };
+  }
+  const parsed = JSON.parse(result.stdout);
+  return parsed.sync_map || parsed;
+}
+function readJson(filePath, label, fallback) {
+  try { return JSON.parse(readFileSync(filePath, "utf8")); }
+  catch (error) { errors.push(`Could not read ${label}: ${error.message}`); return fallback; }
+}
+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, "..");
+}