@jstn-sdk/ma 0.1.13 → 0.14.1

package/scripts/active-autonomy-hook.mjs

@@ -6,6 +6,8 @@ import {
   createDefaultActiveAutonomyCore,
   detectPassivePermissionHandoff,
 } from "../src/runtime/active-autonomy-core.js";
+import { resolveHookProfile } from "../src/runtime/hook-profiles.js";
+import { maskSensitiveText } from "../src/runtime/redaction-gateway.js";
 
 const DEFAULT_RESPONSE =
   "AUTO-CONTINUE: continue the current safe branch, execute the next reversible step, then verify before reporting.";
@@ -57,20 +59,106 @@ function extractAssistantText(payload) {
   return "";
 }
 
+function extractUserText(payload) {
+  const candidates = [
+    payload.last_user_message,
+    payload["last-user-message"],
+    payload.user_message,
+    payload.prompt,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) return candidate;
+  }
+
+  if (Array.isArray(payload.messages)) {
+    const user = [...payload.messages]
+      .reverse()
+      .find((message) => message?.role === "user" && typeof message.content === "string");
+    return user?.content ?? "";
+  }
+
+  return "";
+}
+
+function redactAuditPreview(value) {
+  if (typeof value !== "string" || !value) return { value: value ?? "", redactions: [] };
+  const redacted = maskSensitiveText(value.slice(0, 200));
+  return {
+    value: redacted.sanitizedText,
+    redactions: redacted.replacements.map(({ placeholder, placeholderBase }) => ({
+      placeholder,
+      placeholderBase,
+    })),
+  };
+}
+
 async function appendAudit(cwd, entry) {
   const auditDir = path.join(cwd, ".ma", "hooks");
   await fs.mkdir(auditDir, { recursive: true });
+  const assistantPreview = redactAuditPreview(entry.assistantPreview);
+  const userPreview = redactAuditPreview(entry.userPreview);
+  const safeEntry = {
+    ...entry,
+    ...(entry.assistantPreview !== undefined ? { assistantPreview: assistantPreview.value } : {}),
+    ...(entry.userPreview !== undefined ? { userPreview: userPreview.value } : {}),
+    previewRedactions: {
+      assistant: assistantPreview.redactions,
+      user: userPreview.redactions,
+    },
+  };
   await fs.appendFile(
     path.join(auditDir, "audit.log"),
-    `${JSON.stringify({ timestamp: new Date().toISOString(), ...entry })}\n`,
+    `${JSON.stringify({ timestamp: new Date().toISOString(), ...safeEntry })}\n`,
     "utf8",
   );
 }
 
+function classifyFinding(file) {
+  const value = String(file ?? "").toLowerCase();
+  if (/(node_modules|site-packages|vendor)/.test(value)) return "dependency";
+  if (/(dist|build|\.next|coverage|cache)/.test(value)) return "generated";
+  if (/(compat|legacy|history)/.test(value)) return "compatibility";
+  return "source";
+}
+
+async function writeBlockingReceipt(cwd, receipt) {
+  const receiptDir = path.join(cwd, ".ma", "hooks", "receipts");
+  await fs.mkdir(receiptDir, { recursive: true });
+  const receiptPath = path.join(receiptDir, `active-autonomy-${Date.now()}.json`);
+  await fs.writeFile(receiptPath, `${JSON.stringify(receipt, null, 2)}\n`, "utf8");
+  return path.relative(cwd, receiptPath);
+}
+
 const payload = await readStdinJson();
-const cwd = payload.cwd || payload.working_directory || process.env.MA_ROOT || process.cwd();
+const profile = resolveHookProfile(payload.profile);
+const cwd = path.resolve(
+  payload.project_root ||
+    payload.cwd ||
+    payload.working_directory ||
+    process.env.MA_ROOT ||
+    process.cwd(),
+);
+const broadScan =
+  profile.scanScope === "broad" ||
+  payload.broad_scan === true ||
+  process.env.MA_HOOK_BROAD_SCAN === "1";
+const ignoredArtifactClasses = [
+  "node_modules",
+  ".next",
+  "dist",
+  "build",
+  "coverage",
+  "cache",
+  "venv",
+  ".venv",
+  "site-packages",
+  "vendored bundles",
+];
 const assistantText = extractAssistantText(payload);
