@jstn-sdk/ma 0.1.11 → 0.1.13

package/index.js

@@ -6,9 +6,16 @@ export {
 export {
   appendDecision,
   loadDecisionLog,
-  updateDecisionStatuses,
 } from "./src/decision-log.js";
-export { isValidGitMcpEndpoint, loadMcpServers, validateMcpServers } from "./src/mcp-config.js";
+export {
+  getSupportedLocalCapabilities,
+  isValidGitMcpEndpoint,
+  loadLocalCapabilities,
+  loadMcpServers,
+  runLocalCapabilityReadinessChecks,
+  validateLocalCapabilities,
+  validateMcpServers,
+} from "./src/mcp-config.js";
 export {
   canMarkBuildDone,
   rejectsDirectProdPromotion,
@@ -16,6 +23,218 @@ export {
   validateReleaseOrigin,
 } from "./src/policy.js";
 export { loadReleaseState, saveReleaseState, validateReleaseState } from "./src/release-state.js";
+export {
+  classifyAutonomyBranch,
+  createDefaultActiveAutonomyCore,
+  detectPassivePermissionHandoff,
+  loadActiveAutonomyCore,
+  validateActiveAutonomyCore,
+} from "./src/runtime/active-autonomy-core.js";
+export {
+  createAlignmentRecoveryPlan,
+  createDefaultAlignmentSentinelReport,
+  evaluateAlignmentDrift,
+  loadAlignmentSentinelReportOrDefault,
+  saveAlignmentSentinelReport,
+} from "./src/runtime/alignment-sentinel.js";
+export {
+  createCodeGraphTouchpoint,
+  createCodeGraphTouchpointFromFile,
+  createDefaultCodeGraphRehearse,
+  createRehearsalTrace,
+  extractStaticImports,
+  loadCodeGraphRehearse,
+  validateCodeGraphRehearse,
+} from "./src/runtime/code-graph-rehearse.js";
+export {
+  createContextEconomyPayload,
+  createContextEconomyView,
+  createDefaultContextEconomyCore,
+  createMcpDescriptorEconomy,
+  loadContextEconomyCore,
+  shouldBypassContextEconomy,
+  validateContextEconomyCore,
+} from "./src/runtime/context-economy-core.js";
+export {
+  coreSourceDefinitions,
+  createDefaultCoreSourceIngest,
+  findIngestedCoreSourceForRepo,
+  ingestCoreSources,
+  loadCoreSourceIngest,
+  validateCoreSourceIngest,
+} from "./src/runtime/core-source-ingest.js";
+export {
+  createDefaultEnvironmentAwarenessCore,
+  createDiscoveredEnvironmentAwarenessCore,
+  createEnvironmentCapability,
+  discoverEnvironmentCapabilities,
+  loadEnvironmentAwarenessCore,
+  refreshEnvironmentAwarenessCore,
+  selectEnvironmentCapabilitiesForTask,
+  validateEnvironmentAwarenessCore,
+} from "./src/runtime/environment-awareness-core.js";
+export {
+  scanExposureProfile,
+  scanLockfilePackageExposure,
+  scanPackageExposureFromLockfile,
+  scanPackageExposureFromManifest,
+  validateMcpPolicyExposure,
+} from "./src/runtime/exposure-catalog.js";
+export {
+  chooseHelperRoute,
+  createDefaultHelperOrchestrationCore,
+  createHelperReceipt,
+  evaluateHelperCoreCoverage,
+  helperSkillNames,
+  loadHelperOrchestrationCore,
+  resolveHelperContract,
+  validateHelperOrchestrationCore,
+} from "./src/runtime/helper-orchestration-core.js";
+export {
+  addLearningRecord,
+  createDefaultLearningLoopCore,
+  createLearningRecord,
+  evaluateLearningLoopReadiness,
+  learningLoopDomains,
+  loadLearningLoopCore,
+  validateLearningLoopCore,
+} from "./src/runtime/learning-loop-core.js";
+export {
+  validateRuntimeMcpPolicy,
+  validateRuntimeMcpPolicyFile,
+} from "./src/runtime/mcp-policy.js";
+export {
+  appendObsidianOperationReceipt,
+  createDefaultObsidianBridge,
+  createDefaultObsidianVaultOperations,
+  createObsidianIntakeContext,
+  createObsidianNote,
+  createObsidianPluginRequest,
+  createObsidianVaultContext,
+  createObsidianVaultSnapshotExport,
+  deleteObsidianNote,
+  ensureObsidianGraphLinks,
+  indexObsidianVault,
+  listObsidianNotes,
+  loadObsidianBridge,
+  loadObsidianVaultIndex,
+  loadObsidianVaultOperations,
+  obsidianGraphMapNotePath,
+  readObsidianNote,
+  updateObsidianNote,
+  validateObsidianBridge,
+  validateObsidianVaultIndex,
+  validateObsidianVaultOperations,
+  writeObsidianVaultIndex,
+} from "./src/runtime/obsidian-integration-core.js";
+export {
+  applyObsidianFrontmatterAuthority,
+  createDefaultObsidianPluginBridgeManifest,
+  createObsidianMetadataGraph,
+  createObsidianSelectionContext,
+  drainObsidianPluginRequestQueue,
+  extractObsidianCanvasContext,
+  generateObsidianMarkdownLink,
+  installObsidianPlugin,
+  obsidianPluginActiveContextPath,
+  obsidianPluginAttachmentDir,
+  obsidianPluginId,
+  obsidianPluginName,
+  obsidianPluginQueuePath,
+  registerMetaArchitectObsidianPluginRuntime,
+  registerObsidianEventWatchers,
+  registerObsidianProtocolHandlers,
+  renameObsidianFileSafely,
+  writeObsidianAttachment,
+} from "./src/runtime/obsidian-plugin-bridge.js";
+export {
+  createDefaultPromptStrategyCore,
+  loadPromptStrategyCore,
+  resolvePromptStrategyForRole,
+  resolvePromptStrategyForSurface,
+  validatePromptStrategyCore,
+} from "./src/runtime/prompt-strategy-core.js";
+export {
+  createQuorumReviewReceipt,
+  evaluateQuorumVotes,
+  quorumDecisions,
+} from "./src/runtime/quorum-review.js";
+export {
+  appendRalphProgressEntry,
+  completeRalphStory,
+  createRalphIterationPlan,
+  createRalphPrdContract,
+  selectNextRalphStory,
+  validateRalphPrdContract,
+  writeRalphExecutionContract,
+} from "./src/runtime/ralph-execution-core.js";
+export {
+  loadRedactionVaultOrDefault,
+  maskSensitiveText,
+  redactProviderBoundPayload,
+  redactProviderBoundText,
+  seedRedactionVault,
+} from "./src/runtime/redaction-gateway.js";
+export {
+  createDefaultSemanticRecordingCore,
+  loadSemanticRecordingCore,
+  validateSemanticRecordingCore,
+} from "./src/runtime/semantic-recording-core.js";
+export {
+  agentRegistry,
+  createDefaultSkillsRegistryExport,
+  createHostInstallReceipt,
+  createSkillCompatibilityPayload,
+  createSkillLockEntry,
+  inspectSkillCompatibilityInstall,
+  isUniversalAgent,
+  loadSkillsRegistryExport,
+  renderSkillCompatibilitySkillMd,
+  resolveSkillInstallPlan,
+  validateSkillLockEntry,
+  validateSkillsRegistryExport,
+  verifyCrossAgentInstallMatrix,
+  writeSkillCompatibilityExport,
+} from "./src/runtime/skills-registry-export.js";
+export {
+  createDefaultUniversalPluginBrokerCore,
+  createUniversalPluginManifest,
+  detectInstalledPluginHosts,
+  injectAntigravityMcpServer,
+  injectClaudeCodeMcpServer,
+  injectCodexMcpServer,
+  injectCursorMcpServer,
+  injectPluginToVendors,
+  installUniversalPlugin,
+  loadUniversalPluginBrokerCore,
+  loadUniversalPluginManifest,
+  renderPluginContextSkillMd,
+  renderUniversalMcpServerTemplate,
+  validateUniversalPluginBrokerCore,
+  validateUniversalPluginManifest,
+  writePluginContextSkill,
+} from "./src/runtime/universal-plugin-broker-core.js";
+export {
+  addSemanticReceipt,
+  createDefaultCapabilityComposition,
+  createDefaultSemanticReceiptIndex,
+  createDefaultWorkspaceContextPack,
+  createDefaultWorkspaceEffectiveness,
+  createSemanticReceipt,
+  evaluateWorkspaceEffectiveness,
+  loadWorkspaceIntelligenceArtifacts,
+  validateCapabilityComposition,
+  validateSemanticReceiptIndex,
+  validateWorkspaceContextPack,
+  validateWorkspaceEffectiveness,
+} from "./src/runtime/workspace-intelligence-runtime.js";
+export {
+  createDefaultWorkspaceVirtualizer,
+  createVirtualVerificationReceipt,
+  createVirtualWorkspacePlan,
+  loadWorkspaceVirtualizer,
+  validateWorkspaceVirtualizer,
+} from "./src/runtime/workspace-virtualizer.js";
 export {
   listSkills,
   runArch,
@@ -26,3 +245,4 @@ export {
   runVet,
   runVibe,
 } from "./src/skills.js";
+export { loadCombinedState, syncStatusUpdates } from "./src/state-sync.js";

package/mcp/collections.json

@@ -10,12 +10,29 @@
       "java",
       "dotnet",
       "self-hosted",
-      "system-design"
+      "system-design",
+      "obsidian-api-docs",
+      "obsidian-plugin-scaffold",
+      "prompt-techniques"
     ],
-    "sage": ["meta-list", "typescript", "rust", "go", "python", "java", "dotnet", "self-hosted"],
-    "vet": ["security"],
-    "flow": [],
-    "vibe": [],
-    "build": []
+    "sage": [
+      "meta-list",
+      "typescript",
+      "rust",
+      "go",
+      "python",
+      "java",
+      "dotnet",
+      "self-hosted",
+      "system-design",
+      "obsidian-api-docs",
+      "obsidian-plugin-scaffold",
+      "context-economy",
+      "prompt-techniques"
+    ],
+    "vet": ["security", "context-economy", "prompt-techniques"],
+    "flow": ["system-design", "prompt-techniques"],
+    "vibe": ["obsidian-api-docs", "context-economy", "prompt-techniques"],
+    "build": ["system-design", "context-economy", "prompt-techniques"]
   }
 }

