@mnemom/mnemom 0.16.2 → 0.17.0-next.0

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { program } from "commander";
+import { program, Option } from "commander";
 import { isEntrypoint } from "./lib/entrypoint.js";
 import { CLI_VERSION } from "./version.js";
 import { statusCommand } from "./commands/status.js";
@@ -8,9 +8,9 @@ import { logsCommand } from "./commands/logs.js";
 import { licenseActivateCommand, licenseStatusCommand, licenseDeactivateCommand, } from "./commands/license.js";
 import { cardShowCommand, cardPublishCommand, cardValidateCommand, cardEditCommand, cardEvaluateCommand, } from "./commands/card.js";
 import { policyInitCommand, policyValidateCommand, policyPublishCommand, policyListCommand, policyTestCommand, policyEvaluateCommand, } from "./commands/policy.js";
-import { protectionShowCommand, protectionPublishCommand, protectionValidateCommand, protectionEditCommand, } from "./commands/protection.js";
-import { agentsListCommand, agentsClaimCommand } from "./commands/agents.js";
-import { orgListCommand, orgShowCommand } from "./commands/org.js";
+import { protectionShowCommand, protectionPublishCommand, protectionValidateCommand, protectionEditCommand, protectionDriftCommand, } from "./commands/protection.js";
+import { agentsListCommand, agentsClaimCommand, agentsMoveCommand } from "./commands/agents.js";
+import { orgListCommand, orgShowCommand, orgUseCommand } from "./commands/org.js";
 import { teamListCommand, teamShowCommand, teamTemplateCommand, teamPreviewComposeCommand, teamAdminGrantCommand, teamAdminRevokeCommand, teamAdminListCommand, teamCoverageCommand, } from "./commands/team.js";
 import { advisoriesListCommand, advisoriesShowCommand } from "./commands/advisories.js";
 import { postureListCommand, postureShowCommand, postureCreateCommand, postureUpdateCommand, postureCloneCommand, postureRevisionsCommand, postureDiffCommand, postureAssignCommand, postureUnassignCommand, posturePreviewComposeCommand, postureDeleteCommand, } from "./commands/posture.js";
@@ -20,7 +20,15 @@ import { apiKeyListCommand, apiKeyCreateCommand, apiKeyRotateCommand, apiKeyRevo
 import { webhooksListCommand, webhooksGetCommand, webhooksCreateCommand, webhooksUpdateCommand, webhooksDeleteCommand, webhooksRotateSecretCommand, webhooksTriggerCommand, webhooksListDeliveriesCommand, webhooksRedeliverCommand, webhooksReplayCommand, } from "./commands/webhooks.js";
 import { listenCommand } from "./commands/listen.js";
 import { tryMeCommand } from "./commands/try-me.js";
+import { codeCommand } from "./commands/code.js";
+import { codeConfigCommand } from "./commands/code-config.js";
+import { codeDoctorCommand } from "./commands/code-doctor.js";
+import { codeSetupCommand } from "./commands/code-setup.js";
+import { applyConfigToEnv, loadCodeConfig } from "./lib/code-config.js";
+import { wrapCommand } from "./commands/wrap.js";
+import { onboardCommand } from "./commands/onboard.js";
 import { skillsListCommand, skillsDescribeCommand } from "./commands/skills.js";
+import { usageCommand, parseNumericFlag, parseDaysFlag } from "./commands/usage.js";
 program
     .name("mnemom")
     .description("Transparent AI agent tracing")
@@ -71,6 +79,195 @@ program
         process.exit(1);
     }
 });
