@jstn-sdk/ma 0.1.11 → 0.1.13

package/plugins/meta-architect/obsidian/main.js

@@ -0,0 +1,401 @@
+const { MarkdownView, Modal, Notice, Plugin, PluginSettingTab, Setting } = require("obsidian");
+
+const DEFAULT_SETTINGS = {
+  projectName: "Meta-Architect",
+  activeContextPath: "Meta-Architect/Plugin Context/Active Note Context.md",
+  queuePath: "Meta-Architect/Plugin Requests/request-queue.json",
+  attachmentDir: "Meta-Architect/Attachments",
+  sourceWorkspace: "",
+};
+
+const FORBIDDEN_TARGETS = [".ma/release.json", ".ma/decisions.json", ".ma/plans/", ".ma/specs/"];
+
+module.exports = class MetaArchitectPlugin extends Plugin {
+  async onload() {
+    this.settings = Object.assign({}, DEFAULT_SETTINGS, (await this.loadData()) || {});
+    this.addRibbonIcon("network", "Send current note/selection to MA", async () => {
+      await this.captureActiveNote();
+    });
+
+    const statusBarItem = this.addStatusBarItem();
+    statusBarItem.addClass("ma-status");
+    statusBarItem.setText("MA: vault context");
+
+    this.addCommand({
+      id: "ma-capture-active-note",
+      name: "Send current note/selection to MA",
+      callback: async () => this.captureActiveNote(),
+    });
+
+    this.addCommand({
+      id: "ma-drain-request-queue",
+      name: "Drain MA request queue",
+      callback: async () => {
+        const result = await this.drainRequestQueue();
+        new Notice(
+          `MA queue drained: ${result.processed.length} processed, ${result.refused.length} refused`,
+        );
+      },
+    });
+
+    this.addCommand({
+      id: "ma-open-context-preview",
+      name: "Preview current MA context",
+      checkCallback: (checking) => {
+        const view = this.app.workspace.getActiveViewOfType(MarkdownView);
+        if (!view) return false;
+        if (!checking) new ContextPreviewModal(this.app, this.createSelectionContext()).open();
+        return true;
+      },
+    });
+
+    this.addCommand({
+      id: "ma-open-map",
+      name: "Open MA map of content",
+      callback: async () => this.openNote("Meta-Architect/Map of Content.md"),
+    });
+
+    this.addSettingTab(new MetaArchitectSettingTab(this.app, this));
+    this.registerProtocolHandler();
+    this.registerVaultWatchers();
+    this.registerInterval(
+      window.setInterval(() => this.drainRequestQueue().catch(() => {}), 30 * 1000),
+    );
+  }
+
+  async loadSettings() {
+    this.settings = Object.assign({}, DEFAULT_SETTINGS, (await this.loadData()) || {});
+  }
+
+  async saveSettings() {
+    await this.saveData(this.settings);
+  }
+
+  createSelectionContext() {
+    const file = this.app.workspace.getActiveFile();
+    const view = this.app.workspace.getActiveViewOfType(MarkdownView);
+    const leaf = this.app.workspace.activeLeaf;
+    const editor = view?.editor || leaf?.view?.editor;
+    const selectedText = editor?.getSelection?.() || "";
+    return {
+      record_type: "obsidian_active_note_context",
+      records_as: "vault_context",
+      build_evidence: false,
+      captured_at: new Date().toISOString(),
+      active_note_path: file?.path || null,
+      selected_text: selectedText,
+      selected_text_char_count: selectedText.length,
+      cursor: editor?.getCursor?.() || null,
+      pane_state: leaf?.getViewState?.() || null,
+      metadata: file ? this.app.metadataCache.getFileCache(file) || {} : {},
+    };
+  }
+
+  async captureActiveNote() {
+    const context = this.createSelectionContext();
+    const file = this.app.workspace.getActiveFile();
+    if (file) {
+      await this.app.fileManager.processFrontMatter(file, (frontmatter) => {
+        frontmatter.ma_records_as = "vault_context";
+        frontmatter.ma_project = this.settings.projectName;
+        frontmatter.ma_capabilities = [
+          "obsidian_integration_core",
+          "active_note_selection_context",
+          "metadata_cache_deep_graph",
+        ];
+        if (this.settings.sourceWorkspace) {
+          frontmatter.ma_source_workspace = this.settings.sourceWorkspace;
+        }
+      });
+    }
+    await this.writeVaultContextNote(
+      this.settings.activeContextPath,
+      this.renderContextNote(context),
+      true,
+    );
+    await this.writeBinaryAttachment(
+      `${this.settings.attachmentDir}/active-context-${Date.now()}.json`,
+      JSON.stringify(context, null, 2),
+      "application/json",
+    );
+    new Notice("MA captured current Obsidian context");
+    return context;
+  }
+
+  renderContextNote(context) {
+    const activeLink = context.active_note_path
+      ? this.app.fileManager.generateMarkdownLink(
+          this.app.vault.getAbstractFileByPath(context.active_note_path),
+          this.settings.activeContextPath,
+          undefined,
+          "active note",
+        )
+      : "none";
+    return withVaultContextFrontmatter(`# Active Note Context
+
+- Active note: ${activeLink}
+- Selection chars: ${context.selected_text_char_count}
+- Cursor: ${JSON.stringify(context.cursor)}
+- Captured: ${context.captured_at}
+
+## Selected Text
+
+${context.selected_text || "_No active selection captured._"}
+
+## Obsidian MetadataCache
+
+\`\`\`json
+${JSON.stringify(context.metadata, null, 2)}
+\`\`\`
+
+## Pane State
+
+\`\`\`json
+${JSON.stringify(context.pane_state || {}, null, 2)}
+\`\`\`
+`);
+  }
+
+  registerProtocolHandler() {
+    this.registerObsidianProtocolHandler("ma", async (params) => {
+      if (params.action === "queue") {
+        await this.queueRequest(params);
+        new Notice("MA request queued");
+        return;
+      }
+      if (params.action === "capture" || params.open === "active") {
+        await this.captureActiveNote();
+        return;
+      }
+      await this.openNote(params.path || "Meta-Architect/Map of Content.md");
+    });
+  }
+
+  registerVaultWatchers() {
+    for (const eventName of ["create", "modify", "delete", "rename"]) {
+      this.registerEvent(
+        this.app.vault.on(eventName, () => {
+          this.drainRequestQueue().catch(() => {});
+        }),
+      );
+    }
+    for (const eventName of ["resolved", "changed", "deleted"]) {
+      this.registerEvent(
+        this.app.metadataCache.on(eventName, () => {
+          this.drainRequestQueue().catch(() => {});
+        }),
+      );
+    }
+    for (const eventName of ["active-leaf-change", "layout-change"]) {
+      this.registerEvent(
+        this.app.workspace.on(eventName, () => {
+          this.drainRequestQueue().catch(() => {});
+        }),
+      );
+    }
+  }
+
+  async queueRequest(params) {
+    await this.ensureFolder(this.pathParent(this.settings.queuePath));
+    const file = this.app.vault.getAbstractFileByPath(this.settings.queuePath);
+    const queue = file ? JSON.parse(await this.app.vault.read(file)) : [];
+    queue.push({
+      ...params,
+      id: params.id || `ma-${Date.now()}`,
+      queued_at: new Date().toISOString(),
+      records_as: "vault_context",
+    });
+    const payload = `${JSON.stringify(queue, null, 2)}\n`;
+    if (file) await this.app.vault.modify(file, payload);
+    else await this.app.vault.create(this.settings.queuePath, payload);
+  }
+
+  async drainRequestQueue() {
+    const file = this.app.vault.getAbstractFileByPath(this.settings.queuePath);
+    const queue = file ? JSON.parse(await this.app.vault.read(file)) : [];
+    const processed = [];
+    const refused = [];
+    for (const request of queue) {
+      try {
+        const target = request.note_path || request.path || "";
+        if (target) assertSafeVaultPath(target);
+        if (request.action === "capture_active_note") {
+          processed.push(await this.captureActiveNote());
+        } else if (request.action === "create_note") {
+          processed.push(await this.writeVaultContextNote(target, request.content, true));
+        } else if (request.action === "rename_note") {
+          assertSafeVaultPath(request.to);
+          const fileToRename = this.app.vault.getAbstractFileByPath(request.from);
+          await this.app.fileManager.renameFile(fileToRename, request.to);
+          processed.push({ action: "rename_note", from: request.from, to: request.to });
+        } else if (request.action === "write_attachment") {
+          processed.push(
+            await this.writeBinaryAttachment(target, request.data || "", request.content_type),
+          );
+        } else {
+          throw new Error(`unsupported_action:${request.action}`);
+        }
+      } catch (error) {
+        refused.push({
+          action: request?.action || null,
+          reason: error.message,
+          records_as: "vault_context",
+          build_evidence: false,
+        });
+      }
+    }
+    if (file && queue.length > 0) await this.app.vault.modify(file, "[]\n");
+    return {
+      record_type: "obsidian_plugin_queue_drain",
+      records_as: "vault_context",
+      build_evidence: false,
+      processed,
+      refused,
+    };
+  }
+
+  async writeVaultContextNote(notePath, content, overwrite) {
+    assertSafeVaultPath(notePath);
+    if (!content?.trim()) throw new Error("vault_context note content required");
+    await this.ensureFolder(this.pathParent(notePath));
+    const file = this.app.vault.getAbstractFileByPath(notePath);
+    const payload = withVaultContextFrontmatter(content);
+    if (file && overwrite) await this.app.vault.modify(file, payload);
+    else if (file) throw new Error(`note_exists:${notePath}`);
+    else await this.app.vault.create(notePath, payload);
+    return {
+      action: "write_vault_context_note",
+      note_path: notePath,
+      records_as: "vault_context",
+      build_evidence: false,
+    };
+  }
+
+  async writeBinaryAttachment(attachmentPath, data, contentType) {
+    assertSafeVaultPath(attachmentPath);
+    await this.ensureFolder(this.pathParent(attachmentPath));
+    const bytes = new TextEncoder().encode(String(data || ""));
+    if (this.app.vault.createBinary) {
+      await this.app.vault.createBinary(attachmentPath, bytes.buffer);
+    } else {
+      await this.app.vault.adapter.writeBinary(attachmentPath, bytes.buffer);
+    }
+    return {
+      action: "write_attachment",
+      attachment_path: attachmentPath,
+      content_type: contentType || "application/octet-stream",
+      records_as: "vault_context",
+      build_evidence: false,
+    };
+  }
+
+  async openNote(notePath) {
+    const file = this.app.vault.getAbstractFileByPath(notePath);
+    if (!file) {
+      new Notice(`MA note not found: ${notePath}`);
+      return;
+    }
+    await this.app.workspace.getLeaf(true).openFile(file);
+  }
+
+  async ensureFolder(folderPath) {
+    if (!folderPath || folderPath === ".") return;
+    const segments = folderPath.split("/").filter(Boolean);
+    let current = "";
+    for (const segment of segments) {
+      current = current ? `${current}/${segment}` : segment;
+      if (!this.app.vault.getAbstractFileByPath(current)) {
+        await this.app.vault.createFolder(current).catch(() => {});
+      }
+    }
+  }
+
+  pathParent(filePath) {
+    const parts = filePath.split("/");
+    parts.pop();
+    return parts.join("/");
+  }
+};
+
+class ContextPreviewModal extends Modal {
+  constructor(app, context) {
+    super(app);
+    this.context = context;
+  }
+
+  onOpen() {
+    this.contentEl.addClass("ma-context-modal");
+    this.contentEl.createEl("h2", { text: "Meta-Architect Context Preview" });
+    this.contentEl.createEl("pre", { text: JSON.stringify(this.context, null, 2) });
+  }
+
+  onClose() {
+    this.contentEl.empty();
+  }
+}
+
+class MetaArchitectSettingTab extends PluginSettingTab {
+  constructor(app, plugin) {
+    super(app, plugin);
+    this.plugin = plugin;
+  }
+
+  display() {
+    const { containerEl } = this;
+    containerEl.empty();
+    containerEl.createEl("h2", { text: "Meta-Architect" });
+
+    new Setting(containerEl)
+      .setName("Project name")
+      .setDesc("Stored in MA frontmatter as ma_project.")
+      .addText((text) =>
+        text.setValue(this.plugin.settings.projectName).onChange(async (value) => {
+          this.plugin.settings.projectName = value || "Meta-Architect";
+          await this.plugin.saveSettings();
+        }),
+      );
+
+    new Setting(containerEl)
+      .setName("Active context note")
+      .setDesc("Where captured note/selection context is written.")
+      .addText((text) =>
+        text.setValue(this.plugin.settings.activeContextPath).onChange(async (value) => {
+          this.plugin.settings.activeContextPath = value || DEFAULT_SETTINGS.activeContextPath;
+          await this.plugin.saveSettings();
+        }),
+      );
+  }
+}
+
+function withVaultContextFrontmatter(content) {
+  if (content.trimStart().startsWith("---")) {
+    return content;
+  }
+  return `---
+ma_records_as: vault_context
+ma_project: Meta-Architect
+ma_capabilities:
+  - obsidian_integration_core
+---
+
+${content}`;
+}
+
+function assertSafeVaultPath(targetPath) {
+  const normalized = String(targetPath || "")
+    .replaceAll("\\", "/")
+    .replace(/^\/+/, "");
+  if (
+    !normalized ||
+    normalized === ".." ||
+    normalized.startsWith("../") ||
+    normalized.includes("/../")
+  ) {
+    throw new Error("path_traversal_forbidden");
+  }
+  for (const forbidden of FORBIDDEN_TARGETS) {
+    if (normalized === forbidden || normalized.startsWith(forbidden)) {
+      throw new Error(`forbidden_authoritative_mutation:${forbidden}`);
+    }
+  }
+}