-const blocked = detectPassivePermissionHandoff(assistantText, createDefaultActiveAutonomyCore());
+const userText = extractUserText(payload);
+const blocked =
+  profile.block && detectPassivePermissionHandoff(assistantText, createDefaultActiveAutonomyCore());
 
 const result = blocked
   ? {
@@ -85,12 +173,54 @@ const result = blocked
       reason: "active_autonomy_no_passive_handoff_detected",
     };
 
-await appendAudit(cwd, {
-  hook: "active-autonomy",
-  event: payload.type || payload.event || "unknown",
-  decision: result.decision,
-  stopReason: result.stopReason,
-  assistantPreview: assistantText.slice(0, 200),
-});
+const matchedFiles = Array.isArray(payload.files) ? payload.files : [];
+const receiptPath = blocked
+  ? await writeBlockingReceipt(cwd, {
+      schemaVersion: "0.1.0",
+      record_type: "hook_receipt",
+      hook: "active-autonomy",
+      ruleId: "active_autonomy_passive_handoff",
+      scanRoot: cwd,
+      include: broadScan ? ["all"] : ["active-project"],
+      exclude: broadScan ? [] : ignoredArtifactClasses,
+      matchedFiles: matchedFiles.map((file) => ({
+        path: String(file.path ?? file),
+        line: Number.isInteger(file.line) ? file.line : null,
+        classification: classifyFinding(file.path ?? file),
+      })),
+      classification: matchedFiles.some((file) => classifyFinding(file.path ?? file) === "source")
+        ? "source"
+        : "false_positive_candidate",
+      blocked: true,
+      reason: result.reason,
+      recommendedAction: "Rewrite the response to continue the safe branch and verify it.",
+      suppressionPolicy: "No suppression without an explicit rationale.",
+      createdAt: new Date().toISOString(),
+      profile: profile.id,
+    })
+  : null;
+
+if (!profile.readOnly)
+  await appendAudit(cwd, {
+    hook: "active-autonomy",
+    scanRoot: cwd,
+    scope: broadScan ? "broad-opt-in" : "active-project",
+    ignoredArtifactClasses: broadScan ? [] : ignoredArtifactClasses,
+    event: payload.type || payload.event || "unknown",
+    decision: result.decision,
+    stopReason: result.stopReason,
+    assistantPreview: assistantText,
+    userPreview: userText,
+  });
 
-process.stdout.write(`${JSON.stringify(result)}\n`);
+process.stdout.write(
+  `${JSON.stringify({
+    ...result,
+    scanRoot: cwd,
+    scope: broadScan ? "broad-opt-in" : "active-project",
+    ignoredArtifactClasses: broadScan ? [] : ignoredArtifactClasses,
+    profile: profile.id,
+    readOnly: profile.readOnly,
+    ...(receiptPath ? { receiptPath } : {}),
+  })}\n`,
+);

package/scripts/build-linux-packages.mjs

@@ -2,9 +2,9 @@
 
 import { spawnSync } from "node:child_process";
 import fsp from "node:fs/promises";
-import os from "node:os";
 import path from "node:path";
 import process from "node:process";
