@jstn-sdk/ma 0.1.12 → 0.1.13

package/scripts/active-autonomy-hook.mjs

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+
+import fs from "node:fs/promises";
+import path from "node:path";
+import {
+  createDefaultActiveAutonomyCore,
+  detectPassivePermissionHandoff,
+} from "../src/runtime/active-autonomy-core.js";
+
+const DEFAULT_RESPONSE =
+  "AUTO-CONTINUE: continue the current safe branch, execute the next reversible step, then verify before reporting.";
+
+async function readStdinJson() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+
+  const raw = Buffer.concat(chunks).toString("utf8").trim();
+  if (!raw) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(raw);
+  } catch (error) {
+    return {
+      type: "invalid-hook-payload",
+      raw,
+      parseError: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+function extractAssistantText(payload) {
+  const candidates = [
+    payload.last_assistant_message,
+    payload["last-assistant-message"],
+    payload.message,
+    payload.text,
+    payload.output,
+  ];
+
+  for (const candidate of candidates) {
+    if (typeof candidate === "string" && candidate.trim()) {
+      return candidate;
+    }
+  }
+
+  if (Array.isArray(payload.messages)) {
+    const assistant = [...payload.messages]
+      .reverse()
+      .find((message) => message?.role === "assistant" && typeof message.content === "string");
+    return assistant?.content ?? "";
+  }
+
+  return "";
+}
+
+async function appendAudit(cwd, entry) {
+  const auditDir = path.join(cwd, ".ma", "hooks");
+  await fs.mkdir(auditDir, { recursive: true });
+  await fs.appendFile(
+    path.join(auditDir, "audit.log"),
+    `${JSON.stringify({ timestamp: new Date().toISOString(), ...entry })}\n`,
+    "utf8",
+  );
+}
+
+const payload = await readStdinJson();
+const cwd = payload.cwd || payload.working_directory || process.env.MA_ROOT || process.cwd();
+const assistantText = extractAssistantText(payload);
+const blocked = detectPassivePermissionHandoff(assistantText, createDefaultActiveAutonomyCore());
+
+const result = blocked
+  ? {
+      decision: "block",
+      reason: DEFAULT_RESPONSE,
+      stopReason: "active_autonomy_passive_handoff",
+      systemMessage:
+        "Meta-Architect Active Autonomy blocked passive permission-handoff wording on an AUTO-CONTINUE branch.",
+    }
+  : {
+      decision: "approve",
+      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),
+});
+
+process.stdout.write(`${JSON.stringify(result)}\n`);

package/scripts/doctor.js

