@jstn-sdk/ma 0.1.13 → 0.14.0

package/mcp/local/context.js

@@ -0,0 +1,180 @@
+import path from "node:path";
+import { loadLearningLoopCore, loadLearningRecords } from "../../src/runtime/learning-loop-core.js";
+import {
+  loadObsidianVaultIndex,
+  loadObsidianVaultOperations,
+} from "../../src/runtime/obsidian-integration-core.js";
+import { resolvePreferences } from "../../src/runtime/preferences.js";
+import { loadProjectIndex } from "../../src/runtime/project-context.js";
+import {
+  loadRuntimeHookReceipts,
+  loadRuntimeHooksAuditLog,
+  loadRuntimeHooksConfig,
+} from "../../src/runtime/signal-hooks.js";
+
+const contextResources = [
+  "context://project-index",
+  "context://learning",
+  "context://obsidian",
+  "context://hooks",
+  "context://freshness",
+  "context://commands",
+  "context://agent-brief",
+  "context://architecture",
+  "context://preferences",
+];
+
+export function listContextResources() {
+  return [...contextResources];
+}
+
+async function readOptional(loader, fallback) {
+  try {
+    return { available: true, data: await loader() };
+  } catch (error) {
+    if (error?.code === "ENOENT") return { available: false, data: fallback };
+    throw error;
+  }
+}
+
+function envelope(resource, result, extra = {}) {
+  const freshness = extra.freshness ?? result.data?.freshness ?? null;
+  return {
+    record_type: `mcp_context:${resource}`,
+    authority: "source_truth",
+    source: "meta-architect-runtime",
+    resource,
+    ...extra,
+    ...result,
+    context: {
+      authority: extra.authority ?? "generated_context",
+      source: "meta-architect-runtime",
+      freshness,
+      provenance: result.data?.sourceFiles?.map((file) => file.path) ?? [],
+    },
+    quality: result.data?.quality ?? extra.quality ?? null,
+  };
+}
+
+export async function readContextResource(uri) {
+  if (uri === "context://project-index") {
+    const result = await readOptional(loadProjectIndex, null);
+    return envelope("project-index", result, {
+      authority: result.available ? "source_truth" : "missing_source_truth",
+      fact_ids: result.data?.facts?.map((fact) => fact.id) ?? [],
+      provenance:
+        result.data?.facts?.map((fact) => ({ id: fact.id, provenance: fact.provenance })) ?? [],
+    });
+  }
+
+  if (uri === "context://learning") {
+    const [core, records] = await Promise.all([
+      readOptional(loadLearningLoopCore, null),
+      readOptional(loadLearningRecords, []),
+    ]);
+    return envelope(
+      "learning",
+      {
+        available: core.available || records.available,
+        data: {
+          core: core.data,
+          records: records.data,
+          failure_records: records.data.filter((record) => Boolean(record.failure_state)),
+        },
+      },
+      {
+        authority: "generated_context",
+        fact_ids: records.data.flatMap((record) => record.fact_ids ?? []),
+      },
+    );
+  }
+
+  if (uri === "context://obsidian") {
+    const [index, operations] = await Promise.all([
+      readOptional(loadObsidianVaultIndex, null),
+      readOptional(loadObsidianVaultOperations, null),
+    ]);
+    return envelope(
+      "obsidian",
+      {
+        available: index.available || operations.available,
+        data: { index: index.data, operations: operations.data },
+      },
+      { authority: "vault_note" },
+    );
+  }
+
+  if (uri === "context://hooks") {
+    const [config, audit, receipts] = await Promise.all([
+      readOptional(loadRuntimeHooksConfig, null),
+      readOptional(loadRuntimeHooksAuditLog, ""),
+      readOptional(loadRuntimeHookReceipts, []),
+    ]);
+    return envelope(
+      "hooks",
+      {
+        available: config.available || audit.available,
+        data: { config: config.data, audit: audit.data, receipts: receipts.data },
+      },
+      { authority: "hook_evidence" },
+    );
+  }
+
+  if (
+    uri === "context://commands" ||
+    uri === "context://agent-brief" ||
+    uri === "context://architecture"
+  ) {
+    const relative = uri.slice("context://".length);
+    const loader = async () => {
+      if (relative === "commands") return readOptional(() => readJsonFile("commands.json"), null);
+      return readOptional(() => readTextFile(`${relative}.md`), "");
+    };
+    const result = await loader();
+    const project = await readOptional(loadProjectIndex, null);
+    return envelope(relative, result, {
+      authority: "generated_context",
+      freshness: { status: "derived", stale: false, source: "project-index" },
+      quality: project.data?.quality ?? null,
+    });
+  }
+
+  if (uri === "context://freshness") {
+    const result = await readOptional(loadProjectIndex, null);
+    return envelope(
+      "freshness",
+      { available: result.available, data: result.data?.freshness ?? null },
+      { authority: "source_truth" },
+    );
+  }
+
+  if (uri === "context://preferences") {
+    const result = await readOptional(resolvePreferences, {});
+    return envelope("preferences", result, { authority: "learning_memory" });
+  }
+
+  throw new Error(`Unknown context resource: ${uri}`);
+}
+
+async function readJsonFile(name) {
+  const { readJson } = await import("../../src/fs-utils.js");
+  return readJson(path.join(process.env.MA_ROOT || process.cwd(), ".ma", "context", name));
+}
+
+async function readTextFile(name) {
+  const fs = await import("node:fs/promises");
+  return fs.readFile(
+    path.join(process.env.MA_ROOT || process.cwd(), ".ma", "context", name),
+    "utf8",
+  );
+}
+
+export async function checkContextCapability() {
+  const project = await readContextResource("context://project-index");
+  return {
+    ready: true,
+    detail: project.available
+      ? `project context loaded with ${project.data.sourceFiles?.length ?? 0} source file(s)`
+      : "project context has not been generated; run ma setup",
+  };
+}

