opencode-agent-skill 12.0.0-beta.0 → 13.0.0-beta.0

package/global-config/plugins/ues-router/index.js

@@ -1,4 +1,3 @@
-import { Plugin } from "@opencode/plugin"
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
 import { fileURLToPath } from "node:url"
 import path from "node:path"
@@ -6,6 +5,10 @@ import { spawnSync } from "node:child_process"
 import { classifyIntent, routeSkillsForPolicy } from "./router.js"
 import { destructiveShellRisk } from "./safety.js"
 import { runtimeCapabilities } from "./capabilities.js"
+import { parallelRootBaseline, runEventDrivenDAG } from "./parallel-runtime.js"
+import { readProjectJson, readProjectText } from "./text-runtime.js"
+import { extractVerifierVerdict } from "./verifier-runtime.js"
+import { expandUesPromptAlias } from "./command-runtime.js"
 import {
   budgetToolResult,
   classifyProviderFailure,
@@ -23,6 +26,11 @@ const CONFIG_FILE = path.resolve(
   "router.json",
 )
 
+const COMMAND_TEMPLATE_DIR = path.resolve(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "command-templates",
+)
+
 function routerConfig() {
   try {
     const parsed = JSON.parse(readFileSync(CONFIG_FILE, "utf8"))
@@ -36,8 +44,15 @@ function routerConfig() {
 }
 
 
+function spawnHidden(command, args, options = {}) {
+  return spawnSync(command, args, {
+    ...options,
+    windowsHide: true,
+  })
+}
+
 function findWindowsCommand(name) {
-  const result = spawnSync("where", [name], { encoding: "utf8" })
+  const result = spawnHidden("where", [name], { encoding: "utf8" })
   if (result.status !== 0 || !result.stdout) return null
   const matches = result.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)
   return matches.find((item) => /\.(cmd|bat)$/i.test(item)) || matches[0] || null
@@ -61,16 +76,16 @@ function runOcskill(args, cwd) {
   }
   let result
   if (process.platform !== "win32") {
-    result = spawnSync("ocskill", args, common)
+    result = spawnHidden("ocskill", args, common)
   } else {
     const resolved = findWindowsCommand("ocskill")
     if (!resolved) throw new Error("ocskill command was not found on PATH")
     if (/\.(cmd|bat)$/i.test(resolved)) {
       const entry = findNodeShimEntry(resolved)
       if (!entry) throw new Error("refusing to execute an unrecognized ocskill batch shim through cmd.exe")
-      result = spawnSync(process.execPath, [entry, ...args], common)
+      result = spawnHidden(process.execPath, [entry, ...args], common)
     } else {
-      result = spawnSync(resolved, args, common)
+      result = spawnHidden(resolved, args, common)
     }
   }
   if (result.status !== 0) {
@@ -80,11 +95,31 @@ function runOcskill(args, cwd) {
 }
 
 function runOcskillJSON(args, cwd) {
-  const output = runOcskill(args, cwd)
+  const separator = args.indexOf("--")
+  const machineArgs = separator >= 0
+    ? [...args.slice(0, separator), "--json", ...args.slice(separator)]
+    : [...args, "--json"]
+  let output
+  try {
+    output = runOcskill(machineArgs, cwd)
+  } catch (error) {
+    let parsed = null
+    try { parsed = JSON.parse(String(error?.message || error)) } catch {}
+    if (parsed?.error?.message) {
+      const structured = new Error(parsed.error.message)
+      structured.code = parsed.error.code || "UES_ERROR"
+      structured.hint = parsed.error.hint || null
+      structured.recoverable = parsed.error.recoverable === true
+      throw structured
+    }
+    throw error
+  }
   try {
     return JSON.parse(output)
   } catch {
-    throw new Error("ocskill returned invalid JSON for: " + args.join(" "))
+    const error = new Error("ocskill returned invalid JSON for: " + args.join(" "))
+    error.code = "UES_INVALID_JSON"
+    throw error
   }
 }
 
@@ -140,7 +175,7 @@ function workspaceSignal(root) {
   ]
   const parts = []
   for (const args of commands) {
-    const result = spawnSync("git", args, {
+    const result = spawnHidden("git", args, {
       cwd: root,
       encoding: "utf8",
       maxBuffer: 2 * 1024 * 1024,
@@ -245,7 +280,7 @@ function projectRoutingFacts(projectRoot) {
   }
 }
 
-export default Plugin.define({
+export default {
   id: "ues-router",
   async setup(ctx) {
     const projectRoot = ctx.location.project?.canonical || ctx.location.directory
@@ -499,6 +534,27 @@ export default Plugin.define({
         options: { namespace: "ues", codemode: true },
         execute: async () => ({ content: JSON.stringify(capabilities, null, 2) }),
       })
+      editor.add({
+        name: "text_read",
+        description: "Read a project text or diff file with UTF-8/UTF-16 auto-detection when the normal reader reports binary or encoding trouble. Refuses paths outside the project and real binary data.",
+        input: {
+          type: "object",
+          properties: {
+            file: { type: "string" },
+            start: { type: "integer", minimum: 0 },
+            maxChars: { type: "integer", minimum: 256, maximum: 100000 },
+          },
+          required: ["file"],
+          additionalProperties: false,
+        },
+        options: { namespace: "ues", codemode: true },
+        execute: async (input) => ({
+          content: JSON.stringify(readProjectText(projectRoot, input.file, {
+            start: input.start,
+            maxChars: input.maxChars,
+          }), null, 2),
+        }),
+      })
       editor.add({
         name: "task_policy",
         description: "Classify an engineering request into inline, standard or long-horizon mode with risk/model/context guidance.",
@@ -904,24 +960,7 @@ export default Plugin.define({
           }
         },
       })
-      editor.add({
-        name: "dispatch_task",
-        description: "Start one approved UES task and execute it in a fresh ues-executor session with bounded runtime and interrupt-on-timeout. The parent must inspect the diff and record completion evidence separately.",
-        input: {
-          type: "object",
-          properties: {
-            slug: { type: "string" },
-            task: { type: "string" },
-            timeoutMs: { type: "integer", minimum: 30000, maximum: 3600000 },
-            stallMs: { type: "integer", minimum: 30000, maximum: 300000 },
-            isolate: { type: "boolean" },
-            integrate: { type: "boolean" },
-          },
-          required: ["slug", "task"],
-          additionalProperties: false,
-        },
-        options: { namespace: "ues", codemode: true },
-        execute: async (input, tool) => {
+      const dispatchApprovedTask = async (input, tool, executionOptions = {}) => {
           if (!capabilities.freshDispatch) {
             throw new Error("OpenCode runtime does not expose the fresh-session capabilities required by ues.dispatch_task")
           }
@@ -977,22 +1016,21 @@ export default Plugin.define({
           const workingTree = runOcskillJSON(["working-tree", projectRoot], projectRoot)
           const rootClean = workingTree?.git === true && workingTree?.clean === true
           const writerTask = taskHasWrites(started?.contextPack?.task)
-          if (input.isolate === true && !rootClean) {
-            throw new Error("explicit sandbox isolation requires a clean root working tree; commit/stash or integrate existing changes first")
+          if (input.isolate === true && !rootClean && executionOptions.inheritDirtyRoot !== true) {
+            throw new Error("explicit sandbox isolation requires a clean root working tree unless inherited-root snapshot mode is enabled")
           }
-          if (input.isolate !== false && writerTask && !rootClean) {
-            throw new Error("writer dispatch requires a clean root for automatic worktree isolation; clean the root or explicitly pass isolate:false to accept shared-root writes")
+          if (input.isolate !== false && writerTask && !rootClean && executionOptions.inheritDirtyRoot !== true) {
+            throw new Error("writer dispatch requires a clean root unless the parallel runtime enables inherited-root snapshot isolation")
           }
           const autoIsolate =
             input.isolate === true ||
-            (input.isolate !== false && rootClean && writerTask)
+            (input.isolate !== false && writerTask && (rootClean || executionOptions.inheritDirtyRoot === true))
           let sandbox = null
           let executionDir = projectRoot
           if (autoIsolate) {
-            sandbox = runOcskillJSON(
-              ["sandbox", "create", input.slug, input.task, projectRoot],
-              projectRoot,
-            )
+            const sandboxArgs = ["sandbox", "create", input.slug, input.task, projectRoot]
+            if (executionOptions.inheritDirtyRoot === true && !rootClean) sandboxArgs.push("--inherit-dirty-root")
+            sandbox = runOcskillJSON(sandboxArgs, projectRoot)
             executionDir = sandbox.dir
           }
           const heartbeatStarted = Date.now()
@@ -1009,7 +1047,9 @@ export default Plugin.define({
             const escalationArgs = ["model-policy", "executor", "--attempt", String(attempt + 1)]
             if (taskText) escalationArgs.push("--text", taskText)
             const escalatedPolicy = runOcskillJSON(escalationArgs, projectRoot)
-            let selectedPolicy = policy
+            let selectedPolicy = executionOptions.forceModel === true
+              ? { ...policy, model: executionOptions.modelOverride || null, forcedSingleModel: true }
+              : policy
             let created = null
             let messages = null
             const providerRecovery = []
@@ -1053,6 +1093,12 @@ export default Plugin.define({
               }
 
               await ctx.session.switchAgent({ sessionID: created.id, agent: "ues-executor" })
+              if (capabilities.permissionRules) {
+                await ctx.permission.rules({
+                  sessionID: created.id,
+                  permissions: [{ action: "subagent", resource: "*", effect: "deny" }],
+                })
+              }
               const selectedModel = modelRef(selectedPolicy?.model)
               if (selectedModel) {
                 await ctx.session.switchModel({ sessionID: created.id, model: selectedModel })
@@ -1092,6 +1138,7 @@ export default Plugin.define({
                 const failureKind = classifyProviderFailure(error)
                 const escalationModel = modelRef(escalatedPolicy?.model)
                 const hasEscalationModel = Boolean(
+                  executionOptions.disableModelEscalation !== true &&
                   escalationModel &&
                   escalatedPolicy?.model &&
                   escalatedPolicy.model !== selectedPolicy?.model,
@@ -1204,6 +1251,265 @@ export default Plugin.define({
           } finally {
             clearInterval(heartbeat)
           }
+      }
+
+      editor.add({
+        name: "dispatch_task",
+        description: "Start one approved UES task and execute it in a fresh ues-executor session with bounded runtime and interrupt-on-timeout. The parent must inspect the diff and record completion evidence separately.",
+        input: {
+          type: "object",
+          properties: {
+            slug: { type: "string" },
+            task: { type: "string" },
+            timeoutMs: { type: "integer", minimum: 30000, maximum: 3600000 },
+            stallMs: { type: "integer", minimum: 30000, maximum: 300000 },
+            isolate: { type: "boolean" },
+            integrate: { type: "boolean" },
+          },
+          required: ["slug", "task"],
+          additionalProperties: false,
+        },
+        options: { namespace: "ues", codemode: true },
+        execute: async (input, tool) => dispatchApprovedTask(input, tool),
+      })
+
+      editor.add({
+        name: "dispatch_parallel",
+        description: "Execute an approved UES DAG with multiple fresh sessions of one shared model. Ready tasks run concurrently, each writer is isolated, a fresh same-model verifier must PASS, and integration is serialized with rollback on post-integration failure.",
+        input: {
+          type: "object",
+          properties: {
+            slug: { type: "string" },
+            maxConcurrent: { type: "integer", minimum: 1, maximum: 8 },
+            model: { type: "string" },
+            timeoutMs: { type: "integer", minimum: 30000, maximum: 3600000 },
+            stallMs: { type: "integer", minimum: 30000, maximum: 300000 },
+            verifierTimeoutMs: { type: "integer", minimum: 30000, maximum: 1800000 },
+          },
+          required: ["slug"],
+          additionalProperties: false,
+        },
+        options: { namespace: "ues", codemode: true },
+        execute: async (input, tool) => {
+          if (!capabilities.freshDispatch) {
+            throw new Error("OpenCode runtime does not expose the fresh-session capabilities required by ues.dispatch_parallel")
+          }
+          if (!/^[a-z0-9][a-z0-9-]*$/.test(String(input.slug || ""))) {
+            throw new Error("work slug must use lowercase letters, numbers and dashes")
+          }
+
+          const initialTree = runOcskillJSON(["working-tree", projectRoot], projectRoot)
+          const rootBaseline = parallelRootBaseline(initialTree)
+
+          const workDir = path.join(projectRoot, ".ues-work", input.slug)
+          const planFile = path.join(workDir, "PLAN.json")
+          const stateFile = path.join(workDir, "STATE.json")
+          if (!existsSync(planFile) || !existsSync(stateFile)) {
+            throw new Error("parallel dispatch requires an initialized work item with PLAN.json and STATE.json")
+          }
+          const plan = readProjectJson(projectRoot, path.relative(projectRoot, planFile)).value
+          const state = readProjectJson(projectRoot, path.relative(projectRoot, stateFile)).value
+          if (state?.planApproval?.status !== "passed") throw new Error("parallel dispatch requires an approved active plan")
+          const running = Object.entries(state.tasks || {}).filter(([, record]) => record?.status === "running")
+          if (running.length) throw new Error("parallel dispatch refuses to start while another durable task attempt is already running")
+
+          const completedTaskIds = Object.entries(state.tasks || {})
+            .filter(([, record]) => record?.status === "completed")
+            .map(([id]) => id)
+          const tasks = (plan.tasks || []).filter((task) => !completedTaskIds.includes(task.id))
+          const goalText = String(plan.goal || "parallel approved UES execution")
+          const sharedPolicy = runOcskillJSON(["model-policy", "executor", "--attempt", "1", "--text", goalText], projectRoot)
+          const sharedModel = input.model || sharedPolicy?.model || null
+          if (input.model && !modelRef(input.model)) throw new Error("parallel model must use provider/model[#variant] syntax")
+          if (sharedModel && !capabilities.modelSwitch) {
+            throw new Error("same-model parallel execution selected " + sharedModel + " but this OpenCode runtime cannot switch child-session models")
+          }
+
+          const maxConcurrent = Math.max(1, Math.min(Number(input.maxConcurrent || 4), 8))
+          const verifierTimeoutMs = Math.max(30000, Math.min(Number(input.verifierTimeoutMs || 600000), 1800000))
+          await tool.progress({ status: "parallel UES starting " + tasks.length + " task(s), max " + maxConcurrent + " shared-model workers" })
+
+          const failRunningTask = (taskID, runId, reason) => {
+            try {
+              const failArgs = ["work", "fail", input.slug, taskID, projectRoot, "--reason", String(reason || "parallel task failed")]
+              if (runId) failArgs.push("--run-id", runId)
+              runOcskill(failArgs, projectRoot)
+            } catch {}
+          }
+
+          const scheduler = await runEventDrivenDAG(tasks, {
+            completedTaskIds,
+            maxConcurrent,
+            singleModel: true,
+            model: sharedModel,
+            worker: async (task, context) => {
+              let payload = null
+              try {
+                const response = await dispatchApprovedTask({
+                  slug: input.slug,
+                  task: task.id,
+                  timeoutMs: input.timeoutMs,
+                  stallMs: input.stallMs,
+                  isolate: true,
+                  integrate: false,
+                }, tool, {
+                  forceModel: true,
+                  modelOverride: context.model,
+                  disableModelEscalation: true,
+                  inheritDirtyRoot: true,
+                })
+                payload = JSON.parse(response.content)
+
+                const executionDir = payload.sandbox?.dir || payload.executionDir || projectRoot
+                const beforeVerifierSignal = workspaceSignal(executionDir)
+                const verifierSession = await ctx.session.create({
+                  title: "UES verify " + input.slug + " " + task.id,
+                  location: { directory: executionDir },
+                })
+                runtimeGuard.touch(verifierSession.id)
+                await ctx.session.switchAgent({ sessionID: verifierSession.id, agent: "ues-verifier" })
+                if (capabilities.permissionRules) {
+                  await ctx.permission.rules({
+                    sessionID: verifierSession.id,
+                    permissions: [
+                      { action: "edit", resource: "*", effect: "deny" },
+                      { action: "subagent", resource: "*", effect: "deny" },
+                    ],
+                  })
+                }
+                const verifierModel = modelRef(context.model)
+                if (verifierModel) await ctx.session.switchModel({ sessionID: verifierSession.id, model: verifierModel })
+                await ctx.session.prompt({
+                  sessionID: verifierSession.id,
+                  text:
+                    "Independently verify this completed UES task. Do not edit files. Inspect the task-scoped diff, acceptance criteria and declared verification; run fresh verification commands where appropriate. " +
+                    "Your final line MUST be exactly one line beginning UES_VERDICT_JSON: followed by compact JSON with verdict PASS or FAIL and concise evidence. Use FAIL if any acceptance criterion or verification is not proven.\n\n" +
+                    JSON.stringify({
+                      task: task.id,
+                      title: task.title || null,
+                      summary: task.summary || null,
+                      acceptance: task.acceptance || [],
+                      verification: task.verification || [],
+                      verificationCommands: task.verificationCommands || [],
+                      files: task.files || null,
+                      risk: task.risk || "medium",
+                    }, null, 2),
+                })
+
+                let verifierMessages
+                try {
+                  verifierMessages = await waitForExecutorProgress(verifierSession.id, {
+                    timeoutMs: verifierTimeoutMs,
+                    stallMs: Math.min(Number(input.stallMs || 60000), 300000),
+                  })
+                } catch (error) {
+                  try { await ctx.session.interrupt({ sessionID: verifierSession.id, continue: false }) } catch {}
+                  throw error
+                } finally {
+                  runtimeGuard.clear(verifierSession.id)
+                }
+
+                if (beforeVerifierSignal !== workspaceSignal(executionDir)) {
+                  throw new Error("independent verifier modified the workspace; verifier sessions must be read-only")
+                }
+                const verdict = extractVerifierVerdict(verifierMessages)
+                if (!verdict || verdict.verdict !== "PASS") {
+                  throw new Error("independent verifier did not produce PASS" + (verdict?.evidence ? ": " + verdict.evidence : ""))
+                }
+                return {
+                  ...payload,
+                  verifier: {
+                    sessionID: verifierSession.id,
+                    verdict: verdict.verdict,
+                    evidence: verdict.evidence || "independent verifier PASS",
+                  },
+                }
+              } catch (error) {
+                if (payload?.sandbox?.dir) {
+                  try { runOcskill(["sandbox", "remove", payload.sandbox.dir, projectRoot, "--force", "--delete-branch"], projectRoot) } catch {}
+                }
+                if (payload?.runId) failRunningTask(task.id, payload.runId, "parallel verification failed: " + String(error?.message || error))
+                throw error
+              }
+            },
+            integrate: async (task, result) => {
+              let applied = false
+              let durableCompleted = false
+              try {
+                let integration = null
+                if (result.sandbox?.dir) {
+                  integration = runOcskillJSON(["sandbox", "integrate", result.sandbox.dir, projectRoot, "--keep"], projectRoot)
+                  applied = true
+                }
+                const deterministicReceipts = []
+                for (const commandSpec of task.verificationCommands || []) {
+                  const command = String(commandSpec?.command || "").trim()
+                  if (!command) continue
+                  const commandArgs = Array.isArray(commandSpec?.args)
+                    ? commandSpec.args.map((value) => String(value))
+                    : []
+                  const verified = runOcskillJSON([
+                    "work", "verify-command", input.slug, task.id, projectRoot,
+                    "--run-id", result.runId,
+                    "--", command, ...commandArgs,
+                  ], projectRoot)
+                  deterministicReceipts.push(verified.receipt)
+                }
+                const receipt = runOcskillJSON([
+                  "work", "agent-receipt", input.slug, task.id, projectRoot,
+                  "--run-id", result.runId,
+                  "--verdict", "PASS",
+                  "--verifier", "ues-verifier",
+                  "--session-id", result.verifier.sessionID,
+                  "--evidence", result.verifier.evidence,
+                ], projectRoot)
+                const completed = runOcskillJSON([
+                  "work", "complete", input.slug, task.id, projectRoot,
+                  "--run-id", result.runId,
+                  "--evidence", result.verifier.evidence,
+                ], projectRoot)
+                durableCompleted = true
+
+                if (result.sandbox?.dir) {
+                  try { runOcskill(["sandbox", "remove", result.sandbox.dir, projectRoot, "--force", "--delete-branch"], projectRoot) } catch {}
+                }
+                try { void tool.progress({ status: "parallel task " + task.id + " verified and integrated" }) } catch {}
+                return { integration, deterministicReceipts, receipt, completed }
+              } catch (error) {
+                if (!durableCompleted) {
+                  if (applied && result.sandbox?.dir) {
+                    try { runOcskill(["sandbox", "rollback", result.sandbox.dir, projectRoot], projectRoot) } catch {}
+                  } else if (result.sandbox?.dir) {
+                    try { runOcskill(["sandbox", "remove", result.sandbox.dir, projectRoot, "--force", "--delete-branch"], projectRoot) } catch {}
+                  }
+                  if (result.runId) failRunningTask(task.id, result.runId, "parallel integration failed: " + String(error?.message || error))
+                }
+                throw error
+              }
+            },
+            onEvent: (event) => {
+              if (["task.started", "task.completed", "task.failed"].includes(event.type)) {
+                void tool.progress({ status: "parallel " + event.type + " " + event.task })
+              }
+            },
+          })
+
+          const finalStatus = runOcskillJSON(["work", "status", input.slug, projectRoot], projectRoot)
+          return {
+            content: JSON.stringify({
+              schemaVersion: 1,
+              slug: input.slug,
+              model: sharedModel || "opencode-default",
+              singleModel: true,
+              maxConcurrent,
+              rootBaseline,
+              scheduler,
+              work: finalStatus,
+              next: finalStatus.status === "integration-verification"
+                ? "Run ues-integration-verifier and record the final integration receipt before finalize."
+                : finalStatus.nextAction,
+            }, null, 2),
+          }
         },
       })
     })
@@ -1214,7 +1520,7 @@ export default Plugin.define({
       await ctx.session.hook("context", (event) => {
         event.system.push({
           type: "text",
-          text: "UES: use the minimum context that preserves correctness. FAST reads the target and nearest evidence with direct skills only; STANDARD/DEEP expand when risk or evidence requires it. Preserve exact contracts, verify fresh behavior, and escalate after failed attempts instead of stacking patches.",
+          text: "UES: use the minimum context that preserves correctness. FAST reads the target and nearest evidence with direct skills only; STANDARD/DEEP expand when risk or evidence requires it. Preserve exact contracts and verify fresh behavior. On Windows, never redirect git diff through PowerShell into a text file; use ocskill diff . --out <file> so the result is UTF-8. If normal Read reports binary for a diff or known text file, use ues.text_read instead of inventing a converted copy. For independent approved tasks, prefer ues.dispatch_parallel when one shared model can safely work in isolated sessions.",
         })
         const assignment = sessionAssignments.get(event.sessionID)
         if (assignment?.resumeRequired && assignment.checkpoint) {
@@ -1232,17 +1538,32 @@ export default Plugin.define({
       const config = routerConfig()
       if (!config.enabled) return
 
+      const promptAlias = expandUesPromptAlias(event.prompt?.text, COMMAND_TEMPLATE_DIR)
+      if (promptAlias && event.prompt) {
+        event.prompt.text = promptAlias.text
+        event.metadata = {
+          ...event.metadata,
+          uesPromptAlias: {
+            alias: promptAlias.alias,
+            sourceName: promptAlias.sourceName,
+            preferredAgent: promptAlias.agent,
+            transport: "session.prompt",
+          },
+        }
+      }
+
+      const promptText = String(event.prompt?.text || "")
       let policy = null
       try {
-        policy = runOcskillJSON(["task-policy", event.prompt.text], projectRoot)
+        policy = runOcskillJSON(["task-policy", promptText], projectRoot)
       } catch {}
-      const intent = classifyIntent(event.prompt.text, routingFacts)
+      const intent = classifyIntent(promptText, routingFacts)
       const effectiveMaxSkills = Math.max(
         1,
         Math.min(config.maxSkills, Number(policy?.maxSkills || config.maxSkills)),
       )
       const selected = []
-      for (const id of [...routeSkillsForPolicy(event.prompt.text, policy, effectiveMaxSkills, routingFacts), ...policySkills(policy)]) {
+      for (const id of [...routeSkillsForPolicy(promptText, policy, effectiveMaxSkills, routingFacts), ...policySkills(policy)]) {
         if (!selected.includes(id)) selected.push(id)
         if (selected.length >= effectiveMaxSkills) break
       }
@@ -1266,7 +1587,7 @@ export default Plugin.define({
             feedbackDomains: routingFacts.feedbackDomains,
             acceptedLearningCount: routingFacts.acceptedLearningCount,
           },
-          version: 11,
+          version: 13,
           effectiveMaxSkills,
         },
       }
@@ -1291,4 +1612,4 @@ export default Plugin.define({
       sessionAssignments.clear()
     }
   },
-})
+}