+// ── code — first-class governed coding-agent launcher ────────────────────────
+//
+// `mnemom code <scenario>` launches your coding-agent CLI (Claude Code in v1) with
+// its dev-time model traffic routed through the Mnemom gateway's /anthropic door
+// for observability + governance, under a governed agent identity (the
+// program-level `--agent`, default "code-agent") and an optional per-conversation
+// CONTRACT the gateway seals on the first turn. Three launch shapes — terminal
+// (default), --remote-control (interactive RC in this terminal), --server
+// (headless RC dispatcher) — with yolo on by default. `--cli` selects the
+// executable (name or full path; default claude). The us-2/prod door is the
+// DEFAULT; set MNEMOM_CODE_GATEWAY (or --gateway) to point elsewhere. The
+// Anthropic key is resolved with zero 1Password dependency (env → ~/.mnemom store
+// → interactive prompt) inside the launched process and never logged. See
+// commands/code.ts.
+// ─────────────────────────────────────────────────────────────────────────────
+const collectRepeatable = (value, previous) => {
+    previous.push(value);
+    return previous;
+};
+program
+    .command("code <scenario> [passthrough...]")
+    .description("Launch a governed coding agent through the Mnemom gateway (governed identity + optional sealed contract). " +
+    "Sub-verbs: `mnemom code setup` provisions your governed agent; `mnemom code doctor` preflights prerequisites; `mnemom code config …` manages persistent settings (~/.mnemom/code.toml).")
+    .option("--goal <statement>", "Contract goal statement (required if any contract flag is given)")
+    .option("--requirement <text>", "Contract requirement (repeatable)", collectRepeatable, [])
+    .option("--allow <glob>", "Allowed path/glob (repeatable)", collectRepeatable, [])
+    .option("--forbid <glob>", "Forbidden path/glob (repeatable)", collectRepeatable, [])
+    .option("--goal-id <id>", "Stable goal id to correlate this contract across sessions")
+    .option("--budget <usd>", "Guardrail: spend ceiling in USD (positive number)")
+    .option("--max-turns <n>", "Guardrail: turn ceiling (positive integer)")
+    .option("--stall <n>", "Guardrail: consecutive no-write turns (positive integer)")
+    .option("--conversation-id <id>", "x-mnemom-conversation-id (default: auto-generated)")
+    .option("--cli <name|path>", "Coding-agent CLI to launch: a name or full path (default: claude)")
+    .option("--gateway <url>", "Gateway host override (default: https://gateway.mnemom.ai; or MNEMOM_CODE_GATEWAY)")
+    .option("--remote-control", "Interactive Remote Control session in THIS terminal (behind a local proxy)")
+    .option("--server", "Headless `claude remote-control` dispatcher (behind a local proxy)")
+    .option("--model <alias|id>", "Model to launch (CLI alias or concrete id)")
+    .addOption(new Option("--effort <level>", "Reasoning effort").choices([
+    "low",
+    "medium",
+    "high",
+    "xhigh",
+    "max",
+]))
+    .option("--trim-mcp", "Launch the CLI with no MCP servers (--strict-mcp-config + empty --mcp-config)")
+    .option("--setup", "Provision + claim the governed agent before launch (non-interactive opt-in)")
+    .option("--no-setup", "Skip governed-agent provisioning entirely for this launch")
+    .option("--no-yolo", "Do NOT pass --dangerously-skip-permissions (yolo is on by default)")
+    .option("--no-context-hint", "Do NOT seed Claude Code's context-hint feature flag before launch")
+    .option("--dry-run", "Print the resolved launch plan and exit — no key read, no spawn")
+    .action(async (scenario, passthrough, opts) => {
+    try {
+        // Sub-verb: `mnemom code config …` manages persistent settings and never
+        // launches. (A scenario literally named "config" is reserved for this.)
+        if (scenario === "config") {
+            await codeConfigCommand(passthrough);
+            return;
+        }
+        if (opts.gateway)
+            process.env.MNEMOM_CODE_GATEWAY = opts.gateway;
+        // Persistent settings (~/.mnemom/code.toml) sit UNDER env and flags:
+        // precedence is flag > env > code.toml > built-in. Env-backed settings are
+        // folded into env only when unset (so env/flags still win); the resolvers
+        // in lib/code.ts keep the built-in default as the final fallback.
+        const cfg = loadCodeConfig();
+        applyConfigToEnv(cfg, process.env);
+        // Sub-verb: `mnemom code doctor` runs a read-only preflight and never
+        // launches. Placed after config load so it reports the effective settings.
+        if (scenario === "doctor") {
+            await codeDoctorCommand({ cli: opts.cli });
+            return;
+        }
+        // Sub-verb: `mnemom code setup` provisions/claims the governed agent and
+        // never launches. The agent slug follows the same precedence as a launch.
+        if (scenario === "setup") {
+            await codeSetupCommand({ agent: program.opts().agent ?? cfg.agent });
+            return;
+        }
+        const numToStr = (n) => n === undefined ? undefined : String(n);
+        // Config guardrails apply only when a contract is actually intended (a
+        // --goal is present), so a saved ceiling never forces an unrequested
+        // contract (which would then demand --goal and fail the launch).
+        const contractIntended = Boolean(opts.goal && opts.goal.trim());
+        // The governed identity rides on the program-level `--agent` (which
+        // shadows a subcommand `--agent` under commander@12 — the MNE-238 class),
+        // exactly as status/logs/onboard read it.
+        const parentOpts = program.opts();
+        await codeCommand(scenario, {
+            goal: opts.goal,
+            requirement: opts.requirement,
+            allow: opts.allow,
+            forbid: opts.forbid,
+            goalId: opts.goalId,
+            budget: opts.budget ?? (contractIntended ? numToStr(cfg.guardrails?.budgetUsd) : undefined),
+            maxTurns: opts.maxTurns ?? (contractIntended ? numToStr(cfg.guardrails?.maxTurns) : undefined),
+            stall: opts.stall ?? (contractIntended ? numToStr(cfg.guardrails?.stallTurns) : undefined),
+            agent: parentOpts.agent ?? cfg.agent,
+            conversationId: opts.conversationId,
+            cli: opts.cli,
+            remoteControl: opts.remoteControl,
+            server: opts.server,
+            model: opts.model ?? cfg.model,
+            effort: opts.effort ?? cfg.effort,
+            trimMcp: opts.trimMcp,
+            yolo: opts.yolo,
+            contextHint: opts.contextHint,
+            setup: opts.setup,
+            keySource: cfg.keySource,
+            passthrough,
+            dryRun: opts.dryRun,
+        });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// ── wrap (MNE-935, A4) — instrument an existing agent through the gateway ────
+//
+// `mnemom wrap` is the "bring your production agent" skill: it asks for
+// provider + framework + agent name, births the agent through the gateway,
+// seeds starter alignment + protection cards, and emits a drop-in code snippet.
+// Extends the skill-runner contract from A1 (MNE-932). See commands/wrap.ts.
+// ─────────────────────────────────────────────────────────────────────────────
+program
+    .command("wrap")
+    .description("Instrument an existing agent through the Mnemom gateway (born → cards → snippet)")
+    .option("--provider <provider>", "AI provider: anthropic, openai, gemini (default: prompt)")
+    .option("--framework <framework>", "Language/framework: python, node (default: prompt)")
+    .option("--name <name>", "Agent name used as the x-mnemom-agent header value")
+    .option("--provider-key <key>", "Provider API key for the one-time birth call (default: reads env)")
+    .option("-y, --yes", "Non-interactive: accept defaults, skip all prompts")
+    .option("--json", "Emit machine-readable result (skill / verdict / agent_id / steps)")
+    .action(async (opts) => {
+    try {
+        await wrapCommand({
+            provider: opts.provider,
+            framework: opts.framework,
+            name: opts.name,
+            providerKey: opts.providerKey,
+            yes: opts.yes,
+            json: opts.json,
+        });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// ── onboard (MNE-933, A2) — self-onboard the calling agent end-to-end ────────
+//
+// `mnemom onboard` runs the sovereignty path for the CALLING agent itself:
+// scan its trust posture → claim its identity → declare an alignment card →
+// surface its Trust Rating → hand back a public badge URL. One command, no
+// manifest. Additive + human-in-the-loop preserving: the only mutation is the
+// agent's own alignment-card declaration (its standing scoped token). The agent
+// authenticates as its OWN device-grant principal (MNE-944). The Trust Rating
+// is PROVISIONAL until the observer pipeline generates traces — the signed
+// rating + rendered badge are computed server-side, post-hoc. See
+// commands/onboard.ts for the auth model.
+// ─────────────────────────────────────────────────────────────────────────────
+program
+    .command("onboard")
+    .description("Self-onboard the calling agent (scan → claim → declare → rating → badge); the Trust Rating is provisional until the observer pipeline generates traces")
+    .option("--json", "Emit machine-readable step outcomes (implies non-interactive)")
+    .option("-y, --yes", "Non-interactive: accept defaults, skip all prompts")
+    .option("--key <key>", "The agent's provider API key — the CLI derives the claim hash proof")
+    .option("--hash-proof <hex>", "A pre-computed 64-hex hash proof (advanced/CI; alternative to --key)")
+    .option("--no-open", "Never auto-open the badge URL in a browser — just print it")
+    .action(async (opts) => {
+    try {
+        // The calling agent is selected via the program-level `--agent` (which
+        // shadows any subcommand `--agent` under commander@12 — the MNE-238
+        // class), mirroring how `status`/`logs` read it.
+        const parentOpts = program.opts();
+        await onboardCommand({
+            json: opts.json,
+            yes: opts.yes,
+            key: opts.key,
+            hashProof: opts.hashProof,
+            open: opts.open,
+            agent: parentOpts.agent,
+        });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
 // ── skills (MNE-1324) — discover the zero-install skill surface ──────────────
 const skills = program
     .command("skills")
@@ -346,6 +543,25 @@ protectionCmd
         process.exit(1);
     }
 });
+protectionCmd
+    .command("drift")
+    .argument("<file>", "Path to a committed protection-card snapshot (YAML or JSON)")
+    .description("Compare a committed snapshot against the live canonical card (read-only)")
+    .option("--strict", "Also fail on live fields the snapshot does not record")
+    .option("--json", "Emit the drift result as JSON")
+    .action(async (file, subOpts) => {
+    try {
+        const opts = program.opts();
+        await protectionDriftCommand(file, opts.agent, {
+            strict: subOpts.strict,
+            json: subOpts.json,
+        });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
 // ============================================================================
 // Policy commands (removed — stubs with migration guidance)
 // ============================================================================
@@ -418,15 +634,27 @@ const agentsCmd = program
 agentsCmd
     .command("claim <id-or-name>")
     .description("Claim an agent into an org (ADR-062 claim-to-org)")
-    .option("--org <slug>", "Org slug or id to claim into (default: your personal org)")
+    .option("--org <slug>", "Org slug or id to claim into (default: your ACTIVE org from `mnemom org use`, else your personal org)")
     .option("--key <key>", "The agent's provider API key — the CLI derives the hash proof from it")
     .option("--hash-proof <hex>", "A pre-computed 64-hex SHA-256 proof (advanced/CI; alternative to --key)")
     .option("--name <name>", "Provisioned agent name for proof derivation — auto-resolved from the agent id when possible; pass only to override")
     .option("--json", "Output JSON instead of human-readable text")
     .action(async (idOrName, opts) => {
     try {
+        // `agentsCmd` (the parent `agents` command) ALSO defines `--org` (for
+        // `mnemom agents --org <id>` list-scoping). Commander@12 binds a flag
+        // shared by a parent and a subcommand to whichever of the two owns it
+        // and runs first in the parse chain — here that's the parent — so
+        // `agents claim <id> --org <slug>` had its --org silently swallowed by
+        // `agentsCmd` before this subcommand's own `--org` option ever saw it
+        // (MNE-2496: confirmed live, the agent always landed in the caller's
+        // personal org regardless of --org). Same shadow class as the global
+        // `--agent` fix at MNE-238 (see the `advisories list`/`show` actions
+        // below) — resolve the local value first, falling back to the
+        // parent's captured value so either parse order still works.
+        const org = opts.org ?? agentsCmd.opts().org;
         await agentsClaimCommand(idOrName, {
-            org: opts.org,
+            org,
             key: opts.key,
             hashProof: opts.hashProof,
             name: opts.name,
@@ -438,6 +666,21 @@ agentsCmd
         process.exit(1);
     }
 });
+agentsCmd
+    .command("move <id-or-name>")
+    .description("Move an agent to another org — requires owner/admin in BOTH the current and destination org " +
+    "(role-based; no agent key needed, unlike re-claim)")
+    .option("--to <slug-or-id>", "Destination org (required; never defaults to the active org)")
+    .option("--json", "Output JSON instead of human-readable text")
+    .action(async (idOrName, opts) => {
+    try {
+        await agentsMoveCommand(idOrName, { to: opts.to, json: opts.json });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
 // ============================================================================
 // Organization management (ADR-044, Piece 1 of T1-3.1)
 // ============================================================================
@@ -457,6 +700,21 @@ orgCmd
         process.exit(1);
     }
 });
+orgCmd
+    .command("use [slug-or-id]")
+    .description("Set the ACTIVE org — the default for org-scoped commands like `agents claim` " +
+    "(login binds no org; without this, claims land in your personal org). " +
+    "No argument shows the current setting.")
+    .option("--clear", "Forget the active org (org-scoped commands revert to your personal org)")
+    .action(async (slugOrId, options) => {
+    try {
+        await orgUseCommand(slugOrId, { clear: options.clear });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
 orgCmd
     .command("show [org_id]")
     .description("Show details of an org (default: your personal org if --personal, else single membership)")
@@ -1060,7 +1318,8 @@ postureCmd
 // ============================================================================
 program
     .command("login")
-    .description("Authenticate with your Mnemom account")
+    .description("Authenticate with your Mnemom account (note: login binds no org — set a default " +
+    "for org-scoped commands with `mnemom org use <slug>`)")
     .option("--no-browser", "Use the device code flow instead of opening a browser")
     .action(async (options) => {
     try {
@@ -1443,6 +1702,55 @@ program
         process.exit(1);
     }
 });
+// ============================================================================
+// Usage attribution (MNE-3215 W6 / issue #1221)
+//
+// `mnemom usage --org <id>` shows per-person token and request consumption
+// for an org window. Gated by USAGE_ATTRIBUTION_API_ENABLED on the API side
+// (defaults off in every environment). Reports consumption only — no currency,
+// no spend, no cost.
+//
+// Every flag below maps 1:1 onto a query parameter the endpoint documents in
+// the API's `openapi.json` (`days`, `person_id`, `provider`, `model`, `limit`,
+// `cursor`). It is deliberately not a friendlier invented vocabulary: the first
+// version of this command offered `--period` and `--page`, neither of which the
+// endpoint accepts, so the server silently ignored both and returned an
+// unfiltered first page.
+// ============================================================================
+program
+    .command("usage")
+    .description("Show per-person token and request consumption for an org")
+    .requiredOption("--org <id>", "Org ID to show consumption for")
+    .option("--days <7|30|90>", "Reporting window in days (default: 30)")
+    .option("--person <id>", "Filter to one person's consumption")
+    .option("--provider <name>", "Filter to one provider")
+    .option("--model <name>", "Filter to one model")
+    .option("--limit <n>", "Max rows per page (default: 100, max 200)")
+    .option("--cursor <cursor>", "Continue from a previous page's cursor")
+    .option("--json", "Emit raw JSON instead of rendered output")
+    .action(async (options) => {
+    try {
+        // A miskeyed numeric flag (e.g. `--limit foo`, `--limit 2abc`,
+        // `--limit 0`, `--days 45`) warns and falls back to the default rather
+        // than silently acting on a value the user did not type. Both live in
+        // commands/usage.ts so their reject-and-warn arms are unit-testable
+        // without driving Commander.
+        await usageCommand({
+            org: options.org,
+            days: parseDaysFlag(options.days),
+            person: options.person,
+            provider: options.provider,
+            model: options.model,
+            limit: parseNumericFlag("--limit", options.limit),
+            cursor: options.cursor,
+            json: options.json,
+        });
+    }
+    catch (error) {
+        console.error("Error:", error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
 // Export the fully-assembled commander program so tooling (e.g. the
 // command-tree snapshot generator in scripts/gen-command-tree.mjs) can
 // statically introspect the command surface WITHOUT executing the CLI.

package/dist/lib/agent-config.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Agent identity config store — ~/.mnemom/agent.json.
+ *
+ * Persists the calling agent's resolved identity so skill verbs (try-me,
+ * onboard, wrap) write on first success and read thereafter — no re-prompt for
+ * identity on subsequent invocations (MNE-937).
+ *
+ * Co-located with auth.ts → auth.json. Separate by design: auth.json holds
+ * bearer credentials (wiped on logout); agent.json holds identity metadata
+ * that survives re-login and provider key rotation.
+ */
+export interface AgentConfig {
+    agent_id?: string;
+    agent_name?: string;
+    org_id?: string;
+    gateway_url?: string;
+}
+/** Load the agent config; a missing or corrupt file returns `{}`. */
+export declare function loadAgentConfig(): AgentConfig;
+/** Persist the full agent config (replaces the file). */
+export declare function saveAgentConfig(config: AgentConfig): void;
+/** Shallow-merge `partial` into the existing config and persist. */
+export declare function mergeAgentConfig(partial: Partial<AgentConfig>): void;
+export declare function getAgentId(): string | undefined;
+export declare function getAgentName(): string | undefined;
+export declare function getOrgId(): string | undefined;
+export declare function getGatewayUrl(): string | undefined;

package/dist/lib/agent-config.js

@@ -0,0 +1,86 @@
+/**
+ * Agent identity config store — ~/.mnemom/agent.json.
+ *
+ * Persists the calling agent's resolved identity so skill verbs (try-me,
+ * onboard, wrap) write on first success and read thereafter — no re-prompt for
+ * identity on subsequent invocations (MNE-937).
+ *
+ * Co-located with auth.ts → auth.json. Separate by design: auth.json holds
+ * bearer credentials (wiped on logout); agent.json holds identity metadata
+ * that survives re-login and provider key rotation.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { MNEMOM_DIR } from "./config.js";
+function agentFile() {
+    return path.join(MNEMOM_DIR, "agent.json");
+}
+/** Load the agent config; a missing or corrupt file returns `{}`. */
+export function loadAgentConfig() {
+    try {
+        if (!fs.existsSync(agentFile()))
+            return {};
+        const parsed = JSON.parse(fs.readFileSync(agentFile(), "utf-8"));
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeAgentConfig(config) {
+    if (!fs.existsSync(MNEMOM_DIR)) {
+        // 0700 to match the auth store — the directory holds credentials.
+        fs.mkdirSync(MNEMOM_DIR, { recursive: true, mode: 0o700 });
+    }
+    const resolvedPath = path.resolve(agentFile());
+    const tmpFile = `${resolvedPath}.${process.pid}.tmp`;
+    // Write-then-rename for atomicity; 0600 owner-only to match the auth store posture.
+    try {
+        fs.writeFileSync(tmpFile, JSON.stringify(config, null, 2), { mode: 0o600 });
+        try {
+            fs.chmodSync(tmpFile, 0o600);
+        }
+        catch {
+            /* best effort on platforms without POSIX perms */
+        }
+        fs.renameSync(tmpFile, resolvedPath);
+    }
+    catch (err) {
+        // Don't leave a partially-written `${pid}.tmp` sibling behind on a failed
+        // write/rename — best-effort unlink, then re-throw the original error.
+        try {
+            fs.unlinkSync(tmpFile);
+        }
+        catch {
+            /* the tmp file may not have been created — nothing to clean up */
+        }
+        throw err;
+    }
+}
+/** Persist the full agent config (replaces the file). */
+export function saveAgentConfig(config) {
+    writeAgentConfig(config);
+}
+/** Shallow-merge `partial` into the existing config and persist. */
+export function mergeAgentConfig(partial) {
+    const current = loadAgentConfig();
+    const next = { ...current };
+    for (const key of Object.keys(partial)) {
+        if (partial[key] !== undefined) {
+            next[key] = partial[key];
+        }
+    }
+    writeAgentConfig(next);
+}
+export function getAgentId() {
+    return loadAgentConfig().agent_id;
+}
+export function getAgentName() {
+    return loadAgentConfig().agent_name;
+}
+export function getOrgId() {
+    return loadAgentConfig().org_id;
+}
+export function getGatewayUrl() {
+    return loadAgentConfig().gateway_url;
+}