@sbugallo/opencode-vpet 0.1.1 → 0.2.0

package/dist/index.js

@@ -1,24 +1,114 @@
 // @bun
+// src/index.ts
+import { Plugin } from "@opencode/plugin";
+
+// src/domain/stage.ts
+var DIGIMON_STAGES = [0, 1, 2, 3, 4, 5, 6, 7];
+var isDigimonStage = (value) => {
+  return DIGIMON_STAGES.some((stage) => stage === value);
+};
+
+// src/domain/evolution.ts
+var STAGE_GAUGE_THRESHOLDS = Object.freeze({
+  0: 500000,
+  1: 1e6,
+  2: 2000000,
+  3: 4000000,
+  4: 7500000,
+  5: 12500000,
+  6: 20000000,
+  7: 30000000
+});
+var isRecord = (value) => {
+  return typeof value === "object" && value !== null;
+};
+var isStageThresholds = (thresholds) => {
+  if (!isRecord(thresholds) || !Object.isFrozen(thresholds))
+    return false;
+  return DIGIMON_STAGES.every((stage) => {
+    const threshold = thresholds[stage];
+    return typeof threshold === "number" && Number.isFinite(threshold) && threshold > 0;
+  });
+};
+var applyTokenProgress = (state, tokenDelta, selector, digimonById, thresholds) => {
+  if (!isStageThresholds(thresholds)) {
+    throw new Error("Evolution thresholds must be a complete frozen policy of positive finite numbers");
+  }
+  if (state.isTerminal)
+    return state;
+  const gauge = state.gauge + tokenDelta;
+  if (gauge < thresholds[state.current.stage])
+    return { ...state, gauge };
+  if (state.current.nextEvolutions.length === 0)
+    return { ...state, gauge: 0, isTerminal: true };
+  const selection = selector();
+  if (!Number.isFinite(selection) || selection < 0 || selection >= 1) {
+    throw new Error(`Evolution selector must return a finite number in [0, 1), received ${selection}`);
+  }
+  const targetId = state.current.nextEvolutions[Math.floor(selection * state.current.nextEvolutions.length)];
+  if (targetId === undefined)
+    throw new Error("Evolution target selection failed");
+  const current = digimonById.get(targetId);
+  if (current === undefined)
+    throw new Error(`Evolution target ${targetId} is missing from the catalog`);
+  return { current, gauge: 0, isTerminal: current.nextEvolutions.length === 0 };
+};
+
+// src/application/use-cases/record-usage.ts
+var recordUsage = ({
+  usage,
+  ledger,
+  digimonById,
+  selector,
+  thresholds
+}) => {
+  let evolution;
+  const outcome = ledger.applyUsageReceipt(usage, (partner) => {
+    const current = digimonById.get(partner.currentNodeId);
+    if (current === undefined)
+      throw new Error(`Persisted partner node ${partner.currentNodeId} is missing from the catalog`);
+    const next = applyTokenProgress({ current, gauge: partner.gauge, isTerminal: partner.isTerminal }, usage.tokenDelta, selector, digimonById, thresholds);
+    if (next.current.id !== current.id) {
+      evolution = { fromNodeId: current.id, toNodeId: next.current.id };
+    }
+    return { currentNodeId: next.current.id, gauge: next.gauge, isTerminal: next.isTerminal };
+  });
+  switch (outcome.kind) {
+    case "applied":
+      return evolution === undefined ? { kind: "applied", receiptKey: usage.receiptKey } : { kind: "applied", receiptKey: usage.receiptKey, evolution };
+    case "duplicate":
+      return { kind: "duplicate", receiptKey: usage.receiptKey };
+    case "no_active_partner":
+      return { kind: "no_active_partner", receiptKey: usage.receiptKey };
+  }
+};
+
+// src/application/use-cases/reconcile-usage.ts
+var reconcileUsage = ({
+  usages,
+  ledger,
+  digimonById,
+  selector,
+  thresholds
+}) => {
+  const outcomes = [];
+  for (const usage of usages) {
+    outcomes.push(recordUsage({ usage, ledger, digimonById, selector, thresholds }));
+  }
+  return outcomes;
+};
+
 // src/application/use-cases/freeze-vpet.ts
 var freezeVpet = (control) => control.freeze();
 
 // src/commands/vpet-freeze.ts
