@ouro.bot/cli 0.1.0-alpha.2 → 0.1.0-alpha.21

package/dist/heart/daemon/specialist-tools.js

@@ -0,0 +1,237 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSpecialistTools = getSpecialistTools;
+exports.createSpecialistExecTool = createSpecialistExecTool;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const tools_base_1 = require("../../repertoire/tools-base");
+const hatch_flow_1 = require("./hatch-flow");
+const hatch_animation_1 = require("./hatch-animation");
+const bundle_manifest_1 = require("../../mind/bundle-manifest");
+const runtime_1 = require("../../nerves/runtime");
+const completeAdoptionTool = {
+    type: "function",
+    function: {
+        name: "complete_adoption",
+        description: "finalize the agent bundle and hatch the new agent. call this only when you have written all 5 psyche files and agent.json to the temp directory, and the human has approved the bundle.",
+        parameters: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "the PascalCase name for the new agent (e.g. 'Slugger')",
+                },
+                handoff_message: {
+                    type: "string",
+                    description: "a warm handoff message to display to the human after the agent is hatched",
+                },
+            },
+            required: ["name", "handoff_message"],
+        },
+    },
+};
+const readFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "read_file");
+const writeFileTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "write_file");
+const listDirTool = tools_base_1.baseToolDefinitions.find((d) => d.tool.function.name === "list_directory");
+/**
+ * Returns the specialist's tool schema array.
+ */
+function getSpecialistTools() {
+    return [completeAdoptionTool, tools_base_1.finalAnswerTool, readFileTool.tool, writeFileTool.tool, listDirTool.tool];
+}
+const PSYCHE_FILES = ["SOUL.md", "IDENTITY.md", "LORE.md", "TACIT.md", "ASPIRATIONS.md"];
+function isPascalCase(name) {
+    return /^[A-Z][a-zA-Z0-9]*$/.test(name);
+}
+function writeReadme(dir, purpose) {
+    fs.mkdirSync(dir, { recursive: true });
+    const readmePath = path.join(dir, "README.md");
+    /* v8 ignore next -- defensive: guard against re-scaffold on existing bundle @preserve */
+    if (!fs.existsSync(readmePath)) {
+        fs.writeFileSync(readmePath, `# ${path.basename(dir)}\n\n${purpose}\n`, "utf-8");
+    }
+}
+function scaffoldBundle(bundleRoot) {
+    writeReadme(path.join(bundleRoot, "memory"), "Persistent memory store.");
+    writeReadme(path.join(bundleRoot, "memory", "daily"), "Daily memory entries.");
+    writeReadme(path.join(bundleRoot, "memory", "archive"), "Archived memory.");
+    writeReadme(path.join(bundleRoot, "friends"), "Known friend records.");
+    writeReadme(path.join(bundleRoot, "tasks"), "Task files.");
+    writeReadme(path.join(bundleRoot, "tasks", "habits"), "Recurring tasks.");
+    writeReadme(path.join(bundleRoot, "tasks", "one-shots"), "One-shot tasks.");
+    writeReadme(path.join(bundleRoot, "tasks", "ongoing"), "Ongoing tasks.");
+    writeReadme(path.join(bundleRoot, "skills"), "Local skill files.");
+    writeReadme(path.join(bundleRoot, "senses"), "Sense-specific config.");
+    writeReadme(path.join(bundleRoot, "senses", "teams"), "Teams sense config.");
+    // Memory scaffold files
+    const memoryRoot = path.join(bundleRoot, "memory");
+    const factsPath = path.join(memoryRoot, "facts.jsonl");
+    const entitiesPath = path.join(memoryRoot, "entities.json");
+    /* v8 ignore next -- defensive: guard against re-scaffold on existing bundle @preserve */
+    if (!fs.existsSync(factsPath))
+        fs.writeFileSync(factsPath, "", "utf-8");
+    /* v8 ignore next -- defensive: guard against re-scaffold on existing bundle @preserve */
+    if (!fs.existsSync(entitiesPath))
+        fs.writeFileSync(entitiesPath, "{}\n", "utf-8");
+    // bundle-meta.json
+    const meta = (0, bundle_manifest_1.createBundleMeta)();
+    fs.writeFileSync(path.join(bundleRoot, "bundle-meta.json"), JSON.stringify(meta, null, 2) + "\n", "utf-8");
+}
+function moveDir(src, dest) {
+    try {
+        fs.renameSync(src, dest);
+    }
+    catch {
+        /* v8 ignore start -- cross-device fallback: only triggers on EXDEV (e.g. /tmp → different mount), untestable in CI @preserve */
+        fs.cpSync(src, dest, { recursive: true });
+        fs.rmSync(src, { recursive: true, force: true });
+        /* v8 ignore stop */
+    }
+}
+async function execCompleteAdoption(args, deps) {
+    const name = args.name;
+    const handoffMessage = args.handoff_message;
+    if (!name) {
+        return "error: missing required 'name' parameter";
+    }
+    if (!isPascalCase(name)) {
+        return `error: name '${name}' must be PascalCase (e.g. 'Slugger', 'MyAgent')`;
+    }
+    // Validate psyche files exist
+    const psycheDir = path.join(deps.tempDir, "psyche");
+    const missingPsyche = PSYCHE_FILES.filter((f) => !fs.existsSync(path.join(psycheDir, f)));
+    if (missingPsyche.length > 0) {
+        return `error: missing psyche files in temp directory: ${missingPsyche.join(", ")}. write them first using write_file.`;
+    }
+    // Validate agent.json exists
+    const agentJsonPath = path.join(deps.tempDir, "agent.json");
+    if (!fs.existsSync(agentJsonPath)) {
+        return "error: agent.json not found in temp directory. write it first using write_file.";
+    }
+    // Validate target doesn't exist
+    const targetBundle = path.join(deps.bundlesRoot, `${name}.ouro`);
+    if (fs.existsSync(targetBundle)) {
+        return `error: bundle '${name}.ouro' already exists at ${deps.bundlesRoot}. choose a different name.`;
+    }
+    // Scaffold structural dirs into tempDir
+    scaffoldBundle(deps.tempDir);
+    // Move tempDir -> final bundle location
+    moveDir(deps.tempDir, targetBundle);
+    // Write secrets
+    try {
+        (0, hatch_flow_1.writeSecretsFile)(name, deps.provider, deps.credentials, deps.secretsRoot);
+    }
+    catch (e) {
+        // Rollback: remove the moved bundle
+        try {
+            fs.rmSync(targetBundle, { recursive: true, force: true });
+        }
+        catch {
+            // Best effort cleanup
+        }
+        return `error: failed to write secrets: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive: non-Error catch branch @preserve */ String(e)}`;
+    }
+    // Play hatch animation
+    await (0, hatch_animation_1.playHatchAnimation)(name, deps.animationWriter);
+    // Display handoff message
+    /* v8 ignore next -- UI-only: handoff message display, covered by integration @preserve */
+    if (handoffMessage && deps.animationWriter) {
+        deps.animationWriter(`\n${handoffMessage}\n`);
+    }
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.adoption_complete",
+        message: "adoption completed successfully",
+        meta: { agentName: name, bundlePath: targetBundle },
+    });
+    return JSON.stringify({ success: true, agentName: name, bundlePath: targetBundle });
+}
+/**
+ * Create a specialist tool executor with the given dependencies captured in closure.
+ */
+function createSpecialistExecTool(deps) {
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.specialist_exec_tool_created",
+        message: "specialist exec tool created",
+        meta: { tempDir: deps.tempDir },
+    });
+    return async (name, args) => {
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.specialist_tool_exec",
+            message: "executing specialist tool",
+            meta: { tool: name },
+        });
+        if (name === "complete_adoption") {
+            return execCompleteAdoption(args, deps);
+        }
+        if (name === "read_file") {
+            try {
+                return fs.readFileSync(args.path, "utf-8");
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive @preserve */ String(e)}`;
+            }
+        }
+        if (name === "write_file") {
+            try {
+                const dir = path.dirname(args.path);
+                fs.mkdirSync(dir, { recursive: true });
+                const content = typeof args.content === "string"
+                    ? args.content
+                    : JSON.stringify(args.content, null, 2);
+                fs.writeFileSync(args.path, content, "utf-8");
+                return `wrote ${args.path}`;
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive @preserve */ String(e)}`;
+            }
+        }
+        if (name === "list_directory") {
+            try {
+                return fs
+                    .readdirSync(args.path, { withFileTypes: true })
+                    .map((e) => `${e.isDirectory() ? "d" : "-"}  ${e.name}`)
+                    .join("\n");
+            }
+            catch (e) {
+                return `error: ${e instanceof Error ? e.message : /* v8 ignore next -- defensive @preserve */ String(e)}`;
+            }
+        }
+        return `error: unknown tool '${name}'`;
+    };
+}

