a2acalling 0.6.75 → 0.6.76

package/.claude/worktrees/agent-a5b87d75/scripts/install-skills.js

@@ -0,0 +1,234 @@
+/**
+ * A2A Skill Installer
+ *
+ * Copies Claude Code commands, CLAUDE.md context, SKILL.md reference, and
+ * Codex AGENTS.md into a target project directory. Idempotent: skips files
+ * that already exist with identical content.
+ *
+ * CLAUDE.md is the key file — Claude Code reads it automatically, giving the
+ * agent full context about the a2a CLI, native app, and onboarding flow
+ * immediately after npm install.
+ *
+ * SKILL.md is the deep reference for A2A — invite formatting templates,
+ * incoming call handling, disclosure manifest flow, and protocol details.
+ * We copy it to .claude/ so Claude Code can discover it naturally without
+ * having to grep through node_modules. The .claude/ directory is already
+ * used for slash commands, so this is a natural home for reference docs.
+ *
+ * Unlike CLAUDE.md (which is auto-loaded), the skill reference file is only
+ * read when the agent explicitly looks in .claude/ — so it serves as opt-in
+ * deep reference rather than always-loaded context (avoiding token bloat).
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const PACKAGE_ROOT = path.join(__dirname, '..');
+
+// Section delimiter used to bound the A2A block inside CLAUDE.md.
+// This allows safe replacement of ONLY the A2A content when updating,
+// preserving any user content before or after the A2A section.
+const A2A_SECTION_END_MARKER = '<!-- END A2A CALLING SECTION -->';
+
+const SKILL_FILES = [
+  // CLAUDE.md — gives Claude Code instant context about the a2a CLI
+  { src: 'CLAUDE-INSTALL.md', dest: 'CLAUDE.md', mergeKey: '# A2A Calling' },
+  // SKILL.md — deep reference for A2A (invite formatting, call handling, etc.)
+  // Copied to .claude/ so Claude Code discovers it naturally without grepping
+  // node_modules. This is opt-in context: only loaded when the agent looks.
+  { src: 'SKILL.md', dest: '.claude/a2a-skill-reference.md' },
+  // Claude Code slash commands — core (A2A-28)
+  { src: '.claude/commands/a2a-call.md', dest: '.claude/commands/a2a-call.md' },
+  { src: '.claude/commands/a2a-invite.md', dest: '.claude/commands/a2a-invite.md' },
+  { src: '.claude/commands/a2a-contacts.md', dest: '.claude/commands/a2a-contacts.md' },
+  { src: '.claude/commands/a2a-status.md', dest: '.claude/commands/a2a-status.md' },
+  { src: '.claude/commands/a2a-setup.md', dest: '.claude/commands/a2a-setup.md' },
+  // Claude Code slash commands — extended (A2A-43)
+  { src: '.claude/commands/a2a-update.md', dest: '.claude/commands/a2a-update.md' },
+  { src: '.claude/commands/a2a-uninstall.md', dest: '.claude/commands/a2a-uninstall.md' },
+  { src: '.claude/commands/a2a-app.md', dest: '.claude/commands/a2a-app.md' },
+  { src: '.claude/commands/a2a-conversations.md', dest: '.claude/commands/a2a-conversations.md' },
+  { src: '.claude/commands/a2a-gui.md', dest: '.claude/commands/a2a-gui.md' },
+  { src: '.claude/commands/a2a-skills.md', dest: '.claude/commands/a2a-skills.md' },
+  // Codex agent instructions
+  { src: '.codex/AGENTS.md', dest: '.codex/AGENTS.md' }
+];
+
+function installSkills(targetDir, options = {}) {
+  const result = { installed: [], skipped: [], errors: [] };
+
+  // Install manifest: .a2a-manifest.json
+  //
+  // After installing skill files, we write a manifest recording every file
+  // we touched, what action was taken, and the package version. This serves
+  // three purposes:
+  //   1. Transparency — user can see exactly what the package added
+  //   2. Clean uninstall — `a2a uninstall` reads the manifest to remove files
+  //   3. Upgrade tracking — on re-install, we can compare versions and
+  //      only update files that actually changed
+  //
+  // The manifest is written to the project root (same level as CLAUDE.md)
+  // so it's easy to find.
+  const manifestEntries = [];
+
+  for (const file of SKILL_FILES) {
+    const srcPath = path.join(PACKAGE_ROOT, file.src);
+    const destPath = path.join(targetDir, file.dest);
+
+    try {
+      if (!fs.existsSync(srcPath)) {
+        result.errors.push({ file: file.src, error: 'Source file not found' });
+        manifestEntries.push({ path: file.dest, action: 'error', detail: 'Source file not found' });
+        continue;
+      }
+
+      const srcContent = fs.readFileSync(srcPath, 'utf8');
+
+      if (fs.existsSync(destPath)) {
+        const existing = fs.readFileSync(destPath, 'utf8');
+
+        // ── CLAUDE.md merge strategy ──────────────────────────────────────
+        //
+        // The a2acalling package installs context into the project's CLAUDE.md so
+        // Claude Code has immediate awareness of the CLI, commands, and native app.
+        // But projects often have their own CLAUDE.md with project-specific instructions.
+        //
+        // To avoid clobbering user content, we use a section-delimited merge:
+        //   1. If CLAUDE.md doesn't exist: write CLAUDE-INSTALL.md as-is
+        //   2. If CLAUDE.md exists WITHOUT an A2A section: append at the end
+        //   3. If CLAUDE.md exists WITH an A2A section: replace only between
+        //      "# A2A Calling" and "<!-- END A2A CALLING SECTION -->"
+        //
+        // The end marker ensures user content after the A2A block is preserved.
+        // Legacy installs without the marker fall back to replace-to-EOF (old behavior)
+        // but the marker is added during the update so future updates are safe.
+        if (file.mergeKey) {
+          if (existing.includes(file.mergeKey)) {
+            // A2A section already present — find its boundaries
+            const sectionStart = existing.indexOf(file.mergeKey);
+
+            // Check if the end marker exists to determine section boundaries.
+            // If found, we only replace the bounded section, preserving any
+            // user content after the marker. If not found (legacy installs
+            // that predate the marker), we replace from the header to EOF
+            // and add the marker so future updates are safe.
+            const endMarkerIndex = existing.indexOf(A2A_SECTION_END_MARKER, sectionStart);
+
+            let existingSection;
+            let after = '';
+
+            if (endMarkerIndex !== -1) {
+              // End marker found — extract only the bounded A2A section
+              const sectionEnd = endMarkerIndex + A2A_SECTION_END_MARKER.length;
+              existingSection = existing.slice(sectionStart, sectionEnd);
+              // Preserve everything after the end marker (user's trailing content)
+              after = existing.slice(sectionEnd);
+            } else {
+              // Legacy install without end marker — take everything from header to EOF
+              // The new content includes the marker, so future updates will be safe
+              existingSection = existing.slice(sectionStart);
+            }
+
+            // Compare the existing A2A section with the new source content.
+            // Skip the update if they're identical (idempotent behavior).
+            if (!options.force && existingSection.trim() === srcContent.trim()) {
+              result.skipped.push(file.dest);
+              manifestEntries.push({ path: file.dest, action: 'skipped' });
+              continue;
+            }
+
+            // Replace only the A2A section, preserving content before and after
+            const before = existing.slice(0, sectionStart).trimEnd();
+            let merged = before ? before + '\n\n' + srcContent : srcContent;
+            // Re-attach any trailing content that was after the end marker
+            if (after) {
+              merged = merged.trimEnd() + '\n' + after;
+            }
+            fs.writeFileSync(destPath, merged);
+            result.installed.push(file.dest + ' (updated A2A section)');
+            manifestEntries.push({ path: file.dest, action: 'updated A2A section' });
+          } else {
+            // Existing CLAUDE.md without A2A section — append at the end
+            const merged = existing.trimEnd() + '\n\n' + srcContent;
+            fs.writeFileSync(destPath, merged);
+            result.installed.push(file.dest + ' (appended A2A section)');
+            manifestEntries.push({ path: file.dest, action: 'appended A2A section' });
+          }
+          continue;
+        }
+
+        // Standard mode: skip if identical (non-merge files)
+        if (!options.force && existing === srcContent) {
+          result.skipped.push(file.dest);
+          manifestEntries.push({ path: file.dest, action: 'skipped' });
+          continue;
+        }
+      } else {
+        // File doesn't exist yet — will be created below
+      }
+
+      // Create directory and write file
+      fs.mkdirSync(path.dirname(destPath), { recursive: true });
+      fs.writeFileSync(destPath, srcContent);
+      result.installed.push(file.dest);
+      manifestEntries.push({ path: file.dest, action: 'created' });
+    } catch (err) {
+      result.errors.push({ file: file.dest, error: err.message });
+      manifestEntries.push({ path: file.dest, action: 'error', detail: err.message });
+    }
+  }
+
+  // ── Write install manifest ────────────────────────────────────────────
+  //
+  // The manifest records every file we touched so the user (or `a2a uninstall`)
+  // knows exactly what was installed. We include the manifest itself in the list
+  // for completeness.
+  try {
+    const pkg = require('../package.json');
+    const manifestPath = path.join(targetDir, '.a2a-manifest.json');
+
+    // Add the manifest file itself to the entries list
+    manifestEntries.push({ path: '.a2a-manifest.json', action: 'created' });
+    // Add the install log file (written by postinstall.js)
+    manifestEntries.push({ path: '.a2a-install.log', action: 'created' });
+
+    const manifest = {
+      version: pkg.version,
+      installed_at: new Date().toISOString(),
+      files: manifestEntries,
+    };
+
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2) + '\n');
+  } catch (err) {
+    // Non-fatal — the manifest is a convenience for cleanup, not required
+    // for the skill files to work. Failure here (e.g., read-only dir)
+    // should not break the install.
+    result.errors.push({ file: '.a2a-manifest.json', error: err.message });
+  }
+
+  return result;
+}
+
+// CLI mode: node scripts/install-skills.js [targetDir] [--force]
+if (require.main === module) {
+  const args = process.argv.slice(2);
+  const force = args.includes('--force');
+  const targetDir = args.find(a => !a.startsWith('-')) || process.cwd();
+
+  const result = installSkills(targetDir, { force });
+
+  if (result.installed.length) {
+    console.log(`Installed ${result.installed.length} A2A skill file(s):`);
+    result.installed.forEach(f => console.log(`  + ${f}`));
+  }
+  if (result.skipped.length) {
+    console.log(`Skipped ${result.skipped.length} unchanged file(s)`);
+  }
+  if (result.errors.length) {
+    console.error(`Errors: ${result.errors.length}`);
+    result.errors.forEach(e => console.error(`  ! ${e.file}: ${e.error}`));
+    process.exit(1);
+  }
+}
+
+module.exports = { installSkills, SKILL_FILES };

package/.claude/worktrees/agent-a5b87d75/scripts/postinstall.js

@@ -0,0 +1,224 @@
+#!/usr/bin/env node
+
+// ============================================================================
+// npm postinstall hook — skill installation + silent server setup
+//
+// TWO MODES:
+//
+// 1. Global install (npm install -g a2acalling):
+//    - Silently runs quickstart to start the server and save config
+//    - Installs Claude Code skills into INIT_CWD (if available)
+//    - Prints getting-started summary
+//
+// 2. Local install (npm install a2acalling):
+//    - Installs Claude Code skills (.claude/commands/) into the project
+//    - Prints getting-started summary so the assisting agent has context
+//    - Does NOT start the server (local installs are usually for development)
+//
+// The verbose onboarding (disclosure prompt, workspace scan) happens when the
+// agent runs `a2a quickstart` — enforceOnboarding detects incomplete setup
+// and runs the full flow inline with direct stdio.
+// ============================================================================
+
+if (process.env.CI || process.env.CONTINUOUS_INTEGRATION) process.exit(0);
+if (process.env.DOCKER) process.exit(0);
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawnSync } = require('child_process');
+
+const isGlobal = process.env.npm_config_global === 'true';
+const initCwd = process.env.INIT_CWD || process.env.HOME || process.cwd();
+const cliPath = path.join(__dirname, '..', 'bin', 'cli.js');
+
+// ── Global install: silently run quickstart ──────────────────────────────
+if (isGlobal) {
+  const result = spawnSync(process.execPath, [cliPath, 'quickstart'], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+    cwd: initCwd,
+    env: {
+      ...process.env,
+      A2A_WORKSPACE: process.env.A2A_WORKSPACE || initCwd
+    }
+  });
+
+  if (result.error) {
+    // Don't fail the install — the agent will get onboarding when it runs `a2a`.
+  }
+}
+
+// ── Install skill files (both global and local) ─────────────────────────
+installSkillFiles();
+
+// ── Print getting-started summary ───────────────────────────────────────
+printGettingStarted();
+
+process.exit(0);
+
+// ── Helpers ─────────────────────────────────────────────────────────────
+
+function installSkillFiles() {
+  try {
+    const { installSkills } = require('./install-skills');
+    installSkills(initCwd);
+  } catch (e) {
+    // Silent — skills can be installed later with `a2a skills`
+  }
+}
+
+function printGettingStarted() {
+  const isMac = os.platform() === 'darwin';
+  const pkg = require('../package.json');
+
+  // ── Short critical stderr output ──────────────────────────────────────
+  //
+  // npm v7+ suppresses stdout/stderr from postinstall scripts unless
+  // --foreground-scripts is used. We print a minimal critical line to stderr
+  // (which npm sometimes still shows) AND write the full banner to a log file
+  // so that Claude Code or a human can always find the getting-started info.
+  const shortLines = [
+    `a2acalling v${pkg.version} installed.`,
+    'Next step: a2a quickstart',
+    'Skills installed: /a2a-setup, /a2a-call, /a2a-contacts, /a2a-invite, /a2a-status',
+  ];
+  // Print the short critical summary to stderr — this is the most likely
+  // output to survive npm's output suppression in v7+
+  console.error(shortLines.join('\n'));
+
+  // ── Full verbose banner ───────────────────────────────────────────────
+  const lines = [
+    '',
+    '╔══════════════════════════════════════════════════════════════╗',
+    '║                  A2A Calling — Installed                    ║',
+    '╚══════════════════════════════════════════════════════════════╝',
+    '',
+    `  Version: ${pkg.version}`,
+    '',
+    '  ── Getting Started ──────────────────────────────────────────',
+    '',
+    '  1. Run onboarding (REQUIRED first step):',
+    '',
+    '     a2a quickstart',
+    '',
+    '     This starts the A2A server, detects your hostname,',
+    '     and prompts you to configure what your agent shares.',
+    '',
+    '  2. Create an invite to share with other agents:',
+    '',
+    '     a2a create --name "YourAgent" --tier public --expires 7d',
+    '',
+    '  3. Add a contact and call them:',
+    '',
+    '     a2a add "a2a://host/fed_xxx" "AgentName"',
+    '     a2a call "AgentName" "Hello!"',
+    '',
+  ];
+
+  if (isMac) {
+    lines.push(
+      '  ── Native macOS App ─────────────────────────────────────────',
+      '',
+      '  A native Callbook app is available for macOS:',
+      '',
+      '     a2a app install',
+      '',
+      '  Installs to ~/Applications/A2A Callbook.app',
+      '  (Downloads pre-built binary from GitHub releases)',
+      '',
+    );
+  }
+
+  lines.push(
+    '  ── Full CLI Reference ───────────────────────────────────────',
+    '',
+    '  Onboarding & Setup:',
+    '    a2a quickstart              First-time setup (port, hostname, disclosure)',
+    '    a2a quickstart --force      Re-run onboarding from scratch',
+    '    a2a setup                   Auto setup (gateway-aware dashboard install)',
+    '    a2a status <url>            Check A2A agent status',
+    '    a2a version                 Show installed version',
+    '',
+    '  Tokens & Invites:',
+    '    a2a create [options]        Create an invite token',
+    '      --name, -n  NAME         Token label',
+    '      --tier, -p  TIER         public | friends | family',
+    '      --expires   DURATION     1h | 1d | 7d | 30d | never',
+    '    a2a list                    List active tokens',
+    '    a2a revoke <id>             Revoke a token',
+    '',
+    '  Contacts & Calling:',
+    '    a2a add <url> [name]        Add a contact from invite URL',
+    '    a2a contacts                List all contacts',
+    '    a2a call <contact> <msg>    Call a contact (multi-turn)',
+    '      --single                  One-shot call (no back-and-forth)',
+    '    a2a ping <url>              Check if agent is reachable',
+    '',
+    '  Dashboard & GUI:',
+    '    a2a gui                     Open dashboard in browser',
+    '    a2a gui --tab logs          Open specific tab',
+    '',
+    '  Server:',
+    '    a2a server --port 3001      Start server manually',
+    '    a2a update                  Update to latest version',
+    '    a2a uninstall               Stop server and remove config',
+    '',
+  );
+
+  if (isMac) {
+    lines.push(
+      '  Native App (macOS):',
+      '    a2a app status              Check native app installation',
+      '    a2a app install             Install/update from GitHub releases',
+      '    a2a app uninstall           Remove from ~/Applications',
+      '',
+    );
+  }
+
+  lines.push(
+    '  Skills:',
+    '    a2a skills                  Install Claude Code + Codex skills',
+    '    a2a skills --force          Overwrite existing skill files',
+    '',
+    '  ── Claude Code Skills Installed ────────────────────────────',
+    '',
+    '  The following slash commands are now available:',
+    '    /a2a-setup     — Run onboarding or reset configuration',
+    '    /a2a-call      — Call another A2A agent',
+    '    /a2a-invite    — Create and share an invite token',
+    '    /a2a-contacts  — List and manage contacts',
+    '    /a2a-status    — Check server and agent health',
+    '',
+    '══════════════════════════════════════════════════════════════',
+    '',
+  );
+
+  const fullBanner = lines.join('\n');
+
+  // Print the full banner to stdout for contexts where it's visible
+  // (e.g., --foreground-scripts, direct script execution, agent contexts)
+  console.log(fullBanner);
+
+  // ── Write full banner to a log file ─────────────────────────────────
+  //
+  // Even when npm suppresses terminal output, the agent or human can read
+  // this file to get the full getting-started info. We write to the project
+  // root (initCwd) so it's next to CLAUDE.md and easy to discover.
+  try {
+    const logPath = path.join(initCwd, '.a2a-install.log');
+    const logContent = [
+      `a2acalling v${pkg.version} — install summary`,
+      `Installed at: ${new Date().toISOString()}`,
+      `Target directory: ${initCwd}`,
+      `Global install: ${isGlobal}`,
+      '',
+      ...shortLines,
+      '',
+      fullBanner,
+    ].join('\n');
+    fs.writeFileSync(logPath, logContent);
+  } catch (e) {
+    // Non-fatal — the log file is a convenience, not a requirement.
+    // This can fail if the target directory is read-only (e.g., system dirs).
+  }
+}

package/.claude/worktrees/agent-a5b87d75/scripts/preuninstall.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+// ============================================================================
+// npm preuninstall hook — manifest-driven cleanup
+//
+// When `npm uninstall a2acalling` runs, npm calls this script BEFORE
+// removing the package from node_modules. We read .a2a-manifest.json
+// to find every file our postinstall created and remove them cleanly.
+//
+// CLAUDE.md gets special handling: we only remove the A2A section
+// (between "# A2A Calling" and "<!-- END A2A CALLING SECTION -->"),
+// preserving any project-specific content the user added before/after.
+//
+// If the manifest doesn't exist (manual install, old version), we
+// skip cleanup gracefully — better to leave files than crash the uninstall.
+// ============================================================================
+
+// Skip in CI environments — cleanup is not needed in ephemeral containers
+if (process.env.CI || process.env.CONTINUOUS_INTEGRATION) process.exit(0);
+if (process.env.DOCKER) process.exit(0);
+
+try {
+  const path = require('path');
+  const { cleanupProjectFiles } = require('./cleanup');
+
+  // INIT_CWD is set by npm to the directory where `npm uninstall` was run.
+  // This is the project root where postinstall placed the skill files.
+  // Falls back to cwd() which should also be the project root during npm lifecycle.
+  const targetDir = process.env.INIT_CWD || process.cwd();
+
+  const result = cleanupProjectFiles(targetDir);
+
+  // Print a short summary so the user (or agent) knows what was cleaned up.
+  // This output may be suppressed by npm v7+ unless --foreground-scripts is used,
+  // but it's still useful for debugging and for agents that capture stderr.
+  if (result.removed.length > 0) {
+    console.error(`a2acalling: cleaned up ${result.removed.length} file(s):`);
+    for (const f of result.removed) {
+      console.error(`  - ${f}`);
+    }
+  }
+  if (result.preserved.length > 0) {
+    for (const f of result.preserved) {
+      console.error(`  ~ ${f}`);
+    }
+  }
+  if (result.errors.length > 0) {
+    console.error(`  Warnings (${result.errors.length}):`);
+    for (const e of result.errors) {
+      console.error(`  ! ${e}`);
+    }
+  }
+  if (result.removed.length === 0 && result.preserved.length === 0 && result.errors.length === 0) {
+    // No manifest found or manifest was empty — nothing to clean up.
+    // This is expected for fresh installs that never ran postinstall,
+    // or for projects where cleanup was already done via `a2a uninstall`.
+    console.error('a2acalling: no install manifest found, skipping project cleanup.');
+    console.error('  Tip: run `a2a uninstall` to also remove server config and database.');
+  }
+} catch (err) {
+  // CRITICAL: Never crash the npm uninstall process.
+  // If our cleanup fails for any reason, npm should still be able to remove
+  // the package from node_modules. A failed cleanup leaves orphaned files,
+  // which is annoying but not harmful. A crashed uninstall is much worse.
+  console.error(`a2acalling: cleanup warning — ${err.message}`);
+}
+
+process.exit(0);

package/.claude/worktrees/agent-a5b87d75/scripts/run-e2e.sh

@@ -0,0 +1,52 @@
+#!/usr/bin/env bash
+# A2A-42: Cron/CI wrapper for E2E test orchestrator.
+# Runs orchestration, persists results, optionally alerts on failure.
+#
+# Usage:
+#   scripts/run-e2e.sh              # run + persist
+#   scripts/run-e2e.sh --alert      # run + persist + alert on failure
+#
+# Cron example (every 6 hours):
+#   0 */6 * * * /root/a2acalling/scripts/run-e2e.sh --alert >> /var/log/a2a-e2e.log 2>&1
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+ALERT_SCRIPT="/root/maestro/scripts/alert.sh"
+ALERT_ON_FAILURE=false
+
+for arg in "$@"; do
+  case "$arg" in
+    --alert) ALERT_ON_FAILURE=true ;;
+    --standalone) RUN_STANDALONE=true ;;
+  esac
+done
+
+echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] Starting E2E orchestration..."
+
+cd "$PROJECT_DIR"
+
+# A2A-103: Standalone E2E lane — runs only standalone app tests.
+if [ "${RUN_STANDALONE:-false}" = true ]; then
+  echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] Running standalone E2E tests..."
+  node test/run.js --e2e --filter standalone
+  exit $?
+fi
+
+# A2A-42: Run orchestrator with JSON output and persistence.
+# stdout (JSON) goes to /dev/null; stderr (regression messages, logs) passes through
+# so cron log captures warnings like "REGRESSION DETECTED: ..."
+if node test/e2e/orchestrate.js --json --persist > /dev/null; then
+  echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] E2E: PASSED"
+  exit 0
+else
+  EXIT_CODE=$?
+  echo "[$(date -u +%Y-%m-%dT%H:%M:%SZ)] E2E: FAILED (exit $EXIT_CODE)"
+
+  if [ "$ALERT_ON_FAILURE" = true ] && [ -x "$ALERT_SCRIPT" ]; then
+    "$ALERT_SCRIPT" error "E2E test failure detected — check ~/.config/openclaw/test-results/latest.json"
+  fi
+
+  exit "$EXIT_CODE"
+fi