package/plugins/meta-architect/obsidian/manifest.json

@@ -0,0 +1,9 @@
+{
+  "id": "meta-architect",
+  "name": "Meta-Architect",
+  "version": "0.1.13",
+  "minAppVersion": "1.5.0",
+  "description": "Connects active Obsidian notes, selections, graph metadata, canvases, attachments, and request queues to Meta-Architect vault context.",
+  "author": "JustineDevs",
+  "isDesktopOnly": false
+}

package/plugins/meta-architect/obsidian/styles.css

@@ -0,0 +1,7 @@
+.ma-status {
+  color: var(--text-muted);
+}
+
+.ma-context-modal pre {
+  white-space: pre-wrap;
+}

package/plugins/meta-architect/skills/align/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: align
+description: "Use when the user needs scope alignment, shared language, or docs clarity before or between gated lanes."
+---
+
+# Align
+
+Use this skill inside Codex when the problem is ambiguity, drift, or mismatched language rather than missing implementation. `align` is a non-gating helper skill.
+
+## Output
+
+Produce:
+- current ambiguity or mismatch
+- normalized terminology
+- scope boundary and exclusions
+- acceptance checks or rewritten prompts
+- exact next trigger, usually `$maestro` or the lane that owns the next decision
+
+## Rules
+
+- Align language and scope without creating a new release gate.
+- Prefer tightening existing artifacts over inventing parallel docs.
+- Keep terminology Meta-Architect-native for user-facing surfaces.
+- Use `references/shared-language.md` for naming, taxonomy, and docs-clarity patterns.

