@a5c-ai/babysitter-antigravity-cli 5.1.1-staging.583e3d9a6ed7

package/README.md

@@ -0,0 +1,204 @@
+# @a5c-ai/babysitter-antigravity
+
+Babysitter integration package for Antigravity CLI.
+
+Antigravity CLI is Google's successor to Gemini CLI. It uses a workflow-driven
+hook model and a SKILL.md plugin system. It is model-agnostic, supporting
+Gemini, Claude, and GPT providers.
+
+This package ships an Antigravity CLI plugin bundle:
+
+- `SKILL.md` — Antigravity-native skill manifest with YAML frontmatter
+- `plugin.json` — Babysitter plugin manifest
+- `workflow.json` — Workflow orchestration descriptor
+- `mcp.json` — MCP config for multi-provider tool integration
+- `commands/` — Slash command definitions for all babysitter workflows
+- `hooks/` — Workflow-driven hook scripts
+- `bin/cli.js` — `babysitter-antigravity` installer CLI
+
+It uses the Babysitter SDK CLI and the shared `~/.a5c` process-library state.
+The plugin registers workflow-driven hooks and commands so Antigravity CLI can
+drive the Babysitter orchestration loop from within the agent session.
+
+## Installation
+
+Install the Babysitter CLI once:
+
+```bash
+npm install -g @a5c-ai/babysitter
+```
+
+Install the Antigravity plugin through the SDK helper:
+
+```bash
+# Global install
+babysitter harness:install-plugin antigravity-cli
+
+# Workspace install
+babysitter harness:install-plugin antigravity-cli --workspace /path/to/project
+```
+
+You can also run the published package installer directly:
+
+```bash
+npx --yes @a5c-ai/babysitter-antigravity install --global
+npx --yes @a5c-ai/babysitter-antigravity install --workspace /path/to/project
+```
+
+For development, use a symlink instead of copying files:
+
+```bash
+babysitter-antigravity install --symlink
+```
+
+After installation, restart Antigravity CLI to activate the plugin.
+
+## How It Works
+
+The plugin implements a workflow-driven orchestration loop:
+
+1. `SessionStart` fires when a new Antigravity CLI session begins. It ensures
+   the correct SDK CLI version is installed (pinned via `versions.json`) and
+   initializes session state under `~/.a5c/state/`.
+
+2. The `SKILL.md` context file is loaded into every session, instructing the
+   agent on the full 8-step orchestration workflow -- from interviewing the user
+   and creating a process definition through iterating effects and posting results.
+
+3. The agent performs **one orchestration phase per turn**, then stops.
+
+4. `AfterAgent` fires after every agent turn. It checks whether a babysitter run
+   is bound to the current session. If the run is not yet complete, the hook
+   returns `{"decision":"block","reason":"...","systemMessage":"..."}` to keep
+   the session alive and inject the next iteration prompt. Once the agent emits
+   `<promise>COMPLETION_PROOF</promise>`, the hook allows the session to exit.
+
+## Hook Types
+
+| Hook | Event | Type | Purpose |
+|------|-------|------|---------|
+| Session initialization | `SessionStart` | workflow | Installs the correct SDK version, creates session state |
+| Continuation loop | `AfterAgent` | workflow | Blocks session exit and drives the orchestration loop until the run completes |
+
+Both hooks delegate to the SDK CLI via `babysitter hook:run` for all business
+logic. The workflow-driven hook model replaces the shell-hook scripts used by
+Gemini CLI.
+
+## Differences from Gemini CLI
+
+| Feature | Gemini CLI | Antigravity CLI |
+|---------|-----------|----------------|
+| Hook model | Shell-hook scripts | Workflow-driven hooks |
+| Plugin manifest | `gemini-extension.json` | `SKILL.md` (YAML frontmatter) |
+| Model support | Gemini only | Gemini, Claude, GPT (model-agnostic) |
+| Tool integration | Native | MCP-based multi-provider |
+| Orchestration | Extension-based | Workflow + SKILL.md |
+
+## Available Commands
+
+All commands follow the orchestration workflow described in `SKILL.md`.
+Invoke them in Antigravity CLI with `/babysitter:<command>`.
+
+### Primary Orchestration Commands
+
+| Command | Description |
+|---------|-------------|
+| `/babysitter:call [instructions]` | Start a babysitter-orchestrated run |
+| `/babysitter:plan [instructions]` | Generate a detailed execution plan without running anything |
+| `/babysitter:yolo [instructions]` | Start a run in fully autonomous mode |
+| `/babysitter:forever [instructions]` | Start a run that loops indefinitely |
+| `/babysitter:resume [run-id]` | Resume a paused or interrupted run |
+
+### Diagnostic and Analysis Commands
+
+| Command | Description |
+|---------|-------------|
+| `/babysitter:doctor [run-id]` | Run a health check on a run |
+| `/babysitter:retrospect [run-id...]` | Analyze completed runs and suggest improvements |
+
+### Lifecycle Management Commands
+
+| Command | Description |
+|---------|-------------|
+| `/babysitter:assimilate [target]` | Convert an external methodology into native babysitter process definitions |
+| `/babysitter:cleanup [--dry-run]` | Aggregate insights then remove old run data |
+| `/babysitter:observe` | Launch the real-time observer dashboard |
+
+### Setup Commands
+
+| Command | Description |
+|---------|-------------|
+| `/babysitter:user-install` | First-time onboarding and user profile setup |
+| `/babysitter:project-install` | Onboard a project for babysitter orchestration |
+
+### Plugin and Community Commands
+
+| Command | Description |
+|---------|-------------|
+| `/babysitter:blueprints [action]` | Manage Babysitter blueprints |
+| `/babysitter:contrib [feedback]` | Submit feedback or contribute to the babysitter project |
+| `/babysitter:help [topic]` | Show help for babysitter commands and workflows |
+
+## Configuration
+
+| Source | Purpose |
+|--------|---------|
+| `versions.json` | Pins the required `@a5c-ai/babysitter-sdk` version |
+| `SKILL.md` | Antigravity-native skill manifest with YAML frontmatter metadata |
+| `plugin.json` | Babysitter plugin manifest declaring hooks, commands, and harness |
+| `workflow.json` | Workflow orchestration descriptor for hook execution graph |
+| `mcp.json` | MCP config for multi-provider tool integration |
+| `ANTIGRAVITY_SKILL_PATH` env var | Path to the installed plugin root |
+| `BABYSITTER_LOG_DIR` env var | Override the log directory (defaults to `~/.a5c/logs`) |
+| `~/.a5c/state/` | Session state directory |
+| `~/.a5c/user-profile.json` | User profile for personalizing orchestration |
+
+## Verification
+
+Verify the installed plugin bundle:
+
+```bash
+babysitter-antigravity status --global
+```
+
+Verify the SDK CLI is available:
+
+```bash
+babysitter --version
+```
+
+Verify the active process-library binding:
+
+```bash
+babysitter process-library:active --json
+```
+
+## Troubleshooting
+
+### SDK CLI not found after session start
+
+The SessionStart hook installs the SDK automatically. If permissions prevent
+a global install, check the session-start log:
+
+```bash
+cat ~/.a5c/logs/babysitter-session-start-hook.log
+```
+
+If the CLI is still missing, install it manually:
+
+```bash
+npm install -g @a5c-ai/babysitter-sdk
+```
+
+### Hook logs location
+
+| Log file | Contents |
+|----------|----------|
+| `~/.a5c/logs/babysitter-session-start-hook.log` | SessionStart hook output |
+| `~/.a5c/logs/babysitter-session-start-hook-stderr.log` | SessionStart SDK stderr |
+| `~/.a5c/logs/babysitter-after-agent-hook.log` | AfterAgent hook output |
+| `~/.a5c/logs/babysitter-after-agent-hook-stderr.log` | AfterAgent SDK stderr |
+
+## License
+
+MIT

