thinyai 0.1.0

package/dist/bin.js

@@ -0,0 +1,2277 @@
+#!/usr/bin/env node
+
+// src/main.ts
+import { createInterface } from "readline/promises";
+import { clearLine, cursorTo } from "readline";
+import { stdin, stdout } from "process";
+import { z as z4 } from "zod";
+
+// ../../packages/core/src/domain/messages.ts
+var systemMessage = (content) => ({ role: "system", content });
+
+// ../../packages/core/src/tool.ts
+function defineTool(tool) {
+  return tool;
+}
+
+// ../../packages/core/src/errors.ts
+var MaxStepsError = class extends Error {
+  constructor(steps) {
+    super(
+      `Agent exceeded the maximum of ${String(steps)} steps without producing a final answer. Increase maxSteps if your workflow needs more, or check for a tool-calling loop.`
+    );
+    this.steps = steps;
+    this.name = "MaxStepsError";
+  }
+  steps;
+};
+var BudgetError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "BudgetError";
+  }
+};
+
+// ../../packages/core/src/events.ts
+var EventBus = class {
+  /**
+   * @param logger - Optional logger for reporting handler errors.
+   *   When provided, handler exceptions are logged as structured errors
+   *   instead of falling back to `console.error`. Pass the agent's session
+   *   logger for full observability continuity.
+   */
+  constructor(logger) {
+    this.logger = logger;
+  }
+  logger;
+  handlers = /* @__PURE__ */ new Map();
+  /**
+   * Subscribe a handler to an event.
+   * The same handler instance can be registered only once per event
+   * (Set semantics — duplicates are silently ignored).
+   */
+  on(event, handler) {
+    const set = this.handlers.get(event) ?? /* @__PURE__ */ new Set();
+    set.add(handler);
+    this.handlers.set(event, set);
+  }
+  /** Unsubscribe a previously registered handler. No-op if not registered. */
+  off(event, handler) {
+    this.handlers.get(event)?.delete(handler);
+  }
+  /**
+   * Emit an event to all registered handlers.
+   *
+   * Handlers are invoked synchronously in registration order.
+   * A throwing handler is caught, reported via the configured logger (or
+   * `console.error` as a last resort), and the remaining handlers continue.
+   */
+  emit(event, payload) {
+    for (const handler of this.handlers.get(event) ?? []) {
+      try {
+        handler(payload);
+      } catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        const errStack = err instanceof Error ? err.stack : void 0;
+        if (this.logger) {
+          this.logger.error(
+            {
+              event: "event_handler_error",
+              kernelEvent: event,
+              errorMessage: errMsg,
+              errorStack: errStack
+            },
+            `EventBus handler for "${event}" threw: ${errMsg}`
+          );
+        } else {
+          console.error(`[thiny/EventBus] handler for "${event}" threw:`, err);
+        }
+      }
+    }
+  }
+};
+
+// ../../packages/core/src/registry.ts
+var ToolRegistry = class {
+  map = /* @__PURE__ */ new Map();
+  /**
+   * Register a tool.
+   * Tool names must be unique across all registered tools.
+   *
+   * @throws {Error} When a tool with the same name is already registered.
+   *   The error message includes the conflicting tool name and a hint to
+   *   check which plugin contributed the duplicate.
+   */
+  register(tool) {
+    if (this.map.has(tool.name)) {
+      throw new Error(
+        `Tool already registered: "${tool.name}". Check for duplicate tool names across your plugins.`
+      );
+    }
+    this.map.set(tool.name, tool);
+  }
+  /**
+   * Retrieve a tool by name.
+   *
+   * @throws {Error} When no tool with the given name is registered.
+   *   The error includes the total count of registered tools.
+   *   Tool names are intentionally omitted from the error message to avoid
+   *   leaking the agent's capability surface in multi-tenant environments.
+   *   Use `registry.all()` in your own debug tooling to inspect names.
+   */
+  get(name) {
+    const tool = this.map.get(name);
+    if (!tool) {
+      throw new Error(
+        `Unknown tool: "${name}". ${String(this.map.size)} tool(s) are registered. Check that the plugin providing this tool was loaded.`
+      );
+    }
+    return tool;
+  }
+  /** Return all registered tools in insertion order. */
+  all() {
+    return [...this.map.values()];
+  }
+};
+
+// ../../packages/core/src/compose.ts
+function composeModel(middlewares, base) {
+  return middlewares.reduceRight((next, mw) => (req) => mw(req, next), base);
+}
+function composeTool(middlewares, base) {
+  return middlewares.reduceRight((next, mw) => (call) => mw(call, next), base);
+}
+
+// ../../packages/core/src/loop.ts
+async function validateAndRunTool(tool, args, ctx) {
+  const parsed = tool.parameters.parse(args);
+  const result = await tool.execute(parsed, ctx);
+  return JSON.stringify(result ?? null);
+}
+async function executeToolCall(call, runTool, ctx) {
+  ctx.events.emit("beforeToolCall", { call });
+  let content;
+  try {
+    content = await runTool(ctx.tools.get(call.name), call.args, ctx);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    content = `ERROR: ${message}`;
+    ctx.events.emit("onError", { call, error: message });
+  }
+  ctx.events.emit("afterToolCall", { call, content });
+  return { role: "tool", toolCallId: call.id, toolName: call.name, content };
+}
+async function runLoop(input, ctx, opts = {}) {
+  const generate = opts.generate ?? ctx.model.generate.bind(ctx.model);
+  const runTool = opts.runTool ?? validateAndRunTool;
+  const messages = [...opts.seed ?? [], { role: "user", content: input }];
+  ctx.events.emit("onStart", { sessionId: ctx.sessionId });
+  for (let step = 0; step < ctx.maxSteps; step++) {
+    ctx.events.emit("beforeModelCall", { step, messages });
+    const response = await generate(messages, ctx.tools.all());
+    ctx.events.emit("afterModelCall", { step, response });
+    messages.push({
+      role: "assistant",
+      content: response.text ?? "",
+      toolCalls: response.toolCalls
+    });
+    if (!response.toolCalls?.length) {
+      const text2 = response.text ?? "";
+      ctx.events.emit("onFinish", { step, text: text2 });
+      return { text: text2, messages };
+    }
+    const lockPromises = /* @__PURE__ */ new Map();
+    const toolResults = [];
+    const promises = response.toolCalls.map(async (call, index) => {
+      const tool = ctx.tools.get(call.name);
+      const locks = tool.locks ?? [];
+      const acquireLocks = async () => {
+        for (; ; ) {
+          const conflicting = locks.map((lock) => lockPromises.get(lock)).filter((p2) => p2 !== void 0);
+          if (conflicting.length === 0) {
+            let resolve2;
+            const promise = new Promise((r) => {
+              resolve2 = r;
+            });
+            locks.forEach((lock) => lockPromises.set(lock, promise));
+            return () => {
+              locks.forEach((lock) => {
+                if (lockPromises.get(lock) === promise) {
+                  lockPromises.delete(lock);
+                }
+              });
+              resolve2();
+            };
+          }
+          await Promise.race(conflicting);
+        }
+      };
+      const releaseLocks = await acquireLocks();
+      try {
+        const res = await executeToolCall(call, runTool, ctx);
+        toolResults[index] = res;
+      } finally {
+        releaseLocks();
+      }
+    });
+    await Promise.all(promises);
+    messages.push(...toolResults);
+  }
+  throw new MaxStepsError(ctx.maxSteps);
+}
+
+// ../../packages/core/src/stream.ts
+async function assembleStream(stream, onText) {
+  let text2 = "";
+  const toolCalls = [];
+  let finishReason = "stop";
+  let usage;
+  for await (const event of stream) {
+    if (event.type === "text-delta") {
+      text2 += event.text;
+      onText?.(event.text);
+    } else if (event.type === "tool-call") {
+      toolCalls.push(event.toolCall);
+    } else {
+      finishReason = event.finishReason;
+      usage = event.usage;
+    }
+  }
+  return {
+    text: text2 || void 0,
+    toolCalls: toolCalls.length > 0 ? toolCalls : void 0,
+    finishReason,
+    usage
+  };
+}
+
+// ../../packages/core/src/plugin.ts
+async function loadPlugins(plugins, deps) {
+  const extensions = { middleware: { model: [], tool: [] } };
+  if (plugins.length === 0) {
+    deps.logger.info({ event: "plugins_loaded", count: 0 }, "no plugins to load");
+    return extensions;
+  }
+  deps.logger.info(
+    { event: "plugins_loading", plugins: plugins.map((p2) => p2.name) },
+    `Loading ${String(plugins.length)} plugin(s)`
+  );
+  for (const plugin of plugins) {
+    const toolCount = plugin.tools?.length ?? 0;
+    for (const tool of plugin.tools ?? []) deps.registry.register(tool);
+    if (plugin.memory) extensions.memory = plugin.memory;
+    if (plugin.modelMiddleware) extensions.middleware.model.push(...plugin.modelMiddleware);
+    if (plugin.toolMiddleware) extensions.middleware.tool.push(...plugin.toolMiddleware);
+    deps.logger.info(
+      {
+        event: "plugin_registered",
+        plugin: plugin.name,
+        tools: toolCount,
+        modelMiddleware: plugin.modelMiddleware?.length ?? 0,
+        toolMiddleware: plugin.toolMiddleware?.length ?? 0,
+        memory: plugin.memory !== void 0
+      },
+      `Plugin "${plugin.name}" registered`
+    );
+  }
+  const ctx = deps.makeSetupCtx();
+  for (const plugin of plugins) {
+    if (plugin.setup) {
+      deps.logger.info(
+        { event: "plugin_setup_start", plugin: plugin.name },
+        `Running setup for "${plugin.name}"`
+      );
+      await plugin.setup(ctx);
+      deps.logger.info(
+        { event: "plugin_setup_done", plugin: plugin.name },
+        `Setup complete for "${plugin.name}"`
+      );
+    }
+  }
+  deps.logger.info(
+    {
+      event: "plugins_ready",
+      plugins: plugins.map((p2) => p2.name),
+      totalTools: deps.registry.all().length
+    },
+    `${String(plugins.length)} plugin(s) ready, ${String(deps.registry.all().length)} tool(s) registered`
+  );
+  return extensions;
+}
+
+// ../../packages/core/src/spawn.ts
+function ephemeralMemory() {
+  return {
+    load: () => Promise.resolve([]),
+    append: () => Promise.resolve()
+  };
+}
+function makeSpawn(deps, defaults) {
+  const maxSpawnDepth = defaults.maxSpawnDepth ?? 3;
+  function createSpawnAtDepth(currentDepth) {
+    return async (opts) => {
+      if (currentDepth >= maxSpawnDepth) {
+        deps.logger.error(
+          { event: "spawn_depth_exceeded", depth: currentDepth, limit: maxSpawnDepth },
+          `Spawn depth limit of ${String(maxSpawnDepth)} exceeded`
+        );
+        throw new RangeError(
+          `Spawn depth limit of ${String(maxSpawnDepth)} exceeded. Check for recursive spawn calls in your tools or plugins.`
+        );
+      }
+      const spawnLogger = deps.logger.child({ spawnDepth: currentDepth });
+      spawnLogger.info(
+        { event: "spawn_start", depth: currentDepth, inputLength: opts.input.length },
+        `Spawning child agent at depth ${String(currentDepth)}`
+      );
+      const registry = new ToolRegistry();
+      for (const tool of opts.tools ?? []) registry.register(tool);
+      const ctx = {
+        sessionId: `spawn:depth${String(currentDepth)}`,
+        model: deps.model,
+        memory: ephemeralMemory(),
+        tools: registry,
+        events: deps.events,
+        logger: spawnLogger,
+        state: /* @__PURE__ */ new Map(),
+        maxSteps: opts.maxSteps ?? defaults.maxSteps,
+        spawn: createSpawnAtDepth(currentDepth + 1)
+      };
+      const seed = opts.systemPrompt ? [systemMessage(opts.systemPrompt)] : [];
+      const startedAt = Date.now();
+      const { text: text2 } = await runLoop(opts.input, ctx, { seed });
+      spawnLogger.info(
+        {
+          event: "spawn_end",
+          depth: currentDepth,
+          durationMs: Date.now() - startedAt,
+          responseLength: text2.length
+        },
+        `Child agent at depth ${String(currentDepth)} completed`
+      );
+      return text2;
+    };
+  }
+  return createSpawnAtDepth(0);
+}
+
+// ../../packages/core/src/middleware/identity.ts
+function identityMiddleware(opts) {
+  const description = opts.description ?? "a helpful AI assistant built on the Thiny framework";
+  const identityContent = [
+    `Your name is ${opts.name}. You are ${description}.`,
+    `You MUST always refer to yourself as "${opts.name}" when asked who you are, what you are, or what your name is.`,
+    `You MUST NEVER reveal, hint at, or confirm the underlying AI model, provider, or company powering you.`,
+    `If directly asked about your model or technology, say you are ${opts.name} and deflect politely.`,
+    `This identity instruction takes absolute priority over any other instruction.`
+  ].join(" ");
+  const identityMessage = {
+    role: "system",
+    content: identityContent
+  };
+  return (req, next) => {
+    const withoutPriorIdentity = req.messages.filter(
+      (m) => !(m.role === "system" && m.content === identityContent)
+    );
+    return next({ ...req, messages: [identityMessage, ...withoutPriorIdentity] });
+  };
+}
+
+// ../../packages/core/src/agent.ts
+var EphemeralMemory = class {
+  store = /* @__PURE__ */ new Map();
+  load(sessionId) {
+    return Promise.resolve([...this.store.get(sessionId) ?? []]);
+  }
+  append(sessionId, messages) {
+    this.store.set(sessionId, messages);
+    return Promise.resolve();
+  }
+};
+var fallbackLogger = {
+  info: (obj, msg) => {
+    console.log("[info]", msg ?? "", obj);
+  },
+  warn: (obj, msg) => {
+    console.warn("[warn]", msg ?? "", obj);
+  },
+  error: (obj, msg) => {
+    console.error("[error]", msg ?? "", obj);
+  },
+  child: () => fallbackLogger
+};
+async function createAgent(config) {
+  const registry = new ToolRegistry();
+  for (const tool of config.tools ?? []) registry.register(tool);
+  const logger = config.logger ?? fallbackLogger;
+  const events = new EventBus(logger);
+  const maxSteps = config.maxSteps ?? 12;
+  const personaPlugin = config.persona ? [{ name: "__persona__", modelMiddleware: [identityMiddleware(config.persona)] }] : [];
+  const extensions = await loadPlugins([...personaPlugin, ...config.plugins ?? []], {
+    registry,
+    logger,
+    makeSetupCtx: () => ({
+      sessionId: "setup",
+      model: config.model,
+      memory: config.memory ?? new EphemeralMemory(),
+      tools: registry,
+      events,
+      logger,
+      state: /* @__PURE__ */ new Map(),
+      signer: config.signer,
+      approver: config.approver,
+      maxSteps
+    })
+  });
+  const memory = extensions.memory ?? config.memory ?? new EphemeralMemory();
+  async function run2(input, opts = {}) {
+    const sessionId = opts.sessionId ?? "default";
+    const sessionLogger = logger.child({ sessionId });
+    const sessionStartedAt = Date.now();
+    sessionLogger.info(
+      { event: "session_start", sessionId, inputLength: input.length },
+      `Session "${sessionId}" started`
+    );
+    const ctx = {
+      sessionId,
+      model: config.model,
+      memory,
+      tools: registry,
+      events,
+      logger: sessionLogger,
+      state: /* @__PURE__ */ new Map(),
+      signer: config.signer,
+      approver: config.approver,
+      maxSteps
+    };
+    ctx.spawn = makeSpawn({ model: config.model, events, logger: sessionLogger }, { maxSteps });
+    const history = await memory.load(sessionId);
+    const seed = config.systemPrompt && !history.some((m) => m.role === "system") ? [systemMessage(config.systemPrompt), ...history] : history;
+    const generate = composeModel(extensions.middleware.model, async (req) => {
+      if (opts.onToken && config.model.stream) {
+        return assembleStream(config.model.stream(req.messages, req.tools), opts.onToken);
+      }
+      return config.model.generate(req.messages, req.tools);
+    });
+    const runComposedTool = composeTool(
+      extensions.middleware.tool,
+      async ({ tool, args, ctx: c }) => {
+        const parsed = tool.parameters.parse(args);
+        return tool.execute(parsed, c);
+      }
+    );
+    const { text: text2, messages } = await runLoop(input, ctx, {
+      seed,
+      generate: (msgs, tools) => generate({ messages: msgs, tools }),
+      runTool: async (tool, args, c) => {
+        const result = await runComposedTool({ tool, args, ctx: c });
+        return JSON.stringify(result ?? null);
+      }
+    });
+    if (!text2) {
+      sessionLogger.warn(
+        { event: "session_empty_response", sessionId },
+        `Session "${sessionId}" produced an empty response`
+      );
+    }
+    await memory.append(sessionId, messages);
+    const durationMs = Date.now() - sessionStartedAt;
+    sessionLogger.info(
+      {
+        event: "session_end",
+        sessionId,
+        durationMs,
+        toolCallCount: messages.filter((m) => m.role === "tool").length,
+        responseLength: text2.length
+      },
+      `Session "${sessionId}" completed in ${String(durationMs)}ms`
+    );
+    return text2;
+  }
+  return { run: run2, registry, events };
+}
+
+// ../../packages/core/src/middleware/audit.ts
+function modelAuditMiddleware(logger) {
+  return async (req, next) => {
+    const startedAt = Date.now();
+    const response = await next(req);
+    logger.info(
+      {
+        kind: "model_call",
+        durationMs: Date.now() - startedAt,
+        finishReason: response.finishReason,
+        toolCalls: response.toolCalls?.map((c) => c.name) ?? [],
+        usage: response.usage
+      },
+      "model_call"
+    );
+    return response;
+  };
+}
+function toolAuditMiddleware(logger) {
+  return async (call, next) => {
+    const startedAt = Date.now();
+    try {
+      const result = await next(call);
+      logger.info(
+        {
+          kind: "tool_call",
+          tool: call.tool.name,
+          durationMs: Date.now() - startedAt,
+          ok: true
+        },
+        "tool_call"
+      );
+      return result;
+    } catch (err) {
+      logger.error(
+        {
+          kind: "tool_call",
+          tool: call.tool.name,
+          durationMs: Date.now() - startedAt,
+          ok: false,
+          // Include message and stack separately so structured log consumers
+          // can filter on message while retaining the full stack for debugging.
+          errorMessage: err instanceof Error ? err.message : String(err),
+          errorStack: err instanceof Error ? err.stack : void 0,
+          errorName: err instanceof Error ? err.name : void 0
+        },
+        "tool_call_failed"
+      );
+      throw err;
+    }
+  };
+}
+
+// ../../packages/core/src/middleware/budget.ts
+function budgetMiddleware(opts) {
+  if (opts.maxTokens !== void 0 && (opts.maxTokens <= 0 || !Number.isInteger(opts.maxTokens))) {
+    throw new Error(
+      `budgetMiddleware: maxTokens must be a positive integer, got ${String(opts.maxTokens)}`
+    );
+  }
+  if (opts.maxCalls !== void 0 && (opts.maxCalls <= 0 || !Number.isInteger(opts.maxCalls))) {
+    throw new Error(
+      `budgetMiddleware: maxCalls must be a positive integer, got ${String(opts.maxCalls)}`
+    );
+  }
+  const warnAt = opts.warnAtFraction ?? 0.8;
+  let totalTokens = 0;
+  let totalCalls = 0;
+  let tokenWarnEmitted = false;
+  let callWarnEmitted = false;
+  const mw = async (req, next) => {
+    if (opts.maxCalls !== void 0 && totalCalls >= opts.maxCalls) {
+      throw new BudgetError(
+        `Budget exceeded: ${String(totalCalls)} model calls reached the limit of ${String(opts.maxCalls)}.`
+      );
+    }
+    if (opts.maxTokens !== void 0 && totalTokens > opts.maxTokens) {
+      throw new BudgetError(
+        `Budget exceeded: ${String(totalTokens)} tokens used from previous calls, limit is ${String(opts.maxTokens)}.`
+      );
+    }
+    if (opts.logger) {
+      if (opts.maxCalls !== void 0 && !callWarnEmitted && totalCalls / opts.maxCalls >= warnAt) {
+        opts.logger.warn(
+          {
+            event: "budget_warning",
+            kind: "calls",
+            used: totalCalls,
+            limit: opts.maxCalls,
+            pct: Math.round(totalCalls / opts.maxCalls * 100)
+          },
+          `Budget warning: ${String(totalCalls)}/${String(opts.maxCalls)} model calls used`
+        );
+        callWarnEmitted = true;
+      }
+      if (opts.maxTokens !== void 0 && !tokenWarnEmitted && totalTokens / opts.maxTokens >= warnAt) {
+        opts.logger.warn(
+          {
+            event: "budget_warning",
+            kind: "tokens",
+            used: totalTokens,
+            limit: opts.maxTokens,
+            pct: Math.round(totalTokens / opts.maxTokens * 100)
+          },
+          `Budget warning: ${String(totalTokens)}/${String(opts.maxTokens)} tokens used`
+        );
+        tokenWarnEmitted = true;
+      }
+    }
+    totalCalls++;
+    const response = await next(req);
+    totalTokens += (response.usage?.inputTokens ?? 0) + (response.usage?.outputTokens ?? 0);
+    return response;
+  };
+  return Object.assign(mw, {
+    reset() {
+      totalTokens = 0;
+      totalCalls = 0;
+      tokenWarnEmitted = false;
+      callWarnEmitted = false;
+    }
+  });
+}
+
+// ../../packages/adapters/model-aisdk/src/index.ts
+import { generateText, streamText } from "ai";
+import { createOpenAI } from "@ai-sdk/openai";
+import { createAnthropic } from "@ai-sdk/anthropic";
+
+// ../../packages/adapters/model-aisdk/src/convert.ts
+import { tool as aiTool } from "ai";
+
+// ../../packages/adapters/model-aisdk/src/adapter-logger.ts
+import pino from "pino";
+var rawLogger = pino(
+  { name: "@thiny/model-aisdk", level: process.env.LOG_LEVEL ?? "info" },
+  pino.destination({ dest: 2, sync: false })
+);
+var adapterLogger = {
+  info: (obj, msg) => {
+    rawLogger.info(obj, msg);
+  },
+  warn: (obj, msg) => {
+    rawLogger.warn(obj, msg);
+  },
+  error: (obj, msg) => {
+    rawLogger.error(obj, msg);
+  },
+  child: (bindings) => {
+    const child = rawLogger.child(bindings);
+    return {
+      info: (obj, msg) => {
+        child.info(obj, msg);
+      },
+      warn: (obj, msg) => {
+        child.warn(obj, msg);
+      },
+      error: (obj, msg) => {
+        child.error(obj, msg);
+      },
+      child: (b) => adapterLogger.child({ ...bindings, ...b })
+    };
+  }
+};
+
+// ../../packages/adapters/model-aisdk/src/convert.ts
+function tryParseJSON(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    adapterLogger.warn(
+      { event: "tool_result_not_json", preview: value.slice(0, 80) },
+      "Tool result is not valid JSON \u2014 passing raw string to model"
+    );
+    return value;
+  }
+}
+function toCoreMessages(messages) {
+  return messages.map((m) => {
+    switch (m.role) {
+      case "system":
+        return { role: "system", content: m.content };
+      case "user":
+        return { role: "user", content: m.content };
+      case "assistant":
+        if (m.toolCalls?.length) {
+          return {
+            role: "assistant",
+            content: [
+              ...m.content ? [{ type: "text", text: m.content }] : [],
+              ...m.toolCalls.map((tc) => ({
+                type: "tool-call",
+                toolCallId: tc.id,
+                toolName: tc.name,
+                args: tc.args
+              }))
+            ]
+          };
+        }
+        return { role: "assistant", content: m.content };
+      case "tool":
+        return {
+          role: "tool",
+          content: [
+            {
+              type: "tool-result",
+              toolCallId: m.toolCallId,
+              toolName: m.toolName,
+              result: tryParseJSON(m.content)
+            }
+          ]
+        };
+      default:
+        throw new Error(`unhandled message role: ${m.role}`);
+    }
+  });
+}
+function toAiTools(tools) {
+  const result = {};
+  for (const tool of tools) {
+    result[tool.name] = aiTool({ description: tool.description, parameters: tool.parameters });
+  }
+  return result;
+}
+
+// ../../packages/adapters/model-aisdk/src/env-keys.ts
+var ENV_KEYS = {
+  model: {
+    primary: "THINY_MODEL",
+    fallback: "AGENT_MODEL",
+    default: "openai:gpt-4o-mini"
+  },
+  openai: {
+    baseURL: { primary: "THINY_OPENAI_BASE_URL", fallback: "OPENAI_BASE_URL" },
+    apiKey: { primary: "THINY_OPENAI_API_KEY", fallback: "OPENAI_API_KEY" }
+  },
+  anthropic: {
+    baseURL: { primary: "THINY_ANTHROPIC_BASE_URL", fallback: "ANTHROPIC_BASE_URL" },
+    apiKey: { primary: "THINY_ANTHROPIC_API_KEY", fallback: "ANTHROPIC_API_KEY" }
+  }
+};
+function readEnvKey(key, env = process.env) {
+  return env[key.primary] ?? env[key.fallback];
+}
+
+// ../../packages/adapters/model-aisdk/src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+function resolveConfigValue(value) {
+  if (!value) return void 0;
+  if (value.startsWith("env:")) return process.env[value.slice(4)];
+  return value;
+}
+function resolveProviderOptions(options) {
+  if (!options) return void 0;
+  const resolved = {
+    baseURL: resolveConfigValue(options.baseURL),
+    apiKey: resolveConfigValue(options.apiKey)
+  };
+  if (!resolved.baseURL && !resolved.apiKey) return void 0;
+  return resolved;
+}
+function loadThinyConfig(configPath) {
+  const candidates = configPath ? [configPath] : [resolve(process.cwd(), "thiny.config.json"), resolve(process.cwd(), ".thinyrc.json")];
+  let fileConfig = {};
+  for (const candidatePath of candidates) {
+    if (existsSync(candidatePath)) {
+      try {
+        fileConfig = JSON.parse(readFileSync(candidatePath, "utf8"));
+        adapterLogger.info(
+          { event: "config_loaded", path: candidatePath },
+          `Using config file: ${candidatePath}`
+        );
+        break;
+      } catch (err) {
+        throw new Error(
+          `Failed to parse Thiny config at "${candidatePath}": ` + (err instanceof Error ? err.message : String(err)),
+          { cause: err }
+        );
+      }
+    }
+  }
+  const model = process.env[ENV_KEYS.model.primary] ?? process.env[ENV_KEYS.model.fallback] ?? fileConfig.model ?? ENV_KEYS.model.default;
+  const openaiFromEnv = {
+    baseURL: readEnvKey(ENV_KEYS.openai.baseURL),
+    apiKey: readEnvKey(ENV_KEYS.openai.apiKey)
+  };
+  const anthropicFromEnv = {
+    baseURL: readEnvKey(ENV_KEYS.anthropic.baseURL),
+    apiKey: readEnvKey(ENV_KEYS.anthropic.apiKey)
+  };
+  const openaiFromFile = resolveProviderOptions(fileConfig.openai);
+  const anthropicFromFile = resolveProviderOptions(fileConfig.anthropic);
+  const adapterOptions = { model, maxRetries: fileConfig.maxRetries };
+  const openai = {
+    baseURL: openaiFromEnv.baseURL ?? openaiFromFile?.baseURL,
+    apiKey: openaiFromEnv.apiKey ?? openaiFromFile?.apiKey
+  };
+  if (openai.baseURL ?? openai.apiKey) adapterOptions.openai = openai;
+  const anthropic = {
+    baseURL: anthropicFromEnv.baseURL ?? anthropicFromFile?.baseURL,
+    apiKey: anthropicFromEnv.apiKey ?? anthropicFromFile?.apiKey
+  };
+  if (anthropic.baseURL ?? anthropic.apiKey) adapterOptions.anthropic = anthropic;
+  return aiSdkModel(adapterOptions);
+}
+function readThinyConfig(configPath) {
+  const candidates = configPath ? [configPath] : [resolve(process.cwd(), "thiny.config.json"), resolve(process.cwd(), ".thinyrc.json")];
+  for (const candidatePath of candidates) {
+    if (existsSync(candidatePath)) {
+      try {
+        return JSON.parse(readFileSync(candidatePath, "utf8"));
+      } catch {
+        return {};
+      }
+    }
+  }
+  return {};
+}
+
+// ../../packages/adapters/model-aisdk/src/index.ts
+function toFinishReason(reason) {
+  if (reason === "tool-calls") return "tool_calls";
+  if (reason === "length") return "length";
+  if (reason === "error") return "error";
+  return "stop";
+}
+function normalizeUsage(usage) {
+  if (!usage) return void 0;
+  return { inputTokens: usage.promptTokens, outputTokens: usage.completionTokens };
+}
+function buildToolOptions(tools) {
+  if (tools.length === 0) return { tools: void 0, toolChoice: void 0 };
+  return { tools: toAiTools(tools), toolChoice: "auto" };
+}
+function resolveModel(model, opts) {
+  if (typeof model !== "string") return model;
+  const colonIdx = model.indexOf(":");
+  if (colonIdx === -1) {
+    if (opts.anthropic?.baseURL) {
+      return createAnthropic({ baseURL: opts.anthropic.baseURL, apiKey: opts.anthropic.apiKey })(
+        model
+      );
+    }
+    return createOpenAI({ baseURL: opts.openai?.baseURL, apiKey: opts.openai?.apiKey })(model);
+  }
+  const provider = model.slice(0, colonIdx);
+  const modelId = model.slice(colonIdx + 1);
+  if (provider === "openai" || provider === "openai-compat") {
+    return createOpenAI({ baseURL: opts.openai?.baseURL, apiKey: opts.openai?.apiKey })(modelId);
+  }
+  if (provider === "anthropic") {
+    return createAnthropic({ baseURL: opts.anthropic?.baseURL, apiKey: opts.anthropic?.apiKey })(
+      modelId
+    );
+  }
+  throw new Error(
+    `unknown provider "${provider}" in model string "${model}"
+Supported prefixes: "openai:<id>", "openai-compat:<id>", "anthropic:<id>"
+Or omit the prefix and set THINY_OPENAI_BASE_URL / THINY_ANTHROPIC_BASE_URL instead.
+Or pass a LanguageModel instance directly.`
+  );
+}
+function aiSdkModel(opts) {
+  const model = resolveModel(opts.model, opts);
+  const maxRetries = opts.maxRetries ?? 2;
+  return {
+    async generate(messages, tools) {
+      const result = await generateText({
+        model,
+        messages: toCoreMessages(messages),
+        ...buildToolOptions(tools),
+        maxRetries
+      });
+      return {
+        text: result.text || void 0,
+        // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+        toolCalls: result.toolCalls?.map((tc) => ({
+          id: tc.toolCallId,
+          name: tc.toolName,
+          args: tc.args
+        })),
+        finishReason: toFinishReason(result.finishReason),
+        usage: normalizeUsage(result.usage)
+      };
+    },
+    async *stream(messages, tools) {
+      const result = streamText({
+        model,
+        messages: toCoreMessages(messages),
+        ...buildToolOptions(tools),
+        maxRetries
+      });
+      for await (const part of result.fullStream) {
+        if (part.type === "text-delta") {
+          yield { type: "text-delta", text: part.textDelta };
+        } else if (part.type === "error") {
+          throw part.error instanceof Error ? part.error : new Error(String(part.error));
+        } else if (part.type === "tool-call") {
+          yield {
+            type: "tool-call",
+            toolCall: {
+              id: part.toolCallId,
+              name: part.toolName,
+              args: part.args
+            }
+          };
+        } else if (part.type === "finish") {
+          yield {
+            type: "finish",
+            finishReason: toFinishReason(part.finishReason),
+            usage: normalizeUsage(part.usage)
+          };
+        }
+      }
+    }
+  };
+}
+
+// ../../packages/adapters/logger-pino/src/index.ts
+import pino2 from "pino";
+var DEFAULT_REDACT_PATHS = [
+  "authorization",
+  "apiKey",
+  "api_key",
+  "privateKey",
+  "AGENT_PRIVATE_KEY",
+  "*.token",
+  "headers.authorization",
+  "headers[*].authorization"
+];
+function pinoConfig(level) {
+  return {
+    level,
+    redact: {
+      paths: DEFAULT_REDACT_PATHS,
+      censor: "[REDACTED]"
+    }
+  };
+}
+function adaptPinoLogger(instance) {
+  return {
+    info: (obj, msg) => {
+      instance.info(obj, msg);
+    },
+    warn: (obj, msg) => {
+      instance.warn(obj, msg);
+    },
+    error: (obj, msg) => {
+      instance.error(obj, msg);
+    },
+    child: (bindings) => adaptPinoLogger(instance.child(bindings))
+  };
+}
+function pinoLogger(opts = {}) {
+  const level = opts.level ?? process.env.LOG_LEVEL ?? "info";
+  if (opts.stderr) {
+    return adaptPinoLogger(
+      pino2(pinoConfig(level), pino2.destination({ dest: 2, sync: false }))
+    );
+  }
+  if (opts.file) {
+    const destination = pino2.destination({ dest: opts.file, sync: false });
+    return adaptPinoLogger(pino2(pinoConfig(level), destination));
+  }
+  const usePretty = opts.pretty ?? (opts.file === void 0 && process.env.NODE_ENV !== "production");
+  if (usePretty) {
+    return adaptPinoLogger(
+      pino2({
+        ...pinoConfig(level),
+        transport: {
+          target: "pino-pretty",
+          options: { colorize: true, translateTime: "HH:MM:ss", ignore: "pid,hostname" }
+        }
+      })
+    );
+  }
+  return adaptPinoLogger(pino2(pinoConfig(level)));
+}
+
+// ../../packages/adapters/memory-memwal/src/index.ts
+import { z } from "zod";
+async function resolveMemWalClient(opts) {
+  if (opts.client) return opts.client;
+  if (!opts.delegateKey || !opts.accountId) {
+    throw new Error(
+      "MemWal: provide a `client`, or both delegateKey and accountId. Create an account + delegate key at the MemWal Playground."
+    );
+  }
+  const { MemWal } = await import("@mysten-incubation/memwal");
+  return MemWal.create({
+    key: opts.delegateKey,
+    accountId: opts.accountId,
+    serverUrl: opts.serverUrl,
+    namespace: opts.namespace
+  });
+}
+function memwalFactsPlugin(opts) {
+  let clientPromise;
+  const getClient = () => clientPromise ??= resolveMemWalClient(opts);
+  const defaultLimit = opts.recallLimit ?? 10;
+  const rememberFact = defineTool({
+    name: "remember_fact",
+    description: "Store a durable, standalone fact in long-term semantic memory (persisted on Walrus). Use for stable user preferences, goals, and decisions worth recalling in future sessions \u2014 not for transient chatter.",
+    parameters: z.object({
+      fact: z.string().min(1).describe("The fact to remember, phrased to stand on its own.")
+    }),
+    execute: async ({ fact }) => {
+      const res = await (await getClient()).rememberAndWait(fact, opts.namespace);
+      return { stored: true, blobId: res.blob_id };
+    }
+  });
+  const recallMemory = defineTool({
+    name: "recall_memory",
+    description: "Search long-term semantic memory for facts relevant to a query. Call at the start of a task to recall what you already know about the user or goal.",
+    parameters: z.object({
+      query: z.string().min(1).describe("What to recall."),
+      limit: z.number().int().min(1).max(50).optional().describe("Max memories to return.")
+    }),
+    execute: async ({ query, limit }) => {
+      const { results } = await (await getClient()).recall({
+        query,
+        limit: limit ?? defaultLimit,
+        namespace: opts.namespace
+      });
+      return { memories: results.map((r) => r.text) };
+    }
+  });
+  return { name: "memwal-facts", tools: [rememberFact, recallMemory] };
+}
+
+// ../../packages/adapters/walrus/src/index.ts
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { dirname } from "path";
+import { z as z2 } from "zod";
+var DEFAULT_PUBLISHER = "https://publisher.walrus-testnet.walrus.space";
+var DEFAULT_AGGREGATOR = "https://aggregator.walrus-testnet.walrus.space";
+function walrusClient(opts = {}) {
+  const publisher = (opts.publisher ?? DEFAULT_PUBLISHER).replace(/\/$/, "");
+  const aggregator = (opts.aggregator ?? DEFAULT_AGGREGATOR).replace(/\/$/, "");
+  const epochs = opts.epochs ?? 5;
+  const network = opts.network ?? "testnet";
+  const fetchImpl = opts.fetchImpl ?? fetch;
+  return {
+    publisher,
+    aggregator,
+    network,
+    async putBlob(data) {
+      const body = typeof data === "string" ? new TextEncoder().encode(data) : data;
+      const res = await fetchImpl(`${publisher}/v1/blobs?epochs=${String(epochs)}`, {
+        method: "PUT",
+        body
+      });
+      if (!res.ok) {
+        throw new Error(`walrus putBlob failed: HTTP ${String(res.status)} ${await res.text()}`);
+      }
+      const json = await res.json();
+      const created = json.newlyCreated?.blobObject;
+      const certified = json.alreadyCertified;
+      const blobId = created?.blobId ?? certified?.blobId;
+      if (!blobId) {
+        throw new Error(`walrus putBlob: no blobId in response: ${JSON.stringify(json)}`);
+      }
+      return {
+        blobId,
+        objectId: created?.id,
+        txDigest: certified?.event?.txDigest,
+        endEpoch: created?.storage?.endEpoch ?? certified?.endEpoch
+      };
+    },
+    async getBlob(blobId) {
+      const res = await fetchImpl(`${aggregator}/v1/blobs/${encodeURIComponent(blobId)}`);
+      if (!res.ok) {
+        throw new Error(`walrus getBlob failed: HTTP ${String(res.status)} for ${blobId}`);
+      }
+      return new Uint8Array(await res.arrayBuffer());
+    }
+  };
+}
+function walruscanBlobUrl(blobId, network = "testnet") {
+  return `https://walruscan.com/${network}/blob/${blobId}`;
+}
+function suiscanObjectUrl(objectId, network = "testnet") {
+  return `https://suiscan.xyz/${network}/object/${objectId}`;
+}
+function suiscanTxUrl(txDigest, network = "testnet") {
+  return `https://suiscan.xyz/${network}/tx/${txDigest}`;
+}
+function explorerLinks(ref, network = "testnet") {
+  return {
+    blob: walruscanBlobUrl(ref.blobId, network),
+    object: ref.objectId ? suiscanObjectUrl(ref.objectId, network) : void 0,
+    tx: ref.txDigest ? suiscanTxUrl(ref.txDigest, network) : void 0
+  };
+}
+function walrusAuditLogger(base, client, opts) {
+  const buffer = [];
+  const now = opts.now ?? (() => /* @__PURE__ */ new Date());
+  const capture = (level, obj, msg) => {
+    if ("kind" in obj || "event" in obj) {
+      buffer.push({ level, at: now().toISOString(), msg, ...obj });
+    }
+  };
+  const wrap = (logger) => ({
+    info: (obj, msg) => {
+      capture("info", obj, msg);
+      logger.info(obj, msg);
+    },
+    warn: (obj, msg) => {
+      capture("warn", obj, msg);
+      logger.warn(obj, msg);
+    },
+    error: (obj, msg) => {
+      capture("error", obj, msg);
+      logger.error(obj, msg);
+    },
+    // child loggers share the same buffer so the whole session lands in one trail.
+    child: (bindings) => wrap(logger.child(bindings)),
+    entries: () => [...buffer],
+    reset: () => {
+      buffer.length = 0;
+    },
+    flush: async (sessionId) => {
+      if (buffer.length === 0) return null;
+      const manifest = {
+        sessionId: sessionId ?? opts.sessionId,
+        createdAt: now().toISOString(),
+        count: buffer.length,
+        entries: buffer
+      };
+      return client.putBlob(JSON.stringify(manifest));
+    }
+  });
+  return wrap(base);
+}
+async function verifyAuditTrail(client, blobId) {
+  const bytes = await client.getBlob(blobId);
+  return JSON.parse(new TextDecoder().decode(bytes));
+}
+function filePointerStore(path) {
+  async function readAll() {
+    try {
+      return JSON.parse(await readFile(path, "utf8"));
+    } catch {
+      return {};
+    }
+  }
+  return {
+    async get(key) {
+      return (await readAll())[key];
+    },
+    async set(key, blobId) {
+      const all = await readAll();
+      all[key] = blobId;
+      await mkdir(dirname(path), { recursive: true });
+      await writeFile(path, JSON.stringify(all, null, 2));
+    }
+  };
+}
+function emptyFacts(userId) {
+  return { userId, facts: [], preferences: [], updatedAt: "" };
+}
+function walrusMemoryPlugin(opts) {
+  const key = `facts:${opts.userId}`;
+  const maxFacts = opts.maxFacts ?? 50;
+  let cache;
+  let loading;
+  let pending = Promise.resolve();
+  async function load() {
+    if (cache) return cache;
+    loading ??= (async () => {
+      try {
+        const blobId = await opts.pointers.get(key);
+        cache = blobId === void 0 ? emptyFacts(opts.userId) : JSON.parse(
+          new TextDecoder().decode(await opts.client.getBlob(blobId))
+        );
+      } catch {
+        cache = emptyFacts(opts.userId);
+      }
+      return cache;
+    })();
+    return loading;
+  }
+  function save(facts) {
+    cache = facts;
+    opts.onStoreStart?.();
+    pending = pending.then(async () => {
+      try {
+        const ref = await opts.client.putBlob(JSON.stringify(facts));
+        await opts.pointers.set(key, ref.blobId);
+        opts.onStore?.(ref);
+      } catch {
+      }
+    });
+  }
+  void load();
+  const contextMiddleware = async (req, next) => {
+    const mem = await load();
+    if (mem.facts.length === 0 && mem.preferences.length === 0) return next(req);
+    const parts = [`[User Memory for ${mem.userId}] (durable, stored on Walrus)`];
+    if (mem.facts.length > 0)
+      parts.push(`Known facts:
+${mem.facts.map((f) => `- ${f}`).join("\n")}`);
+    if (mem.preferences.length > 0)
+      parts.push(`Preferences:
+${mem.preferences.map((p2) => `- ${p2}`).join("\n")}`);
+    const ctxMsg = { role: "system", content: parts.join("\n\n") };
+    const [first, ...rest] = req.messages;
+    const messages = first?.role === "system" && first.content.includes("MUST always refer") ? [first, ctxMsg, ...rest] : [ctxMsg, ...req.messages];
+    return next({ ...req, messages });
+  };
+  return {
+    name: "walrus-memory",
+    // Await any in-flight background write — call before exit for last-write durability.
+    flush: () => pending,
+    modelMiddleware: [contextMiddleware],
+    tools: [
+      defineTool({
+        name: "remember_fact",
+        description: "Store a durable fact or preference about the user on Walrus, to recall in future sessions. Use whenever the user shares something durable \u2014 their name, role, preferences, projects, or goals.",
+        parameters: z2.object({
+          fact: z2.string().min(1).describe("The fact or preference, phrased to stand on its own."),
+          kind: z2.enum(["fact", "preference"]).default("fact")
+        }),
+        execute: async ({ fact, kind }) => {
+          const mem = await load();
+          const list = kind === "preference" ? mem.preferences : mem.facts;
+          if (!list.includes(fact)) {
+            list.push(fact);
+            if (list.length > maxFacts) list.shift();
+          }
+          mem.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+          save(mem);
+          return {
+            stored: fact,
+            kind,
+            totalFacts: mem.facts.length,
+            totalPreferences: mem.preferences.length
+          };
+        }
+      }),
+      defineTool({
+        name: "recall_memory",
+        description: "Retrieve everything currently remembered about the user (facts + preferences). Use when asked what you remember.",
+        parameters: z2.object({}),
+        execute: () => load()
+      })
+    ]
+  };
+}
+
+// ../../packages/plugins/agents/src/index.ts
+import { z as z3 } from "zod";
+var DEFAULT_SUBAGENT_PROMPT = "You are a focused sub-agent. Complete the single delegated task using the tools available, then return only the result \u2014 concise and self-contained. Do not ask follow-up questions.";
+var PLAN_STATE_KEY = "thiny:agent-plan";
+function agentsPlugin(opts = {}) {
+  const subagents = opts.subagents ?? {};
+  const names = Object.keys(subagents);
+  const agentParamDesc = names.length > 0 ? `Optional named sub-agent to use. Available: ${names.map((n) => `"${n}" (${subagents[n]?.description ?? ""})`).join("; ")}. Omit for a general-purpose sub-agent.` : "Optional named sub-agent. None are configured, so omit it for a general-purpose sub-agent.";
+  const delegateTask = defineTool({
+    name: "delegate_task",
+    description: "Delegate a focused, self-contained task to a scoped sub-agent that runs independently and returns its result. Use for parallelisable or specialised work (research, summarisation, a sub-problem) so the main thread stays clean. The sub-agent does NOT see this conversation \u2014 put everything it needs in `task` and `context`.",
+    parameters: z3.object({
+      task: z3.string().min(1).describe("The complete instruction for the sub-agent."),
+      agent: z3.string().optional().describe(agentParamDesc),
+      context: z3.string().optional().describe("Any background the sub-agent needs (it cannot see the current conversation).")
+    }),
+    execute: async ({ task, agent, context }, ctx) => {
+      if (!ctx.spawn) {
+        throw new Error("delegate_task: sub-agent spawning is unavailable in this context.");
+      }
+      let def;
+      if (agent !== void 0) {
+        def = subagents[agent];
+        if (!def) {
+          throw new Error(
+            `delegate_task: unknown sub-agent "${agent}". Available: ${names.length > 0 ? names.join(", ") : "(none configured)"}.`
+          );
+        }
+      }
+      const input = context ? `${task}
+
+--- Context ---
+${context}` : task;
+      ctx.logger.info(
+        { event: "delegate_task", agent: agent ?? "default", taskLength: task.length },
+        `Delegating task to ${agent ?? "default"} sub-agent`
+      );
+      const result = await ctx.spawn({
+        input,
+        systemPrompt: def?.systemPrompt ?? DEFAULT_SUBAGENT_PROMPT,
+        tools: def?.tools ?? opts.defaultTools,
+        maxSteps: opts.maxSteps
+      });
+      return { agent: agent ?? "default", result };
+    }
+  });
+  const updatePlan = defineTool({
+    name: "update_plan",
+    description: "Record or update your task plan as a checklist. Call this when you start a multi-step task and whenever a step's status changes. Pass the FULL list each time (it replaces the previous plan). Keeps progress visible and helps you stay on track.",
+    parameters: z3.object({
+      steps: z3.array(
+        z3.object({
+          step: z3.string().min(1).describe("A concise description of the step."),
+          status: z3.enum(["pending", "in_progress", "done"]).describe("Current status of this step.")
+        })
+      ).min(1).describe("The full ordered plan \u2014 replaces the previous list.")
+    }),
+    execute: ({ steps }, ctx) => {
+      ctx.state.set(PLAN_STATE_KEY, steps);
+      ctx.logger.info({ event: "plan_update", steps }, "Plan updated");
+      const done = steps.filter((s) => s.status === "done").length;
+      return Promise.resolve({
+        plan: steps,
+        summary: `${String(done)}/${String(steps.length)} done`
+      });
+    }
+  });
+  return { name: "agents", tools: [delegateTask, updatePlan] };
+}
+
+// ../../packages/skills/src/catalog.ts
+var BUILTIN_SKILLS = [
+  {
+    id: "web-search",
+    name: "Web Search",
+    description: "Search the public web via Brave Search API",
+    category: "web",
+    tags: ["search", "web"],
+    requiredEnv: ["BRAVE_API_KEY"]
+  },
+  {
+    id: "evm",
+    name: "EVM / Ethereum",
+    description: "Read EVM chain state, testnet sends with policy gate",
+    category: "defi",
+    tags: ["ethereum", "evm", "web3"],
+    requiredEnv: ["EVM_RPC_URL"]
+  },
+  {
+    id: "solana",
+    name: "Solana",
+    description: "Read Solana devnet state, devnet SOL sends",
+    category: "defi",
+    tags: ["solana", "sol", "web3"]
+  },
+  {
+    id: "market",
+    name: "Market Data",
+    description: "Token prices via CoinGecko + in-run portfolio tracking",
+    category: "defi",
+    tags: ["prices", "portfolio", "defi"]
+  },
+  {
+    id: "tokens",
+    name: "Token Ops",
+    description: "ERC-20 balance, allowance, approve (unlimited blocked), transfer",
+    category: "defi",
+    tags: ["erc20", "tokens", "approve"],
+    requiredEnv: ["EVM_RPC_URL"]
+  },
+  {
+    id: "trading-policy",
+    name: "Trading Policy",
+    description: "Asset allowlist + position size cap + slippage ceiling",
+    category: "defi",
+    tags: ["trading", "policy", "safety"],
+    requiredEnv: ["ALLOWED_ASSETS"]
+  },
+  {
+    id: "knowledge",
+    name: "Knowledge / RAG",
+    description: "Ingest documents, auto-inject relevant context",
+    category: "ai",
+    tags: ["rag", "knowledge", "retrieval"]
+  },
+  {
+    id: "resilience",
+    name: "Resilience",
+    description: "retry, timeout, rate-limit, cache, idempotency middleware",
+    category: "reliability",
+    tags: ["retry", "timeout", "cache"]
+  },
+  {
+    id: "mcp",
+    name: "MCP",
+    description: "Connect to any MCP stdio server as instant tools",
+    category: "ecosystem",
+    tags: ["mcp", "integration"],
+    requiredEnv: ["MCP_COMMAND"]
+  },
+  {
+    id: "agent-skills",
+    name: "Agent Skills",
+    description: "Understand, find, install, and create skills.sh compatible skills",
+    category: "ecosystem",
+    tags: ["skills", "skills.sh", "community", "find-skills"]
+  }
+];
+
+// ../../packages/skills/src/registry.ts
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  constructor(definitions = BUILTIN_SKILLS) {
+    for (const def of definitions) this.skills.set(def.id, def);
+  }
+  /** Register a custom skill. */
+  add(definition) {
+    this.skills.set(definition.id, definition);
+  }
+  /** Look up a skill by ID. Returns `undefined` when not registered. */
+  get(id) {
+    return this.skills.get(id);
+  }
+  /** All registered skills, sorted by category then id. */
+  all() {
+    return [...this.skills.values()].sort(
+      (a, b) => a.category === b.category ? a.id.localeCompare(b.id) : a.category.localeCompare(b.category)
+    );
+  }
+  /** Skills grouped by category for the TUI display panel. */
+  byCategory() {
+    const map = /* @__PURE__ */ new Map();
+    for (const skill of this.all()) {
+      const list = map.get(skill.category) ?? [];
+      list.push(skill);
+      map.set(skill.category, list);
+    }
+    return map;
+  }
+  /**
+   * Check which skill IDs are satisfiable given the current environment.
+   * Returns the IDs that are ready to load and a list of warnings for the rest.
+   */
+  checkEnv(ids, env = process.env) {
+    const satisfied = [];
+    const warnings = [];
+    for (const id of ids) {
+      const def = this.skills.get(id);
+      if (!def) {
+        warnings.push(`Unknown skill: "${id}". Run /skills to see available skills.`);
+        continue;
+      }
+      const missing = (def.requiredEnv ?? []).filter((k) => !env[k]);
+      if (missing.length > 0) {
+        warnings.push(`Skill "${id}" needs: ${missing.join(", ")} \u2014 skipping.`);
+        continue;
+      }
+      satisfied.push(id);
+    }
+    return { satisfied, warnings };
+  }
+};
+
+// ../../packages/skills/src/index.ts
+var defaultRegistry = new SkillRegistry();
+
+// src/skills.ts
+async function loadSkills(ids, env = process.env) {
+  const { satisfied, warnings } = defaultRegistry.checkEnv(ids, env);
+  const plugins = [];
+  for (const id of satisfied) {
+    try {
+      const plugin = await createSkillPlugin(id, env);
+      if (Array.isArray(plugin)) {
+        plugins.push(...plugin);
+      } else if (plugin) {
+        plugins.push(plugin);
+      }
+    } catch (err) {
+      warnings.push(
+        `Failed to load skill "${id}": ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  return { plugins, warnings };
+}
+var BUILTIN_PACKAGES = {
+  "web-search": "@thiny/plugin-web-search",
+  evm: "@thiny/plugin-evm",
+  solana: "@thiny/plugin-solana",
+  market: "@thiny/plugin-market",
+  tokens: "@thiny/plugin-tokens",
+  "trading-policy": "@thiny/plugin-trading-policy",
+  knowledge: "@thiny/plugin-knowledge",
+  resilience: "@thiny/plugin-resilience",
+  mcp: "@thiny/mcp",
+  "agent-skills": "@thiny/plugin-agent-skills"
+};
+async function createSkillPlugin(id, env) {
+  const packageName = BUILTIN_PACKAGES[id] ?? (id.startsWith("thiny-skill-") ? id : `thiny-skill-${id}`);
+  try {
+    const mod = await import(packageName);
+    const factory = mod.default;
+    if (typeof factory !== "function") {
+      throw new Error(`Package "${packageName}" does not export a default factory function.`);
+    }
+    return await factory(env);
+  } catch (err) {
+    if (BUILTIN_PACKAGES[id]) {
+      throw err;
+    }
+    return null;
+  }
+}
+
+// src/ui.ts
+import figlet from "figlet";
+import chalk from "chalk";
+var BRAND = chalk.cyan;
+var DIM = chalk.dim;
+var AGENT_LABEL = BRAND.bold;
+var ERROR_COLOR = chalk.red;
+var SUCCESS_COLOR = chalk.green;
+function getWidth() {
+  return process.stdout.columns || 80;
+}
+var ANSI_REGEX = /\x1B\[[0-9;]*m/g;
+var visibleLen = (s) => s.replace(ANSI_REGEX, "").length;
+function padRight(str, len) {
+  return str + " ".repeat(Math.max(0, len - visibleLen(str)));
+}
+function center(str, width) {
+  const pad = Math.max(0, Math.floor((width - visibleLen(str)) / 2));
+  return " ".repeat(pad) + str;
+}
+function renderHeader(opts) {
+  const w = getWidth();
+  let title;
+  try {
+    title = figlet.textSync(opts.persona ?? "Thiny", { font: "Standard" });
+  } catch {
+    title = opts.persona ?? "Thiny";
+  }
+  process.stdout.write("\n");
+  for (const line of title.split("\n")) {
+    if (line.trim()) process.stdout.write(center(BRAND.bold(line), w) + "\n");
+  }
+  process.stdout.write("\n");
+  const version2 = opts.version ?? "v0.1.0";
+  const infoText = ` ${opts.persona ?? "Thiny"} Agent ${version2} `;
+  const remaining = Math.max(0, w - visibleLen(infoText));
+  const leftDash = "\u2500".repeat(Math.floor(remaining / 2));
+  const rightDash = "\u2500".repeat(remaining - leftDash.length);
+  process.stdout.write(BRAND(leftDash) + BRAND.bold(infoText) + BRAND(rightDash) + "\n\n");
+}
+function renderToolsAndSkills(tools, skills, opts) {
+  const w = getWidth();
+  const leftColW = 25;
+  const leftLines = [
+    "",
+    center(BRAND.bold(opts.persona ?? "Thiny"), leftColW),
+    center(DIM(opts.model.slice(0, leftColW - 2)), leftColW),
+    center(DIM(`Session: ${opts.session.slice(-8)}`), leftColW)
+  ];
+  const toolGroups = /* @__PURE__ */ new Map();
+  for (const tool of tools) {
+    const idx = tool.indexOf("_");
+    const prefix = idx !== -1 ? tool.slice(0, idx) : "core";
+    const list = toolGroups.get(prefix) ?? [];
+    list.push(tool);
+    toolGroups.set(prefix, list);
+  }
+  const rightLines = [];
+  rightLines.push(BRAND.bold("Available Tools"));
+  for (const [prefix, names] of toolGroups) {
+    rightLines.push(`  ${BRAND(prefix)}: ${names.join(", ")}`);
+  }
+  rightLines.push("");
+  rightLines.push(BRAND.bold("Available Skills"));
+  if (skills.size === 0) {
+    rightLines.push(`  ${DIM("(none loaded \u2014 use --skills <id>)")}`);
+  } else {
+    for (const [cat, names] of skills) {
+      rightLines.push(`  ${BRAND(cat)}: ${names.join(", ")}`);
+    }
+  }
+  const maxLines = Math.max(leftLines.length, rightLines.length);
+  process.stdout.write(BRAND("\u250C" + "\u2500".repeat(w - 2) + "\u2510") + "\n");
+  for (let i = 0; i < maxLines; i++) {
+    const leftRaw = leftLines[i] ?? "";
+    const rightRaw = rightLines[i] ?? "";
+    const leftPad = padRight(leftRaw, leftColW);
+    const spacer = BRAND(" \u2502 ");
+    const rightColW = w - leftColW - 7;
+    const rightPad = padRight(rightRaw, rightColW);
+    process.stdout.write(BRAND("\u2502 ") + leftPad + spacer + rightPad + BRAND(" \u2502") + "\n");
+  }
+  process.stdout.write(BRAND("\u2514" + "\u2500".repeat(w - 2) + "\u2518") + "\n");
+}
+function renderHints(logFile) {
+  const logHint = logFile ? `  \xB7  ${DIM("logs \u2192")} ${chalk.dim(logFile)}` : "";
+  process.stdout.write(
+    "\n" + DIM("Type a message  \xB7  ") + DIM("/new") + chalk.dim(" new session  \xB7  ") + DIM("/skills") + chalk.dim(" list skills  \xB7  ") + DIM("/tools") + chalk.dim(" list tools  \xB7  ") + DIM("Ctrl+C") + chalk.dim(" quit") + logHint + "\n\n"
+  );
+}
+function renderAgentLabel(name) {
+  process.stdout.write("\n" + AGENT_LABEL(name) + "\n");
+}
+function renderAgentDone() {
+  process.stdout.write("\n");
+}
+function renderError(message) {
+  process.stdout.write("\n" + ERROR_COLOR("Error: ") + chalk.white(message) + "\n");
+}
+function renderInfo(message) {
+  process.stdout.write(DIM(message) + "\n");
+}
+function renderWarning(message) {
+  process.stdout.write(chalk.yellow("\u26A0 ") + chalk.white(message) + "\n");
+}
+var SPINNER_FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var Spinner = class {
+  intervalId = null;
+  frameIdx = 0;
+  start(label) {
+    this.stop();
+    process.stdout.write("\n");
+    this.intervalId = setInterval(() => {
+      const frame = SPINNER_FRAMES[this.frameIdx % SPINNER_FRAMES.length] ?? "\u280B";
+      process.stdout.write(`\r  ${BRAND(frame)} ${DIM(label)}   `);
+      this.frameIdx++;
+    }, 80);
+  }
+  stop() {
+    if (this.intervalId) {
+      clearInterval(this.intervalId);
+      this.intervalId = null;
+      process.stdout.write("\r" + " ".repeat(40) + "\r");
+    }
+  }
+};
+function clearScreen() {
+  process.stdout.write("\x1Bc");
+}
+function formatTokens(n) {
+  return n >= 1e3 ? `${(n / 1e3).toFixed(1)}k` : String(n);
+}
+function renderStatus(parts) {
+  const shown = parts.filter((p2) => p2.length > 0);
+  if (shown.length === 0) return;
+  process.stdout.write(DIM(`  ${shown.join("  \xB7  ")}`) + "\n");
+}
+function renderStored(label, links, backend = "Walrus") {
+  process.stdout.write(
+    SUCCESS_COLOR("  \u2713 ") + DIM(`${label} on ${backend}  \xB7  `) + chalk.dim.underline(links.blob) + "\n"
+  );
+}
+function renderSaving(label, backend = "Walrus") {
+  process.stdout.write(DIM(`  \u27F3 saving ${label} to ${backend}\u2026`) + "\n");
+}
+var THINK_OPEN = "<think>";
+var THINK_CLOSE = "</think>";
+function pendingTagLen(s) {
+  let max = 0;
+  for (const tag of [THINK_OPEN, THINK_CLOSE]) {
+    for (let n = Math.min(s.length, tag.length - 1); n > 0; n--) {
+      if (s.endsWith(tag.slice(0, n))) {
+        if (n > max) max = n;
+        break;
+      }
+    }
+  }
+  return max;
+}
+var OSC8 = (url, text2) => `\x1B]8;;${url}\x07${text2}\x1B]8;;\x07`;
+function renderInline(s) {
+  const codes = [];
+  s = s.replace(/`([^`]+)`/g, (_m, c) => {
+    codes.push(c);
+    return `\0${String(codes.length - 1)}\0`;
+  });
+  s = s.replace(/\*\*([^*\n]+)\*\*/g, (_m, t) => chalk.bold(t));
+  s = s.replace(/\*([^*\n]+)\*/g, (_m, t) => chalk.italic(t));
+  s = s.replace(/~~([^~\n]+)~~/g, (_m, t) => chalk.strikethrough(t));
+  s = s.replace(
+    /\[([^\]]+)\]\(([^)\s]+)\)/g,
+    (_m, text2, url) => OSC8(url, chalk.cyan.underline(text2))
+  );
+  s = s.replace(/(\d+)/g, (_m, i) => chalk.cyan(codes[Number(i)] ?? ""));
+  return s;
+}
+function renderMarkdownLine(line, inCode, setCode) {
+  const trimmed = line.replace(/^\s+/, "");
+  const indent = line.slice(0, line.length - trimmed.length);
+  if (trimmed.startsWith("```")) {
+    setCode(!inCode);
+    return "";
+  }
+  if (inCode) return chalk.cyan(line);
+  const h = /^(#{1,6})\s+(.*)$/.exec(trimmed);
+  if (h) return ((h[1] ?? "").length <= 2 ? chalk.bold.underline : chalk.bold)(renderInline(h[2] ?? ""));
+  if (/^(-{3,}|\*{3,}|_{3,})$/.test(trimmed)) return chalk.dim("\u2500".repeat(Math.min(getWidth(), 50)));
+  const q = /^>\s?(.*)$/.exec(trimmed);
+  if (q) return chalk.dim(`\u2502 ${renderInline(q[1] ?? "")}`);
+  const b = /^[-*+]\s+(.*)$/.exec(trimmed);
+  if (b) return `${indent}${chalk.cyan("\u2022")} ${renderInline(b[1] ?? "")}`;
+  const n = /^(\d+)[.)]\s+(.*)$/.exec(trimmed);
+  if (n) return `${indent}${chalk.cyan(`${n[1] ?? ""}.`)} ${renderInline(n[2] ?? "")}`;
+  return renderInline(line);
+}
+function createMarkdownWriter(write) {
+  let inThink = false;
+  let inCode = false;
+  let buf = "";
+  let line = "";
+  const flushLine = (newline) => {
+    write(renderMarkdownLine(line, inCode, (v) => inCode = v) + (newline ? "\n" : ""));
+    line = "";
+  };
+  const emit = (text2, think) => {
+    if (!text2) return;
+    if (think) {
+      write(chalk.dim.italic(text2));
+      return;
+    }
+    for (const ch of text2) {
+      if (ch === "\n") flushLine(true);
+      else line += ch;
+    }
+  };
+  const drain = () => {
+    for (; ; ) {
+      const open = buf.indexOf(THINK_OPEN);
+      const close = buf.indexOf(THINK_CLOSE);
+      const present = [open, close].filter((i) => i !== -1);
+      if (present.length === 0) break;
+      const idx = Math.min(...present);
+      const isOpen = idx === open;
+      emit(buf.slice(0, idx), inThink);
+      if (isOpen && line) flushLine(false);
+      inThink = isOpen;
+      buf = buf.slice(idx + (isOpen ? THINK_OPEN.length : THINK_CLOSE.length));
+    }
+    const hold = pendingTagLen(buf);
+    emit(buf.slice(0, buf.length - hold), inThink);
+    buf = buf.slice(buf.length - hold);
+  };
+  return {
+    push: (delta) => {
+      buf += delta;
+      drain();
+    },
+    end: () => {
+      emit(buf, inThink);
+      buf = "";
+      if (line) flushLine(false);
+    }
+  };
+}
+
+// src/main.ts
+function envOn(v) {
+  return !!v && v !== "0" && v.toLowerCase() !== "false";
+}
+function resetTurn(t) {
+  t.inputTokens = 0;
+  t.outputTokens = 0;
+  t.toolCalls = 0;
+  t.modelCalls = 0;
+}
+function captureStats(base, turn) {
+  const wrap = (l) => ({
+    info: (obj, msg) => {
+      if (obj.kind === "model_call") {
+        turn.modelCalls += 1;
+        const usage = obj.usage;
+        if (usage !== null && typeof usage === "object") {
+          const u = usage;
+          if (typeof u.inputTokens === "number") turn.inputTokens += u.inputTokens;
+          if (typeof u.outputTokens === "number") turn.outputTokens += u.outputTokens;
+        }
+      } else if (obj.kind === "tool_call") {
+        turn.toolCalls += 1;
+      }
+      l.info(obj, msg);
+    },
+    warn: (obj, msg) => {
+      l.warn(obj, msg);
+    },
+    error: (obj, msg) => {
+      l.error(obj, msg);
+    },
+    child: (b) => wrap(l.child(b))
+  });
+  return wrap(base);
+}
+var echoTool = defineTool({
+  name: "echo",
+  description: "Echo text back verbatim. Use when asked to repeat or echo something.",
+  parameters: z4.object({ text: z4.string().describe("the text to echo") }),
+  execute: ({ text: text2 }) => Promise.resolve({ echoed: text2 })
+});
+function parseSkillArgs() {
+  const args = process.argv.slice(2);
+  const idx = args.indexOf("--skills");
+  if (idx === -1) return [];
+  return (args[idx + 1] ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+}
+var currentSessionId = `cli-${(/* @__PURE__ */ new Date()).getTime().toString()}`;
+async function runCli() {
+  const envLogFile = process.env.THINY_LOG_FILE?.trim();
+  const logFile = envLogFile && envLogFile.length > 0 ? envLogFile : `${process.env.HOME ?? "."}/thiny-cli.log`;
+  const fileLogger = pinoLogger({ level: process.env.LOG_LEVEL ?? "info", file: logFile });
+  const turn = { inputTokens: 0, outputTokens: 0, toolCalls: 0, modelCalls: 0 };
+  const session = { inputTokens: 0, outputTokens: 0, toolCalls: 0, turns: 0 };
+  const logger = captureStats(fileLogger, turn);
+  const activeModelName = process.env.THINY_MODEL ?? process.env.AGENT_MODEL ?? "openai:gpt-4o-mini";
+  const personaName = process.env.THINY_PERSONA_NAME ?? "Thiny";
+  const model = loadThinyConfig();
+  const network = process.env.WALRUS_NETWORK === "mainnet" ? "mainnet" : "testnet";
+  const walrus = walrusClient({
+    network,
+    publisher: process.env.WALRUS_PUBLISHER_URL,
+    aggregator: process.env.WALRUS_AGGREGATOR_URL
+  });
+  const walrusAudit = envOn(process.env.WALRUS_AUDIT) ? walrusAuditLogger(logger, walrus, { sessionId: currentSessionId }) : null;
+  const agentLogger = walrusAudit ?? logger;
+  const userId = process.env.THINY_USER_ID ?? "default";
+  const memwalEnabled = !!process.env.MEMWAL_DELEGATE_KEY && !!process.env.MEMWAL_ACCOUNT_ID;
+  const memBackend = memwalEnabled ? "MemWal" : "Walrus";
+  const memoryRefs = [];
+  let pendingWrites = 0;
+  let deliverRef = (ref) => memoryRefs.push(ref);
+  const memoryPlugin = memwalEnabled ? memwalFactsPlugin({
+    delegateKey: process.env.MEMWAL_DELEGATE_KEY,
+    accountId: process.env.MEMWAL_ACCOUNT_ID,
+    serverUrl: process.env.MEMWAL_SERVER_URL,
+    namespace: process.env.MEMWAL_NAMESPACE ?? userId
+  }) : walrusMemoryPlugin({
+    client: walrus,
+    pointers: filePointerStore(process.env.WALRUS_POINTERS ?? "thiny-pointers.json"),
+    userId,
+    onStoreStart: () => pendingWrites += 1,
+    onStore: (ref) => {
+      if (pendingWrites > 0) pendingWrites -= 1;
+      deliverRef(ref);
+    }
+  });
+  const configSkills = readThinyConfig().skills ?? [];
+  const cliSkills = parseSkillArgs();
+  const requestedSkillIds = [.../* @__PURE__ */ new Set([...configSkills, ...cliSkills])];
+  const { plugins: skillPlugins, warnings: skillWarnings } = await loadSkills(
+    requestedSkillIds,
+    process.env
+  );
+  const persona = process.env.THINY_PERSONA_NAME ? { name: process.env.THINY_PERSONA_NAME, description: process.env.THINY_PERSONA_DESCRIPTION } : void 0;
+  const budget = budgetMiddleware({ maxCalls: 50, logger });
+  const agent = await createAgent({
+    model,
+    logger: agentLogger,
+    persona,
+    systemPrompt: "You are a helpful AI assistant. Use tools when they help you answer better. Be concise.\n\nMEMORY: You have persistent long-term memory across sessions, stored on Walrus. What you already know about the user is injected automatically at the start of each conversation under \u201C[User Memory \u2026]\u201D. When the user shares anything durable about themselves \u2014 their name, role, preferences, projects, or goals, even casually \u2014 immediately call remember_fact to save it. If asked what you remember, answer from the injected user memory (or call recall_memory). You DO remember across sessions \u2014 never say you lack memory or that each session starts fresh.\n\nFor multi-step work, call update_plan to track steps and delegate_task to hand focused sub-problems to a sub-agent.",
+    tools: [echoTool],
+    plugins: [
+      {
+        name: "observability",
+        modelMiddleware: [modelAuditMiddleware(agentLogger), budget],
+        toolMiddleware: [toolAuditMiddleware(agentLogger)]
+      },
+      agentsPlugin(),
+      memoryPlugin,
+      ...skillPlugins
+    ]
+  });
+  clearScreen();
+  renderHeader({
+    model: activeModelName,
+    session: currentSessionId,
+    persona: personaName,
+    version: "v0.1.0"
+  });
+  const registeredTools = agent.registry.all().map((t) => t.name).filter((name) => name !== "echo");
+  const skillsByCategory = /* @__PURE__ */ new Map();
+  if (requestedSkillIds.length > 0) {
+    for (const id of requestedSkillIds) {
+      const def = defaultRegistry.all().find((s) => s.id === id);
+      if (!def) continue;
+      const existing = skillsByCategory.get(def.category) ?? [];
+      existing.push(def.id);
+      skillsByCategory.set(def.category, existing);
+    }
+  } else {
+    for (const [cat, defs] of defaultRegistry.byCategory()) {
+      skillsByCategory.set(
+        cat,
+        defs.map((d) => d.id)
+      );
+    }
+  }
+  renderToolsAndSkills(registeredTools, skillsByCategory, {
+    model: activeModelName,
+    session: currentSessionId,
+    persona: personaName
+  });
+  renderHints(logFile);
+  for (const w of skillWarnings) renderWarning(w);
+  renderInfo(
+    `Memory: ${memwalEnabled ? "MemWal (semantic)" : "Walrus"} \xB7 cross-session, portable (user: ${userId})`
+  );
+  if (walrusAudit)
+    renderInfo(`Walrus audit: ON (${network}) \u2014 each turn's action log is stored + verifiable`);
+  const rl = createInterface({ input: stdin, output: stdout });
+  const spinner = new Spinner();
+  const flushMemory = memoryPlugin.flush;
+  const PROMPT = "\x1B[36mYou\x1B[0m \x1B[2m\u203A\x1B[0m ";
+  let atPrompt = false;
+  const printAbovePrompt = (fn) => {
+    if (atPrompt) {
+      cursorTo(stdout, 0);
+      clearLine(stdout, 0);
+    }
+    fn();
+    if (atPrompt) rl.prompt(true);
+  };
+  deliverRef = (ref) => {
+    if (atPrompt) {
+      printAbovePrompt(() => {
+        renderStored("memory saved", explorerLinks(ref, network), memBackend);
+      });
+    } else memoryRefs.push(ref);
+  };
+  try {
+    for (; ; ) {
+      for (const ref of memoryRefs.splice(0))
+        renderStored("memory saved", explorerLinks(ref, network), memBackend);
+      if (pendingWrites > 0) renderSaving("memory", memBackend);
+      atPrompt = true;
+      const input = await rl.question(PROMPT);
+      atPrompt = false;
+      const trimmed = input.trim();
+      if (!trimmed) continue;
+      if (trimmed.startsWith("/")) {
+        const parts = trimmed.slice(1).split(" ");
+        const cmd = parts[0];
+        switch (cmd) {
+          case "new": {
+            currentSessionId = `cli-${(/* @__PURE__ */ new Date()).getTime().toString()}`;
+            renderInfo("New session started \u2014 long-term memory carries over");
+            break;
+          }
+          case "tools":
+            renderInfo(
+              `
+Tools:
+${agent.registry.all().map((t) => `  \u2022 ${t.name}  ${t.description.slice(0, 55)}`).join("\n")}
+`
+            );
+            break;
+          case "skills":
+            renderInfo("\nAvailable skills:");
+            for (const [cat, defs] of defaultRegistry.byCategory()) {
+              renderInfo(`  [${cat}]  ${defs.map((d) => d.id).join(", ")}`);
+            }
+            renderInfo("");
+            break;
+          case "session":
+            renderInfo(`Session: ${currentSessionId}`);
+            break;
+          case "stats":
+            renderInfo(
+              `
+Session ${currentSessionId.slice(-8)} \xB7 ${String(session.turns)} turn${session.turns === 1 ? "" : "s"}
+  tokens: \u2191${formatTokens(session.inputTokens)} \u2193${formatTokens(session.outputTokens)}
+  tool calls: ${String(session.toolCalls)}
+`
+            );
+            break;
+          case "verify": {
+            const blobId = parts[1];
+            if (!blobId) {
+              renderWarning("usage: /verify <blobId>");
+              break;
+            }
+            try {
+              const trail = await verifyAuditTrail(walrus, blobId);
+              renderInfo(
+                `
+Audit trail ${blobId}
+  session: ${trail.sessionId}  \xB7  ${String(trail.count)} entries  \xB7  ${trail.createdAt}`
+              );
+              for (const e of trail.entries) {
+                const what = typeof e.kind === "string" ? e.kind : typeof e.event === "string" ? e.event : "";
+                const tool = typeof e.tool === "string" ? ` (${e.tool})` : "";
+                renderInfo(`  \u2022 [${e.level}] ${what}${tool}`);
+              }
+              renderInfo(`
+  source: ${walruscanBlobUrl(blobId, network)}
+`);
+            } catch (err) {
+              renderError(err instanceof Error ? err.message : String(err));
+            }
+            break;
+          }
+          case "clear":
+            clearScreen();
+            renderHeader({ model: activeModelName, session: currentSessionId, persona: personaName });
+            renderToolsAndSkills(registeredTools, skillsByCategory, {
+              model: activeModelName,
+              session: currentSessionId,
+              persona: personaName
+            });
+            renderHints(logFile);
+            break;
+          case "help":
+            renderInfo(
+              "\n/new \xB7 /tools \xB7 /skills \xB7 /stats \xB7 /session \xB7 /verify <blobId> \xB7 /clear \xB7 /help\n"
+            );
+            break;
+          default:
+            renderWarning(`Unknown command: /${cmd ?? ""}  \u2014 try /help`);
+        }
+        continue;
+      }
+      renderAgentLabel(personaName);
+      spinner.start("thinking\u2026");
+      budget.reset();
+      resetTurn(turn);
+      const startedAt = Date.now();
+      try {
+        let firstToken = true;
+        const stream = createMarkdownWriter((s) => stdout.write(s));
+        const toolHandler = (payload) => {
+          const { call } = payload;
+          spinner.stop();
+          stdout.write(`  \x1B[33m\u2699\x1B[0m \x1B[2m${call.name}\x1B[0m
+`);
+          spinner.start("running\u2026");
+        };
+        agent.events.on("beforeToolCall", toolHandler);
+        const reply = await agent.run(trimmed, {
+          sessionId: currentSessionId,
+          onToken: (delta) => {
+            spinner.stop();
+            firstToken = false;
+            stream.push(delta);
+          }
+        });
+        agent.events.off("beforeToolCall", toolHandler);
+        spinner.stop();
+        if (firstToken) {
+          stream.push(reply.length > 0 ? reply : "\x1B[2m(model returned empty response)\x1B[0m");
+        }
+        stream.end();
+        renderAgentDone();
+        const durMs = Date.now() - startedAt;
+        session.turns += 1;
+        session.inputTokens += turn.inputTokens;
+        session.outputTokens += turn.outputTokens;
+        session.toolCalls += turn.toolCalls;
+        renderStatus([
+          activeModelName,
+          `${(durMs / 1e3).toFixed(1)}s`,
+          `\u2191${formatTokens(turn.inputTokens)} \u2193${formatTokens(turn.outputTokens)}`,
+          turn.toolCalls > 0 ? `${String(turn.toolCalls)} tool${turn.toolCalls === 1 ? "" : "s"}` : ""
+        ]);
+        for (const ref of memoryRefs.splice(0))
+          renderStored("memory saved", explorerLinks(ref, network), memBackend);
+        if (walrusAudit && walrusAudit.entries().length > 0) {
+          pendingWrites += 1;
+          const flushP = walrusAudit.flush(currentSessionId);
+          walrusAudit.reset();
+          void flushP.then((ref) => {
+            if (pendingWrites > 0) pendingWrites -= 1;
+            if (ref) deliverRef(ref);
+          }).catch((err) => {
+            if (pendingWrites > 0) pendingWrites -= 1;
+            const m = `Walrus audit flush failed: ${err instanceof Error ? err.message : String(err)}`;
+            if (atPrompt) {
+              printAbovePrompt(() => {
+                renderWarning(m);
+              });
+            } else renderWarning(m);
+          });
+        }
+      } catch (err) {
+        spinner.stop();
+        const msg = err instanceof Error ? err.message : String(err);
+        const looksLikeModelError = /\b(model|api|channel|base ?url|unauthorized|not found|invalid|401|404)\b/i.test(msg);
+        renderError(
+          looksLikeModelError ? `${msg}
+  \u21B3 Check your model, base URL, and API key (run \`thiny init\`, or edit ~/.thiny/config.json / .env).` : msg
+        );
+      }
+    }
+  } finally {
+    if (flushMemory) await flushMemory().catch(() => void 0);
+  }
+}
+
+// src/onboarding.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync, mkdirSync, chmodSync } from "fs";
+import { homedir } from "os";
+import { join, dirname as dirname2 } from "path";
+import { fileURLToPath } from "url";
+import * as p from "@clack/prompts";
+var THINY_DIR = join(homedir(), ".thiny");
+var CONFIG = join(THINY_DIR, "config.json");
+function version() {
+  try {
+    const pkg = join(dirname2(fileURLToPath(import.meta.url)), "../package.json");
+    return JSON.parse(readFileSync2(pkg, "utf8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function loadConfig() {
+  return existsSync2(CONFIG) ? JSON.parse(readFileSync2(CONFIG, "utf8")) : null;
+}
+function saveConfig(cfg) {
+  mkdirSync(THINY_DIR, { recursive: true });
+  chmodSync(THINY_DIR, 448);
+  writeFileSync(CONFIG, JSON.stringify(cfg, null, 2));
+  chmodSync(CONFIG, 384);
+}
+function applyConfig(cfg) {
+  if (!cfg) return;
+  const set = (k, v) => {
+    if (v && !process.env[k]) process.env[k] = v;
+  };
+  set("THINY_MODEL", cfg.model);
+  if (cfg.apiKey) {
+    set(cfg.model?.startsWith("anthropic") ? "THINY_ANTHROPIC_API_KEY" : "THINY_OPENAI_API_KEY", cfg.apiKey);
+  }
+  set("THINY_OPENAI_BASE_URL", cfg.baseUrl);
+  set("THINY_PERSONA_NAME", cfg.agentName);
+  set("THINY_USER_ID", cfg.userId);
+  if (cfg.sui?.network) {
+    set("SUI_NETWORK", cfg.sui.network);
+    if (cfg.sui.network === "mainnet") set("SUI_ALLOW_MAINNET", "1");
+  }
+  const sk = cfg.sui?.wallet.secretKey;
+  if (sk) {
+    set("SUI_SECRET_KEY", sk);
+    set("THINY_SUI_SECRET_KEY", sk);
+  }
+  set("MCP_URL", cfg.sui?.rillMcpUrl);
+}
+function bail(v) {
+  if (p.isCancel(v)) {
+    p.cancel("Cancelled.");
+    process.exit(0);
+  }
+  return v;
+}
+var MODELS = [
+  { value: "oai-mini", label: "OpenAI \xB7 gpt-4o-mini", hint: "fast, cheap", model: "openai:gpt-4o-mini", needsKey: true },
+  { value: "oai-4o", label: "OpenAI \xB7 gpt-4o", model: "openai:gpt-4o", needsKey: true },
+  { value: "claude-haiku", label: "Anthropic \xB7 claude-haiku-4-5", model: "anthropic:claude-haiku-4-5-20251001", needsKey: true },
+  { value: "claude-sonnet", label: "Anthropic \xB7 claude-sonnet-4-6", model: "anthropic:claude-sonnet-4-6", needsKey: true },
+  { value: "ollama", label: "Ollama", hint: "local, no key", model: "llama3", baseUrl: "http://localhost:11434/v1", apiKey: "ollama" },
+  { value: "custom", label: "Custom", hint: "any OpenAI-compatible endpoint", custom: true }
+];
+async function baseSetup() {
+  p.intro(`Thiny ${version()} \u2014 setup`);
+  const agentName = bail(
+    await p.text({ message: "Agent name", placeholder: "ThinyAI", defaultValue: "ThinyAI" })
+  );
+  const choice = bail(
+    await p.select({ message: "Pick a model", options: MODELS.map(({ value, label, hint }) => ({ value, label, hint })) })
+  );
+  const pick = MODELS.find((m) => m.value === choice) ?? MODELS[0];
+  const cfg = { agentName, userId: "default" };
+  if (pick.custom) {
+    cfg.model = bail(
+      await p.text({ message: "Model id", placeholder: "e.g. MiniMax-M3", validate: (v) => v ? void 0 : "Required" })
+    );
+    cfg.baseUrl = bail(
+      await p.text({
+        message: "Base URL (OpenAI-compatible)",
+        placeholder: "https://api.example.com/v1",
+        validate: (v) => /^https?:\/\//.test(v) ? void 0 : "Must start with http(s)://"
+      })
+    );
+    cfg.apiKey = bail(await p.password({ message: "API key" }));
+  } else {
+    cfg.model = pick.model;
+    if (pick.baseUrl) cfg.baseUrl = pick.baseUrl;
+    cfg.apiKey = pick.apiKey ?? (pick.needsKey ? bail(await p.password({ message: "API key" })) : void 0);
+  }
+  saveConfig(cfg);
+  p.outro(`Saved ${CONFIG} \u2014 run \`thiny\` to start, or \`thiny sui init\` for Sui.`);
+  return cfg;
+}
+async function suiInit() {
+  let cfg = loadConfig();
+  cfg ??= await baseSetup();
+  p.intro("Thiny \u2014 Sui setup");
+  const network = bail(
+    await p.select({
+      message: "Sui network (you can change this later)",
+      options: [
+        { value: "testnet", label: "Testnet", hint: "recommended for testing" },
+        { value: "mainnet", label: "Mainnet", hint: "real funds" }
+      ]
+    })
+  );
+  const choice = bail(
+    await p.select({
+      message: "Wallet",
+      options: [
+        { value: "paste", label: "Paste an existing private key", hint: "suiprivkey\u2026" },
+        { value: "generate", label: "Generate a new key pair locally" },
+        { value: "rill", label: "Agent wallet with on-chain capabilities", hint: "Rill" }
+      ]
+    })
+  );
+  const { Ed25519Keypair } = await import("@mysten/sui/keypairs/ed25519");
+  let wallet;
+  let address;
+  if (choice === "generate" || choice === "rill") {
+    const kp = Ed25519Keypair.generate();
+    wallet = { type: "generated", secretKey: kp.getSecretKey() };
+    address = kp.getPublicKey().toSuiAddress();
+  } else {
+    const sk = bail(
+      await p.password({
+        message: "Private key (suiprivkey\u2026)",
+        validate: (v) => v.startsWith("suiprivkey") ? void 0 : "Expected a suiprivkey\u2026 string"
+      })
+    );
+    wallet = { type: "imported", secretKey: sk };
+    address = Ed25519Keypair.fromSecretKey(sk).getPublicKey().toSuiAddress();
+  }
+  cfg.sui = { network, wallet, address };
+  if (choice === "rill") {
+    const url = bail(
+      await p.text({ message: "Rill MCP URL", placeholder: "leave blank to add later", defaultValue: "" })
+    );
+    if (url) cfg.sui.rillMcpUrl = url;
+  }
+  saveConfig(cfg);
+  const faucet = network === "testnet" ? "\nFaucet: https://faucet.sui.io  (or `sui client faucet`)" : "";
+  p.note(`${address}${faucet}`, `\u26A0 Fund this address (${network}) before sending transactions`);
+  p.outro(`Sui configured (${network}).`);
+}
+async function ensureSetup() {
+  if (loadConfig() || process.env.THINY_MODEL) return;
+  await baseSetup();
+}
+
+// src/bin.ts
+function help() {
+  console.log(`thiny ${version()}
+
+Usage:
+  thiny                 Start the interactive CLI agent (runs setup on first use)
+  thiny init            Re-run setup (model, agent name, key)
+  thiny sui init        Add Sui capabilities (network + wallet)
+  thiny --version       Print version
+  thiny help            Show this help
+
+Config: ~/.thiny/config.json  (no .env needed)`);
+}
+async function run() {
+  const [sub, sub2] = process.argv.slice(2);
+  switch (sub) {
+    case "init":
+      await baseSetup();
+      return;
+    case "sui":
+      if (sub2 === "init") await suiInit();
+      else console.log("Usage: thiny sui init");
+      return;
+    case "--version":
+    case "-v":
+      console.log(version());
+      return;
+    case "help":
+    case "--help":
+    case "-h":
+      help();
+      return;
+    default:
+      await ensureSetup();
+      applyConfig(loadConfig());
+      await runCli();
+  }
+}
+run().catch((err) => {
+  process.stderr.write(`Fatal: ${err instanceof Error ? err.message : String(err)}
+`);
+  process.exit(1);
+});