package/mcp/local/code-intel.js

@@ -0,0 +1,113 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { getRepoRoot } from "../../src/paths.js";
+
+const ignoredDirs = new Set([".git", ".ma", ".omx", "node_modules"]);
+const codeIntelTools = [
+  "code_intel.list_files",
+  "code_intel.search_text",
+  "code_intel.read_excerpt",
+];
+
+async function walk(rootDir, currentDir = rootDir, files = [], limit = Number.POSITIVE_INFINITY) {
+  if (files.length >= limit) {
+    return files;
+  }
+
+  const entries = await fs.readdir(currentDir, { withFileTypes: true });
+  for (const entry of entries) {
+    if (files.length >= limit) {
+      break;
+    }
+
+    if (entry.isDirectory()) {
+      if (ignoredDirs.has(entry.name)) {
+        continue;
+      }
+      await walk(rootDir, path.join(currentDir, entry.name), files, limit);
+      continue;
+    }
+
+    if (!entry.isFile()) {
+      continue;
+    }
+    files.push(path.relative(rootDir, path.join(currentDir, entry.name)));
+  }
+
+  return files;
+}
+
+export function listCodeIntelTools() {
+  return [...codeIntelTools];
+}
+
+export async function listRepoFiles(limit = 200) {
+  const repoRoot = getRepoRoot();
+  return walk(repoRoot, repoRoot, [], limit);
+}
+
+export async function searchRepoText(query, limit = 20) {
+  const repoRoot = getRepoRoot();
+  const files = await listRepoFiles(500);
+  const matches = [];
+
+  for (const relativePath of files) {
+    if (matches.length >= limit) {
+      break;
+    }
+
+    try {
+      const content = await fs.readFile(path.join(repoRoot, relativePath), "utf8");
+      const lines = content.split("\n");
+      lines.forEach((line, index) => {
+        if (matches.length < limit && line.includes(query)) {
+          matches.push({ file: relativePath, line: index + 1, text: line.trim() });
+        }
+      });
+    } catch {
+      // Skip non-text files.
+    }
+  }
+
+  return matches;
+}
+
+export async function readRepoExcerpt(relativePath, line = 1, context = 2) {
+  const repoRoot = getRepoRoot();
+  const content = await fs.readFile(path.join(repoRoot, relativePath), "utf8");
+  const lines = content.split("\n");
+  const start = Math.max(0, line - context - 1);
+  const end = Math.min(lines.length, line + context);
+  return lines.slice(start, end).map((text, index) => ({
+    line: start + index + 1,
+    text,
+  }));
+}
+
+export async function callCodeIntelTool(name, args = {}) {
+  if (name === "code_intel.list_files") {
+    return listRepoFiles(args.limit);
+  }
+  if (name === "code_intel.search_text") {
+    if (typeof args.query !== "string" || args.query.trim() === "") {
+      throw new Error("code_intel.search_text requires a non-empty query");
+    }
+    return searchRepoText(args.query, args.limit);
+  }
+  if (name === "code_intel.read_excerpt") {
+    if (typeof args.file !== "string" || args.file.trim() === "") {
+      throw new Error("code_intel.read_excerpt requires a file path");
+    }
+    return readRepoExcerpt(args.file, args.line, args.context);
+  }
+
+  throw new Error(`Unknown code_intel tool: ${name}`);
+}
+
+export async function checkCodeIntelCapability() {
+  const files = await listRepoFiles(10);
+  return {
+    ready: files.length > 0,
+    detail: `code intel indexed ${files.length} repo file(s) in the readiness sample`,
+  };
+}