+import { createTestNamespace } from "../src/test-fixtures.js";
 import {
   getDebArtifactPath,
   getLinuxPackageManifestPath,
@@ -87,6 +87,10 @@ async function createCommonRoot(root, packArtifactPath) {
   run("tar", ["-xzf", packArtifactPath, "-C", libRoot, "--strip-components=1", "package"], {
     cwd: repoRoot,
   });
+  const agentCompatSource = path.join(repoRoot, "node_modules", "@jstn-sdk", "agents");
+  const agentCompatTarget = path.join(libRoot, "node_modules", "@jstn-sdk", "agents");
+  await fsp.access(agentCompatSource);
+  await copyDir(agentCompatSource, agentCompatTarget);
 
   const wrapper = `#!/bin/sh
 PREFIX="\${META_ARCHITECT_PREFIX:-}"
@@ -267,6 +271,7 @@ async function main() {
 
   await fsp.mkdir(distRoot, { recursive: true });
   const packArtifactPath = getPackArtifactPath(distRoot, packageName, version);
+  const workRoot = createTestNamespace("meta-architect-linux-packages");
   await fsp.rm(packArtifactPath, { force: true });
   run(
     "npm",
@@ -275,14 +280,13 @@ async function main() {
       ".",
       "--ignore-scripts",
       "--cache",
-      path.join(distRoot, ".npm-cache"),
+      path.join(workRoot, "npm-cache"),
       "--pack-destination",
       distRoot,
     ],
     { cwd: repoRoot },
   );
 
-  const workRoot = await fsp.mkdtemp(path.join(os.tmpdir(), "meta-architect-linux-packages-"));
   const commonRoot = path.join(workRoot, "root");
   await createCommonRoot(commonRoot, packArtifactPath);
 

package/scripts/cleanup-test-fixtures.sh

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+REQUESTED_TMP_DIR="${MA_TEST_ROOT:-/tmp/ma-tests}"
+MAX_SIZE_BYTES=$((2 * 1024 * 1024 * 1024))
+
+case "$REQUESTED_TMP_DIR" in
+  /tmp/ma-tests|/tmp/ma-tests/*) ;;
+  *) echo "Refusing to clean unexpected path: $REQUESTED_TMP_DIR" >&2; exit 2 ;;
+esac
+
+TMP_DIR=$(node -e 'const path = require("node:path"); process.stdout.write(path.resolve(process.argv[1]));' "$REQUESTED_TMP_DIR")
+case "$TMP_DIR" in
+  /tmp/ma-tests|/tmp/ma-tests/*) ;;
+  *) echo "Refusing to clean resolved path: $TMP_DIR" >&2; exit 2 ;;
+esac
+
+if [ ! -d "$TMP_DIR" ]; then
+  echo "Test fixture root does not exist: $TMP_DIR"
+  exit 0
+fi
+
+find "$TMP_DIR" -type f \( -name '*.tar.zst' -o -name '*.tar.gz' \) -mtime +7 -delete
+find "$TMP_DIR" -type f -name '*.log' -mtime +3 -delete
+namespace_is_active() {
+  local namespace="$1"
+  local pid
+  if [ ! -f "$namespace/.active" ]; then return 1; fi
+  pid=$(cat "$namespace/.active" 2>/dev/null || true)
+  [[ "$pid" =~ ^[0-9]+$ ]] && kill -0 "$pid" 2>/dev/null
+}
+
+prune_namespaces_older_than() {
+  local age_minutes="$1"
+  local namespace
+  shopt -s nullglob
+  for namespace in "$TMP_DIR"/*; do
+    [ -d "$namespace" ] || continue
+    [ "$(basename "$namespace")" = retained ] && continue
+    namespace_is_active "$namespace" && continue
+    find "$namespace" -maxdepth 0 -type d -mmin +"$age_minutes" -exec rm -rf -- {} +
+  done
+}
+
+# Retained archives have their own seven-day policy and are not namespaces.
+prune_namespaces_older_than 1440
+
+CURRENT_KIB=$(du -sk "$TMP_DIR" 2>/dev/null | cut -f1 || echo 0)
+CURRENT_BYTES=$((CURRENT_KIB * 1024))
+echo "Current $TMP_DIR usage: $CURRENT_BYTES bytes"
+
+if [ "$CURRENT_BYTES" -gt "$MAX_SIZE_BYTES" ]; then
+  echo "::warning::$TMP_DIR exceeded 2GB; removing expired namespaces"
+  prune_namespaces_older_than 60
+fi

package/scripts/context-hydration-hook.mjs

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import { createBudgetedContext } from "../src/runtime/context-economy-core.js";
+import { maskSensitiveText } from "../src/runtime/redaction-gateway.js";
+
+const root = path.resolve(process.env.MA_ROOT || process.cwd());
+const contextRoot = path.join(root, ".ma", "context");
+
+async function read(relative, fallback = null) {
+  try {
+    return await fs.readFile(path.join(contextRoot, relative), "utf8");
+  } catch {
+    return fallback;
+  }
+}
+
+const [project, brief, commands, learning] = await Promise.all([
+  read("project-index.json"),
+  read("agent-brief.md", ""),
+  read("commands.json"),
+  fs.readFile(path.join(root, ".ma", "learning", "records.jsonl"), "utf8").catch(() => ""),
+]);
+const preferences = await fs
+  .readFile(path.join(root, ".ma", "memory", "preferences.json"), "utf8")
+  .catch(() => "{}");
+const records = learning
+  .split("\n")
+  .filter(Boolean)
+  .slice(-3)
+  .map((line) => {
+    try {
+      const value = JSON.parse(line);
+      return { claim: value.claim, status: value.status, authority: "learning_memory" };
+    } catch {
+      return null;
+    }
+  })
+  .filter(Boolean);
+
+const result = {
+  record_type: "context_hydration",
+  root,
+  loaded: {
+    projectIndex: Boolean(project),
+    agentBrief: Boolean(brief),
+    commands: Boolean(commands),
+    learningRecords: records.length,
+    preferences: preferences !== "{}",
+  },
+  skipped: ["repository-wide source scan", "full Obsidian vault"],
+  stale: project
+    ? (() => {
+        try {
+          return JSON.parse(project).freshness?.status === "stale";
+        } catch {
+          return true;
+        }
+      })()
+    : true,
+  authority: "generated_context",
+  context: {
+    project: project ? maskSensitiveText(project).sanitizedText : null,
+    brief: maskSensitiveText(brief).sanitizedText,
+    commands: commands ? maskSensitiveText(commands).sanitizedText : null,
+    learning: records,
+    preferences: (() => {
+      try {
+        return JSON.parse(preferences).preferences ?? {};
+      } catch {
+        return {};
+      }
+    })(),
+  },
+};
+const budgeted = createBudgetedContext({
+  budgetChars: Number(process.env.MA_CONTEXT_BUDGET_CHARS || 12000),
+  topic: process.env.MA_CONTEXT_TOPIC,
+  items: [
+    { id: "agent-brief", tier: 1, topic: "brief", text: brief },
+    { id: "commands", tier: 3, topic: "commands", text: commands ?? "" },
+    { id: "learning", tier: 4, topic: "learning", text: JSON.stringify(records) },
+    { id: "preferences", tier: 4, topic: "preferences", text: preferences },
+    { id: "project-index", tier: 5, topic: "project", text: project ?? "" },
+  ],
+});
+result.budget = budgeted;
+process.stdout.write(`${JSON.stringify(result)}\n`);

package/scripts/demo-smoke.js

@@ -0,0 +1,285 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  createContextEconomyView,
+  createDefaultLearningLoopCore,
+  createDefaultPromptStrategyCore,
+  createDiscoveredEnvironmentAwarenessCore,
+  createObsidianNote,
+  createRalphPrdContract,
+  evaluateLearningLoopReadiness,
+  indexObsidianVault,
+  readObsidianNote,
+  runIdea,
+  runInit,
+  updateObsidianNote,
+  validatePromptStrategyCore,
+  validateRalphPrdContract,
+  writeObsidianVaultIndex,
+} from "../index.js";
+import { loadRuntimeSnapshot } from "../src/runtime/runtime-state.js";
+import { runMaestro } from "../src/skills.js";
+import { createTestNamespace } from "../src/test-fixtures.js";
+
+const demoIdea =
+  "Northstar Logistics wants to harden an existing dispatch analytics workspace for a production release. MA must inspect current runtime context, use Obsidian vault notes as brain context, route through relevant roles, preserve security gates, and produce a release-safe next action instead of asking for permission.";
+
+async function writeFile(file, content) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  await fs.writeFile(file, content, "utf8");
+}
+
+async function seedWorkspace(root) {
+  await writeFile(
+    path.join(root, "package.json"),
+    `${JSON.stringify(
+      {
+        name: "northstar-dispatch-analytics",
+        version: "2.4.0",
+        type: "module",
+        scripts: {
+          test: "node --test",
+          check: "node --check src/index.js",
+          release: "node scripts/release-check.js",
+        },
+        dependencies: {
+          "@modelcontextprotocol/sdk": "^1.0.0",
+        },
+      },
+      null,
+      2,
+    )}\n`,
+  );
+  await writeFile(
+    path.join(root, "src", "index.js"),
+    "export const serviceName = 'northstar-dispatch-analytics';\n",
+  );
+  await writeFile(
+    path.join(root, "mcp", "servers.json"),
+    `${JSON.stringify(
+      {
+        mcpServers: {
+          "obsidian-api Docs": {
+            url: "https://gitmcp.io/obsidianmd/obsidian-api",
+          },
+        },
+      },
+      null,
+      2,
+    )}\n`,
+  );
+}
+
+async function seedVault(vaultPath) {
+  await writeFile(
+    path.join(vaultPath, "Northstar", "Dispatch Release Objective.md"),
+    `---
+ma_records_as: vault_context
+ma_project: northstar-dispatch-analytics
+ma_capabilities:
+  - maestro
+  - obsidian
+  - learning-loop
+ma_source_workspace: northstar-dispatch-analytics
+---
+# Dispatch Release Objective
+
+Northstar Logistics needs a production-safe release plan for dispatch analytics.
+
+## Pain Points
+
+- Missed gate ownership causes late release rollback risk. #release
+- Unstructured knowledge lives in operations notes and is not visible to build planning. #knowledge
+- Security and DX review happen after implementation instead of before build execution. #security #dx
+
+## Links
+
+- [[Northstar/Risk Register]]
+- [[Meta-Architect/Core Brain Context]]
+`,
+  );
+  await writeFile(
+    path.join(vaultPath, "Northstar", "Risk Register.md"),
+    `---
+ma_records_as: vault_context
+ma_project: northstar-dispatch-analytics
+---
+# Risk Register
+
+Known risks:
+
+- Third-party carrier API failures can block dispatch reconciliation.
+- Customer PII must not be copied into prompt-bound release artifacts.
+- [[Northstar/Dispatch Release Objective]] owns the business target.
+`,
+  );
+  await writeFile(
+    path.join(vaultPath, "Meta-Architect", "Core Brain Context.md"),
+    `---
+ma_records_as: vault_context
+ma_project: northstar-dispatch-analytics
+---
+# Core Brain Context
+
+MA should treat this vault as semantic brain context only.
+Authoritative build evidence must return through $maestro or the owning lane.
+`,
+  );
+}
+
+function assertNoDemoBranding(value) {
+  const serialized = JSON.stringify(value);
+  assert.doesNotMatch(serialized, /Demo Account|Test Company|Sample Co|Acme/i);
+}
+
+async function main() {
+  const originalCwd = process.cwd();
+  const workspace = createTestNamespace("ma-real-demo");
+  const vaultPath = path.join(workspace, "Northstar Vault");
+  await seedWorkspace(workspace);
+  await seedVault(vaultPath);
+
+  process.chdir(workspace);
+  try {
+    await runInit();
+    await runIdea(demoIdea);
+    await runMaestro();
+
+    const createdNote = await createObsidianNote({
+      vaultPath,
+      notePath: "Meta-Architect/Release Gate Plan.md",
+      overwrite: true,
+      content: `---
+ma_records_as: vault_context
+ma_project: northstar-dispatch-analytics
+ma_source_workspace: northstar-dispatch-analytics
+---
+# Release Gate Plan
+
+This note records the MA demo path for Northstar Logistics.
+
+- Start at [[Meta-Architect/Map of Content]]
+- Use [[Northstar/Dispatch Release Objective]] for buyer context
+- Keep build evidence in MA lane artifacts
+`,
+    });
+    await updateObsidianNote({
+      vaultPath,
+      notePath: "Meta-Architect/Release Gate Plan.md",
+      content: `${createdNote.relative_path ? "" : ""}---
+ma_records_as: vault_context
+ma_project: northstar-dispatch-analytics
+ma_source_workspace: northstar-dispatch-analytics
+---
+# Release Gate Plan
+
+This note records the MA demo path for Northstar Logistics.
+
+- Start at [[Meta-Architect/Map of Content]]
+- Use [[Northstar/Dispatch Release Objective]] for buyer context
+- Use [[Northstar/Risk Register]] for security and rollback concerns
+- Keep build evidence in MA lane artifacts
+`,
+    });
+    const readNote = await readObsidianNote({
+      vaultPath,
+      notePath: "Meta-Architect/Release Gate Plan.md",
+    });
+    const vaultIndex = await writeObsidianVaultIndex({ vaultPath });
+    const directVaultIndex = await indexObsidianVault({ vaultPath });
+
+    const learningReadiness = evaluateLearningLoopReadiness(createDefaultLearningLoopCore());
+    const promptStrategy = validatePromptStrategyCore(createDefaultPromptStrategyCore());
+    const contextEconomy = createContextEconomyView({
+      text: "The architecture lane should preserve exact commands, risk language, and verification gaps while compressing low-value filler for the live demo operator.",
+      level: "full",
+    });
+    const environmentAwareness = await createDiscoveredEnvironmentAwarenessCore({ cwd: workspace });
+    const ralphContract = validateRalphPrdContract(
+      createRalphPrdContract({
+        project: "northstar-dispatch-analytics",
+        branchName: "ralph/northstar-release-gates",
+        description: "Prepare release-safe dispatch analytics execution handoff.",
+        buildSlice: [
+          "Verify MA release gates before Ralph-style execution begins.",
+          "Preserve Obsidian context as vault_context, not build_evidence.",
+        ],
+        verificationPlan: [
+          "$arch, $sage, $flow, $vet, and $vibe are represented before $build.",
+          "Obsidian context is tagged as vault_context, not build_evidence.",
+        ],
+      }),
+    );
+    const runtimeSnapshot = await loadRuntimeSnapshot();
+
+    const proof = {
+      record_type: "ma_real_demo_smoke_proof",
+      workspace,
+      vaultPath,
+      idea: demoIdea,
+      maestro: {
+        global_status: runtimeSnapshot.maestroState.global_status,
+        track_count: Object.keys(runtimeSnapshot.maestroState.runtime_tracks).length,
+        next_plan_exists: true,
+      },
+      obsidian: {
+        note_count: vaultIndex.note_count,
+        records_as: vaultIndex.records_as,
+        build_evidence: vaultIndex.build_evidence,
+        graph_map_present: vaultIndex.notes.some(
+          (note) => note.relative_path === "Meta-Architect/Map of Content.md",
+        ),
+        linked_release_plan: readNote.content.includes("[[Meta-Architect/Map of Content]]"),
+        direct_index_note_count: directVaultIndex.note_count,
+      },
+      learning: {
+        domain_count: learningReadiness.domains,
+        verified_domain_count: learningReadiness.verified_domains,
+        ready: learningReadiness.ready,
+      },
+      prompt_strategy: {
+        lane_count: Object.keys(promptStrategy.lane_policy).length,
+      },
+      context_economy: {
+        mode: contextEconomy.mode,
+        preserved_exact_count: contextEconomy.preserved_exact.length,
+      },
+      environment_awareness: {
+        capability_count: environmentAwareness.capabilities.length,
+        capability_types: [
+          ...new Set(environmentAwareness.capabilities.map((item) => item.capability_type)),
+        ].sort(),
+      },
+      ralph: {
+        story_count: ralphContract.userStories.length,
+        authority: ralphContract.authority,
+      },
+    };
+
+    assert.equal(proof.obsidian.records_as, "vault_context");
+    assert.equal(proof.obsidian.build_evidence, false);
+    assert.equal(proof.obsidian.graph_map_present, true);
+    assert.equal(proof.obsidian.linked_release_plan, true);
+    assert.equal(proof.learning.ready, true);
+    assert.equal(proof.ralph.story_count, 1);
+    assertNoDemoBranding(proof);
+
+    await writeFile(
+      path.join(workspace, ".ma", "evidence", "real-demo-smoke-proof.json"),
+      `${JSON.stringify(proof, null, 2)}\n`,
+    );
+    console.log(JSON.stringify(proof, null, 2));
+  } finally {
+    process.chdir(originalCwd);
+  }
+}
+
+try {
+  await main();
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+}

package/scripts/doctor.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import fs from "node:fs";
+import { printDoctorStatuses } from "../src/runtime/doctor-report.js";
 import {
   getDebArtifactName,
   getPacmanArtifactName,
@@ -56,14 +57,15 @@ const checks = [
   ["prompts/architect.md", fs.existsSync("prompts/architect.md")],
 ];
 
-let failures = 0;
+const statuses = [];
 for (const [label, ok] of checks) {
-  if (ok) {
-    console.log(`[OK] ${label}`);
-  } else {
-    console.log(`[MISSING] ${label}`);
-    failures += 1;
-  }
+  statuses.push({
+    kind: ok ? "OK" : "BLOCKED",
+    label,
+    detail: ok ? "present" : "missing release artifact",
+  });
 }
 
-process.exitCode = failures === 0 ? 0 : 1;
+console.log("Scope: maintainer release/package artifacts (not installed environment health)");
+const result = printDoctorStatuses("Meta-Architect Package Doctor", statuses);
+process.exitCode = result === "READY" ? 0 : 1;