package/plugins/meta-architect/skills/align/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "$align"
+  short_description: "Scope alignment and shared language helper"
+  default_prompt: "Use $align to resolve scope drift, normalize terminology, and tighten prompts or docs before handing work back to the owning gated lane."

package/plugins/meta-architect/skills/align/references/shared-language.md

@@ -0,0 +1,24 @@
+# Shared Language
+
+Use this reference pack with `align` when terminology, scope, or docs are drifting.
+
+## Naming rules
+
+- `$maestro` is the only umbrella surface.
+- `$arch -> $sage -> $flow -> $vet -> $vibe -> $build` remains the fixed gated sequence.
+- `align`, `diagnose`, `tdd`, and `cleanup` are helper skills only.
+- User-facing guidance stays Meta-Architect-native; external source names may appear as evidence, not as product surfaces.
+
+## Alignment checklist
+
+- Name the current artifact, lane, and decision owner.
+- Replace vague nouns with one stable term.
+- Separate what is in scope, out of scope, and not yet decided.
+- Rewrite prompts or docs so the next trigger is obvious.
+
+## Docs-clarity patterns
+
+- Put the next trigger in one line.
+- Distinguish terminal helper commands from in-session skills.
+- Distinguish gated lanes from helper skills.
+- Prefer concise, high-signal wording over long catalogs or branding-heavy lists.