package/mcp/local/memory.js

@@ -0,0 +1,46 @@
+import {
+  loadContinuityIndex,
+  loadContinuityNotes,
+  storeContinuityNote,
+} from "../../src/runtime/continuity-notes.js";
+
+const memoryResources = ["memory://notes", "memory://index"];
+const memoryTools = ["memory.store_note"];
+
+export function listMemoryResources() {
+  return [...memoryResources];
+}
+
+export function listMemoryTools() {
+  return [...memoryTools];
+}
+
+export async function readMemoryResource(uri) {
+  if (uri === "memory://notes") {
+    return loadContinuityNotes();
+  }
+  if (uri === "memory://index") {
+    return loadContinuityIndex();
+  }
+
+  throw new Error(`Unknown memory resource: ${uri}`);
+}
+
+export async function callMemoryTool(name, args = {}, options = {}) {
+  if (name !== "memory.store_note") {
+    throw new Error(`Unknown memory tool: ${name}`);
+  }
+
+  return storeContinuityNote(args.content ?? "", {
+    ...options,
+    actor: "local-capability:memory",
+  });
+}
+
+export async function checkMemoryCapability() {
+  const index = await readMemoryResource("memory://index");
+  return {
+    ready: typeof index.sessionCount === "number",
+    detail: `continuity index loaded with sessionCount=${index.sessionCount}`,
+  };
+}