package/mcp/local/memory.js

@@ -1,11 +1,13 @@
+import { loadContinuityGraph, queryContinuityGraph } from "../../src/runtime/continuity-graph.js";
 import {
   loadContinuityIndex,
   loadContinuityNotes,
   storeContinuityNote,
 } from "../../src/runtime/continuity-notes.js";
+import { withMcpWriteGate } from "../../src/runtime/mcp-authority.js";
 
-const memoryResources = ["memory://notes", "memory://index"];
-const memoryTools = ["memory.store_note"];
+const memoryResources = ["memory://notes", "memory://index", "memory://graph"];
+const memoryTools = ["memory.store_note", "memory.query_graph"];
 
 export function listMemoryResources() {
   return [...memoryResources];
@@ -22,19 +24,28 @@ export async function readMemoryResource(uri) {
   if (uri === "memory://index") {
     return loadContinuityIndex();
   }
+  if (uri === "memory://graph") {
+    return loadContinuityGraph();
+  }
 
   throw new Error(`Unknown memory resource: ${uri}`);
 }
 
 export async function callMemoryTool(name, args = {}, options = {}) {
+  if (name === "memory.query_graph") {
+    return queryMemoryGraph(args);
+  }
   if (name !== "memory.store_note") {
     throw new Error(`Unknown memory tool: ${name}`);
   }
 
-  return storeContinuityNote(args.content ?? "", {
-    ...options,
-    actor: "local-capability:memory",
-  });
+  return withMcpWriteGate({ tool: name, options, payload: args }, (metadata) =>
+    storeContinuityNote(args.content ?? "", { ...options, ...metadata }),
+  );
+}
+
+export async function queryMemoryGraph(args = {}) {
+  return queryContinuityGraph(await loadContinuityGraph(), args);
 }
 
 export async function checkMemoryCapability() {

package/mcp/local/quality.js

@@ -0,0 +1,39 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getRepoRoot } from "../../src/paths.js";
+
+const qualityRoot = () => path.join(getRepoRoot(), ".ma", "quality");
+
+export const qualityResources = ["quality://violations", "quality://kpis"];
+
+export async function readQualityResource(uri) {
+  const file =
+    uri === "quality://violations"
+      ? "violations.json"
+      : uri === "quality://kpis"
+        ? "kpis.json"
+        : null;
+  if (!file) throw new Error(`Unknown quality resource: ${uri}`);
+  try {
+    return JSON.parse(await fs.readFile(path.join(qualityRoot(), file), "utf8"));
+  } catch (error) {
+    if (error.code === "ENOENT") return [];
+    throw error;
+  }
+}
+
+export async function queryQualityStatus() {
+  const [violations, kpis] = await Promise.all([
+    readQualityResource("quality://violations"),
+    readQualityResource("quality://kpis"),
+  ]);
+  return {
+    violations,
+    kpis,
+    passed:
+      violations.length > 0 &&
+      kpis.length > 0 &&
+      violations.every((record) => record.violations?.length === 0) &&
+      kpis.every((record) => record.kpis?.qualityScore >= 60),
+  };
+}

package/mcp/local/state.js

@@ -1,5 +1,6 @@
 import { appendDecision } from "../../src/decision-log.js";
 import { loadManagerRunRegistryOrDefault } from "../../src/runtime/maestro-manager.js";
+import { withMcpWriteGate } from "../../src/runtime/mcp-authority.js";
 import { createRuntimeSummary, loadRuntimeSnapshot } from "../../src/runtime/runtime-state.js";
 import { loadCombinedState, syncStatusUpdates } from "../../src/state-sync.js";
 
@@ -45,15 +46,18 @@ export async function readStateResource(uri) {
 }
 
 export async function callStateTool(name, args = {}, options = {}) {
-  const localOptions = { ...options, actor: "local-capability:_state" };
   if (name === "state.sync_release_status") {
     const statusUpdates = args.statusUpdates ?? args;
-    return syncStatusUpdates(statusUpdates, localOptions);
+    return withMcpWriteGate({ tool: name, options, payload: statusUpdates }, (metadata) =>
+      syncStatusUpdates(statusUpdates, metadata),
+    );
   }
 
   if (name === "state.append_decision") {
     const entry = args.entry ?? args;
-    return appendDecision(entry, localOptions);
+    return withMcpWriteGate({ tool: name, options, payload: entry }, (metadata) =>
+      appendDecision(entry, metadata),
+    );
   }
 
   throw new Error(`Unknown _state tool: ${name}`);

package/mcp/local/team-run.js

@@ -1,4 +1,5 @@
 import fs from "node:fs/promises";
+import { withMcpWriteGate } from "../../src/runtime/mcp-authority.js";
 import {
   controlTask,
   getTask,
@@ -50,9 +51,11 @@ export async function readTeamRunResource(uri) {
 }
 
 export async function callTeamRunTool(name, args = {}, options = {}) {
-  const localOptions = { ...options, actor: "local-capability:team_run" };
   if (name === "team_run.submit_task") {
-    return submitTask(args.task ?? args, localOptions);
+    const task = args.task ?? args;
+    return withMcpWriteGate({ tool: name, options, payload: task }, (metadata) =>
+      submitTask(task, metadata),
+    );
   }
   if (name === "team_run.get_status") {
     return getTask(args.taskId);
@@ -64,7 +67,9 @@ export async function callTeamRunTool(name, args = {}, options = {}) {
     return waitForTask(args.taskId, args);
   }
   if (name === "team_run.control_task") {
-    return controlTask(args.taskId, args.action, localOptions);
+    return withMcpWriteGate({ tool: name, options, payload: args }, (metadata) =>
+      controlTask(args.taskId, args.action, metadata),
+    );
   }
 
   throw new Error(`Unknown team_run tool: ${name}`);

package/mcp/local-capabilities.json

@@ -51,6 +51,15 @@
       "module": "./local/playbooks.js",
       "readinessCheck": "checkPlaybooksCapability",
       "seededByBootstrap": true
+    },
+    {
+      "kind": "local-capability",
+      "capability": "context",
+      "transport": "inproc",
+      "module": "./local/context.js",
+      "readinessCheck": "checkContextCapability",
+      "seededByBootstrap": true,
+      "authorityMode": "read-only-evidence"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jstn-sdk/ma",
-  "version": "0.1.13",
+  "version": "0.14.0",
   "description": "Codex-native skills system for architecture, evidence, review, and gated build guidance.",
   "license": "MIT",
   "author": "JustineDevs",
@@ -40,9 +40,21 @@
     "templates/",
     "sprint/",
     "skills/",
-    "docs/",
+    "docs/README.md",
+    "docs/getting-started.md",
+    "docs/skills.md",
+    "docs/mcp-setup.md",
+    "docs/installed-sdk.md",
+    "docs/release-spec.md",
+    "docs/quality.md",
+    "docs/codex-integration.md",
+    "docs/autonomous-tasks.md",
+    "docs/reference/",
+    "docs/qa/",
     "data/",
     "scripts/",
+    "schemas/",
+    "support-bundle.json",
     "index.js",
     "README.md",
     "DEMO.md",
@@ -58,8 +70,12 @@
   },
   "scripts": {
     "prepare": "husky",
+    "prepack": "node ./scripts/prepack.js",
     "postinstall": "node ./scripts/postinstall.js",
-    "test": "node --test --test-concurrency=1",
+    "test": "node --test --test-concurrency=1 test/*.test.js",
+    "test:disk": "node --test --test-concurrency=1 test/test-fixtures.test.js",
+    "fixtures:cleanup": "bash ./scripts/cleanup-test-fixtures.sh",
+    "demo:smoke": "node ./scripts/demo-smoke.js",
     "status": "node ./bin/ma.js status",
     "linux:packages:build": "node ./scripts/build-linux-packages.mjs",
     "linux:packages:smoke": "node ./scripts/linux-package-smoke.mjs",
@@ -69,6 +85,7 @@
     "release:advance": "node ./scripts/release-sync.js --force --bump patch",
     "release:verify": "node ./scripts/release-verify.js",
     "release:assets": "node ./.github/scripts/validate-release-assets.js",
+    "release:assets:generate": "node ./.github/scripts/validate-release-assets.js --generate",
     "release:check": "npm run release:verify && npm run skills:manifest && npm run plugin:sync && npm run skills:validate && npm run plugin:verify && npm run skills:pack && npm run check && npm test && npm run pack:inspect",
     "skills:manifest": "node ./scripts/skills-manifest.js",
     "skills:validate": "node ./scripts/skills-validate.js",
@@ -77,7 +94,9 @@
     "plugin:sync": "node ./scripts/plugin-sync.js",
     "plugin:verify": "node ./scripts/plugin-sync.js --check",
     "pack:inspect": "npm pack --dry-run --ignore-scripts --cache ./.npm-cache",
-    "doctor": "node ./scripts/doctor.js",
+    "package:size": "node ./scripts/package-size-check.mjs",
+    "package:doctor": "node ./scripts/doctor.js",
+    "release:doctor": "npm run package:doctor",
     "lint": "biome lint .",
     "format": "biome format .",
     "check": "biome check ."
@@ -89,5 +108,8 @@
   "devDependencies": {
     "@biomejs/biome": "^2.4.13",
     "husky": "^9.1.7"
+  },
+  "dependencies": {
+    "@jstn-sdk/agents": "0.1.0"
   }
 }

package/plugins/meta-architect/.app.json

@@ -1,7 +1,7 @@
 {
   "name": "meta-architect",
   "displayName": "Meta-Architect",
-  "version": "0.1.13",
+  "version": "0.14.0",
   "description": "Programmatic architecture and verified engineering skills for Codex-native workflows.",
   "entry": "./README.md",
   "skillsDir": "./skills"

package/plugins/meta-architect/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "meta-architect",
-  "version": "0.1.13",
+  "version": "0.14.0",
   "description": "Skills-first workflow layer for Codex with a bounded autonomous manager, architecture, evidence, review, and gated build guidance.",
   "author": {
     "name": "JustineDevs",

package/plugins/meta-architect/.mcp.json

@@ -1,6 +1,6 @@
 {
   "name": "meta-architect",
-  "version": "0.1.13",
+  "version": "0.14.0",
   "collections": [
     "sindresorhus/awesome",
     "dzharii/awesome-typescript",

package/plugins/meta-architect/README.md

@@ -52,7 +52,7 @@ Recommended CLI install for macOS, Linux, WSL, and Git-Bash:
 
 ```bash
 # One-line install (POSIX shells only; use WSL/Git-Bash on Windows)
-curl -fsSL https://cdn.jsdelivr.net/gh/JustineDevs/meta-architect@main/scripts/install.sh | sh
+curl -fsSLo install.sh https://cdn.jsdelivr.net/gh/JustineDevs/meta-architect@latest/scripts/install.sh && curl -fsSLo install.sh.sha256 https://cdn.jsdelivr.net/gh/JustineDevs/meta-architect@latest/scripts/install.sh.sha256 && sed 's#scripts/install.sh#install.sh#' install.sh.sha256 | sha256sum -c - && sh install.sh
 ```
 
 Canonical package/runtime path:
@@ -138,7 +138,7 @@ When consuming the plugin:
 The plugin version should track the release scope of the core repo.
 
 For this repository:
-- plugin scope is aligned to Meta-Architect `v0.1.13`
+- plugin scope is aligned to Meta-Architect `v0.14.0`
 - any breaking contract change should be versioned intentionally
 
 The plugin is one distribution surface of the same product, not a separate product line.