-var runVpetFreezeCommand = async (control, context) => {
+var runVpetFreezeCommand = async (control) => {
   const outcome = freezeVpet(control);
-  const parts = [
-    {
-      id: context.messageID,
-      sessionID: context.sessionID,
-      messageID: context.messageID,
-      type: "text",
-      text: "VPet frozen."
-    }
-  ];
   switch (outcome.kind) {
     case "frozen":
-      return { parts, event: { kind: "frozen" } };
+      return { message: "VPet frozen.", variant: "info", event: { kind: "frozen" } };
     case "already_frozen":
-      return { parts };
+      return { message: "VPet is already frozen.", variant: "info" };
     default: {
       const unexpectedOutcome = outcome;
       return unexpectedOutcome;
@@ -26,65 +116,30 @@ var runVpetFreezeCommand = async (control, context) => {
   }
 };
 
-// src/application/use-cases/spawn-partner.ts
-var spawnPartner = (lifecycle, createdAt) => {
-  const partner = lifecycle.spawnPartner({
-    currentNodeId: "0-001",
-    gauge: 0,
-    isTerminal: false,
-    createdAt
-  });
-  return { generation: partner.generation };
-};
-
-// src/commands/vpet-spawn.ts
-var runVpetSpawnCommand = async (lifecycle, context) => {
-  const partner = spawnPartner(lifecycle, context.createdAt);
-  return {
-    parts: [
-      {
-        id: context.messageID,
-        sessionID: context.sessionID,
-        messageID: context.messageID,
-        type: "text",
-        text: `Spawned Generation ${partner.generation}.`
-      }
-    ],
-    event: { kind: "spawned", nodeId: "0-001", generation: partner.generation }
-  };
-};
-
 // src/application/use-cases/set-vpet-cheat-node.ts
 var setVpetCheatNode = (control, validatedNodeId) => control.setCheatNode(validatedNodeId);
 
 // src/commands/vpet-set.ts
-var textPart = (context, text) => ({
-  id: context.messageID,
-  sessionID: context.sessionID,
-  messageID: context.messageID,
-  type: "text",
-  text
-});
 var runVpetSetCommand = async (control, context, loadCatalog) => {
   if (context.arguments.includes(`
 `))
-    return { parts: [textPart(context, "Usage: /vpet-set <id>.")] };
+    return { message: "Usage: /vpet-set <id>.", variant: "warning" };
   const tokens = context.arguments.trim().split(/\s+/);
   if (context.arguments.trim() === "" || tokens.length !== 1)
-    return { parts: [textPart(context, "Usage: /vpet-set <id>.")] };
+    return { message: "Usage: /vpet-set <id>.", variant: "warning" };
   const requestedId = tokens[0];
   if (requestedId === undefined)
-    return { parts: [textPart(context, "Usage: /vpet-set <id>.")] };
+    return { message: "Usage: /vpet-set <id>.", variant: "warning" };
   const node = (await loadCatalog()).byId.get(requestedId);
   if (node === undefined)
-    return { parts: [textPart(context, `Unknown Digimon ID: ${requestedId}.`)] };
+    return { message: `Unknown Digimon ID: ${requestedId}.`, variant: "warning" };
   const outcome = setVpetCheatNode(control, node.id);
-  const parts = [textPart(context, `VPet set to ${node.nameEn} (${node.id}).`)];
+  const message = `VPet set to ${node.nameEn} (${node.id}).`;
   switch (outcome.kind) {
     case "set":
-      return { parts, event: { kind: "set", nodeId: node.id } };
+      return { message, variant: "info", event: { kind: "set", nodeId: node.id } };
     case "already_set":
-      return { parts };
+      return { message, variant: "info" };
     default: {
       const unexpectedOutcome = outcome;
       return unexpectedOutcome;
@@ -92,26 +147,38 @@ var runVpetSetCommand = async (control, context, loadCatalog) => {
   }
 };
 
+// src/application/use-cases/spawn-partner.ts
+var spawnPartner = (lifecycle, createdAt) => {
+  const partner = lifecycle.spawnPartner({
+    currentNodeId: "0-001",
+    gauge: 0,
+    isTerminal: false,
+    createdAt
+  });
+  return { generation: partner.generation };
+};
+
+// src/commands/vpet-spawn.ts
+var runVpetSpawnCommand = async (lifecycle, context) => {
+  const partner = spawnPartner(lifecycle, context.createdAt);
+  return {
+    message: `Spawned Generation ${partner.generation}.`,
+    variant: "info",
+    event: { kind: "spawned", nodeId: "0-001", generation: partner.generation }
+  };
+};
+
 // src/application/use-cases/unfreeze-vpet.ts
 var unfreezeVpet = (control) => control.unfreeze();
 
 // src/commands/vpet-unfreeze.ts
-var runVpetUnfreezeCommand = async (control, context) => {
+var runVpetUnfreezeCommand = async (control) => {
   const outcome = unfreezeVpet(control);
-  const parts = [
-    {
-      id: context.messageID,
-      sessionID: context.sessionID,
-      messageID: context.messageID,
-      type: "text",
-      text: "VPet unfrozen."
-    }
-  ];
   switch (outcome.kind) {
     case "unfrozen":
-      return { parts, event: { kind: "unfrozen" } };
+      return { message: "VPet unfrozen.", variant: "info", event: { kind: "unfrozen" } };
     case "already_unfrozen":
-      return { parts };
+      return { message: "VPet is not frozen.", variant: "info" };
     default: {
       const unexpectedOutcome = outcome;
       return unexpectedOutcome;
@@ -119,6 +186,121 @@ var runVpetUnfreezeCommand = async (control, context) => {
   }
 };
 
+// src/config/global-vpet-settings.ts
+import { readFile } from "fs/promises";
+import { homedir } from "os";
+import { join } from "path";
+
+// src/config/defaults.ts
+var EN_STAGE_LABELS = Object.freeze({
+  egg: "DigiEgg",
+  babyI: "In Training I",
+  babyII: "In Training II",
+  child: "Rookie",
+  adult: "Champion",
+  perfect: "Ultimate",
+  ultimate: "Mega",
+  superUltimate: "Ultra"
+});
+var JP_STAGE_LABELS = Object.freeze({
+  egg: "Digitama",
+  babyI: "Baby I",
+  babyII: "Baby II",
+  child: "Child",
+  adult: "Adult",
+  perfect: "Perfect",
+  ultimate: "Ultimate",
+  superUltimate: "SuperUltimate"
+});
+var VPET_STAGE_LABELS = Object.freeze({
+  en: EN_STAGE_LABELS,
+  jp: JP_STAGE_LABELS
+});
+var DEFAULT_STAGE_THRESHOLDS = Object.freeze({
+  egg: 500000,
+  babyI: 1e6,
+  babyII: 2000000,
+  child: 4000000,
+  adult: 7500000,
+  perfect: 12500000,
+  ultimate: 20000000,
+  superUltimate: 30000000
+});
+var DEFAULT_VPET_SETTINGS = Object.freeze({
+  language: "jp",
+  notifications: true,
+  stageLabels: VPET_STAGE_LABELS,
+  stageThresholds: DEFAULT_STAGE_THRESHOLDS
+});
+
+// src/config/normalize.ts
+var isRecord2 = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var isLanguage = (value) => value === "en" || value === "jp";
+var isBoolean = (value) => typeof value === "boolean";
+var isThreshold = (value) => {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+};
+var read = (input, key) => {
+  try {
+    return input[key];
+  } catch {
+    return;
+  }
+};
+var normalizeThreshold = (input, key) => {
+  const value = read(input, key);
+  return isThreshold(value) ? value : DEFAULT_STAGE_THRESHOLDS[key];
+};
+var normalizeVpetSettings = (input) => {
+  try {
+    if (!isRecord2(input))
+      return DEFAULT_VPET_SETTINGS;
+    const thresholdInput = read(input, "stageThresholds");
+    const thresholds = isRecord2(thresholdInput) ? thresholdInput : {};
+    const stageThresholds = Object.freeze({
+      egg: normalizeThreshold(thresholds, "egg"),
+      babyI: normalizeThreshold(thresholds, "babyI"),
+      babyII: normalizeThreshold(thresholds, "babyII"),
+      child: normalizeThreshold(thresholds, "child"),
+      adult: normalizeThreshold(thresholds, "adult"),
+      perfect: normalizeThreshold(thresholds, "perfect"),
+      ultimate: normalizeThreshold(thresholds, "ultimate"),
+      superUltimate: normalizeThreshold(thresholds, "superUltimate")
+    });
+    const language = read(input, "language");
+    const notifications = read(input, "notifications");
+    return Object.freeze({
+      language: isLanguage(language) ? language : DEFAULT_VPET_SETTINGS.language,
+      notifications: isBoolean(notifications) ? notifications : DEFAULT_VPET_SETTINGS.notifications,
+      stageLabels: DEFAULT_VPET_SETTINGS.stageLabels,
+      stageThresholds
+    });
+  } catch {
+    return DEFAULT_VPET_SETTINGS;
+  }
+};
+
+// src/config/global-vpet-settings.ts
+var resolveGlobalVpetConfigPath = (options = {}) => {
+  const pathApi = options.pathApi ?? { join };
+  const env = options.env ?? process.env;
+  const home = options.home ?? homedir();
+  if ((options.platform ?? process.platform) === "win32") {
+    const { APPDATA } = env;
+    return pathApi.join(APPDATA ?? pathApi.join(home, "AppData", "Roaming"), "opencode-vpet.json");
+  }
+  return pathApi.join(home, ".config", "opencode-vpet.json");
+};
+var loadGlobalVpetSettings = async (options = {}) => {
+  try {
+    return normalizeVpetSettings(JSON.parse(await readFile(resolveGlobalVpetConfigPath(options), "utf8")));
+  } catch {
+    return DEFAULT_VPET_SETTINGS;
+  }
+};
+
 // src/data/digimon-data.ts
 var DIGIMON_DATA = [
   {
@@ -6227,12 +6409,6 @@ var DIGIMON_DATA = [
   }
 ];
 
-// src/domain/stage.ts
-var DIGIMON_STAGES = [0, 1, 2, 3, 4, 5, 6, 7];
-var isDigimonStage = (value) => {
-  return DIGIMON_STAGES.some((stage) => stage === value);
-};
-
 // src/data/catalog.ts
 var parseNode = (input) => {
   if (!isDigimonStage(input.stage))
@@ -6256,131 +6432,98 @@ var parseDigimonCatalog = (input) => {
     byId.set(node.id, node);
   }
   for (const node of nodes) {
-    for (const targetId of node.nextEvolutions) {
-      if (!byId.has(targetId))
-        throw new Error(`Invalid next_evolutions reference ${targetId} from ${node.id}`);
-    }
-  }
-  return Object.freeze({ nodes: Object.freeze(nodes), byId });
-};
-var DIGIMON_CATALOG = parseDigimonCatalog(DIGIMON_DATA);
-var loadDigimonCatalog = async () => DIGIMON_CATALOG;
-
-// src/domain/evolution.ts
-var STAGE_GAUGE_THRESHOLDS = Object.freeze({
-  0: 500000,
-  1: 1e6,
-  2: 2000000,
-  3: 4000000,
-  4: 7500000,
-  5: 12500000,
-  6: 20000000,
-  7: 30000000
-});
-var isRecord = (value) => {
-  return typeof value === "object" && value !== null;
-};
-var isStageThresholds = (thresholds) => {
-  if (!isRecord(thresholds) || !Object.isFrozen(thresholds))
-    return false;
-  return DIGIMON_STAGES.every((stage) => {
-    const threshold = thresholds[stage];
-    return typeof threshold === "number" && Number.isFinite(threshold) && threshold > 0;
-  });
-};
-var applyTokenProgress = (state, tokenDelta, selector, digimonById, thresholds) => {
-  if (!isStageThresholds(thresholds)) {
-    throw new Error("Evolution thresholds must be a complete frozen policy of positive finite numbers");
-  }
-  if (state.isTerminal)
-    return state;
-  const gauge = state.gauge + tokenDelta;
-  if (gauge < thresholds[state.current.stage])
-    return { ...state, gauge };
-  if (state.current.nextEvolutions.length === 0)
-    return { ...state, gauge: 0, isTerminal: true };
-  const selection = selector();
-  if (!Number.isFinite(selection) || selection < 0 || selection >= 1) {
-    throw new Error(`Evolution selector must return a finite number in [0, 1), received ${selection}`);
-  }
-  const targetId = state.current.nextEvolutions[Math.floor(selection * state.current.nextEvolutions.length)];
-  if (targetId === undefined)
-    throw new Error("Evolution target selection failed");
-  const current = digimonById.get(targetId);
-  if (current === undefined)
-    throw new Error(`Evolution target ${targetId} is missing from the catalog`);
-  return { current, gauge: 0, isTerminal: current.nextEvolutions.length === 0 };
-};
-
-// src/application/use-cases/record-usage.ts
-var recordUsage = ({
-  usage,
-  ledger,
-  digimonById,
-  selector,
-  thresholds
-}) => {
-  let evolution;
-  const outcome = ledger.applyUsageReceipt(usage, (partner) => {
-    const current = digimonById.get(partner.currentNodeId);
-    if (current === undefined)
-      throw new Error(`Persisted partner node ${partner.currentNodeId} is missing from the catalog`);
-    const next = applyTokenProgress({ current, gauge: partner.gauge, isTerminal: partner.isTerminal }, usage.tokenDelta, selector, digimonById, thresholds);
-    if (next.current.id !== current.id) {
-      evolution = { fromNodeId: current.id, toNodeId: next.current.id };
+    for (const targetId of node.nextEvolutions) {
+      if (!byId.has(targetId))
+        throw new Error(`Invalid next_evolutions reference ${targetId} from ${node.id}`);
     }
-    return { currentNodeId: next.current.id, gauge: next.gauge, isTerminal: next.isTerminal };
-  });
-  switch (outcome.kind) {
-    case "applied":
-      return evolution === undefined ? { kind: "applied", receiptKey: usage.receiptKey } : { kind: "applied", receiptKey: usage.receiptKey, evolution };
-    case "duplicate":
-      return { kind: "duplicate", receiptKey: usage.receiptKey };
-    case "no_active_partner":
-      return { kind: "no_active_partner", receiptKey: usage.receiptKey };
   }
+  return Object.freeze({ nodes: Object.freeze(nodes), byId });
 };
+var DIGIMON_CATALOG = parseDigimonCatalog(DIGIMON_DATA);
+var loadDigimonCatalog = async () => DIGIMON_CATALOG;
 
-// src/application/use-cases/reconcile-usage.ts
-var reconcileUsage = ({
-  usages,
-  ledger,
-  digimonById,
-  selector,
-  thresholds
-}) => {
-  const outcomes = [];
-  for (const usage of usages) {
-    outcomes.push(recordUsage({ usage, ledger, digimonById, selector, thresholds }));
+// src/rpc.ts
+import { Rpc } from "@opencode/plugin/rpc";
+var VpetRpc = Rpc.define({
+  id: "vpet",
+  methods: {},
+  events: {
+    toast: {
+      schema: {
+        type: "object",
+        properties: {
+          title: { type: "string" },
+          message: { type: "string" },
+          variant: { enum: ["info", "success", "warning"] },
+          duration: { type: "number" }
+        },
+        required: ["title", "message", "variant", "duration"],
+        additionalProperties: false
+      }
+    }
   }
-  return outcomes;
+});
+
+// src/adapters/opencode/session-messages.ts
+var createSessionMessagesFetcher = (client) => {
+  return async (sessionID) => client.session.context({ sessionID });
 };
 
 // src/adapters/opencode/usage-event-mapper.ts
-var isCompletedAssistantMessage = (message) => {
-  return message.role === "assistant" && "time" in message && message.time.completed !== undefined;
+var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var toFiniteNumber = (value) => typeof value === "number" && Number.isFinite(value) ? value : undefined;
+var toTokenCount = (value) => {
+  const count = toFiniteNumber(value);
+  return count === undefined || count < 0 ? undefined : count;
 };
 var toCompletedUsageFromMessage = (message) => {
-  if (!isCompletedAssistantMessage(message))
+  if (!isRecord3(message))
+    return null;
+  const { type, id, time, tokens, cost: rawCost } = message;
+  if (type !== "assistant")
+    return null;
+  if (typeof id !== "string" || id.length === 0)
+    return null;
+  if (!isRecord3(time))
     return null;
-  const completedAt = message.time.completed;
+  const { completed } = time;
+  const completedAt = toFiniteNumber(completed);
   if (completedAt === undefined)
     return null;
+  if (!isRecord3(tokens))
+    return null;
+  const { input: rawInput, output: rawOutput, reasoning: rawReasoning, cache } = tokens;
+  if (!isRecord3(cache))
+    return null;
+  const { read: rawRead, write: rawWrite } = cache;
+  const input = toTokenCount(rawInput);
+  const output = toTokenCount(rawOutput);
+  const reasoning = toTokenCount(rawReasoning);
+  const cacheRead = toTokenCount(rawRead);
+  const cacheWrite = toTokenCount(rawWrite);
+  if (input === undefined || output === undefined || reasoning === undefined || cacheRead === undefined || cacheWrite === undefined) {
+    return null;
+  }
+  const cost = toFiniteNumber(rawCost);
   return {
-    receiptKey: `message:${message.id}`,
-    eventId: `usage:${message.id}`,
-    tokenDelta: message.tokens.input + message.tokens.output + message.tokens.reasoning + message.tokens.cache.read + message.tokens.cache.write,
-    cost: Number.isFinite(message.cost) && message.cost > 0 ? message.cost : null,
+    receiptKey: `message:${id}`,
+    eventId: `usage:${id}`,
+    tokenDelta: input + output + reasoning + cacheRead + cacheWrite,
+    cost: cost !== undefined && cost > 0 ? cost : null,
     createdAt: new Date(completedAt).toISOString()
   };
 };
-var toCompletedUsageFromEvent = (event) => {
-  if (event.type !== "message.updated")
-    return null;
-  return toCompletedUsageFromMessage(event.properties.info);
-};
 
 // src/adapters/opencode/vpet-toast.ts
+var toVpetToastPayload = (data) => {
+  if (typeof data !== "object" || data === null || Array.isArray(data))
+    return;
+  const { title, message, variant, duration } = data;
+  if (typeof title !== "string" || typeof message !== "string" || variant !== "info" && variant !== "success" && variant !== "warning" || typeof duration !== "number") {
+    return;
+  }
+  return { title, message, variant, duration };
+};
 var assertNever = (value) => {
   throw new Error(`Unhandled VPet toast event: ${JSON.stringify(value)}`);
 };
@@ -6444,9 +6587,24 @@ var createBestEffortVpetToastNotifier = (transport) => {
   });
 };
 
-// src/adapters/opencode/create-server-hooks.ts
+// src/adapters/opencode/server-plugin.ts
 var noOpNotifier = async () => {};
 var EMPTY_CATALOG = Object.freeze({ nodes: Object.freeze([]), byId: new Map });
+var isRecord4 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var getStringOption = (options, name) => {
+  const value = options[name];
+  return typeof value === "string" ? value : undefined;
+};
+var toEvolutionThresholds = (settings) => Object.freeze({
+  0: settings.stageThresholds.egg,
+  1: settings.stageThresholds.babyI,
+  2: settings.stageThresholds.babyII,
+  3: settings.stageThresholds.child,
+  4: settings.stageThresholds.adult,
+  5: settings.stageThresholds.perfect,
+  6: settings.stageThresholds.ultimate,
+  7: settings.stageThresholds.superUltimate
+});
 var toToastEvent = (result) => {
   switch (result.kind) {
     case "applied":
@@ -6484,172 +6642,226 @@ var requiresCatalog = (event) => {
   }
 };
 var createCommandConfig = () => ({
-  "vpet-spawn": { template: "Spawn a new virtual pet." },
-  "vpet-freeze": { template: "Freeze virtual pet progression." },
-  "vpet-unfreeze": { template: "Unfreeze virtual pet progression." },
-  "vpet-set": { template: "Set the virtual pet to a Digimon ID: $ARGUMENTS" }
+  "vpet-spawn": { description: "Spawn a new virtual pet." },
+  "vpet-freeze": { description: "Freeze virtual pet progression." },
+  "vpet-unfreeze": { description: "Unfreeze virtual pet progression." },
+  "vpet-set": { description: "Set the virtual pet to a Digimon ID." }
 });
-var createServerHooks = ({
+var toEventSessionID = (data) => {
+  if (!isRecord4(data))
+    return;
+  const { sessionID } = data;
+  return typeof sessionID === "string" && sessionID.length > 0 ? sessionID : undefined;
+};
+var toReconcileSessionID = (event) => {
+  if (!isRecord4(event))
+    return;
+  const { type, data } = event;
+  if (typeof type !== "string")
+    return;
+  switch (type) {
+    case "session.execution.succeeded":
+    case "session.idle":
+      return toEventSessionID(data);
+    case "session.status": {
+      if (!isRecord4(data))
+        return;
+      const { status } = data;
+      if (!isRecord4(status))
+        return;
+      const { type: statusType } = status;
+      if (statusType !== "idle")
+        return;
+      return toEventSessionID(data);
+    }
+    default:
+      return;
+  }
+};
+var consumeVpetSessionEvents = async (input) => {
+  for await (const event of input.event.subscribe({ signal: input.signal })) {
+    const sessionID = toReconcileSessionID(event);
+    if (sessionID === undefined)
+      continue;
+    const messages = await input.fetchMessages(sessionID);
+    await input.reconcile(messages);
+  }
+};
+var createVpetCommandDefinitions = ({
   repository,
-  resource,
-  evolutionSelector = Math.random,
-  evolutionThresholds = STAGE_GAUGE_THRESHOLDS,
-  fetchMessages,
-  language = "jp",
-  notificationsEnabled = true,
-  loadCatalog = loadDigimonCatalog,
-  notify = noOpNotifier
+  emit,
+  loadCatalog
 }) => {
-  let closePromise;
-  const notifyEvent = async (event, catalog) => {
-    if (!notificationsEnabled)
-      return;
-    await Promise.resolve().then(async () => {
-      const resolvedCatalog = catalog ?? (requiresCatalog(event) ? await loadCatalog() : EMPTY_CATALOG);
-      const payload = formatVpetToast(event, language, resolvedCatalog);
-      if (payload !== undefined)
-        await notify(payload);
-    }).then(() => {
-      return;
-    }, () => {
-      return;
-    });
-  };
-  return {
-    async config(config) {
-      config.command = {
-        ...config.command,
-        ...createCommandConfig()
-      };
+  const config = createCommandConfig();
+  return [
+    {
+      name: "vpet-spawn",
+      description: config["vpet-spawn"].description,
+      execute: async () => {
+        await emit(await runVpetSpawnCommand(repository, { createdAt: new Date().toISOString() }));
+      }
     },
-    async "command.execute.before"(input, output) {
-      const messageID = `vpet-${input.command}-${input.sessionID}-${crypto.randomUUID()}`;
-      switch (input.command) {
-        case "vpet-spawn":
-          {
-            const result = await runVpetSpawnCommand(repository, {
-              sessionID: input.sessionID,
-              messageID,
-              createdAt: new Date().toISOString()
-            });
-            output.parts.push(...result.parts);
-            if (result.event !== undefined)
-              await notifyEvent(toCommandToastEvent(result.event));
-          }
-          return;
-        case "vpet-freeze":
-          {
-            const result = await runVpetFreezeCommand(repository, { sessionID: input.sessionID, messageID });
-            output.parts.push(...result.parts);
-            if (result.event !== undefined)
-              await notifyEvent(toCommandToastEvent(result.event));
-          }
-          return;
-        case "vpet-unfreeze":
-          {
-            const result = await runVpetUnfreezeCommand(repository, { sessionID: input.sessionID, messageID });
-            output.parts.push(...result.parts);
-            if (result.event !== undefined)
-              await notifyEvent(toCommandToastEvent(result.event));
-          }
-          return;
-        case "vpet-set":
-          {
-            let catalog;
-            const loadCommandCatalog = async () => catalog ??= await loadCatalog();
-            const result = await runVpetSetCommand(repository, { sessionID: input.sessionID, messageID, arguments: input.arguments }, loadCommandCatalog);
-            output.parts.push(...result.parts);
-            if (result.event !== undefined)
-              await notifyEvent(toCommandToastEvent(result.event), await loadCommandCatalog());
-          }
-          return;
-        default:
-          return;
+    {
+      name: "vpet-freeze",
+      description: config["vpet-freeze"].description,
+      execute: async () => {
+        await emit(await runVpetFreezeCommand(repository));
+      }
+    },
+    {
+      name: "vpet-unfreeze",
+      description: config["vpet-unfreeze"].description,
+      execute: async () => {
+        await emit(await runVpetUnfreezeCommand(repository));
       }
     },
-    async event({ event }) {
-      switch (event.type) {
-        case "message.updated": {
-          const usage = toCompletedUsageFromEvent(event);
-          if (usage === null)
-            return;
-          const catalog = await loadCatalog();
-          const result = recordUsage({
-            usage,
-            ledger: repository,
-            digimonById: catalog.byId,
-            selector: evolutionSelector,
-            thresholds: evolutionThresholds
-          });
+    {
+      name: "vpet-set",
+      description: config["vpet-set"].description,
+      execute: async ({ prompt }) => {
+        let catalog;
+        const loadCommandCatalog = async () => catalog ??= await loadCatalog();
+        const result = await runVpetSetCommand(repository, { arguments: prompt.text }, loadCommandCatalog);
+        await emit(result, result.event === undefined ? undefined : await loadCommandCatalog());
+      }
+    }
+  ];
+};
+var setupVpetServer = async (context, dependencies) => {
+  const appDataRoot = getStringOption(context.options, "appDataRoot");
+  const databasePath = getStringOption(context.options, "databasePath");
+  const settings = await (dependencies.loadSettings ?? loadGlobalVpetSettings)();
+  const repository = await dependencies.openRepository({
+    ...appDataRoot === undefined ? {} : { appDataRoot },
+    ...databasePath === undefined ? {} : { databasePath }
+  });
+  try {
+    const language = dependencies.language ?? settings.language;
+    const notificationsEnabled = dependencies.notificationsEnabled ?? settings.notifications;
+    const evolutionSelector = dependencies.evolutionSelector ?? Math.random;
+    const evolutionThresholds = dependencies.evolutionThresholds ?? toEvolutionThresholds(settings);
+    const loadCatalog = dependencies.loadCatalog ?? loadDigimonCatalog;
+    const fetchMessages = dependencies.fetchMessages ?? createSessionMessagesFetcher(context);
+    let notify = dependencies.notify ?? noOpNotifier;
+    if (dependencies.notify === undefined && notificationsEnabled) {
+      const registration = await context.rpc.register(VpetRpc, {});
+      notify = createBestEffortVpetToastNotifier(async (payload) => {
+        await registration.events.emit("toast", payload);
+      });
+    }
+    const notifyEvent = async (event, catalog) => {
+      if (!notificationsEnabled)
+        return;
+      await Promise.resolve().then(async () => {
+        const resolvedCatalog = catalog ?? (requiresCatalog(event) ? await loadCatalog() : EMPTY_CATALOG);
+        const payload = formatVpetToast(event, language, resolvedCatalog);
+        if (payload !== undefined)
+          await notify(payload);
+      }).then(() => {
+        return;
+      }, () => {
+        return;
+      });
+    };
+    const emit = async (result, catalog) => {
+      if (result.event !== undefined) {
+        await notifyEvent(toCommandToastEvent(result.event), catalog);
+        return;
+      }
+      if (!notificationsEnabled)
+        return;
+      await Promise.resolve().then(() => notify({ title: "VPet", message: result.message, variant: result.variant, duration: 3000 })).then(() => {
+        return;
+      }, () => {
+        return;
+      });
+    };
+    const definitions = createVpetCommandDefinitions({ repository, emit, loadCatalog });
+    await context.command.transform((editor) => {
+      for (const definition of definitions)
+        editor.add(definition);
+    });
+    const usageAbortController = new AbortController;
+    let reconciliationFailed = false;
+    let reconciliationFailure;
+    const reconciliation = consumeVpetSessionEvents({
+      event: context.event,
+      signal: usageAbortController.signal,
+      fetchMessages,
+      reconcile: async (messages) => {
+        const usages = messages.flatMap((message) => {
+          const usage = toCompletedUsageFromMessage(message);
+          return usage === null ? [] : [usage];
+        });
+        if (usages.length === 0)
+          return;
+        const catalog = await loadCatalog();
+        const results = reconcileUsage({
+          usages,
+          ledger: repository,
+          digimonById: catalog.byId,
+          selector: evolutionSelector,
+          thresholds: evolutionThresholds
+        });
+        for (const result of results) {
           const toastEvent = toToastEvent(result);
           if (toastEvent !== undefined)
             await notifyEvent(toastEvent, catalog);
-          return;
-        }
-        case "session.idle": {
-          if (fetchMessages === undefined)
-            return;
-          const messages = await fetchMessages(event.properties.sessionID);
-          const usages = messages.flatMap((message) => {
-            const usage = toCompletedUsageFromMessage(message);
-            return usage === null ? [] : [usage];
-          });
-          const catalog = await loadCatalog();
-          const results = reconcileUsage({
-            usages,
-            ledger: repository,
-            digimonById: catalog.byId,
-            selector: evolutionSelector,
-            thresholds: evolutionThresholds
-          });
-          for (const result of results) {
-            const toastEvent = toToastEvent(result);
-            if (toastEvent !== undefined)
-              await notifyEvent(toastEvent, catalog);
-          }
-          return;
         }
-        default:
-          return;
       }
-    },
-    async dispose() {
-      closePromise ??= resource.close();
-      await closePromise;
+    }).catch((error) => {
+      reconciliationFailed = true;
+      reconciliationFailure = error;
+    });
+    let closePromise;
+    const closeRepository = () => closePromise ??= repository.close();
+    return async () => {
+      usageAbortController.abort();
+      await reconciliation;
+      let closeFailure;
+      try {
+        await closeRepository();
+      } catch (error) {
+        closeFailure = error;
+      }
+      if (reconciliationFailed && closeFailure !== undefined) {
+        throw new AggregateError([reconciliationFailure, closeFailure], "VPet usage reconciliation and repository cleanup failed.");
+      }
+      if (reconciliationFailed)
+        throw reconciliationFailure;
+      if (closeFailure !== undefined)
+        throw closeFailure;
+    };
+  } catch (setupFailure) {
+    try {
+      await repository.close();
+    } catch (closeFailure) {
+      throw new AggregateError([setupFailure, closeFailure], "VPet setup and repository cleanup failed.");
     }
-  };
-};
-
-// src/adapters/opencode/session-messages.ts
-var createSessionMessagesFetcher = (client) => {
-  return async (sessionID) => {
-    const result = await client.session.messages({ path: { id: sessionID } });
-    if (result.data === undefined)
-      throw new Error(`Unable to list messages for idle session ${sessionID}`);
-    return result.data.map(({ info }) => info);
-  };
+    throw setupFailure;
+  }
 };
 
 // src/adapters/sqlite/app-data-path.ts
-import { homedir } from "os";
-import { join } from "path";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 var APP_DIRECTORY_NAME = "opencode-vpet";
 var DATABASE_FILE_NAME = "pet.db";
 var resolveDefaultAppDataRoot = () => {
   if (process.platform === "darwin") {
-    return join(homedir(), "Library", "Application Support");
+    return join2(homedir2(), "Library", "Application Support");
   }
   if (process.platform === "win32") {
     const { APPDATA } = process.env;
-    return APPDATA ?? join(homedir(), "AppData", "Roaming");
+    return APPDATA ?? join2(homedir2(), "AppData", "Roaming");
   }
-  return join(homedir(), ".local", "share");
+  return join2(homedir2(), ".local", "share");
 };
 var resolveHostDataDirectory = (options = {}) => {
-  return join(options.appDataRoot ?? resolveDefaultAppDataRoot(), APP_DIRECTORY_NAME);
+  return join2(options.appDataRoot ?? resolveDefaultAppDataRoot(), APP_DIRECTORY_NAME);
 };
 var resolveHostDatabasePath = (options = {}) => {
-  return join(resolveHostDataDirectory(options), DATABASE_FILE_NAME);
+  return join2(resolveHostDataDirectory(options), DATABASE_FILE_NAME);
 };
 
 // src/adapters/sqlite/bun-sqlite-driver.ts
@@ -7101,159 +7313,12 @@ var createSqliteVpetRepository = async (options = {}) => {
   return store;
 };
 
-// src/config/global-vpet-settings.ts
-import { readFile } from "fs/promises";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-
-// src/config/defaults.ts
-var EN_STAGE_LABELS = Object.freeze({
-  egg: "DigiEgg",
-  babyI: "In Training I",
-  babyII: "In Training II",
-  child: "Rookie",
-  adult: "Champion",
-  perfect: "Ultimate",
-  ultimate: "Mega",
-  superUltimate: "Ultra"
-});
-var JP_STAGE_LABELS = Object.freeze({
-  egg: "Digitama",
-  babyI: "Baby I",
-  babyII: "Baby II",
-  child: "Child",
-  adult: "Adult",
-  perfect: "Perfect",
-  ultimate: "Ultimate",
-  superUltimate: "SuperUltimate"
-});
-var VPET_STAGE_LABELS = Object.freeze({
-  en: EN_STAGE_LABELS,
-  jp: JP_STAGE_LABELS
-});
-var DEFAULT_STAGE_THRESHOLDS = Object.freeze({
-  egg: 500000,
-  babyI: 1e6,
-  babyII: 2000000,
-  child: 4000000,
-  adult: 7500000,
-  perfect: 12500000,
-  ultimate: 20000000,
-  superUltimate: 30000000
-});
-var DEFAULT_VPET_SETTINGS = Object.freeze({
-  language: "jp",
-  notifications: true,
-  stageLabels: VPET_STAGE_LABELS,
-  stageThresholds: DEFAULT_STAGE_THRESHOLDS
-});
-
-// src/config/normalize.ts
-var isRecord2 = (value) => {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-};
-var isLanguage = (value) => value === "en" || value === "jp";
-var isBoolean = (value) => typeof value === "boolean";
-var isThreshold = (value) => {
-  return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
-};
-var read = (input, key) => {
-  try {
-    return input[key];
-  } catch {
-    return;
-  }
-};
-var normalizeThreshold = (input, key) => {
-  const value = read(input, key);
-  return isThreshold(value) ? value : DEFAULT_STAGE_THRESHOLDS[key];
-};
-var normalizeVpetSettings = (input) => {
-  try {
-    if (!isRecord2(input))
-      return DEFAULT_VPET_SETTINGS;
-    const thresholdInput = read(input, "stageThresholds");
-    const thresholds = isRecord2(thresholdInput) ? thresholdInput : {};
-    const stageThresholds = Object.freeze({
-      egg: normalizeThreshold(thresholds, "egg"),
-      babyI: normalizeThreshold(thresholds, "babyI"),
-      babyII: normalizeThreshold(thresholds, "babyII"),
-      child: normalizeThreshold(thresholds, "child"),
-      adult: normalizeThreshold(thresholds, "adult"),
-      perfect: normalizeThreshold(thresholds, "perfect"),
-      ultimate: normalizeThreshold(thresholds, "ultimate"),
-      superUltimate: normalizeThreshold(thresholds, "superUltimate")
-    });
-    const language = read(input, "language");
-    const notifications = read(input, "notifications");
-    return Object.freeze({
-      language: isLanguage(language) ? language : DEFAULT_VPET_SETTINGS.language,
-      notifications: isBoolean(notifications) ? notifications : DEFAULT_VPET_SETTINGS.notifications,
-      stageLabels: DEFAULT_VPET_SETTINGS.stageLabels,
-      stageThresholds
-    });
-  } catch {
-    return DEFAULT_VPET_SETTINGS;
-  }
-};
-
-// src/config/global-vpet-settings.ts
-var resolveGlobalVpetConfigPath = (options = {}) => {
-  const pathApi = options.pathApi ?? { join: join2 };
-  const env = options.env ?? process.env;
-  const home = options.home ?? homedir2();
-  if ((options.platform ?? process.platform) === "win32") {
-    const { APPDATA } = env;
-    return pathApi.join(APPDATA ?? pathApi.join(home, "AppData", "Roaming"), "opencode-vpet.json");
-  }
-  return pathApi.join(home, ".config", "opencode-vpet.json");
-};
-var loadGlobalVpetSettings = async (options = {}) => {
-  try {
-    return normalizeVpetSettings(JSON.parse(await readFile(resolveGlobalVpetConfigPath(options), "utf8")));
-  } catch {
-    return DEFAULT_VPET_SETTINGS;
-  }
-};
-
 // src/index.ts
-var getStringOption = (options, name) => {
-  const value = options?.[name];
-  return typeof value === "string" ? value : undefined;
-};
-var toEvolutionThresholds = (settings) => Object.freeze({
-  0: settings.stageThresholds.egg,
-  1: settings.stageThresholds.babyI,
-  2: settings.stageThresholds.babyII,
-  3: settings.stageThresholds.child,
-  4: settings.stageThresholds.adult,
-  5: settings.stageThresholds.perfect,
-  6: settings.stageThresholds.ultimate,
-  7: settings.stageThresholds.superUltimate
-});
-var plugin = async (input, options) => {
-  const appDataRoot = getStringOption(options, "appDataRoot");
-  const databasePath = getStringOption(options, "databasePath");
-  const settings = await loadGlobalVpetSettings();
-  const repository = await createSqliteVpetRepository({
-    ...appDataRoot === undefined ? {} : { appDataRoot },
-    ...databasePath === undefined ? {} : { databasePath }
-  });
-  return createServerHooks({
-    repository,
-    resource: repository,
-    evolutionThresholds: toEvolutionThresholds(settings),
-    fetchMessages: createSessionMessagesFetcher(input.client),
-    language: settings.language,
-    notificationsEnabled: settings.notifications,
-    notify: createBestEffortVpetToastNotifier(async (payload) => (await input.client.tui.showToast({ body: payload })).data ?? false)
-  });
-};
-var entryPlugin = {
+var plugin = Plugin.define({
   id: "opencode-vpet",
-  server: plugin
-};
-var src_default = entryPlugin;
+  setup: (context) => setupVpetServer(context, { openRepository: createSqliteVpetRepository })
+});
+var src_default = plugin;
 export {
   plugin,
   src_default as default,
@@ -7261,5 +7326,5 @@ export {
   DIGIMON_DATA
 };
 
-//# debugId=831F7233213F01D764756E2164756E21
+//# debugId=73759DE8C0C8860264756E2164756E21
 //# sourceMappingURL=index.js.map