package/.claude/worktrees/agent-a5b87d75/scripts/smoke-test-standalone.sh

@@ -0,0 +1,101 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# A2A-97: fast smoke coverage for packaged standalone server startup + SQLite-backed routes.
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
+BINARY_PATH="${1:-}"
+
+if [[ -z "$BINARY_PATH" ]]; then
+  for candidate in \
+    "$PROJECT_DIR/native/macos/src-tauri/binaries/a2a-server-universal-apple-darwin" \
+    "$PROJECT_DIR/native/macos/src-tauri/binaries/a2a-server-aarch64-apple-darwin" \
+    "$PROJECT_DIR/native/macos/src-tauri/binaries/a2a-server-x86_64-apple-darwin"
+  do
+    if [[ -x "$candidate" ]]; then
+      BINARY_PATH="$candidate"
+      break
+    fi
+  done
+fi
+
+if [[ -z "$BINARY_PATH" || ! -x "$BINARY_PATH" ]]; then
+  echo "Standalone binary not found or not executable: ${BINARY_PATH:-<unset>}" >&2
+  exit 1
+fi
+
+TMP_ROOT="$(mktemp -d)"
+CONFIG_DIR="$TMP_ROOT/config"
+LOG_FILE="$TMP_ROOT/server.log"
+mkdir -p "$CONFIG_DIR"
+
+PORT="$((
+  $(node -e "const net=require('net'); const s=net.createServer(); s.listen(0,'127.0.0.1',()=>{console.log(s.address().port); s.close();});")
+))"
+
+PID=""
+cleanup() {
+  if [[ -n "$PID" ]] && kill -0 "$PID" 2>/dev/null; then
+    kill "$PID" 2>/dev/null || true
+    wait "$PID" 2>/dev/null || true
+  fi
+  rm -rf "$TMP_ROOT"
+}
+trap cleanup EXIT
+
+fail() {
+  echo "Smoke test failed: $1" >&2
+  if [[ -f "$LOG_FILE" ]]; then
+    echo "---- server log tail (last 50 lines) ----" >&2
+    tail -n 50 "$LOG_FILE" >&2 || true
+  fi
+  exit 1
+}
+
+A2A_RUNTIME=test \
+NO_AUTO_UPDATE=1 \
+A2A_CONFIG_DIR="$CONFIG_DIR" \
+OPENCLAW_CONFIG_DIR="$CONFIG_DIR" \
+"$BINARY_PATH" "$PORT" >"$LOG_FILE" 2>&1 &
+PID="$!"
+
+health_ok=0
+for _ in $(seq 1 60); do
+  if curl -fsS "http://127.0.0.1:${PORT}/api/a2a/status" >/dev/null 2>&1; then
+    health_ok=1
+    break
+  fi
+  sleep 1
+done
+
+if [[ "$health_ok" -ne 1 ]]; then
+  fail "server did not become healthy within 60 seconds"
+fi
+
+# A2A-97: hit conversation list endpoint to exercise SQLite-backed dashboard storage path.
+curl -fsS "http://127.0.0.1:${PORT}/api/a2a/dashboard/calls" >/dev/null \
+  || fail "dashboard calls endpoint failed (possible SQLite/native binding issue)"
+
+create_resp="$(
+  curl -fsS -X POST "http://127.0.0.1:${PORT}/api/a2a/dashboard/invites" \
+    -H 'content-type: application/json' \
+    -d '{"name":"CI Smoke","tier":"public","expires":"1h"}'
+)"
+
+invite_id="$(node -e "const payload=JSON.parse(process.argv[1]); process.stdout.write(payload.token && payload.token.id ? payload.token.id : '');" "$create_resp")"
+if [[ -z "$invite_id" ]]; then
+  fail "invite creation returned no token id"
+fi
+
+curl -fsS -X POST "http://127.0.0.1:${PORT}/api/a2a/dashboard/invites/${invite_id}/revoke" >/dev/null \
+  || fail "invite revoke failed"
+
+if ! kill -0 "$PID" 2>/dev/null; then
+  fail "server exited unexpectedly during smoke checks"
+fi
+
+kill "$PID" 2>/dev/null || true
+wait "$PID" 2>/dev/null || true
+PID=""
+
+echo "Standalone smoke test passed for ${BINARY_PATH}"