package/dist/heart/daemon/subagent-installer.js

@@ -55,9 +55,18 @@ function listSubagentSources(subagentsDir) {
         .map((name) => path.join(subagentsDir, name))
         .sort((a, b) => a.localeCompare(b));
 }
+function pathExists(target) {
+    try {
+        fs.lstatSync(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 function ensureSymlink(source, target) {
     fs.mkdirSync(path.dirname(target), { recursive: true });
-    if (fs.existsSync(target)) {
+    if (pathExists(target)) {
         const stats = fs.lstatSync(target);
         if (stats.isSymbolicLink()) {
             const linkedPath = fs.readlinkSync(target);

package/dist/heart/daemon/wrapper-publish-guard.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assessWrapperPublishSync = assessWrapperPublishSync;
+const runtime_1 = require("../../nerves/runtime");
+function wrapperPackageChanged(changedFiles) {
+    return changedFiles.some((file) => file.startsWith("packages/ouro.bot/"));
+}
+function assessWrapperPublishSync(input) {
+    let result;
+    if (!wrapperPackageChanged(input.changedFiles)) {
+        result = {
+            ok: true,
+            message: "wrapper package unchanged",
+        };
+        (0, runtime_1.emitNervesEvent)({
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: { changed: false, localVersion: input.localVersion, publishedVersion: input.publishedVersion, ok: result.ok },
+        });
+        return result;
+    }
+    if (input.publishedVersion === input.localVersion) {
+        result = {
+            ok: false,
+            message: `ouro.bot wrapper changed but ouro.bot@${input.localVersion} is already published; bump packages/ouro.bot/package.json before merging`,
+        };
+        (0, runtime_1.emitNervesEvent)({
+            level: "warn",
+            component: "daemon",
+            event: "daemon.wrapper_publish_guard_checked",
+            message: "evaluated wrapper publish sync",
+            meta: { changed: true, localVersion: input.localVersion, publishedVersion: input.publishedVersion, ok: result.ok },
+        });
+        return result;
+    }
+    result = {
+        ok: true,
+        message: "wrapper package changed and local wrapper version is unpublished",
+    };
+    (0, runtime_1.emitNervesEvent)({
+        component: "daemon",
+        event: "daemon.wrapper_publish_guard_checked",
+        message: "evaluated wrapper publish sync",
+        meta: { changed: true, localVersion: input.localVersion, publishedVersion: input.publishedVersion, ok: result.ok },
+    });
+    return result;
+}

package/dist/heart/identity.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
+exports.DEFAULT_AGENT_SENSES = exports.DEFAULT_AGENT_PHRASES = exports.DEFAULT_AGENT_CONTEXT = void 0;
 exports.buildDefaultAgentTemplate = buildDefaultAgentTemplate;
 exports.getAgentName = getAgentName;
 exports.getRepoRoot = getRepoRoot;
@@ -42,6 +42,7 @@ exports.getAgentRoot = getAgentRoot;
 exports.getAgentSecretsPath = getAgentSecretsPath;
 exports.loadAgentConfig = loadAgentConfig;
 exports.setAgentName = setAgentName;
+exports.setAgentConfigOverride = setAgentConfigOverride;
 exports.resetIdentity = resetIdentity;
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -56,12 +57,73 @@ exports.DEFAULT_AGENT_PHRASES = {
     tool: ["running tool"],
     followup: ["processing"],
 };
+exports.DEFAULT_AGENT_SENSES = {
+    cli: { enabled: true },
+    teams: { enabled: false },
+    bluebubbles: { enabled: false },
+};
+function normalizeSenses(value, configFile) {
+    const defaults = {
+        cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+    if (value === undefined) {
+        return defaults;
+    }
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        (0, runtime_1.emitNervesEvent)({
+            level: "error",
+            event: "config_identity.error",
+            component: "config/identity",
+            message: "agent config has invalid senses block",
+            meta: { path: configFile },
+        });
+        throw new Error(`agent.json at ${configFile} must include senses as an object when present.`);
+    }
+    const raw = value;
+    const senseNames = ["cli", "teams", "bluebubbles"];
+    for (const senseName of senseNames) {
+        const rawSense = raw[senseName];
+        if (rawSense === undefined) {
+            continue;
+        }
+        if (!rawSense || typeof rawSense !== "object" || Array.isArray(rawSense)) {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense config",
+                meta: { path: configFile, sense: senseName },
+            });
+            throw new Error(`agent.json at ${configFile} has invalid senses.${senseName} config.`);
+        }
+        const enabled = rawSense.enabled;
+        if (typeof enabled !== "boolean") {
+            (0, runtime_1.emitNervesEvent)({
+                level: "error",
+                event: "config_identity.error",
+                component: "config/identity",
+                message: "agent config has invalid sense enabled flag",
+                meta: { path: configFile, sense: senseName, enabled: enabled ?? null },
+            });
+            throw new Error(`agent.json at ${configFile} must include senses.${senseName}.enabled as boolean.`);
+        }
+        defaults[senseName] = { enabled };
+    }
+    return defaults;
+}
 function buildDefaultAgentTemplate(_agentName) {
     return {
         version: 1,
         enabled: true,
         provider: "anthropic",
         context: { ...exports.DEFAULT_AGENT_CONTEXT },
+        senses: {
+            cli: { ...exports.DEFAULT_AGENT_SENSES.cli },
+            teams: { ...exports.DEFAULT_AGENT_SENSES.teams },
+            bluebubbles: { ...exports.DEFAULT_AGENT_SENSES.bluebubbles },
+        },
         phrases: {
             thinking: [...exports.DEFAULT_AGENT_PHRASES.thinking],
             tool: [...exports.DEFAULT_AGENT_PHRASES.tool],
@@ -71,6 +133,7 @@ function buildDefaultAgentTemplate(_agentName) {
 }
 let _cachedAgentName = null;
 let _cachedAgentConfig = null;
+let _agentConfigOverride = null;
 /**
  * Parse `--agent <name>` from process.argv.
  * Caches the result after first parse.
@@ -131,6 +194,9 @@ function getAgentSecretsPath(agentName = getAgentName()) {
  * Throws descriptive error if file is missing or contains invalid JSON.
  */
 function loadAgentConfig() {
+    if (_agentConfigOverride) {
+        return _agentConfigOverride;
+    }
     if (_cachedAgentConfig) {
         (0, runtime_1.emitNervesEvent)({
             event: "identity.resolve",
@@ -252,6 +318,7 @@ function loadAgentConfig() {
         provider: rawProvider,
         context: parsed.context,
         logging: parsed.logging,
+        senses: normalizeSenses(parsed.senses, configFile),
         phrases: parsed.phrases,
     };
     (0, runtime_1.emitNervesEvent)({
@@ -271,6 +338,14 @@ function loadAgentConfig() {
 function setAgentName(name) {
     _cachedAgentName = name;
 }
+/**
+ * Override the agent config returned by loadAgentConfig().
+ * When set to a non-null AgentConfig, loadAgentConfig() returns the override
+ * instead of reading from disk. When set to null, normal disk-based loading resumes.
+ */
+function setAgentConfigOverride(config) {
+    _agentConfigOverride = config;
+}
 /**
  * Clear all cached identity state.
  * Used in tests and when switching agent context.
@@ -278,4 +353,5 @@ function setAgentName(name) {
 function resetIdentity() {
     _cachedAgentName = null;
     _cachedAgentConfig = null;
+    _agentConfigOverride = null;
 }

package/dist/heart/providers/anthropic.js

@@ -8,6 +8,7 @@ const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
 const config_1 = require("../config");
 const identity_1 = require("../identity");
 const runtime_1 = require("../../nerves/runtime");
+const streaming_1 = require("../streaming");
 const ANTHROPIC_SETUP_TOKEN_PREFIX = "sk-ant-oat01-";
 const ANTHROPIC_SETUP_TOKEN_MIN_LENGTH = 80;
 const ANTHROPIC_OAUTH_BETA_HEADER = "claude-code-20250219,oauth-2025-04-20,fine-grained-tool-streaming-2025-05-14,interleaved-thinking-2025-05-14";
@@ -98,6 +99,9 @@ function toAnthropicMessages(messages) {
             }
             if (assistant.tool_calls) {
                 for (const toolCall of assistant.tool_calls) {
+                    /* v8 ignore next -- type narrowing: OpenAI SDK only emits function tool_calls @preserve */
+                    if (toolCall.type !== "function")
+                        continue;
                     blocks.push({
                         type: "tool_use",
                         id: toolCall.id,
@@ -215,6 +219,7 @@ async function streamAnthropicMessages(client, model, request) {
     let streamStarted = false;
     let usage;
     const toolCalls = new Map();
+    const answerStreamer = new streaming_1.FinalAnswerStreamer(request.callbacks);
     try {
         for await (const event of response) {
             if (request.signal?.aborted)
@@ -228,11 +233,17 @@ async function streamAnthropicMessages(client, model, request) {
                     const input = rawInput && typeof rawInput === "object"
                         ? JSON.stringify(rawInput)
                         : "";
+                    const name = String(block.name ?? "");
                     toolCalls.set(index, {
                         id: String(block.id ?? ""),
-                        name: String(block.name ?? ""),
+                        name,
                         arguments: input,
                     });
+                    // Activate eager streaming for sole final_answer tool call
+                    /* v8 ignore next -- final_answer streaming activation, tested via FinalAnswerStreamer unit tests @preserve */
+                    if (name === "final_answer" && toolCalls.size === 1) {
+                        answerStreamer.activate();
+                    }
                 }
                 continue;
             }
@@ -261,7 +272,12 @@ async function streamAnthropicMessages(client, model, request) {
                     const index = Number(event.index);
                     const existing = toolCalls.get(index);
                     if (existing) {
-                        existing.arguments = mergeAnthropicToolArguments(existing.arguments, String(delta?.partial_json ?? ""));
+                        const partialJson = String(delta?.partial_json ?? "");
+                        existing.arguments = mergeAnthropicToolArguments(existing.arguments, partialJson);
+                        /* v8 ignore next -- final_answer delta streaming, tested via FinalAnswerStreamer unit tests @preserve */
+                        if (existing.name === "final_answer" && toolCalls.size === 1) {
+                            answerStreamer.processDelta(partialJson);
+                        }
                     }
                     continue;
                 }
@@ -290,6 +306,7 @@ async function streamAnthropicMessages(client, model, request) {
         toolCalls: [...toolCalls.values()],
         outputItems: [],
         usage,
+        finalAnswerStreamed: answerStreamer.streamed,
     };
 }
 function createAnthropicProviderRuntime() {

package/dist/heart/sense-truth.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSenseInventory = getSenseInventory;
+const runtime_1 = require("../nerves/runtime");
+const identity_1 = require("./identity");
+const SENSES = [
+    { sense: "cli", label: "CLI", daemonManaged: false },
+    { sense: "teams", label: "Teams", daemonManaged: true },
+    { sense: "bluebubbles", label: "BlueBubbles", daemonManaged: true },
+];
+function configuredSenses(senses) {
+    return senses ?? {
+        cli: { ...identity_1.DEFAULT_AGENT_SENSES.cli },
+        teams: { ...identity_1.DEFAULT_AGENT_SENSES.teams },
+        bluebubbles: { ...identity_1.DEFAULT_AGENT_SENSES.bluebubbles },
+    };
+}
+function resolveStatus(enabled, daemonManaged, runtimeInfo) {
+    if (!enabled) {
+        return "disabled";
+    }
+    if (!daemonManaged) {
+        return "interactive";
+    }
+    if (runtimeInfo?.runtime === "error") {
+        return "error";
+    }
+    if (runtimeInfo?.runtime === "running") {
+        return "running";
+    }
+    if (runtimeInfo?.configured === false) {
+        return "needs_config";
+    }
+    return "ready";
+}
+function getSenseInventory(agent, runtime = {}) {
+    const senses = configuredSenses(agent.senses);
+    const inventory = SENSES.map(({ sense, label, daemonManaged }) => {
+        const enabled = senses[sense].enabled;
+        return {
+            sense,
+            label,
+            enabled,
+            daemonManaged,
+            status: resolveStatus(enabled, daemonManaged, runtime[sense]),
+        };
+    });
+    (0, runtime_1.emitNervesEvent)({
+        component: "channels",
+        event: "channel.sense_inventory_built",
+        message: "built sense inventory",
+        meta: {
+            senses: inventory.map((entry) => ({
+                sense: entry.sense,
+                enabled: entry.enabled,
+                status: entry.status,
+            })),
+        },
+    });
+    return inventory;
+}