@kal-elsam/kairo-runtime 0.1.4 → 0.2.0

package/README.md

@@ -161,6 +161,14 @@ kairo install --agents all
 kairo install --agents cursor,codex --components orchestrator,sdd-core
 kairo doctor
 kairo doctor --json
+kairo orchestrator --json
+kairo intelligence status
+kairo intelligence models
+kairo intelligence context --json
+kairo intelligence route --task "explain architecture"
+kairo intelligence ask --prompt "Summarize project risks" --json
+# Cloud (OpenRouter/free) only after explicit consent + confirm:
+# OPENROUTER_API_KEY=... kairo intelligence ask --prompt "..." --cloud-consent --yes
 kairo update   # technical alias; prefer sync
 kairo detect
 kairo components
@@ -180,6 +188,21 @@ kairo uninstall
 kairo install --scope=workspace   # opt-in / legacy
 ```
 
+### Intelligence layer (0.2.0)
+
+Kairo owns **Harness Engineering** governance: compile relevant project context, route to a backend, and require human confirmation for cloud transmission. It does not store credentials.
+
+| Backend | Detection | Invoke |
+|---|---|---|
+| Ollama | `GET $OLLAMA_HOST/api/tags` (default `http://127.0.0.1:11434`) | Local chat |
+| OpenRouter | `OPENROUTER_API_KEY` in env | `openrouter/free` after `--cloud-consent` + `--yes` |
+| Custom HTTP | Profile `customProviders` (`baseUrl`, `modelId`, optional local-only `apiKeyEnv`) | OpenAI-compatible `/chat/completions` |
+
+Routing order: user override → Ollama → OpenRouter free (consent) → diagnostics mode.
+
+Private paths (`.env`, secrets, keys) are excluded from context packs unless `--include-private`.
+Remote custom providers require explicit cloud consent and cannot receive an `apiKeyEnv` credential in 0.2.0; use a built-in provider or a local custom endpoint for env-backed authentication.
+
 Legacy CLI aliases (backward compatible): `harness`, `agentic-harness`, `sgs-harness`, `harness-sgs`
 
 `kairo help` lists commands and JSON support; longer examples live in this README.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kal-elsam/kairo-runtime",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "description": "Kairo Runtime — local agent operating system for Codex, Cursor, Claude, Gemini, Copilot, Engram, and Graphify.",
   "type": "module",
   "homepage": "https://github.com/Kal-elSam/harness#readme",

package/src/cli.js

