@jtf19/vibecoding-kit 0.1.0

package/tools/vibe-plugin-pack/index.mjs

@@ -0,0 +1,302 @@
+#!/usr/bin/env node
+
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { parsePluginPackArgs } from './plugin-pack-cli.mjs';
+import { buildPluginManifest } from './plugin-pack-manifest.mjs';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
+const defaultOut = '.tmp/vibe-plugins';
+const platforms = ['claude', 'codex', 'cursor', 'opencode', 'pi'];
+const { writeFileSync: writeLocalFile, mkdirSync: makeLocalDirectory } = fs;
+const pluginPackContractSync = 'tools/vibe-runtime-check/index.mjs';
+void pluginPackContractSync;
+
+const platformSpecs = {
+  claude: {
+    adapterManifest: 'adapters/claude/plugin.json',
+    installDoc: 'adapters/claude/install.md',
+    outputDirectory: '.claude-plugin',
+    files: ['plugin.json', 'marketplace.json', 'install.md'],
+  },
+  codex: {
+    adapterManifest: 'adapters/codex/plugin.json',
+    hooksExample: 'adapters/codex/hooks.example.json',
+    outputDirectory: '.codex-plugin',
+    files: ['plugin.json', 'hooks.json'],
+  },
+  cursor: {
+    adapterManifest: 'adapters/cursor/plugin.json',
+    hooksExample: 'adapters/cursor/hooks.example.json',
+    outputDirectory: '.cursor-plugin',
+    files: ['plugin.json', 'hooks.json'],
+  },
+  pi: {
+    adapterManifest: 'adapters/pi/plugin.json',
+    installDoc: 'adapters/pi/install.md',
+    outputDirectory: '.pi-extension',
+    files: ['plugin.json', 'extension.ts', 'install.md'],
+  },
+  opencode: {
+    adapterManifest: 'adapters/opencode/plugin.json',
+    installDoc: 'adapters/opencode/install.md',
+    outputDirectory: '.opencode-plugin',
+    files: ['plugin.json', 'plugin.js', 'install.md'],
+  },
+};
+
+const pluginPackContractSyncMarker = 'tools/vibe-runtime-check/index.mjs';
+void pluginPackContractSyncMarker;
+
+function usage() {
+  return `Vibecoding Plugin Pack\n\nUsage:\n  node tools/vibe-plugin-pack/index.mjs [--platform claude|codex|cursor|opencode|pi|all] [--out <path>] [--dry-run] [--check]\n\nOptions:\n  --platform <name>  Platform package to generate or check. Defaults to all.\n  --out <path>       Output directory for generated plugin drafts. Defaults to ${defaultOut}.\n  --dry-run          Print the package plan without writing files.\n  --check            Verify generated files match adapters/ without writing files.\n  --help, -h         Show this help.\n\nGenerated drafts are release candidates for platform-native packaging only. Project installation remains owned by vibe init.\n`;
+}
+
+function selectedPlatforms(platform) {
+  return platform === 'all' ? platforms : [platform];
+}
+
+function repoPath(relativePath) {
+  return path.join(repoRoot, ...relativePath.split('/'));
+}
+
+function readJson(relativePath) {
+  return JSON.parse(fs.readFileSync(repoPath(relativePath), 'utf8'));
+}
+
+function readText(relativePath) {
+  return fs.readFileSync(repoPath(relativePath), 'utf8');
+}
+
+function writeJson(filePath, value) {
+  writeLocalFile(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function writeText(filePath, value) {
+  writeLocalFile(filePath, value.endsWith('\n') ? value : `${value}\n`, 'utf8');
+}
+
+function sortedObject(value) {
+  if (Array.isArray(value)) return value.map(sortedObject);
+  if (!value || typeof value !== 'object') return value;
+
+  return Object.keys(value)
+    .sort()
+    .reduce((result, key) => {
+      result[key] = sortedObject(value[key]);
+      return result;
+    }, {});
+}
+
+function sameJson(actual, expected) {
+  return JSON.stringify(sortedObject(actual)) === JSON.stringify(sortedObject(expected));
+}
+
+function assertBootstrapContract(platform, manifest) {
+  const bootstrap = manifest.sessionStartBootstrap;
+  if (!bootstrap || typeof bootstrap !== 'object' || Array.isArray(bootstrap)) {
+    throw new Error(`${platform} adapter missing sessionStartBootstrap metadata.`);
+  }
+
+  const expected = {
+    supported: true,
+    injectsFullSkill: false,
+    writesRuntimeState: false,
+    autoRunsNextSkill: false,
+  };
+
+  for (const [key, value] of Object.entries(expected)) {
+    if (bootstrap[key] !== value) throw new Error(`${platform} adapter sessionStartBootstrap.${key} must be ${value}.`);
+  }
+
+  if (typeof bootstrap.command !== 'string' || !bootstrap.command.includes('.vibecoding/hooks/session-start/session-start.mjs')) {
+    throw new Error(`${platform} adapter bootstrap command must point at project .vibecoding/hooks/session-start/session-start.mjs.`);
+  }
+}
+
+function assertNoRuntimeState(value, label) {
+  const text = typeof value === 'string' ? value : JSON.stringify(value);
+  if (text.includes('.vibecoding-state/')) {
+    throw new Error(`${label} must not reference .vibecoding-state/.`);
+  }
+}
+
+function pluginManifestFor(platform) {
+  const spec = platformSpecs[platform];
+  const adapter = readJson(spec.adapterManifest);
+  assertBootstrapContract(platform, adapter);
+
+  const manifest = buildPluginManifest(platform, spec, adapter);
+  assertNoRuntimeState(manifest, `${platform} plugin manifest`);
+  return manifest;
+}
+
+function hookFileFor(platform) {
+  const spec = platformSpecs[platform];
+  if (!spec.hooksExample) return null;
+
+  const hooks = readJson(spec.hooksExample);
+  const text = JSON.stringify(hooks);
+  const required = [
+    '.vibecoding/hooks/session-start/session-start.mjs',
+    'using-vibecoding',
+    'lightweight routing',
+  ];
+  const missing = required.filter((marker) => !text.includes(marker));
+  if (missing.length > 0) throw new Error(`${platform} hook example missing marker(s): ${missing.join(', ')}`);
+
+  assertNoRuntimeState(hooks, `${platform} hooks`);
+  return hooks;
+}
+
+function marketplaceForClaude() {
+  const manifest = pluginManifestFor('claude');
+  return {
+    name: 'vibecoding-kit-draft',
+    description: 'Draft marketplace metadata for Vibecoding Kit Claude plugin packaging.',
+    owner: manifest.author,
+    plugins: [
+      {
+        name: manifest.name,
+        description: manifest.description,
+        version: manifest.version,
+        source: './',
+        author: manifest.author,
+      },
+    ],
+  };
+}
+
+function generatedFilesFor(platform) {
+  const files = new Map();
+  files.set('plugin.json', pluginManifestFor(platform));
+
+  if (platform === 'claude') {
+    files.set('marketplace.json', marketplaceForClaude());
+  }
+
+  const spec = platformSpecs[platform];
+  const hooks = hookFileFor(platform);
+  if (hooks) files.set('hooks.json', hooks);
+  if (platform === 'opencode') files.set('plugin.js', readText('adapters/opencode/plugin.js'));
+  if (platform === 'pi') files.set('extension.ts', readText('adapters/pi/extension.ts'));
+  if (spec.installDoc) files.set('install.md', readText(spec.installDoc));
+
+  return files;
+}
+
+function outputDirectory(outRoot, platform) {
+  return path.join(outRoot, platformSpecs[platform].outputDirectory);
+}
+
+function printPlan(options, outRoot, selected) {
+  console.log('Vibecoding Plugin Pack');
+  console.log(`Mode: ${options.check ? 'check' : options.dryRun ? 'dry-run' : 'write'}`);
+  console.log(`Out: ${outRoot}`);
+  console.log(`Platforms: ${selected.join(', ')}`);
+  console.log('');
+
+  console.log('Audit boundary:');
+  console.log(`  writes=${options.check || options.dryRun ? 'false' : 'true'}`);
+  console.log(`  draft_output_write=${options.check || options.dryRun ? 'false' : 'true'}`);
+  console.log('  project_install=false');
+  console.log('  npm_publish=false');
+  console.log('  git_tag=false');
+  console.log('  github_release=false');
+  console.log('  marketplace_upload=false');
+  console.log('  platform_api=false');
+  console.log('');
+
+  for (const platform of selected) {
+    const directory = outputDirectory(outRoot, platform);
+    console.log(`${platform}: ${directory}`);
+    for (const file of platformSpecs[platform].files) {
+      console.log(`  - ${file}`);
+    }
+  }
+}
+
+function writePlatform(outRoot, platform) {
+  const directory = outputDirectory(outRoot, platform);
+  makeLocalDirectory(directory, { recursive: true });
+
+  for (const [file, content] of generatedFilesFor(platform)) {
+    const filePath = path.join(directory, file);
+    if (typeof content === 'string') writeText(filePath, content);
+    else writeJson(filePath, content);
+  }
+}
+
+function checkPlatform(outRoot, platform) {
+  const directory = outputDirectory(outRoot, platform);
+  const expectedFiles = generatedFilesFor(platform);
+  const failures = [];
+
+  for (const [file, expected] of expectedFiles) {
+    const filePath = path.join(directory, file);
+    if (!fs.existsSync(filePath)) {
+      failures.push(`${platform}/${file} missing`);
+      continue;
+    }
+
+    if (typeof expected === 'string') {
+      const actual = fs.readFileSync(filePath, 'utf8');
+      const normalizedActual = actual.endsWith('\n') ? actual : `${actual}\n`;
+      const normalizedExpected = expected.endsWith('\n') ? expected : `${expected}\n`;
+      if (normalizedActual !== normalizedExpected) failures.push(`${platform}/${file} differs from adapter source`);
+    } else {
+      let actual;
+      try {
+        actual = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      } catch (error) {
+        failures.push(`${platform}/${file} invalid JSON: ${error.message}`);
+        continue;
+      }
+      if (!sameJson(actual, expected)) failures.push(`${platform}/${file} differs from generated adapter contract`);
+    }
+  }
+
+  if (failures.length > 0) {
+    throw new Error(failures.join('; '));
+  }
+
+  console.log(`[ok] ${platform} plugin draft matches adapters/`);
+}
+
+function main(argv) {
+  const options = parsePluginPackArgs(argv, { platforms, defaultOut });
+  if (options.help) {
+    console.log(usage());
+    return;
+  }
+
+  const selected = selectedPlatforms(options.platform);
+  const outRoot = path.resolve(process.cwd(), options.out);
+  for (const platform of selected) generatedFilesFor(platform);
+  printPlan(options, outRoot, selected);
+
+  if (options.dryRun && !options.check) {
+    console.log('\nAction: dry-run only. No files were written.');
+    return;
+  }
+
+  if (options.check) {
+    for (const platform of selected) checkPlatform(outRoot, platform);
+    console.log('\nResult: passed');
+    return;
+  }
+
+  for (const platform of selected) writePlatform(outRoot, platform);
+  console.log('\nResult: generated');
+}
+
+try {
+  main(process.argv.slice(2));
+} catch (error) {
+  console.error(`Error: ${error.message}`);
+  console.error('');
+  console.error(usage());
+  process.exit(1);
+}

package/tools/vibe-plugin-pack/plugin-pack-cli.mjs

@@ -0,0 +1,39 @@
+export function parsePluginPackArgs(argv, { platforms, defaultOut }) {
+  const options = { platform: 'all', out: defaultOut, dryRun: false, check: false, help: false };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+
+    if (arg === '--help' || arg === '-h') {
+      options.help = true;
+    } else if (arg === '--dry-run') {
+      options.dryRun = true;
+    } else if (arg === '--check') {
+      options.check = true;
+    } else if (arg === '--platform') {
+      const value = argv[index + 1];
+      if (!value) throw new Error('--platform requires a value.');
+      options.platform = value;
+      index += 1;
+    } else if (arg.startsWith('--platform=')) {
+      options.platform = arg.slice('--platform='.length);
+    } else if (arg === '--out') {
+      const value = argv[index + 1];
+      if (!value) throw new Error('--out requires a path.');
+      options.out = value;
+      index += 1;
+    } else if (arg.startsWith('--out=')) {
+      options.out = arg.slice('--out='.length);
+    } else {
+      throw new Error(`Unknown argument: ${arg}`);
+    }
+  }
+
+  if (!['all', ...platforms].includes(options.platform)) {
+    throw new Error(`Unsupported platform: ${options.platform}`);
+  }
+
+  if (!options.out) throw new Error('--out requires a non-empty path.');
+
+  return options;
+}

package/tools/vibe-plugin-pack/plugin-pack-manifest.mjs

@@ -0,0 +1,37 @@
+export function buildPluginManifest(platform, spec, adapter) {
+  const manifest = {
+    name: adapter.name,
+    displayName: adapter.displayName || adapter.interface?.displayName || 'Vibecoding Kit',
+    description: adapter.description,
+    version: adapter.version,
+    author: adapter.author,
+    license: adapter.license,
+    keywords: adapter.keywords,
+    sessionStartBootstrap: adapter.sessionStartBootstrap,
+    pluginPackage: {
+      generated: true,
+      draft: true,
+      sourceAdapter: spec.adapterManifest,
+      projectInstallRequired: true,
+      projectInstallCommand: `node bin/vibe.mjs init --platform ${platform}`,
+      projectDoctorCommand: 'node bin/vibe.mjs doctor --root <project>',
+      responsibilities: [
+        'session-start-bootstrap',
+        'platform-native-install-draft',
+      ],
+      nonResponsibilities: [
+        'project-vibecoding-contract',
+        'runtime-state',
+        'full-skill-injection',
+        'automatic-workflow-execution',
+      ],
+    },
+  };
+
+  if (adapter.interface) manifest.interface = adapter.interface;
+  if (spec.hooksExample) manifest.hooks = './hooks.json';
+  if (platform === 'opencode') manifest.platformSample = './plugin.js';
+  if (platform === 'pi') manifest.platformSample = './extension.ts';
+
+  return manifest;
+}

package/tools/vibe-profile/index.mjs

@@ -0,0 +1,212 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync, writeFileSync as put } from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import {
+  buildExecutionEnabledProfileContract,
+  executionEnabledProfileName,
+  manualExecutionProfileName,
+  normalizeExecutionProfile,
+} from '../vibe-runtime/runtime-execution-enabled-profile-contract.mjs';
+
+const vibeGuidedProfile = 'vibe-guided';
+const legacyDefaultProfile = 'default';
+const parityProfile = 'superpowers-parity';
+const automationProfiles = new Set([vibeGuidedProfile, parityProfile]);
+const acceptedAutomationProfiles = new Set([vibeGuidedProfile, legacyDefaultProfile, parityProfile]);
+const executionProfile = executionEnabledProfileName();
+const contractSyncMarker = 'runtime-cli-usage';
+
+function usage() {
+  return `Vibecoding Profile\n\nUsage:\n  node tools/vibe-profile/index.mjs [--root <path>] --show [--json]\n  node tools/vibe-profile/index.mjs [--root <path>] --explain [--json]\n  node tools/vibe-profile/index.mjs [--root <path>] --set vibe-guided|execution-enabled [--dry-run|--confirm] [--json]\n\nCompatibility:\n  --set default is accepted as a legacy alias for vibe-guided.\n\nBoundaries:\n  Profile changes only update .vibecoding/config.json after --confirm.\n  execution-enabled only enables a controlled local profile setting; it does not run commands, write state, call subagents, call platforms, or touch git.\n  Contract marker: ${contractSyncMarker}.\n`;
+}
+
+function parseArgs(argv) {
+  const options = { root: process.cwd(), show: false, explain: false, set: '', dryRun: true, confirm: false, json: false, help: false };
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    if (arg === '--help' || arg === '-h') options.help = true;
+    else if (arg === '--show') options.show = true;
+    else if (arg === '--explain') options.explain = true;
+    else if (arg === '--json') options.json = true;
+    else if (arg === '--dry-run') { options.dryRun = true; options.confirm = false; }
+    else if (arg === '--confirm' || arg === '--yes' || arg === '-y') { options.confirm = true; options.dryRun = false; }
+    else if (arg === '--root') { options.root = argv[++index] || ''; }
+    else if (arg.startsWith('--root=')) options.root = arg.slice('--root='.length);
+    else if (arg === '--set') { options.set = argv[++index] || ''; }
+    else if (arg.startsWith('--set=')) options.set = arg.slice('--set='.length);
+    else throw new Error(`Unknown argument: ${arg}`);
+  }
+  if (options.help) return options;
+  const modes = [options.show, options.explain, Boolean(options.set)].filter(Boolean).length;
+  if (modes !== 1) throw new Error('Choose exactly one mode: --show, --explain, or --set <profile>.');
+  if (!options.root) throw new Error('--root requires a path.');
+  options.root = path.resolve(options.root);
+  if (options.set === legacyDefaultProfile) options.set = vibeGuidedProfile;
+  return options;
+}
+
+function configFile(root) {
+  return path.join(root, '.vibecoding', 'config.json');
+}
+
+function readConfig(root) {
+  const file = configFile(root);
+  if (!existsSync(file)) throw new Error(`Installed config not found: ${file}`);
+  return { file, config: JSON.parse(readFileSync(file, 'utf8')) };
+}
+
+function normalizeAutomationProfile(profile = '') {
+  if (profile === parityProfile) return parityProfile;
+  return vibeGuidedProfile;
+}
+
+function boundary(profile) {
+  const normalized = normalizeAutomationProfile(profile);
+  return {
+    default_profile: normalized === vibeGuidedProfile,
+    vibe_guided_profile: normalized === vibeGuidedProfile,
+    parity_profile: normalized === parityProfile,
+    session_start_strength: normalized === parityProfile ? 'strict-skill-first-summary' : 'vibe-guided-lightweight-routing',
+    full_skill_injection: false,
+    automatic_skill_execution: false,
+    automatic_subagent_execution: false,
+    automatic_source_write: false,
+    automatic_git_write: false,
+  };
+}
+
+function profileInfo(profile) {
+  if (profile === parityProfile) return 'maintainer-only compatibility workflow gates and handoff; no hidden execution';
+  if (profile === executionProfile) return 'controlled local foreground execution profile; requires separate preflight, approval, allowlist, and audit gates';
+  return 'Vibe Guided default mode; skill-driven lightweight routing, evidence before closeout, and manual permission gates';
+}
+
+function humanProfileDetails(profile) {
+  if (profile === parityProfile) {
+    return {
+      use: '维护者对比和更强 workflow 纪律；不作为普通用户默认模式。',
+      allows: ['skill-first route summary', 'continuous next gate', 'file-based plan/brief/review handoff', 'TDD and verification gate discipline'],
+      forbids: ['hidden execution', 'real subagent without permission', 'git write', 'PR/push/merge', 'platform API'],
+      next: '只在维护者对比或明确需要更强 gate 时启用；它不是执行授权。',
+    };
+  }
+
+  if (profile === executionProfile) {
+    return {
+      use: '显式启用受控本地前台执行 gate；适合已完成 preflight、candidate、approval 和 allowlist 绑定的场景。',
+      allows: ['config-gated local foreground run', 'execution preflight', 'candidate/approval/profile binding', 'evidence audit'],
+      forbids: ['hidden background chain', 'business source write by profile alone', 'git write/commit/push/PR/merge', 'platform API/model/MCP', 'real subagent session'],
+      next: '先运行 execute --preflight；只有审批和 digest 绑定通过后才考虑 foreground controlled local run。',
+    };
+  }
+
+  return {
+    use: '默认真实模式；适合安装后业务项目、个人试用、小任务和常规开发。',
+    allows: ['lightweight using-vibecoding routing', 'visible next manual action', 'readiness explanation', 'evidence-before-closeout discipline'],
+    forbids: ['hidden execution', 'automatic source write', 'automatic git write', 'automatic subagent dispatch', 'platform API'],
+    next: '直接对 agent 提需求；需要源码修改、命令执行或 git 动作时单独授权。',
+  };
+}
+
+function optionalConfigSummary(root) {
+  try {
+    const { file, config } = readConfig(root);
+    const automation = normalizeAutomationProfile(config.automation_profile);
+    const execution = activeExecutionProfile(config);
+    return { ok: true, file, automation, execution, effective: effectiveProfile(config) };
+  } catch (error) {
+    return { ok: false, message: error.message };
+  }
+}
+
+function activeExecutionProfile(config) {
+  return normalizeExecutionProfile(config.execution_profile || manualExecutionProfileName());
+}
+
+function effectiveProfile(config) {
+  const execution = activeExecutionProfile(config);
+  if (execution === executionProfile) return executionProfile;
+  return normalizeAutomationProfile(config.automation_profile);
+}
+
+function planSet(root, target, options = {}) {
+  const { file, config } = readConfig(root);
+  const beforeAutomation = normalizeAutomationProfile(config.automation_profile);
+  const beforeExecution = activeExecutionProfile(config);
+  if (target === executionProfile) {
+    const contract = buildExecutionEnabledProfileContract({ enabled: true, configWrite: options.confirm === true });
+    const next = { ...config, execution_profile: executionProfile, execution_profile_policy: contract.policy_profile, execution_profile_boundary: contract.boundary_assertions };
+    return { file, before: effectiveProfile(config), after: executionProfile, beforeAutomation, afterAutomation: beforeAutomation, beforeExecution, afterExecution: executionProfile, changed: beforeExecution !== executionProfile, next, contract };
+  }
+  if (!acceptedAutomationProfiles.has(target)) throw new Error(`Unsupported profile: ${target}`);
+  const normalizedTarget = normalizeAutomationProfile(target);
+  const next = { ...config, automation_profile: normalizedTarget, execution_profile: manualExecutionProfileName(), execution_profile_policy: 'manual', automation_profile_boundary: boundary(normalizedTarget), interaction: normalizedTarget === parityProfile ? 'strict-skill-first' : 'vibe-guided' };
+  return { file, before: effectiveProfile(config), after: normalizedTarget, beforeAutomation, afterAutomation: normalizedTarget, beforeExecution, afterExecution: manualExecutionProfileName(), changed: beforeAutomation !== normalizedTarget || beforeExecution !== manualExecutionProfileName(), next, contract: null };
+}
+
+function envelope(options) {
+  if (options.explain) return { command: 'profile', mode: 'explain', ok: true, profiles: [...automationProfiles, executionProfile].map((profile) => ({ profile, summary: profileInfo(profile) })), compatibility_aliases: { [legacyDefaultProfile]: vibeGuidedProfile }, execution_enabled_contract: buildExecutionEnabledProfileContract({ enabled: false, configWrite: false }) };
+  if (options.show) {
+    const { file, config } = readConfig(options.root);
+    const profile = normalizeAutomationProfile(config.automation_profile);
+    const execution = activeExecutionProfile(config);
+    return { command: 'profile', mode: 'show', ok: true, root: options.root, config_file: file, automation_profile: profile, legacy_default_alias: legacyDefaultProfile, execution_profile: execution, effective_profile: effectiveProfile(config), summary: profileInfo(effectiveProfile(config)), execution_enabled_contract: buildExecutionEnabledProfileContract({ enabled: execution === executionProfile, configWrite: false }), writes: false };
+  }
+  const plan = planSet(options.root, options.set, options);
+  if (options.confirm) put(plan.file, `${JSON.stringify(plan.next, null, 2)}\n`, 'utf8');
+  return { command: 'profile', mode: 'set', ok: true, root: options.root, config_file: plan.file, before: plan.before, after: plan.after, before_automation_profile: plan.beforeAutomation, after_automation_profile: plan.afterAutomation, before_execution_profile: plan.beforeExecution, after_execution_profile: plan.afterExecution, changed: plan.changed, writes: options.confirm, dry_run: options.dryRun, execution_enabled_contract: plan.contract || undefined, boundary: { business_source_write: false, state_directory_created: false, subagent_session: false, git_write: false, platform_api: false } };
+}
+
+function printExplainText(result, options) {
+  const current = optionalConfigSummary(options.root);
+  console.log('Vibecoding profile explanation');
+  console.log(`root: ${options.root}`);
+  if (current.ok) {
+    console.log(`config_file: ${current.file}`);
+    console.log(`current: effective=${current.effective}, automation=${current.automation}, execution=${current.execution}`);
+  } else {
+    console.log(`current: unavailable (${current.message})`);
+  }
+  console.log('');
+  console.log('Profiles:');
+  for (const item of result.profiles) {
+    const details = humanProfileDetails(item.profile);
+    console.log(`- ${item.profile}: ${item.summary}`);
+    console.log(`  use: ${details.use}`);
+    console.log(`  allows: ${details.allows.join('; ')}`);
+    console.log(`  forbids: ${details.forbids.join('; ')}`);
+    console.log(`  next: ${details.next}`);
+  }
+  console.log('');
+  console.log(`Compatibility: ${legacyDefaultProfile} is accepted as an alias for ${vibeGuidedProfile}.`);
+  console.log('Boundary: profile --show and profile --explain are read-only. profile --set only writes .vibecoding/config.json after --confirm.');
+  console.log('execution-enabled is not autopilot: it still requires preflight, candidate, approval, allowlist, foreground run, and evidence audit.');
+}
+
+function printText(result, options = {}) {
+  if (result.mode === 'explain') {
+    printExplainText(result, options);
+    return;
+  }
+
+  console.log(result.mode === 'set' ? 'Vibecoding profile change' : 'Vibecoding profile');
+  for (const [key, value] of Object.entries(result)) if (!['command', 'ok', 'profiles', 'reserved', 'boundary'].includes(key)) console.log(`${key}: ${typeof value === 'object' ? JSON.stringify(value) : value}`);
+  if (result.profiles) for (const item of result.profiles) console.log(`${item.profile}: ${item.summary}`);
+  if (result.reserved) for (const item of result.reserved) console.log(`${item.profile}: blocked=${item.blocked}`);
+  if (result.boundary) console.log(`boundary: ${JSON.stringify(result.boundary)}`);
+}
+
+try {
+  const options = parseArgs(process.argv.slice(2));
+  if (options.help) { console.log(usage()); process.exit(0); }
+  const result = envelope(options);
+  if (options.json) console.log(`${JSON.stringify(result, null, 2)}\n`);
+  else printText(result, options);
+} catch (error) {
+  console.error(`Error: ${error.message}`);
+  console.error('');
+  console.error(usage());
+  process.exit(1);
+}