package/bin/cli.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+let shared;
+try { shared = require('./install-shared'); } catch {}
+
+function printUsage() {
+  console.error([
+    'Usage:',
+    '  babysitter-antigravity-cli install [--global]',
+    '  babysitter-antigravity-cli install --workspace [path]',
+    '  babysitter-antigravity-cli uninstall',
+  ].join('\n'));
+}
+
+function parseInstallArgs(argv) {
+  let scope = 'global';
+  let workspace = null;
+  const passthrough = [];
+
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === '--global') {
+      scope = 'global';
+      continue;
+    }
+    if (arg === '--workspace') {
+      scope = 'workspace';
+      const next = argv[i + 1];
+      if (next && !next.startsWith('-')) {
+        workspace = path.resolve(next);
+        i += 1;
+      } else {
+        workspace = process.cwd();
+      }
+      continue;
+    }
+    passthrough.push(arg);
+  }
+
+  return { scope, workspace, passthrough };
+}
+
+function runNodeScript(scriptPath, args, extraEnv = {}) {
+  const result = spawnSync(process.execPath, [scriptPath, ...args], {
+    cwd: process.cwd(),
+    stdio: 'inherit',
+    env: { ...process.env, ...extraEnv },
+  });
+  process.exitCode = result.status ?? 1;
+}
+
+function main() {
+  const [command, ...rest] = process.argv.slice(2);
+  if (!command || command === '--help' || command === '-h' || command === 'help') {
+    printUsage();
+    process.exitCode = command ? 0 : 1;
+    return;
+  }
+
+  if (command === 'install') {
+    if (shared && typeof shared.harnessCliRoute === 'function' && shared.harnessCliRoute(rest, PACKAGE_ROOT, runNodeScript)) {
+      return;
+    }
+    const parsed = parseInstallArgs(rest);
+    if (parsed.scope === 'workspace') {
+      const args = [];
+      if (parsed.workspace) {
+        args.push('--workspace', parsed.workspace);
+      }
+      args.push(...parsed.passthrough);
+      runNodeScript(
+        path.join(PACKAGE_ROOT, 'scripts', 'team-install.js'),
+        args,
+        { PLUGIN_PACKAGE_ROOT: PACKAGE_ROOT },
+      );
+      return;
+    }
+    runNodeScript(path.join(PACKAGE_ROOT, 'bin', 'install.js'), parsed.passthrough);
+    return;
+  }
+
+  if (command === 'uninstall') {
+    runNodeScript(path.join(PACKAGE_ROOT, 'bin', 'uninstall.js'), rest);
+    return;
+  }
+
+  printUsage();
+  process.exitCode = 1;
+}
+
+main();