@@ -30,6 +30,8 @@ import {
 import { applyPolicyToOptions, loadPolicyFile } from "./global/policy.js";
 import { resolveHomeDir } from "./global/paths.js";
 import { runWorkspaceDetect, runWorkspaceDoctor, runWorkspaceInit, runWorkspaceUpdate } from "./workspace-cli.js";
+import { runOrchestratorDiagnostics, runOrchestratorShell } from "./global/orchestrator.js";
+import { runIntelligenceCli } from "./global/intelligence-cli.js";
 import {
   LEGACY_PACKAGE_NAME,
   PACKAGE_NAME,
@@ -66,6 +68,27 @@ export async function runCli(argv) {
   const invoke = resolveSuggestedInvocation(packageManifest.name);
 
   switch (command) {
+    case "shell":
+      await runOrchestratorShell({
+        packageRoot,
+        packageManifest,
+        workspaceRoot: optionsWithPolicy.cwd,
+        interactive: optionsWithPolicy.interactive
+      });
+      return;
+    case "orchestrator":
+      await runOrchestratorDiagnostics({
+        homeDir: resolveHomeDir(),
+        workspaceRoot: optionsWithPolicy.cwd,
+        packageName: packageManifest.name,
+        packageRoot,
+        cliVersion: packageManifest.version,
+        json: optionsWithPolicy.json
+      });
+      return;
+    case "intelligence":
+      await runIntelligenceCli(optionsWithPolicy, packageManifest);
+      return;
     case "setup":
       await runGlobalSetup(optionsWithPolicy, packageManifest, packageRoot);
       return;
@@ -219,7 +242,37 @@ function resolveImplicitCommand(args) {
   if (argsWantsWorkspaceScope(args)) {
     return "init";
   }
-  return "setup";
+  if (hasImplicitSetupFlags(args)) {
+    return "setup";
+  }
+  return "shell";
+}
+
+function hasImplicitSetupFlags(args) {
+  const setupFlags = new Set([
+    "--dry-run",
+    "--yes",
+    "-y",
+    "--confirm",
+    "--simple",
+    "--no-preflight",
+    "--all-adapters",
+    "--no-default-components",
+    "--detect"
+  ]);
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (setupFlags.has(arg)) return true;
+    if (arg.startsWith("--mode=")) return true;
+    if (arg.startsWith("--adapters=") || arg.startsWith("--agents=")) return true;
+    if (arg.startsWith("--components=")) return true;
+    if (arg === "--mode" || arg === "--adapters" || arg === "--agents" || arg === "--components") {
+      return true;
+    }
+  }
+
+  return false;
 }
 
 function argsWantsWorkspaceScope(args) {
@@ -275,7 +328,13 @@ export function parseArgs(argv) {
     simple: false,
     help: false,
     version: false,
-    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY)
+    interactive: Boolean(process.stdin.isTTY && process.stdout.isTTY),
+    intelligenceAction: null,
+    intelligenceTask: null,
+    intelligencePrompt: null,
+    intelligencePaths: [],
+    includePrivate: false,
+    cloudConsent: false
   };
 
   if (command === "components") {
@@ -290,6 +349,10 @@ export function parseArgs(argv) {
     parseHistoryAction(args, options);
   }
 
+  if (command === "intelligence") {
+    parseIntelligenceAction(args, options);
+  }
+
   for (let index = 0; index < args.length; index += 1) {
     const arg = args[index];
 
@@ -351,6 +414,14 @@ export function parseArgs(argv) {
     else if (arg === "--out") options.outPath = resolve(args[++index]);
     else if (arg.startsWith("--out=")) options.outPath = resolve(arg.slice("--out=".length));
     else if (arg === "--simple") options.simple = true;
+    else if (arg === "--task") options.intelligenceTask = args[++index];
+    else if (arg.startsWith("--task=")) options.intelligenceTask = arg.slice("--task=".length);
+    else if (arg === "--prompt") options.intelligencePrompt = args[++index];
+    else if (arg.startsWith("--prompt=")) options.intelligencePrompt = arg.slice("--prompt=".length);
+    else if (arg === "--paths") options.intelligencePaths = parsePathList(args[++index]);
+    else if (arg.startsWith("--paths=")) options.intelligencePaths = parsePathList(arg.slice("--paths=".length));
+    else if (arg === "--include-private") options.includePrivate = true;
+    else if (arg === "--cloud-consent") options.cloudConsent = true;
     else if (arg === "--help" || arg === "-h") options.help = true;
     else if (arg === "--version" || arg === "-v") options.version = true;
     else throw new Error(`Unknown option "${arg}".`);
@@ -441,6 +512,31 @@ function parseHistoryAction(args, options) {
   throw new Error(`Unknown history action "${action}". Use last or omit for the full log.`);
 }
 
+function parseIntelligenceAction(args, options) {
+  const action = args[0];
+  if (!action || action.startsWith("-")) {
+    options.intelligenceAction = "status";
+    return;
+  }
+
+  args.shift();
+  const allowed = new Set(["status", "models", "context", "route", "ask"]);
+  if (!allowed.has(action)) {
+    throw new Error(`Unknown intelligence action "${action}". Use status, models, context, route, or ask.`);
+  }
+  options.intelligenceAction = action;
+}
+
+function parsePathList(value) {
+  if (!value) return [];
+  return [...new Set(
+    value
+      .split(",")
+      .map((item) => item.trim())
+      .filter(Boolean)
+  )];
+}
+
 function parsePositiveInt(value, label) {
   const parsed = Number.parseInt(value, 10);
   if (!Number.isFinite(parsed) || parsed < 1) {
@@ -461,6 +557,9 @@ function normalizeCommand(command) {
   if (!command) return "install";
 
   if (command === "install" || command === "i") return "install";
+  if (command === "shell") return "shell";
+  if (command === "orchestrator") return "orchestrator";
+  if (command === "intelligence" || command === "intel") return "intelligence";
   if (command === "setup") return "setup";
   if (command === "status") return "status";
   if (command === "sync") return "sync";
@@ -517,8 +616,13 @@ sections, components, backups, and drift repair under ~/.harness.
 Bootstrap: see README.md (curl install.sh or npx ${PACKAGE_NAME}).
 
 Usage:
-  ${cli} [--dry-run] [--yes] [--confirm] [--agents <list|all>] [--components <list>]
+  ${cli}                              Interactive orchestrator shell (TTY)
+  ${cli} --dry-run                      Setup dry-run (scriptable)
   ${cli} --version
+  ${cli} shell                          Interactive orchestrator shell (TTY)
+  ${cli} orchestrator [--json]          Read-only agent capability diagnostics
+  ${cli} intelligence [status|models|context|route|ask] [--json]
+  ${cli} intelligence ask --prompt "..." [--cloud-consent] [--yes] [--paths a,b]
   ${cli} setup [--dry-run] [--yes] [--confirm] [--simple] [--no-preflight] [--agents <list|all>] [--components <list>]
   ${cli} status [--json]
   ${cli} sync [--dry-run] [--yes] [--confirm] [--json] [--no-preflight]
@@ -552,7 +656,12 @@ Scopes:
                           Explicit --scope=workspace only.
 
 Commands:
-  setup      Interactive Ink UI (TTY). Use --simple for Clack prompts.
+  shell      Interactive Ink orchestrator (TTY). Bare ${cli} opens this in TTY sessions.
+  orchestrator  Read-only capability registry diagnostics (--json supported).
+  intelligence  Harness Engineering layer: backends, context packs, routing, budgets.
+             Local-first (Ollama). Cloud (OpenRouter/free) only with --cloud-consent.
+             Credentials via env only (OPENROUTER_API_KEY, OLLAMA_HOST). Never stored.
+  setup      Managed ecosystem setup. Interactive Ink UI (TTY). Use --simple for Clack prompts.
   status     Control panel: agents, components, drift, backups, next action.
   sync       Converge managed content (repair drift), then show status.
   upgrade    Preview or apply ecosystem updates (apply requires --yes).

package/src/global/action-planner.js

@@ -0,0 +1,230 @@
+import { CAPABILITY_STATES } from "./capability-states.js";
+import { inspectAllCapabilities } from "./capability-registry.js";
+import { resolveProfile, resolveProfileAgents } from "./profile.js";
+import { formatCliCommand } from "./brand/cli.js";
+import {
+  inspectIntelligenceBackends,
+  summarizeIntelligenceBackends,
+  resolveRoutingDecision
+} from "./intelligence/index.js";
+
+export const PLAN_ACTIONS = {
+  DIAGNOSE: "diagnose",
+  SETUP: "setup",
+  SYNC: "sync",
+  INSTALL: "install",
+  STATUS: "status"
+};
+
+export async function buildReadOnlyDiagnostics({
+  homeDir,
+  workspaceRoot,
+  packageName,
+  packageRoot,
+  cliVersion,
+  env = process.env,
+  fetchImpl = globalThis.fetch
+}) {
+  const [{ profile, sources }, capabilities] = await Promise.all([
+    resolveProfile({ homeDir, workspaceRoot }),
+    inspectAllCapabilities({ homeDir, workspaceRoot, packageName })
+  ]);
+
+  const intelligence = await inspectIntelligenceBackends({
+    env,
+    fetchImpl,
+    customProviders: profile.customProviders ?? []
+  });
+
+  const detectedIds = capabilities.filter((entry) => entry.detected).map((entry) => entry.id);
+  const profileAgents = resolveProfileAgents(profile, detectedIds);
+  const diagnostics = summarizeDiagnostics(capabilities);
+  const intelligenceSummary = summarizeIntelligenceBackends(intelligence);
+  const routingPreview = resolveRoutingDecision({
+    backends: intelligence,
+    profile,
+    // Session consent only — profile.cloudConsent is a preference, never live authorization.
+    cloudConsent: false,
+    tokenBudget: profile.tokenBudget
+  });
+
+  return {
+    readOnly: true,
+    cliVersion,
+    profile: { ...profile, sources },
+    capabilities,
+    profileAgents,
+    diagnostics,
+    intelligence: {
+      backends: intelligence,
+      summary: intelligenceSummary,
+      routingPreview
+    },
+    recommendations: buildDiagnosticRecommendations({
+      capabilities,
+      profile,
+      diagnostics,
+      intelligenceSummary,
+      routingPreview
+    })
+  };
+}
+
+export async function buildActionPlan({
+  action,
+  homeDir,
+  workspaceRoot,
+  packageName,
+  options = {}
+}) {
+  const diagnostics = await buildReadOnlyDiagnostics({
+    homeDir,
+    workspaceRoot,
+    packageName,
+    packageRoot: options.packageRoot ?? null,
+    cliVersion: options.cliVersion ?? null
+  });
+
+  const steps = [];
+  const warnings = [];
+
+  switch (action) {
+    case PLAN_ACTIONS.DIAGNOSE:
+    case PLAN_ACTIONS.STATUS:
+      return {
+        action,
+        readOnly: true,
+        requiresConfirmation: false,
+        steps: ["Show ecosystem diagnostics (read-only)."],
+        diagnostics,
+        warnings
+      };
+    case PLAN_ACTIONS.SETUP:
+    case PLAN_ACTIONS.INSTALL:
+      steps.push(`Target agents: ${diagnostics.profileAgents.join(", ")}`);
+      steps.push("Preview managed section changes under ~/.harness and agent config files.");
+      steps.push("Create backups before writing managed content.");
+      if (options.dryRun) {
+        steps.push("Dry run: no files will be written.");
+      }
+      return {
+        action,
+        readOnly: Boolean(options.dryRun),
+        requiresConfirmation: !options.dryRun,
+        steps,
+        diagnostics,
+        warnings: collectCapabilityWarnings(diagnostics.capabilities)
+      };
+    case PLAN_ACTIONS.SYNC:
+      steps.push("Compare managed content against bundled assets.");
+      steps.push("Repair drift in agent config files when differences are found.");
+      if (options.dryRun) {
+        steps.push("Dry run: show planned repairs only.");
+      }
+      return {
+        action,
+        readOnly: Boolean(options.dryRun),
+        requiresConfirmation: !options.dryRun,
+        steps,
+        diagnostics,
+        warnings: collectCapabilityWarnings(diagnostics.capabilities)
+      };
+    default: {
+      const _exhaustive = action;
+      throw new Error(`Unknown plan action "${_exhaustive}".`);
+    }
+  }
+}
+
+export function shouldExecutePlan(plan, { confirmed = false } = {}) {
+  if (plan.readOnly) return true;
+  return confirmed;
+}
+
+export function formatActionPlan(plan) {
+  const lines = [];
+  lines.push(`Action: ${plan.action}`);
+  lines.push(`Mode: ${plan.readOnly ? "read-only" : "write"}`);
+  lines.push(`Confirmation required: ${plan.requiresConfirmation ? "yes" : "no"}`);
+  lines.push("");
+  lines.push("Steps:");
+  for (const step of plan.steps) {
+    lines.push(`  - ${step}`);
+  }
+
+  if (plan.warnings.length > 0) {
+    lines.push("");
+    lines.push("Warnings:");
+    for (const warning of plan.warnings) {
+      lines.push(`  - ${warning}`);
+    }
+  }
+
+  if (plan.diagnostics.recommendations.length > 0) {
+    lines.push("");
+    lines.push("Recommendations:");
+    for (const recommendation of plan.diagnostics.recommendations) {
+      lines.push(`  - ${recommendation}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+function summarizeDiagnostics(capabilities) {
+  return {
+    detected: capabilities.filter((entry) => entry.detected).length,
+    available: capabilities.filter((entry) => entry.state === CAPABILITY_STATES.AVAILABLE).length,
+    unknown: capabilities.filter((entry) => entry.state === CAPABILITY_STATES.UNKNOWN).length,
+    errors: capabilities.filter((entry) => entry.state === CAPABILITY_STATES.ERROR).length
+  };
+}
+
+function buildDiagnosticRecommendations({
+  capabilities,
+  profile,
+  diagnostics,
+  intelligenceSummary,
+  routingPreview
+}) {
+  const recommendations = [];
+
+  if (diagnostics.detected === 0) {
+    recommendations.push(`No agents detected. Run ${formatCliCommand("detect")} or install a supported agent CLI.`);
+  }
+
+  if (profile.coordinator) {
+    const coordinator = capabilities.find((entry) => entry.id === profile.coordinator);
+    if (!coordinator?.detected && coordinator?.state === CAPABILITY_STATES.UNKNOWN) {
+      recommendations.push(`Profile coordinator "${profile.coordinator}" is not detected on this machine.`);
+    }
+  }
+
+  for (const capability of capabilities) {
+    if (capability.recommendation) {
+      recommendations.push(`${capability.label}: ${capability.recommendation}`);
+    }
+  }
+
+  if (!intelligenceSummary?.localAvailable && !intelligenceSummary?.cloudAuthenticated) {
+    recommendations.push(
+      "No intelligence backend available. Start Ollama or set OPENROUTER_API_KEY (env only). Diagnostics mode remains available."
+    );
+  } else if (!intelligenceSummary?.localAvailable && intelligenceSummary?.cloudAuthenticated) {
+    recommendations.push(
+      `OpenRouter is authenticated. Cloud invoke still requires session flags: ${formatCliCommand("intelligence ask --cloud-consent --yes")}.`
+    );
+  }
+
+  if (routingPreview && !routingPreview.canInvoke) {
+    recommendations.push(`Routing: ${routingPreview.reason}`);
+  }
+
+  return [...new Set(recommendations)];
+}
+
+function collectCapabilityWarnings(capabilities) {
+  return capabilities
+    .filter((entry) => entry.state === CAPABILITY_STATES.ERROR || entry.state === CAPABILITY_STATES.UNKNOWN)
+    .map((entry) => `${entry.label} is ${entry.state}${entry.error ? ` (${entry.error})` : ""}.`);
+}

package/src/global/agent-capabilities/create-capability-adapter.js

@@ -0,0 +1,224 @@
+import { CAPABILITY_STATES } from "../capability-states.js";
+import {
+  isExecutableAvailable,
+  parseVersionFromOutput,
+  probeCommand,
+  resolveProbeState
+} from "../cli-probe.js";
+
+export function createAgentCapabilityAdapter({
+  id,
+  label,
+  managedAdapter,
+  executable = null,
+  versionArgs = ["--version"],
+  authArgs = null,
+  modelsArgs = null,
+  opaqueAuth = false,
+  runExecutable = null
+}) {
+  const cliName = runExecutable ?? executable;
+
+  return {
+    id,
+    label,
+    managedAdapter,
+
+    detect(context) {
+      return managedAdapter.detect(context);
+    },
+
+    inspect(context, { probeImpl = defaultProbe } = {}) {
+      const detected = managedAdapter.detect(context);
+      const cliAvailable = executable ? isExecutableAvailable(executable) : false;
+
+      if (!detected && !cliAvailable) {
+        return buildInspection({
+          id,
+          label,
+          state: CAPABILITY_STATES.UNKNOWN,
+          detected: false,
+          cliAvailable: false,
+          version: null,
+          authenticated: null,
+          recommendation: `Install ${label} or run ${formatCliCommand("setup")} to configure managed sections.`
+        });
+      }
+
+      if (opaqueAuth) {
+        return buildInspection({
+          id,
+          label,
+          state: detected || cliAvailable ? CAPABILITY_STATES.DETECTED : CAPABILITY_STATES.UNKNOWN,
+          detected,
+          cliAvailable,
+          version: null,
+          authenticated: null,
+          recommendation: detected
+            ? `${label} config detected. Authentication status is provider-managed.`
+            : `Install ${label} to enable managed configuration.`
+        });
+      }
+
+      return probeImpl({
+        id,
+        label,
+        detected,
+        cliAvailable,
+        executable,
+        versionArgs,
+        authArgs
+      });
+    },
+
+    listModels(context, { probeImpl = defaultProbeModels } = {}) {
+      if (!modelsArgs || !executable) return null;
+      if (!isExecutableAvailable(executable)) return null;
+      return probeImpl({ executable, modelsArgs, context });
+    },
+
+    run(context, { args = [], cwd = context.workspaceRoot ?? process.cwd(), spawnImpl = probeCommand } = {}) {
+      if (!cliName) {
+        return {
+          ok: false,
+          state: CAPABILITY_STATES.ERROR,
+          message: `${label} does not expose a delegatable CLI through Kairo.`
+        };
+      }
+
+      if (!isExecutableAvailable(cliName)) {
+        return {
+          ok: false,
+          state: CAPABILITY_STATES.ERROR,
+          message: `${label} CLI "${cliName}" is not on PATH. Install the agent or add it to PATH.`
+        };
+      }
+
+      const result = spawnImpl(cliName, args, { cwd, env: process.env });
+
+      if (!result.ok) {
+        const detail = result.stderr || result.stdout || result.error || "unknown error";
+        return {
+          ok: false,
+          state: CAPABILITY_STATES.ERROR,
+          message: `${label} CLI failed: ${detail}`
+        };
+      }
+
+      return {
+        ok: true,
+        state: CAPABILITY_STATES.AVAILABLE,
+        stdout: result.stdout,
+        stderr: result.stderr
+      };
+    }
+  };
+}
+
+function defaultProbe({ id, label, detected, cliAvailable, executable, versionArgs, authArgs }) {
+  let version = null;
+  let authenticated = null;
+  let probeError = null;
+  let authReady = false;
+
+  if (cliAvailable && executable) {
+    const versionResult = probeCommand(executable, versionArgs);
+    if (versionResult.timedOut || versionResult.error) {
+      probeError = versionResult.error ?? "probe timed out";
+    } else if (versionResult.ok) {
+      version = parseVersionFromOutput(versionResult.stdout) ?? versionResult.stdout.split("\n")[0] ?? null;
+    }
+
+    if (authArgs) {
+      const authResult = probeCommand(executable, authArgs);
+      if (authResult.timedOut || authResult.error) {
+        probeError = probeError ?? authResult.error ?? "auth probe timed out";
+      } else {
+        authenticated = authResult.ok;
+        authReady = authResult.ok;
+      }
+    } else if (version) {
+      authenticated = null;
+      authReady = true;
+    }
+  }
+
+  const state = resolveProbeState({
+    detected,
+    cliAvailable,
+    authReady,
+    probeError,
+    opaque: false
+  });
+
+  return buildInspection({
+    id,
+    label,
+    state,
+    detected,
+    cliAvailable,
+    version,
+    authenticated,
+    error: probeError,
+    recommendation: buildRecommendation({ label, state, detected, cliAvailable, authenticated })
+  });
+}
+
+function defaultProbeModels({ executable, modelsArgs }) {
+  const result = probeCommand(executable, modelsArgs);
+  if (!result.ok) return null;
+
+  const lines = result.stdout
+    .split("\n")
+    .map((line) => line.trim())
+    .filter(Boolean);
+
+  return lines.length > 0 ? lines : null;
+}
+
+function buildInspection(fields) {
+  return {
+    id: fields.id,
+    label: fields.label,
+    state: fields.state,
+    detected: fields.detected,
+    cliAvailable: fields.cliAvailable,
+    version: fields.version ?? null,
+    authenticated: fields.authenticated ?? null,
+    models: fields.models ?? null,
+    error: fields.error ?? null,
+    recommendation: fields.recommendation ?? null
+  };
+}
+
+function buildRecommendation({ label, state, detected, cliAvailable, authenticated }) {
+  if (state === CAPABILITY_STATES.ERROR) {
+    return `Re-run detection or check ${label} CLI logs for details.`;
+  }
+
+  if (state === CAPABILITY_STATES.UNKNOWN) {
+    return `Install ${label} or run ${formatCliCommand("detect")} after setup.`;
+  }
+
+  if (state === CAPABILITY_STATES.AVAILABLE) {
+    return `${label} is ready. Delegate tasks through its CLI.`;
+  }
+
+  if (authenticated === false) {
+    return `Authenticate with ${label} (provider login) before delegating work.`;
+  }
+
+  if (detected && !cliAvailable) {
+    return `${label} config detected but CLI not on PATH.`;
+  }
+
+  if (cliAvailable && !detected) {
+    return `${label} CLI found. Run ${formatCliCommand("setup")} to add managed sections.`;
+  }
+
+  return `${label} detected. Run ${formatCliCommand("status")} for ecosystem health.`;
+}
+
+function formatCliCommand(command) {
+  return `kairo ${command}`;
+}