package/mcp/local/playbooks.js

@@ -0,0 +1,168 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  getBundledDocsPath,
+  getBundledMcpPath,
+  getBundledNativePlaybooksPath,
+  getBundledSkillsPath,
+} from "../../src/paths.js";
+
+const playbookRoots = [getBundledDocsPath(), getBundledSkillsPath(), getBundledMcpPath()];
+
+function validateObjectWithArray(parsed, field, label) {
+  if (!parsed || typeof parsed !== "object" || !Array.isArray(parsed[field])) {
+    throw new Error(`${label} must be an object with a ${field} array`);
+  }
+
+  return parsed;
+}
+
+function resolveAllowlistedResourcePath(relativePath) {
+  if (typeof relativePath !== "string" || relativePath.trim() === "") {
+    throw new Error("Playbook references require a non-empty relative path");
+  }
+  if (path.isAbsolute(relativePath)) {
+    throw new Error(`Playbook reference cannot use an absolute path: ${relativePath}`);
+  }
+
+  const resolved = path.resolve(
+    path.join(path.dirname(getBundledNativePlaybooksPath()), "..", relativePath),
+  );
+  const isAllowlisted = playbookRoots.some((root) => {
+    const normalizedRoot = path.resolve(root);
+    return resolved === normalizedRoot || resolved.startsWith(`${normalizedRoot}${path.sep}`);
+  });
+
+  if (!isAllowlisted) {
+    throw new Error(
+      `Playbook reference must resolve inside bundled docs, skills, or mcp: ${relativePath}`,
+    );
+  }
+
+  return resolved;
+}
+
+function findPack(manifest, packId) {
+  return manifest.packs.find((pack) => pack.id === packId) ?? null;
+}
+
+function findPackReference(manifest, packId, referenceId) {
+  const pack = findPack(manifest, packId);
+  if (!pack) {
+    return { pack: null, reference: null };
+  }
+
+  return {
+    pack,
+    reference: pack.references.find((item) => item.id === referenceId) ?? null,
+  };
+}
+
+export async function loadNativePlaybooks() {
+  const raw = await fs.readFile(getBundledNativePlaybooksPath(), "utf8");
+  const parsed = validateObjectWithArray(JSON.parse(raw), "packs", "mcp/native-playbooks.json");
+  const seen = new Set();
+
+  for (const pack of parsed.packs) {
+    if (typeof pack.id !== "string" || pack.id.trim() === "") {
+      throw new Error("Each native playbook pack requires a non-empty id");
+    }
+    if (seen.has(pack.id)) {
+      throw new Error(`Duplicate native playbook pack: ${pack.id}`);
+    }
+    if (typeof pack.title !== "string" || pack.title.trim() === "") {
+      throw new Error(`Native playbook pack ${pack.id} requires a title`);
+    }
+    if (!Array.isArray(pack.references)) {
+      throw new Error(`Native playbook pack ${pack.id} requires a references array`);
+    }
+
+    const referenceIds = new Set();
+    for (const reference of pack.references) {
+      if (typeof reference.id !== "string" || reference.id.trim() === "") {
+        throw new Error(`Native playbook pack ${pack.id} has a reference without an id`);
+      }
+      if (referenceIds.has(reference.id)) {
+        throw new Error(`Duplicate reference ${reference.id} in native playbook pack ${pack.id}`);
+      }
+      resolveAllowlistedResourcePath(reference.path);
+      referenceIds.add(reference.id);
+    }
+
+    seen.add(pack.id);
+  }
+
+  return parsed;
+}
+
+export async function listPlaybookResources() {
+  const manifest = await loadNativePlaybooks();
+  const resources = ["playbooks://manifest"];
+
+  for (const pack of manifest.packs) {
+    resources.push(`playbooks://packs/${pack.id}`);
+    for (const reference of pack.references) {
+      resources.push(`playbooks://references/${pack.id}/${reference.id}`);
+    }
+  }
+
+  return resources;
+}
+
+export function listPlaybookTools() {
+  return [];
+}
+
+export async function readPlaybookResource(uri) {
+  const manifest = await loadNativePlaybooks();
+
+  if (uri === "playbooks://manifest") {
+    return manifest;
+  }
+
+  const packMatch = /^playbooks:\/\/packs\/([^/]+)$/.exec(uri);
+  if (packMatch) {
+    const pack = findPack(manifest, packMatch[1]);
+    if (!pack) {
+      throw new Error(`Unknown playbooks pack: ${packMatch[1]}`);
+    }
+    return pack;
+  }
+
+  const referenceMatch = /^playbooks:\/\/references\/([^/]+)\/([^/]+)$/.exec(uri);
+  if (referenceMatch) {
+    const { pack, reference } = findPackReference(manifest, referenceMatch[1], referenceMatch[2]);
+    if (!pack || !reference) {
+      throw new Error(`Unknown playbooks reference: ${referenceMatch[1]}/${referenceMatch[2]}`);
+    }
+
+    const resolvedPath = resolveAllowlistedResourcePath(reference.path);
+    const content = await fs.readFile(resolvedPath, "utf8");
+    return {
+      packId: pack.id,
+      referenceId: reference.id,
+      title: reference.title,
+      path: reference.path,
+      content,
+    };
+  }
+
+  throw new Error(`Unknown playbooks resource: ${uri}`);
+}
+
+export async function checkPlaybooksCapability() {
+  const manifest = await loadNativePlaybooks();
+  let referenceCount = 0;
+
+  for (const pack of manifest.packs) {
+    for (const reference of pack.references) {
+      await fs.access(resolveAllowlistedResourcePath(reference.path));
+      referenceCount += 1;
+    }
+  }
+
+  return {
+    ready: manifest.packs.length > 0,
+    detail: `loaded ${manifest.packs.length} playbook pack(s) and ${referenceCount} referenced resource(s)`,
+  };
+}