package/bin/install-shared.js

@@ -0,0 +1,219 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const PLUGIN_NAME = "babysitter";
+const PLUGIN_CATEGORY = 'Coding';
+
+function getUserHome() {
+  return os.homedir();
+}
+
+function getHarnessHome() {
+  return path.join(os.homedir(), '.a5c');
+}
+
+function getHomePluginRoot(scope) {
+  if (scope === 'workspace') return path.join(process.cwd(), '.a5c', 'plugins', PLUGIN_NAME);
+  return path.join(path.join(getHarnessHome(), 'plugins'), PLUGIN_NAME);
+}
+
+function getHomeMarketplacePath() {
+  return path.join(getHarnessHome(), 'plugins', 'marketplace.json');
+}
+
+function writeFileIfChanged(filePath, contents) {
+  try {
+    const existing = fs.readFileSync(filePath, 'utf8');
+    if (existing === contents) return false;
+  } catch (e) { process.stderr.write('[extensions-adapter] file read failed for ' + filePath + ', overwriting: ' + (e instanceof Error ? e.message : String(e)) + '\n'); }
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, contents);
+  return true;
+}
+
+function copyRecursive(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  for (const entry of fs.readdirSync(src, { withFileTypes: true })) {
+    if (entry.name === 'node_modules' || entry.name === '.git') continue;
+    const s = path.join(src, entry.name);
+    const d = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyRecursive(s, d);
+    } else {
+      fs.copyFileSync(s, d);
+    }
+  }
+}
+
+function copyPluginBundle(packageRoot, pluginRoot) {
+  const bundleEntries = fs.readdirSync(packageRoot).filter(
+    e => !['node_modules', '.git', 'test', 'dist'].includes(e)
+  );
+  fs.mkdirSync(pluginRoot, { recursive: true });
+  for (const entry of bundleEntries) {
+    const src = path.join(packageRoot, entry);
+    const dest = path.join(pluginRoot, entry);
+    const stat = fs.statSync(src);
+    if (stat.isDirectory()) {
+      copyRecursive(src, dest);
+    } else {
+      fs.copyFileSync(src, dest);
+    }
+  }
+}
+
+function readJson(filePath) {
+  try {
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n');
+}
+
+function ensureExecutable(filePath) {
+  try {
+    fs.chmodSync(filePath, 0o755);
+  } catch (e) { process.stderr.write('[extensions-adapter] chmod failed for ' + filePath + ': ' + (e instanceof Error ? e.message : String(e)) + '\n'); }
+}
+
+function normalizeMarketplaceSourcePath(source, marketplacePath) {
+  if (typeof source === 'string') {
+    return path.relative(path.dirname(marketplacePath), source).replace(/\\/g, '/');
+  }
+  return source;
+}
+
+function ensureMarketplaceEntry(marketplacePath, pluginRoot) {
+  let marketplace = readJson(marketplacePath) || {
+    name: "a5c.ai",
+    plugins: [],
+  };
+  if (!Array.isArray(marketplace.plugins)) marketplace.plugins = [];
+  const idx = marketplace.plugins.findIndex(p => p.name === PLUGIN_NAME);
+  const relSource = './' + normalizeMarketplaceSourcePath(pluginRoot, marketplacePath);
+  const entry = {
+    name: PLUGIN_NAME,
+    source: relSource,
+    description: "Orchestrate complex, multi-step workflows with event-sourced state management, hook-based extensibility, and human-in-the-loop approval",
+    version: "5.1.1-staging.583e3d9a6ed7",
+    author: { name: "a5c.ai" },
+  };
+  if (idx >= 0) marketplace.plugins[idx] = entry;
+  else marketplace.plugins.push(entry);
+  writeJson(marketplacePath, marketplace);
+}
+
+function removeMarketplaceEntry(marketplacePath) {
+  const marketplace = readJson(marketplacePath);
+  if (!marketplace || !Array.isArray(marketplace.plugins)) return;
+  marketplace.plugins = marketplace.plugins.filter(p => p.name !== PLUGIN_NAME);
+  writeJson(marketplacePath, marketplace);
+}
+
+function warnWindowsHooks() {
+  if (process.platform === 'win32') {
+    console.warn('[' + PLUGIN_NAME + '] Windows detected — shell hooks (.sh) require Git Bash or WSL.');
+  }
+}
+
+function runPostInstall(pluginRoot) {
+  const postInstall = path.join(pluginRoot, 'scripts', 'post-install.js');
+  if (fs.existsSync(postInstall)) {
+    spawnSync(process.execPath, [postInstall], {
+      cwd: pluginRoot, stdio: 'inherit',
+      env: { ...process.env, PLUGIN_ROOT: pluginRoot, CLAUDE_PLUGIN_ROOT: pluginRoot },
+    });
+  }
+}
+
+function getGlobalStateDir() {
+  return process.env.BABYSITTER_GLOBAL_STATE_DIR || path.join(getUserHome(), '.a5c');
+}
+
+function resolveCliCommand(packageRoot) {
+  try {
+    const result = spawnSync('babysitter', ['--version'], { stdio: 'pipe', timeout: 10000 });
+    if (result.status === 0) return 'babysitter';
+  } catch {}
+  const versionsPath = path.join(packageRoot, 'versions.json');
+  const versions = readJson(versionsPath) || {};
+  const ver = versions.sdkVersion || 'latest';
+  return `npm exec --yes --package @a5c-ai/babysitter-sdk@${ver} -- babysitter`;
+}
+
+function runCli(packageRoot, cliArgs, options = {}) {
+  const cmd = resolveCliCommand(packageRoot);
+  const parts = cmd.split(' ');
+  const result = spawnSync(parts[0], [...parts.slice(1), ...cliArgs], {
+    stdio: options.stdio || 'inherit',
+    timeout: options.timeout || 120000,
+    cwd: options.cwd || process.cwd(),
+    env: { ...process.env, ...options.env },
+  });
+  return result;
+}
+
+function ensureGlobalProcessLibrary(packageRoot) {
+  const stateDir = getGlobalStateDir();
+  const activeFile = path.join(stateDir, 'active', 'process-library.json');
+  let active = readJson(activeFile);
+  if (active && active.binding && active.binding.dir) {
+    return active;
+  }
+  const defaultSpec = readJson(path.join(stateDir, 'process-library-defaults.json'));
+  const cloneDir = defaultSpec && defaultSpec.cloneDir
+    ? defaultSpec.cloneDir
+    : path.join(stateDir, 'process-library', PLUGIN_NAME + '-repo');
+  runCli(packageRoot, [
+    'process-library:clone',
+    '--dir', cloneDir,
+    '--state-dir', stateDir,
+    '--json',
+  ], { stdio: 'pipe' });
+  runCli(packageRoot, [
+    'process-library:use',
+    '--dir', cloneDir,
+    '--state-dir', stateDir,
+    '--json',
+  ], { stdio: 'pipe' });
+  active = readJson(activeFile);
+  return {
+    binding: active && active.binding ? active.binding : { dir: cloneDir },
+    defaultSpec: defaultSpec || { cloneDir },
+    stateFile: activeFile,
+  };
+}
+
+
+module.exports = {
+  PLUGIN_NAME,
+  PLUGIN_CATEGORY,
+  getUserHome,
+  getHarnessHome,
+  getHomePluginRoot,
+  getHomeMarketplacePath,
+  writeFileIfChanged,
+  copyRecursive,
+  copyPluginBundle,
+  readJson,
+  writeJson,
+  ensureExecutable,
+  normalizeMarketplaceSourcePath,
+  ensureMarketplaceEntry,
+  removeMarketplaceEntry,
+  warnWindowsHooks,
+  runPostInstall,
+  getGlobalStateDir,
+  resolveCliCommand,
+  runCli,
+  ensureGlobalProcessLibrary,
+};

package/bin/install.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const shared = require('./install-shared');
+
+const PACKAGE_ROOT = path.resolve(__dirname, '..');
+
+function main() {
+  const pluginRoot = shared.getHomePluginRoot();
+  const marketplacePath = shared.getHomeMarketplacePath();
+
+  console.log(`[${shared.PLUGIN_NAME}] Installing plugin to ${pluginRoot}`);
+
+  try {
+    shared.copyPluginBundle(PACKAGE_ROOT, pluginRoot);
+    shared.ensureMarketplaceEntry(marketplacePath, pluginRoot);
+    if (typeof shared.harnessInstall === 'function') {
+      shared.harnessInstall(PACKAGE_ROOT, pluginRoot);
+    }
+    shared.runPostInstall && shared.runPostInstall(pluginRoot);
+    console.log(`[${shared.PLUGIN_NAME}] Installation complete!`);
+    console.log(`[${shared.PLUGIN_NAME}] Restart your IDE/CLI to pick up the plugin.`);
+  } catch (err) {
+    console.error(`[${shared.PLUGIN_NAME}] Failed to install: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/bin/uninstall.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+'use strict';
+
+const fs = require('fs');
+const shared = require('./install-shared');
+
+function main() {
+  const pluginRoot = shared.getHomePluginRoot();
+
+  if (!fs.existsSync(pluginRoot)) {
+    console.log(`[${shared.PLUGIN_NAME}] Plugin not installed at ${pluginRoot}`);
+    return;
+  }
+
+  try {
+    fs.rmSync(pluginRoot, { recursive: true, force: true });
+    console.log(`[${shared.PLUGIN_NAME}] Uninstalled from ${pluginRoot}`);
+  } catch (err) {
+    console.error(`[${shared.PLUGIN_NAME}] Failed to uninstall: ${err.message}`);
+    process.exitCode = 1;
+  }
+}
+
+main();

package/commands/assimilate.md

@@ -0,0 +1,37 @@
+---
+description: Assimilate an external methodology, harness, or specification into babysitter process definitions with skills and agents.
+argument-hint: Target to assimilate (e.g. repo URL, harness name, or spec path)
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Grep, Glob, WebFetch, WebSearch, Search, AskUserQuestion, TodoWrite, TodoRead, Skill, BashOutput, KillShell, MultiEdit, LS
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md).
+
+Use the assimilation domain processes from the active process library to convert external sources into well-defined babysitter process definitions with accompanying skills/ and agents/ directories.
+
+If the workspace does not already have an active process-library binding, initialize it first through the shared global SDK binding:
+
+```bash
+babysitter process-library:active --json
+```
+
+Run the process after formalizing it.
+
+Available assimilation workflows:
+- **methodology-assimilation** (`specializations/meta/assimilation/workflows/methodology-assimilation`) - Learns an external methodology from its repo and converts procedural instructions, commands, and manual flows into babysitter processes with refactored skills and agents. Supports output as methodology or specialization.
+- **harness integration** (`specializations/meta/assimilation/harness/*`) - Integrates babysitter SDK with a specific AI coding harness (generic, codex, opencode, gemini-cli, openclaw, antigravity).
+
+During the interview phase, determine which assimilation workflow to use based on the user's target:
+- If the target is a **repo URL or methodology name** then use the methodology-assimilation workflow.
+- If the target is a **harness name** (e.g. codex, opencode, antigravity) then use the matching harness process.
+- If the target is a **specification or other source** then adapt the methodology-assimilation workflow for the spec format.
+- If unclear, ask the user to clarify the assimilation target and type.
+
+## After Assimilation: Contribute Back
+
+After successfully assimilating a methodology or harness integration, prompt the user to share it with the community. The assimilated process definitions, skills, and agents could benefit other babysitter users:
+
+- **Completed a methodology assimilation**: `/babysitter:contrib library contribution: assimilated [methodology-name] into babysitter process definitions`
+- **Completed a harness integration**: `/babysitter:contrib library contribution: [harness-name] harness integration`
+- **Hit issues during assimilation** (e.g. unsupported patterns, missing SDK features): `/babysitter:contrib bug report: assimilation of [target] failed because [description]` or `/babysitter:contrib feature request: [what the SDK needs to support]`
+
+Even just reporting that an assimilation didn't work well helps improve babysitter for everyone.

package/commands/blueprints.md

@@ -0,0 +1,64 @@
+---
+description: manage Babysitter blueprints. Use this command to list installed blueprints, browse marketplaces, install, update, uninstall, configure, or create a new blueprint.
+argument-hint: Blueprint action and options.
+---
+
+This command installs and manages Babysitter blueprints. A blueprint is a version-managed package of contextual instructions or deterministic Babysitter processes, not a conventional software plugin.
+
+If the command is run without arguments, list installed blueprints with their name, version, marketplace, installation date, and last update date. Also list configured marketplaces and show how to add the default marketplace when none exist.
+
+Blueprints can be installed at two scopes:
+
+- **global** (`--global`): stored under `~/.a5c/`, available for all projects
+- **project** (`--project`): stored under `<projectDir>/.a5c/`, project-specific
+
+## Marketplace Management
+
+Marketplaces are git repositories containing a `marketplace.json` manifest and blueprint package directories. The SDK clones new marketplaces to `.a5c/blueprints/marketplaces/` for the selected scope and reads legacy `.a5c/marketplaces/` clones for compatibility.
+
+### Add a marketplace
+
+```bash
+babysitter blueprints:add-marketplace --marketplace-url <url> [--marketplace-path <relative-path>] [--marketplace-branch <ref>] [--force] --global|--project [--json]
+```
+
+### Update a marketplace
+
+```bash
+babysitter blueprints:update-marketplace --marketplace-name <name> [--marketplace-branch <ref>] --global|--project [--json]
+```
+
+### List blueprints in a marketplace
+
+```bash
+babysitter blueprints:list-plugins --marketplace-name <name> --global|--project [--json]
+```
+
+## Blueprint Lifecycle
+
+For `blueprint:install`, `blueprint:update`, `blueprint:configure`, and `blueprint:list-plugins`, the `--marketplace-name` flag is auto-detected when only one marketplace is cloned for the selected scope.
+
+```bash
+babysitter blueprints:install --plugin-name <name> [--marketplace-name <mp>] --global|--project [--json]
+babysitter blueprints:update --plugin-name <name> --marketplace-name <mp> --global|--project [--json]
+babysitter blueprints:configure --plugin-name <name> --marketplace-name <mp> --global|--project [--json]
+babysitter blueprints:uninstall --plugin-name <name> --marketplace-name <mp> --global|--project [--json]
+```
+
+The `--plugin-name` flag is preserved for CLI compatibility with existing marketplace manifests. User-facing docs should call the installable a blueprint.
+
+## Registry Management
+
+```bash
+babysitter blueprints:list-installed --global|--project [--json]
+babysitter blueprints:update-registry --plugin-name <name> --plugin-version <ver> --marketplace-name <mp> --global|--project [--json]
+babysitter blueprints:remove-from-registry --plugin-name <name> --global|--project [--json]
+```
+
+## Deprecated Aliases
+
+The old `plugin:*` commands remain available as deprecated aliases for one release. Prefer `blueprint:*` in new docs, skills, and process instructions.
+
+## Agent Plugins Are Separate
+
+Do not rename or reinterpret agent harness plugins while handling blueprints. `CLAUDE_PLUGIN_ROOT`, `PI_PLUGIN_ROOT`, `.claude/plugins/`, hooks-adapter, extensions-adapter, and agent plugin manifests stay plugin-specific.

package/commands/call.md

@@ -0,0 +1,11 @@
+---
+description: Orchestrate a babysitter run. use this command to start babysitting a complex workflow.
+argument-hint: Specific instructions for the run.
+allowed-tools: Read, Grep, Write, Task, Bash, Edit, Grep, Glob, WebFetch, WebSearch, Search, AskUserQuestion, TodoWrite, TodoRead, Skill, BashOutput, KillShell, MultiEdit, LS
+---
+
+Invoke the babysitter:babysit skill (using the Skill tool) and follow its instructions (SKILL.md). Then continue executing the returned instructions in this same turn. Do not stop after the Skill tool returns; carry the requested run through to completion proof.
+
+User arguments for this command:
+
+$ARGUMENTS