package/plugins/meta-architect/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/plugins/meta-architect/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/plugins/meta-architect/skills/cleanup/SKILL.md

@@ -0,0 +1,23 @@
+---
+name: cleanup
+description: "Use when the user wants contract-preserving simplification, anti-slop cleanup, or a final-pass polish after the main decision is made."
+---
+
+# Cleanup
+
+Use this skill inside Codex when the core behavior is understood but the artifact still needs simplification, deslop work, or clearer prose. `cleanup` is a non-gating helper skill.
+
+## Output
+
+Produce:
+- removable complexity or noisy wording
+- behavior-preserving simplifications
+- residual risks after cleanup
+- exact next trigger, usually the owning lane or release verification
+
+## Rules
+
+- Prefer deletion over addition.
+- Preserve behavior and decision ownership while cleaning up.
+- Keep user-facing wording concise and product-native.
+- Use `references/style-and-deslop.md` for simplification and prose cleanup patterns.

package/plugins/meta-architect/skills/cleanup/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "$cleanup"
+  short_description: "Anti-slop cleanup and final-pass polish"
+  default_prompt: "Use $cleanup to simplify noisy code or docs, remove avoidable slop, and polish wording without changing the owning lane."

package/plugins/meta-architect/skills/cleanup/references/style-and-deslop.md