@@ -28,7 +28,24 @@ const checks = [
   [".codex/hooks.json", fs.existsSync(".codex/hooks.json")],
   [".ma/decisions.json", fs.existsSync(".ma/decisions.json")],
   [".ma/release.json", fs.existsSync(".ma/release.json")],
+  [
+    ".ma/context/helper-orchestration-core.json",
+    fs.existsSync(".ma/context/helper-orchestration-core.json"),
+  ],
+  [
+    ".ma/context/environment-awareness-core.json",
+    fs.existsSync(".ma/context/environment-awareness-core.json"),
+  ],
+  [
+    ".ma/context/universal-plugin-broker-core.json",
+    fs.existsSync(".ma/context/universal-plugin-broker-core.json"),
+  ],
   ["docs/release-spec.md", fs.existsSync("docs/release-spec.md")],
+  ["DEMO.md", fs.existsSync("DEMO.md")],
+  ["COVERAGE.md", fs.existsSync("COVERAGE.md")],
+  ["data/clone-data.proof.json", fs.existsSync("data/clone-data.proof.json")],
+  ["data/clone-data.ledger.json", fs.existsSync("data/clone-data.ledger.json")],
+  ["data/clone-data.rvf", fs.existsSync("data/clone-data.rvf")],
   [".agents/plugins/marketplace.json", fs.existsSync(".agents/plugins/marketplace.json")],
   ["plugins/meta-architect/.app.json", fs.existsSync("plugins/meta-architect/.app.json")],
   [
@@ -36,10 +53,6 @@ const checks = [
     fs.existsSync("plugins/meta-architect/.codex-plugin/plugin.json"),
   ],
   ["plugins/meta-architect/.mcp.json", fs.existsSync("plugins/meta-architect/.mcp.json")],
-  [
-    "missions/collaborative-whiteboard/mission.md",
-    fs.existsSync("missions/collaborative-whiteboard/mission.md"),
-  ],
   ["prompts/architect.md", fs.existsSync("prompts/architect.md")],
 ];
 

package/scripts/install.sh

@@ -0,0 +1,28 @@
+#!/usr/bin/env sh
+set -eu
+
+MA_PACKAGE="${MA_PACKAGE:-@jstn-sdk/ma@latest}"
+CODEX_PACKAGE="${CODEX_PACKAGE:-@openai/codex@latest}"
+
+need_cmd() {
+  command -v "$1" >/dev/null 2>&1 || {
+    echo "meta-architect install: missing required command: $1" >&2
+    exit 1
+  }
+}
+
+need_cmd npm
+need_cmd node
+
+echo "meta-architect install: installing Codex + Meta-Architect"
+npm i -g "$CODEX_PACKAGE" "$MA_PACKAGE"
+
+if command -v ma >/dev/null 2>&1; then
+  echo "meta-architect install: seeding local MA runtime"
+  ma setup >/dev/null
+  echo "meta-architect install: ready"
+  echo "start: ma --madmax --high"
+else
+  echo "meta-architect install: ma command not found after npm install" >&2
+  exit 1
+fi

package/scripts/ralph/prompt.md

@@ -0,0 +1,35 @@
+# Meta-Architect Ralph Execution Core
+
+You are executing a Meta-Architect story contract, not an independent release authority.
+
+## Required Inputs
+
+1. Read `.ma/plans/prd.json`.
+2. Read `.ma/plans/progress.txt`.
+3. Pick the highest-priority story where `passes` is `false`.
+4. Execute exactly one bounded story per iteration.
+
+## MA Quality Gates
+
+Before marking a story passed, verify:
+
+- `$arch` architecture constraints remain satisfied.
+- `$sage` evidence and source claims remain valid.
+- `$flow` logic/state invariants remain valid.
+- `$vet` security blockers are absent or explicitly owned.
+- `$vibe` DX/UX constraints remain acceptable.
+- `$build` real-workspace checks pass for the changed slice.
+
+## Authority Boundaries
+
+- Do not mutate `.ma/release.json` or `.ma/decisions.json` directly.
+- Return authoritative status through `$maestro`, `$build`, or the owning lane.
+- Treat Obsidian/vault context as `vault_context`, never `build_evidence`.
+- Treat virtual workspace output as context only, never production proof.
+- Treat code-graph rehearsal as a read-only trajectory preview.
+
+## Completion Contract
+
+Update story `passes` only after fresh verification evidence exists.
+Append progress to `.ma/plans/progress.txt`.
+Record reusable learnings in scoped guidance without overwriting the base workspace contract.

package/scripts/release-verify.js

@@ -3,9 +3,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import process from "node:process";
+import { validateReleaseIssueGates } from "../src/release-issue-gates.js";
 
 const CANONICAL_PACKAGE = "@jstn-sdk/ma";
 const CANONICAL_INSTALL = "npm i -g @openai/codex@latest @jstn-sdk/ma@latest";
+const CDN_INSTALL =
+  "curl -fsSL https://cdn.jsdelivr.net/gh/JustineDevs/meta-architect@main/scripts/install.sh | sh";
 const CANONICAL_LAUNCH = "ma --madmax --high";
 const UNINSTALL_MA = "npm uninstall -g @jstn-sdk/ma";
 const UNINSTALL_BOTH = "npm uninstall -g @jstn-sdk/ma @openai/codex";
@@ -40,10 +43,12 @@ function parseVersion(version) {
 
 function verifyInstallBlock(file) {
   const content = readText(file);
-  if (!content.includes(CANONICAL_INSTALL)) {
+  if (!content.includes(CANONICAL_INSTALL) && !content.includes(CDN_INSTALL)) {
     return;
   }
 
+  assert(content.includes(CDN_INSTALL), `${file}: missing jsDelivr POSIX installer command`);
+  assert(content.includes(CANONICAL_INSTALL), `${file}: missing canonical npm install command`);
   assert(content.includes(CANONICAL_LAUNCH), `${file}: missing canonical launch command`);
   assert(content.includes(UNINSTALL_MA), `${file}: missing uninstall Meta-Architect command`);
   assert(
@@ -52,6 +57,146 @@ function verifyInstallBlock(file) {
   );
 }
 
+function verifyNpmIgnore() {
+  assert(fs.existsSync(".npmignore"), ".npmignore: missing production package ignore file");
+  const content = readText(".npmignore");
+  for (const requiredPattern of [
+    ".ma/",
+    ".omx/",
+    "node_modules/",
+    ".npm-cache/",
+    "dist/",
+    "test/",
+    ".github/",
+    "*.tgz",
+  ]) {
+    assert(
+      content.includes(requiredPattern),
+      `.npmignore: missing required production ignore pattern ${requiredPattern}`,
+    );
+  }
+}
+
+function verifyDemoDoc({ version, gitTag }) {
+  assert(fs.existsSync("DEMO.md"), "DEMO.md: missing demo guide");
+  const content = readText("DEMO.md");
+  assert(content.includes(`Release line: \`${gitTag}\``), "DEMO.md: wrong release line");
+  assert(content.includes("Package: `@jstn-sdk/ma`"), "DEMO.md: missing package name");
+  assert(content.includes(CDN_INSTALL), "DEMO.md: missing jsDelivr installer");
+  assert(content.includes(CANONICAL_INSTALL), "DEMO.md: missing canonical npm install");
+  assert(content.includes(CANONICAL_LAUNCH), "DEMO.md: missing canonical launch");
+  assert(content.includes(UNINSTALL_MA), "DEMO.md: missing MA uninstall command");
+  assert(content.includes(UNINSTALL_BOTH), "DEMO.md: missing MA + Codex uninstall command");
+  assert(content.includes("npm run release:check"), "DEMO.md: missing full release demo command");
+  assert(
+    content.includes("Learning Loop Core") || content.includes("learning loop"),
+    "DEMO.md: missing learning loop coverage",
+  );
+  assert(content.includes("Obsidian"), "DEMO.md: missing Obsidian coverage");
+  assert(content.includes("Ralph"), "DEMO.md: missing Ralph execution coverage");
+  assert(content.includes("data/clone-data.proof.json"), "DEMO.md: missing clone-data proof");
+  assert(content.includes("COVERAGE.md"), "DEMO.md: missing coverage artifact");
+  assert(content.includes(`version line is \`${version}\``), "DEMO.md: missing current version");
+}
+
+function verifyCoverageDoc({ version, gitTag }) {
+  assert(fs.existsSync("COVERAGE.md"), "COVERAGE.md: missing coverage matrix");
+  const content = readText("COVERAGE.md");
+  assert(content.includes(`Target release: \`${gitTag}\``), "COVERAGE.md: wrong target release");
+  assert(
+    content.includes(`Package: \`@jstn-sdk/ma@${version}\``),
+    "COVERAGE.md: wrong package version",
+  );
+  assert(content.includes("Learning Loop Core"), "COVERAGE.md: missing learning-loop coverage");
+  assert(
+    content.includes("Helper Orchestration Core"),
+    "COVERAGE.md: missing helper orchestration coverage",
+  );
+  assert(
+    content.includes("Environment Awareness Core"),
+    "COVERAGE.md: missing environment awareness coverage",
+  );
+  assert(
+    content.includes("Universal Plugin Broker Core"),
+    "COVERAGE.md: missing universal plugin broker coverage",
+  );
+  assert(content.includes("Obsidian Integration Core"), "COVERAGE.md: missing Obsidian coverage");
+  assert(content.includes("Ralph Execution Core"), "COVERAGE.md: missing Ralph coverage");
+  assert(content.includes("36/36 passing"), "COVERAGE.md: missing current test count");
+  assert(
+    content.includes("This repository is not a toy demo."),
+    "COVERAGE.md: missing truth statement",
+  );
+  assert(!content.includes("@jstn-sdk/ma@0.1.0"), "COVERAGE.md: stale npm package version");
+  assert(!content.includes("v0.1.0 release bar"), "COVERAGE.md: stale release bar");
+}
+
+function verifyCanonicalSemanticSurfaces({ version, gitTag }) {
+  const usageWorkflow = readText(path.join("example", "usage-workflow.md"));
+  assert(
+    usageWorkflow.includes(`$maestro I want to harden Meta-Architect ${gitTag}`),
+    "example/usage-workflow.md: missing current $maestro release-hardening scenario",
+  );
+  for (const requiredTerm of ["Obsidian", "Ralph", "Caveman", "learning-loop"]) {
+    assert(
+      usageWorkflow.includes(requiredTerm),
+      `example/usage-workflow.md: missing ${requiredTerm} semantic-core term`,
+    );
+  }
+  for (const staleTerm of [
+    "Build a demo",
+    "demo app",
+    "collaborative whiteboard",
+    "smart contract security review",
+    "Timeline: 4 weeks",
+    "Delivery plan for v0.1.0",
+    "@jstn-sdk/ma@0.1.0",
+  ]) {
+    assert(
+      !usageWorkflow.includes(staleTerm),
+      `example/usage-workflow.md: stale current-facing term ${staleTerm}`,
+    );
+  }
+
+  const mission = readText(path.join("missions", "collaborative-whiteboard", "mission.md"));
+  assert(
+    mission.includes("# Mission: Semantic Release Hardening"),
+    "missions/collaborative-whiteboard/mission.md: stale mission title",
+  );
+  assert(
+    mission.includes("Obsidian is core vault-context infrastructure"),
+    "missions/collaborative-whiteboard/mission.md: missing Obsidian core mission contract",
+  );
+  assert(
+    mission.includes("Ralph is the execution loop"),
+    "missions/collaborative-whiteboard/mission.md: missing Ralph core mission contract",
+  );
+  assert(
+    !mission.toLowerCase().includes("real-time collaborative whiteboard"),
+    "missions/collaborative-whiteboard/mission.md: stale whiteboard mission text",
+  );
+
+  const currentQa = readText(path.join("docs", "qa", `release-readiness-${version}.md`));
+  assert(
+    currentQa.includes("Harden Meta-Architect v0.1.13 semantic core"),
+    `docs/qa/release-readiness-${version}.md: missing realistic semantic smoke idea`,
+  );
+  assert(
+    !currentQa.includes('ma idea "Build a demo app"'),
+    `docs/qa/release-readiness-${version}.md: stale demo-app helper path`,
+  );
+
+  const archPrompt = readText(path.join("prompts", "architect.md"));
+  assert(
+    !archPrompt.includes("v0.1.0` skills library"),
+    "prompts/architect.md: stale v0.1.0 skills-library wording",
+  );
+  assert(
+    archPrompt.includes("current Meta-Architect skills library"),
+    "prompts/architect.md: missing current library wording",
+  );
+}
+
 function main() {
   const pkg = readJson("package.json");
   const lock = readJson("package-lock.json");
@@ -68,6 +213,13 @@ function main() {
     pkg.publishConfig?.access === "public",
     "package.json: publishConfig.access must be public",
   );
+  assert(pkg.files?.includes("DEMO.md"), "package.json: files must include DEMO.md");
+  assert(pkg.files?.includes("COVERAGE.md"), "package.json: files must include COVERAGE.md");
+
+  verifyNpmIgnore();
+  verifyDemoDoc({ version, gitTag });
+  verifyCoverageDoc({ version, gitTag });
+  verifyCanonicalSemanticSurfaces({ version, gitTag });
 
   const changelog = readText("CHANGELOG.md");
   assert(changelog.includes(`## ${gitTag}`), "CHANGELOG.md: missing current version heading");
@@ -95,6 +247,17 @@ function main() {
   const qa = readText(qaPath);
   assert(qa.includes(`# Release Readiness ${version}`), `${qaPath}: wrong title version`);
 
+  const issueGatesPath = path.join("docs", "qa", `release-issue-gates-${version}.json`);
+  assert(fs.existsSync(issueGatesPath), `Missing release issue gate file: ${issueGatesPath}`);
+  const issueGates = validateReleaseIssueGates(readJson(issueGatesPath), {
+    version,
+    requirePassed: true,
+  });
+  assert(
+    issueGates.valid,
+    `${issueGatesPath}: release issue gates are not production-passed\n- ${issueGates.errors.join("\n- ")}`,
+  );
+
   const pluginApp = readJson(path.join("plugins", "meta-architect", ".app.json"));
   const pluginMcp = readJson(path.join("plugins", "meta-architect", ".mcp.json"));
   const pluginManifest = readJson(
@@ -109,6 +272,8 @@ function main() {
 
   for (const file of [
     "README.md",
+    "DEMO.md",
+    "COVERAGE.md",
     path.join("docs", "getting-started.md"),
     path.join("docs", "onboarding.md"),
     path.join("docs", "skills.md"),

package/skills/arch/SKILL.md

@@ -11,9 +11,11 @@ Use this skill inside Codex to turn a product idea into a concrete architecture
 
 Produce:
 - problem framing
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - user and workload assumptions
 - system architecture and subsystem boundaries
 - stack recommendation with tradeoffs
+- rejected alternatives with rationale
 - data model and storage choices
 - auth, security, and operational concerns
 - phased delivery plan

package/skills/build/SKILL.md

@@ -14,11 +14,14 @@ Produce:
 - blockers that still prevent implementation
 - the narrowest viable build slice
 - branch or worktree suggestions when relevant
+- bounded execution state when the build lane is already in progress
 - test and verification expectations
+- repair path when the bounded slice needs another pass
 - the exact next implementation step
 
 ## Rules
 
 - Do not claim readiness if architecture, evidence, logic, security, or DX/UX gaps remain unresolved.
 - Keep the recommended build slice small, testable, and reversible.
+- Treat `$build` as the sole owner of `.ma/plans/build.md` and `build_status`.
 - If the user wants code immediately and the path is clear, end with a concrete implementation plan rather than more review prose.

package/skills/flow/SKILL.md

@@ -10,7 +10,9 @@ Use this skill inside Codex to pressure-test how the system behaves, not just ho
 ## Output
 
 Produce:
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - key actors and system states
+- state map and failure flows
 - main flows and failure flows
 - invariants and state transitions
 - race conditions, dead ends, and consistency risks

package/skills/sage/SKILL.md

@@ -11,8 +11,10 @@ Use this skill inside Codex to verify or challenge stack choices with real sourc
 
 Produce:
 - candidate tools, libraries, or services
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - why each option fits or fails the architecture
 - source-backed evidence from official docs, upstream repos, or approved GitMCP sources
+- evidence grade and exact upstream mapping
 - recommendation with tradeoffs
 - unresolved gaps or missing evidence
 - exact next trigger, usually `$flow`

package/skills/sage/references/source-selection.md

@@ -23,6 +23,14 @@ Use this reference pack inside `$sage` when the repo needs evidence-backed selec
 - Claimed capability verified from a primary source
 - Maturity caveats called out when evidence is weak
 
+## Evidence grades
+
+- `VERIFIED`: exact upstream mapping plus primary-source confirmation
+- `PARTIAL`: candidate is mapped, but live proof or maturity proof is incomplete
+- `MISSING`: no trustworthy exact upstream mapping yet
+
+Always expose the evidence grade and the exact upstream mapping in user-facing `$sage` output.
+
 ## Native posture
 
 Meta-Architect ships curated guidance and playbooks. It does not ship a raw mirror of external catalogs. External sources remain evidence inputs, not user-facing skill identities.

package/skills/vet/SKILL.md

@@ -10,11 +10,13 @@ Use this skill inside Codex to review security posture before the build lane. `$
 ## Output
 
 Produce:
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - trust boundaries
 - authn/authz expectations
 - sensitive data paths
 - abuse cases and likely failure modes
 - concrete mitigations
+- accepted risks
 - release blockers vs acceptable risks
 - exact next trigger, usually `$vibe`
 

package/skills/vet/references/security-playbooks.md

@@ -18,6 +18,13 @@ Use this reference pack inside `$vet` for repeatable trust-boundary reviews that
 - Distinguish blockers from accepted risk.
 - Route remediation back to the owning lane rather than creating a parallel security workflow.
 
+## Adversarial hardening
+
+- For higher-risk changes, run a bounded adversarial hardening pass before final approval.
+- Keep the hardening work inside the private scratchpad/runtime layer.
+- Return structured findings, not direct gate mutations.
+- If the hardening pass cannot resolve or clearly classify the risk, keep `$vet` in a non-terminal state instead of over-approving.
+
 ## Product boundary
 
 This pack deepens `$vet`; it does not create a new security skill family. Security patterns are packaged as Meta-Architect guidance, not as mirrored external catalogs or branded upstream surfaces.

package/skills/vibe/SKILL.md

@@ -10,8 +10,10 @@ Use this skill inside Codex to review whether the system will feel coherent for
 ## Output
 
 Produce:
+- `decision`, `status`, `evidence`, `blockers`, `next_allowed_triggers`
 - developer workflow risks
 - user workflow risks
+- operator friction and user friction
 - complexity hotspots
 - onboarding or operability friction
 - simplifications that improve clarity

package/src/bootstrap.js

@@ -152,6 +152,20 @@ async function inspectLocalScaffold() {
     getRuntimeWritePath("release.json"),
     getRuntimeWritePath("guidance", "merged.json"),
     getRuntimeWritePath("guidance", "include-graph.json"),
+    getRuntimeWritePath("context", "active-autonomy-core.json"),
+    getRuntimeWritePath("context", "capability-composition.json"),
+    getRuntimeWritePath("context", "code-graph-rehearse.json"),
+    getRuntimeWritePath("context", "core-source-ingest.json"),
+    getRuntimeWritePath("context", "learning-loop-core.json"),
+    getRuntimeWritePath("context", "obsidian-bridge.json"),
+    getRuntimeWritePath("context", "obsidian-vault-index.json"),
+    getRuntimeWritePath("context", "obsidian-vault-operations.json"),
+    getRuntimeWritePath("context", "prompt-strategy-core.json"),
+    getRuntimeWritePath("context", "recording-core.json"),
+    getRuntimeWritePath("context", "skills-registry-export.json"),
+    getRuntimeWritePath("context", "workspace-virtualizer.json"),
+    getRuntimeWritePath("context", "workspace-context-pack.json"),
+    getRuntimeWritePath("context", "workspace-effectiveness.json"),
     getRuntimeWritePath("memory", "notes.md"),
     getRuntimeWritePath("memory", "index.json"),
     getRuntimeWritePath("hooks", "config.json"),
@@ -161,6 +175,9 @@ async function inspectLocalScaffold() {
     getRuntimeWritePath("tasks", "locks"),
     getRuntimeWritePath("workspaces", "index.json"),
     getRuntimeWritePath("state", "manager-runs.json"),
+    getRuntimeWritePath("state", "maestro-state.json"),
+    getRuntimeWritePath("evidence", "semantic-receipts.json"),
+    path.join(getRepoRoot(), "docs", "qa", "release-issue-gates-0.1.13.json"),
     path.join(getMcpRootPath(), "servers.json"),
     path.join(getMcpRootPath(), "local-capabilities.json"),
   ];

package/src/build-gate.js

@@ -26,10 +26,10 @@ export function evaluateBuildGate(releaseState) {
     });
   }
 
-  if (!["LOCKED", "READY"].includes(releaseState.build_status)) {
+  if (!["LOCKED", "READY", "RUNNING"].includes(releaseState.build_status)) {
     blockers.push({
       field: "build_status",
-      expected: "LOCKED or READY",
+      expected: "LOCKED, READY, or RUNNING",
       actual: releaseState.build_status,
       trigger: "$build",
     });

package/src/launcher.js

@@ -8,8 +8,12 @@ const nativeCommands = new Set([
   "init",
   "idea",
   "skills",
+  "core-ingest",
+  "obsidian",
+  "obsidian-index",
   "sdk-path",
   "status",
+  "verify",
   "merge",
   "release",
   "run",