package/mcp/local/state.js

@@ -0,0 +1,71 @@
+import { appendDecision } from "../../src/decision-log.js";
+import { loadManagerRunRegistryOrDefault } from "../../src/runtime/maestro-manager.js";
+import { createRuntimeSummary, loadRuntimeSnapshot } from "../../src/runtime/runtime-state.js";
+import { loadCombinedState, syncStatusUpdates } from "../../src/state-sync.js";
+
+const stateResources = [
+  "state://runtime/snapshot",
+  "state://manager/runs",
+  "state://release",
+  "state://decisions",
+  "state://combined",
+];
+const stateTools = ["state.sync_release_status", "state.append_decision"];
+
+export function listStateResources() {
+  return [...stateResources];
+}
+
+export function listStateTools() {
+  return [...stateTools];
+}
+
+export async function readStateResource(uri) {
+  if (uri === "state://runtime/snapshot") {
+    const snapshot = await loadRuntimeSnapshot();
+    return { snapshot, summary: createRuntimeSummary(snapshot) };
+  }
+
+  if (uri === "state://manager/runs") {
+    return loadManagerRunRegistryOrDefault();
+  }
+
+  const combined = await loadCombinedState();
+  if (uri === "state://release") {
+    return combined.release;
+  }
+  if (uri === "state://decisions") {
+    return combined.decisions;
+  }
+  if (uri === "state://combined") {
+    return combined;
+  }
+
+  throw new Error(`Unknown _state resource: ${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);
+  }
+
+  if (name === "state.append_decision") {
+    const entry = args.entry ?? args;
+    return appendDecision(entry, localOptions);
+  }
+
+  throw new Error(`Unknown _state tool: ${name}`);
+}
+
+export async function checkStateCapability() {
+  const [snapshot, managerRuns] = await Promise.all([
+    readStateResource("state://runtime/snapshot"),
+    readStateResource("state://manager/runs"),
+  ]);
+  return {
+    ready: true,
+    detail: `runtime summary loaded with ${snapshot.summary.decisionCount} recorded decision(s) and ${managerRuns.runs.length} manager run(s)`,
+  };
+}