@@ -0,0 +1,18 @@
+# Style And Deslop
+
+Use this reference pack with `cleanup` when an artifact works but still feels bloated, generic, or hard to trust.
+
+## Cleanup priorities
+
+- remove repeated framing
+- cut placeholder language and empty intensifiers
+- collapse duplicate concepts into one stable term
+- prefer shorter, sharper instructions when they preserve meaning
+- delete unused or non-essential surface area before adding more structure
+
+## Safe cleanup checks
+
+- behavior or contract is unchanged
+- the next trigger is still explicit
+- helper-vs-gated distinctions remain intact
+- no upstream brand names are introduced as product surfaces

package/plugins/meta-architect/skills/diagnose/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: diagnose
+description: "Use when the user needs failure triage, blocked-lane diagnosis, or root-cause decomposition before the next gate can move."
+---
+
+# Diagnose
+
+Use this skill inside Codex when a lane is blocked, a symptom is vague, or the next useful move is to decompose the failure before editing code. `diagnose` is a non-gating helper skill.
+
+## Output
+
+Produce:
+- observed symptom
+- likely failure slices
+- missing evidence or missing reproduction steps
+- smallest next probe
+- exact next trigger, usually the owning lane or `$maestro`
+
+## Rules
+
+- Decompose the problem before proposing broad fixes.
+- Prefer the smallest reproducible boundary that can confirm or kill a hypothesis.
+- Keep release-state ownership with the gated lane that is blocked.
+- Escalate assumptions clearly when evidence is still incomplete.

package/plugins/meta-architect/skills/diagnose/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "$diagnose"
+  short_description: "Blocked-lane diagnosis and failure triage"
+  default_prompt: "Use $diagnose to break a vague failure into concrete hypotheses, probes, and the smallest next debugging step without changing gate ownership."

package/plugins/meta-architect/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/plugins/meta-architect/skills/maestro/SKILL.md

@@ -1,11 +1,34 @@
 ---
 name: maestro
-description: "Use when the user wants Meta-Architect to choose the best next workflow step, explain why, and recommend the right lane or assignment."
+description: "Use when the user wants the singular Meta-Architect in-session autonomous manager: choose the best next workflow step, manage the fixed gated workflow, and route bounded helper handoffs inside Codex."
 ---
 
 # Maestro
 
-Use this skill inside Codex when you want Meta-Architect to act like a workflow manager.
+## Overview
+
+Use this skill inside Codex as the singular Meta-Architect umbrella surface and bounded autonomous manager. It inspects workflow state, chooses the smallest safe next step, manages the fixed gated design-and-review sequence one lane at a time, and routes helper handoffs when they are enough. There is no separate shipped `$meta-architect` skill.
+
+## Workflow
+
+1. Inspect the current gate state, active evidence, and current blockers.
+2. Choose the smallest safe next step and decide whether the next move is:
+   - a direct advisory result
+   - a helper-skill handoff
+   - a gated-lane handoff
+3. When the issue is alignment, diagnosis, regression-first execution, or final-pass cleanup, hand work to the publishable but non-gating helper skills:
+   - `$align`
+   - `$diagnose`
+   - `$tdd`
+   - `$cleanup`
+4. When the user wants the full Meta-Architect workflow, manage the fixed gated sequence without inventing new gates or skipping lane ownership:
+   - `$arch`
+   - `$sage`
+   - `$flow`
+   - `$vet`
+   - `$vibe`
+   - `$build`
+5. End with a clear result shape: decision, evidence, blockers, the lane assignment if any, and the exact next trigger.
 
 ## Output
 
@@ -22,4 +45,14 @@ Produce:
 - Prefer the smallest next step that moves the workflow forward safely.
 - Respect current gate state before recommending implementation or release work.
 - Be explicit when more evidence, planning, or validation is still needed.
-- Route to the in-session skill flow first; use helper commands only when they are the clearest support path.
+- Treat the in-session skill flow as primary. Use `ma ...` terminal helpers only when repo-local setup, inspection, or scripted state automation is explicitly the better support path.
+- Keep `$maestro` as the only umbrella surface. It owns next-step management and bounded handoff decisions, but it does not replace the outputs owned by the gated lanes.
+- Helper skills are publishable mirrors, but they are non-gating. They support a lane and then hand control back to `$maestro` or the fixed gated sequence.
+- Do not expand the release-gated sequence for this release. Gate ownership stays with `$arch -> $sage -> $flow -> $vet -> $vibe -> $build`.
+- Stay inside Codex unless the user explicitly asks for repo-local helper commands.
+- Keep the workflow architecture-first. Do not jump into code before the architecture and review lanes are grounded.
+- Use approved discovery accelerators such as Ossium, Trendshift, Dev Hunt, Libraries.io, Open Hub, and Open-source Projects when you need faster OSS candidate discovery, then validate any promising project through upstream repos and official docs.
+- Keep the `$sage` order explicit: known upstream sources first, discovery accelerators second, exact repo mapping third, approval only after upstream verification.
+- Prefer official docs, upstream repos, and repo-configured GitMCP sources when validating tooling choices.
+- For release gates and branch policy, read `references/core-release-rules.md`.
+- For the native helper-family contract and pattern classification, read `references/native-ingest-map.md`.

package/plugins/meta-architect/skills/maestro/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "$maestro"
-  short_description: "Best next step and lane orchestration"
-  default_prompt: "Use $maestro to inspect the current Meta-Architect workflow state, choose the best next step, explain why it is next, and recommend the right lane or assignment."
+  short_description: "Bounded autonomous manager for the gated workflow and helper handoffs"
+  default_prompt: "Use $maestro as the singular Meta-Architect in-session autonomous manager: inspect workflow state, choose the smallest safe next step, hand work to $align, $diagnose, $tdd, or $cleanup when a publishable non-gating helper is enough, and manage the fixed gated sequence at $arch, $sage, $flow, $vet, $vibe, and $build without inventing new gates."