@jmanuelcorral/openteam 0.23.0 → 0.24.0

package/dist/index.js

@@ -4103,6 +4103,28 @@ import { z as z13 } from "zod";
 // src/telemetry/events.ts
 import { z as z11 } from "zod";
 
+// src/messages/reload.ts
+var reloadMessages = {
+  description: "Queue a project-instance reload only after the user explicitly answers the fresh /create_roster reload question affirmatively. General tool approval, YOLO and earlier project-description answers are not consent. End this turn after queuing; do not dispatch work. Cancel withdraws a pending request.",
+  action: "Request a confirmed reload or cancel this session's queued request.",
+  confirmed: "True only for an unambiguous affirmative human answer to the current reload question, after successful preparation and the full Agent/Role/Model and file summaries. This field records consent; it does not independently prove a human answered.",
+  invalid: "Reload not queued: provide only action (request or cancel) and explicit boolean confirmed. No target directory or other arguments are accepted.",
+  declined: "Reload not queued: explicit affirmative consent to the current reload question is required. No files or policies were changed.",
+  denied: "Reload is restricted to the openteam primary in this plugin's project.",
+  closed: "This reload controller is no longer active. Check the current opencode instance before requesting another reload; agent discovery has not been verified.",
+  other: "A reload request is already pending for another session. This call does not replace or extend its confirmation.",
+  authorizing: "Host permission for this project's reload is still pending. This call queues nothing and does not extend the confirmation deadline.",
+  none: "There is no queued reload for this session to cancel.",
+  "reload-queued": "Reload queued, not completed. Waiting up to 30 seconds for this tool and confirming turn to finish and for all project sessions to be idle. End this turn now; no project work or agent readiness is implied.",
+  "reload-waiting": "Reload is still waiting: project sessions are busy or retrying. They will not be aborted; the original 30-second deadline is unchanged.",
+  "reload-accepted": "opencode accepted the project-instance reload request. Agent discovery and readiness have not been verified; existing discovery safeguards still apply.",
+  "reload-cancelled": "The pending reload was cancelled before disposal was requested. Prepared files, history and policies are unchanged.",
+  "reload-timeout": "Reload was not requested: the 30-second idle deadline expired. A new explicit confirmation is required; nothing will retry automatically.",
+  "reload-status-failed": "Reload was not requested: project activity was missing, malformed, unavailable or did not respond within 5 seconds. No idle state was assumed and no automatic retry is armed.",
+  "reload-dispose-failed": "opencode did not confirm acceptance of the reload request. No automatic retry is armed; check the current instance before trying again. Agent readiness is unverified.",
+  "reload-unconfirmed": "Reload acceptance is unconfirmed because the request timed out, was cancelled or the instance was disposed while it was in flight. The host may still finish it; no automatic retry is armed. Check the current instance and agent discovery."
+};
+
 // src/telemetry/diagnostics.ts
 var DIAGNOSTIC_CODES = [
   "availability-refresh-failed",
@@ -4115,6 +4137,14 @@ var DIAGNOSTIC_CODES = [
   "opencode-server-url",
   "opencode-version-read-failed",
   "privacy-inert",
+  "reload-queued",
+  "reload-waiting",
+  "reload-accepted",
+  "reload-cancelled",
+  "reload-timeout",
+  "reload-status-failed",
+  "reload-dispose-failed",
+  "reload-unconfirmed",
   "soak-evidence-rejected",
   "telemetry-warning",
   "telemetry-write-failed",
@@ -4142,6 +4172,15 @@ function diagnosticDescription(code) {
       return "openteam could not read the live opencode version; graph gates fail closed when this happens.";
     case "privacy-inert":
       return routingMessages.privacyModeDeprecated;
+    case "reload-queued":
+    case "reload-waiting":
+    case "reload-accepted":
+    case "reload-cancelled":
+    case "reload-timeout":
+    case "reload-status-failed":
+    case "reload-dispose-failed":
+    case "reload-unconfirmed":
+      return reloadMessages[code];
     case "soak-evidence-rejected":
       return "Graph soak evidence contained rejected observation lines; cutover gate evidence may be incomplete.";
     case "telemetry-warning":
@@ -4894,6 +4933,48 @@ function withDeterministicGitLocale(env) {
   };
 }
 
+// src/opencodeArtifacts/createRosterReload.ts
+var CREATE_ROSTER_RELOAD_INSTRUCTIONS = [
+  "## Reload confirmation — /create_roster only",
+  "",
+  "Only after successful persisted registration and verified agent files may you offer reload:",
+  "read back the parseable persisted roster, including guaranteed roles; actually create each missing",
+  "subagent file and verify every required existing or created file.",
+  "First show the complete Agent/Role/Model table returned by `openteam-register-cast`,",
+  "including primary, guaranteed and preserved agents with their unchanged tool-returned policy values.",
+  "Then show the created-versus-preserved file summary and any warnings. Both must be visible",
+  "BEFORE asking a fresh explicit reload question in this opencode conversation.",
+  "If registration, file creation or verification failed or is partial, do not ask the reload question:",
+  "report the exact blocker and do not claim readiness. If registration succeeded, still show its",
+  "complete table even when file preparation later fails.",
+  "",
+  "Ask whether to reload this project's opencode agent definitions now, explaining the request is",
+  "queued/waiting until the requesting turn completes and all project sessions are idle.",
+  "Use the host question tool when available; otherwise ask a normal conversational question",
+  "in opencode and WAIT for the user's answer. Never use a terminal wizard, tool permission",
+  "approval or YOLO permission as reload consent. A greenfield project-description reply is NOT reload consent.",
+  "Only an explicit affirmative answer to this specific reload question authorizes",
+  '`openteam-reload` with `{ action: "request", confirmed: true }`.',
+  "False, no, cancel, an ambiguous answer or no reply means no reload request.",
+  "A decline before anything is queued needs no tool call; do not turn ambiguity into confirmation.",
+  "To cancel an already queued request at the user's direction, use",
+  '`openteam-reload` with `{ action: "cancel", confirmed: false }` and report its actual result.',
+  "",
+  "This internal tool is restricted to the product primary `openteam` and its bound project.",
+  "Do not supply a directory, project, session or other model-selected target.",
+  "Report queued/waiting honestly and end the confirming turn immediately.",
+  "Do not await your own idle state, poll or hold the turn open. Do not start work or call",
+  "`task` or `openteam-orchestrate`; do not rewrite/recast files or change models, permissions",
+  "or execution policies. The idle wait has a finite timeout; surface timeout and failure results",
+  "when the runtime reports them, including rejected requests, rather than promising success or silently retrying.",
+  "SDK acceptance is not verified discovery or readiness. Preserve all existing discovery guards:",
+  "if new agents remain undiscovered, surface the reload/discovery blocker;",
+  "do not dispatch through a generic substitute or claim readiness.",
+  "This workflow and all its replies remain composition only. After completion, decline or cancellation,",
+  "wait for a separate work request; neither a reload answer nor queued acceptance starts project work."
+].join(`
+`);
+
 // src/opencodeArtifacts/rosterSummary.ts
 var ROSTER_SUMMARY_INSTRUCTIONS = [
   "After every successful cast creation, repair or extension, show the complete Agent/Role/Model table",
@@ -4926,6 +5007,20 @@ var TEAM_PREPARATION_INSTRUCTIONS = [
   "machine bindings stay unchanged; do not require a terminal or manually edit policy to finish hiring.",
   "Never infer execution domains from prose, relax permissions, or invent a concrete auto model.",
   "Registration/review is idempotent: a capable configured team needs no extra members or file rewrites.",
+  "`agentName`, not `roleID`, determines each worker filename.",
+  "Create `.opencode/agent/<agentName>.md` only for registered roster entries.",
+  "A built-in role profile is not an extra agent.",
+  "Do not create a parallel `<roleID>.md` when the roster maps that role to another alias.",
+  "An existing roster alias equal to its roleID is still valid; do not rename it.",
+  "Do not run `openteam setup` to hire workers or repair their files.",
+  "Preserve unrelated and legacy generic files; do not delete, overwrite or silently register them.",
+  "Registration writes roster/profile state, not worker Markdown.",
+  "Report only verified file changes; do not call pre-existing files newly created.",
+  "When creating a scribe worker, put the following memory instructions in its charter:",
+  "Use `openteam-memory` for durable, reusable facts, entities and typed relations.",
+  "Send only redacted knowledge messages, never raw conversations, prompts or credentials.",
+  "Honor operator permissions and memory settings; do not broaden them.",
+  "A disabled-memory or nothing-recorded result is expected; do not retry it.",
   "Create only missing agent definitions; preserve customized files. Show the registration table",
   "and verify preparation before dispatch. If opencode cannot discover a new agent, surface",
   "the reload/discovery blocker; do not dispatch through a generic substitute or claim readiness."
@@ -4967,33 +5062,43 @@ function buildOrchestratorAgent(model, options = {}) {
     "primary agent: there is no pre-created team. You **build the team of",
     "subagents on demand** according to the goal of the user and the repository.",
     "",
-    "## Golden rule: check the team on EVERY request",
-    "",
-    "Before answering or delegating **any** request, your **first action",
-    "always** is to check whether a team already exists, even if the user does not",
-    "explicitly ask you to create it. Never assume there is a team or that there is not:",
-    `verify it by looking at \`${OPENTEAM_ROSTER_PATH}\` and the \`.opencode/agent/*.md\``,
-    "files with `mode: subagent` (use `read`/`glob`/`list`).",
-    "",
-    ROSTER_SUMMARY_INSTRUCTIONS,
-    "",
-    TEAM_PREPARATION_INSTRUCTIONS,
-    "",
     "## Roster composition takes precedence",
     "",
     "For `/create_roster`, including replies to its pending questions, follow",
     "the command's roster-only workflow: do not distribute tasks or start implementation.",
+    "These rules override the ordinary golden rule and capability checks below.",
+    "A bare yes to a pending reload question continues only reload confirmation:",
+    "do not restart roster reads, capability preparation or registration.",
     "Reuse or conservatively extend the existing cast and preserve customized agent files.",
     "Use a supplied description; otherwise inspect real project source read-only.",
     "If there is no meaningful source and no description, ask what the user wants to",
     "build in this conversation and wait before any writes or cast registration.",
     "Register through `openteam-register-cast`, create missing subagent files, verify",
-    "the persisted roster and files, then stop. Do not call `openteam-orchestrate` or",
+    "the persisted roster and files, then follow the reload confirmation below.",
+    "Do not call `openteam-orchestrate` or",
     "`task` for this workflow. A later answer to your question continues composition",
     "only until it completes or the user cancels; it is not an implementation request.",
     "",
+    CREATE_ROSTER_RELOAD_INSTRUCTIONS,
+    "",
+    "## Golden rule: check the team on EVERY request",
+    "",
+    "The roster composition and pending reload-reply rules above take precedence.",
+    "Before answering or delegating **any ordinary work** request, your **first action",
+    "always** is to check whether a team already exists, even if the user does not",
+    "explicitly ask you to create it. Never assume there is a team or that there is not:",
+    `verify it by looking at \`${OPENTEAM_ROSTER_PATH}\` and the \`.opencode/agent/*.md\``,
+    "files with `mode: subagent` (use `read`/`glob`/`list`).",
+    "",
+    ROSTER_SUMMARY_INSTRUCTIONS,
+    "",
+    TEAM_PREPARATION_INSTRUCTIONS,
+    "",
     "## For work requests, including analysis, review and documentation",
     "",
+    "Ordinary automatic hiring must NOT ask for reload or automatically reset the project.",
+    "If discovery is blocked, surface the blocker and preserve the discovery guards instead.",
+    "",
     "- **If the team ALREADY exists** → review capability coverage, reuse suitable",
     "  members and extend only for uncovered needs. Complete any existing member's",
     "  profile through `openteam-register-cast`; do not hire for a configuration gap.",
@@ -5368,8 +5473,10 @@ function buildCreateRosterCommand() {
     "required agent file exists. If anything failed, report the incomplete state and exact",
     "blocker; do not delete preserved state or claim the team is ready.",
     "Summarize the cast, role rationale/evidence, preserved versus newly created files, and",
-    "any warnings. New subagents may require an opencode reload before discovery.",
-    "Stop after composition; wait for a separate request before starting project work.",
+    "any warnings. Continue only to the reload confirmation below, including its pending replies;",
+    "do not restart preparation when the user answers that reload question.",
+    "",
+    CREATE_ROSTER_RELOAD_INSTRUCTIONS,
     "",
     "## Project description (user input)",
     "",
@@ -5636,7 +5743,7 @@ import { z as z15 } from "zod";
 // package.json
 var package_default = {
   name: "@jmanuelcorral/openteam",
-  version: "0.23.0",
+  version: "0.24.0",
   packageManager: "bun@1.3.14",
   description: "Cost-aware, local-first routing plugin for opencode with cheapest-capable frontier fallback and multi-agent orchestration.",
   license: "MIT",
@@ -6015,12 +6122,14 @@ var executionSetupMessages = {
     `Local runtimes: ${params.localRuntimes}`,
     `YOLO mode: ${params.yolo ? "enabled (auto-approves permissions)" : "disabled"}`,
     "Web Console: launched separately with 'openteam console' (multi-session, loopback)",
-    `Wrote: ${params.opencodePath}, ${params.configPath}, ${params.agentPath}, ${params.agentDir}/*.md (${params.roleAgentCount} standard subagents), ${params.commandDir}/*.md (${params.commandCount} commands); ensured ${params.gitignorePath}`,
+    `Wrote: ${params.opencodePath}, ${params.configPath}, ${params.agentPath}, ${params.commandDir}/*.md (${params.commandCount} commands); ensured ${params.gitignorePath}`,
+    "Worker files are created through conversational roster preparation, not setup; existing worker files were left untouched.",
     "",
     "Next steps:",
     params.executionMode === "local" ? "  1. No frontier authentication is required while local execution is active" : "  1. Authenticate the frontier provider: opencode auth login",
     params.executionMode === "local" ? executionSetupMessages.localRuntimeNextStep : params.executionMode === "mixed" ? executionSetupMessages.mixedNextStep : executionSetupMessages.frontierNextStep,
-    "  3. Press Tab and pick the 'openteam' agent, or type / and pick an /openteam… command"
+    "  3. Press Tab and pick the 'openteam' agent, or type / and pick an /openteam… command",
+    "  4. Use /create_roster to compose the team without starting project work, or describe a task to prepare the team and begin work"
   ],
   configuredTitle: "openteam configured",
   complete: (paths) => `openteam setup complete: ${paths}`,
@@ -10294,8 +10403,11 @@ var UNAUTHORIZED_MODEL_SWITCH_REASON = "routing-model-switch-not-authorized";
 function invalidRoleIdentifier(roleID) {
   return `invalid role identifier "${roleID}" — use letters, numbers, underscores, or hyphens, starting with a letter or number`;
 }
+function agentPreparationRemedy(agentName) {
+  return "Use `/create_roster` in opencode to complete the missing roster agent " + "definitions without changing existing aliases. " + `If \`.opencode/agent/${agentName}.md\` already exists, reload opencode ` + "to discover it before retrying; do not substitute an unrelated agent.";
+}
 function missingAgentDefinition(agentName, roleID) {
-  return `agent definition "${agentName}" is not installed for role "${roleID}". ` + `Create .opencode/agent/${agentName}.md or choose an installed builtin agent before retrying.`;
+  return `agent definition "${agentName}" is not installed for role "${roleID}". ` + agentPreparationRemedy(agentName);
 }
 function dependencyValidationError(code, detail) {
   return `dependency validation error: ${code} (${detail})`;
@@ -10548,6 +10660,50 @@ function lifecycleRecordingAdvisory(status) {
   return `Lifecycle history recording is ${status.state}${failure}; model execution continued without claiming complete history.`;
 }
 
+// src/orchestrator/sessionStatus.ts
+function dataProperties(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    return;
+  try {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+      return;
+    if (Reflect.ownKeys(value).some((key) => typeof key !== "string"))
+      return;
+    const properties = Object.getOwnPropertyDescriptors(value);
+    return Object.values(properties).every((property) => ("value" in property) && property.enumerable === true) ? properties : undefined;
+  } catch {
+    return;
+  }
+}
+function parseSessionStatus(value) {
+  const properties = dataProperties(value);
+  if (properties === undefined)
+    return;
+  const type = properties.type?.value;
+  if (type === "idle" || type === "busy")
+    return { type };
+  const attempt = properties.attempt?.value;
+  const message = properties.message?.value;
+  const next = properties.next?.value;
+  if (type === "retry" && typeof attempt === "number" && Number.isFinite(attempt) && typeof message === "string" && typeof next === "number" && Number.isFinite(next))
+    return { type, attempt, message, next };
+  return;
+}
+function parseSessionStatusMap(value) {
+  const properties = dataProperties(value);
+  if (properties === undefined)
+    return;
+  const entries = [];
+  for (const [sessionID, property] of Object.entries(properties)) {
+    const status = parseSessionStatus(property.value);
+    if (status === undefined)
+      return;
+    entries.push([sessionID, status]);
+  }
+  return Object.fromEntries(entries);
+}
+
 // src/orchestrator/subsessions.ts
 var DEFAULT_ABORT_GRACE_MS = 2000;
 var DEFAULT_STATUS_POLL_MS = 100;
@@ -10773,28 +10929,6 @@ function statusArgs(directory, signal) {
 function abortArgs(sessionID, directory, signal) {
   return directory === undefined ? { path: { id: sessionID }, signal } : { path: { id: sessionID }, query: { directory }, signal };
 }
-function isSessionStatus(value) {
-  if (!isObject3(value))
-    return false;
-  const type = safeGet(value, "type");
-  if (type === "idle" || type === "busy")
-    return true;
-  if (type !== "retry")
-    return false;
-  return typeof safeGet(value, "attempt") === "number" && typeof safeGet(value, "message") === "string" && typeof safeGet(value, "next") === "number";
-}
-function isSessionStatusMap(value) {
-  if (!isObject3(value) || Array.isArray(value))
-    return false;
-  try {
-    const prototype = Object.getPrototypeOf(value);
-    if (prototype !== Object.prototype && prototype !== null)
-      return false;
-    return Object.values(value).every(isSessionStatus);
-  } catch {
-    return false;
-  }
-}
 async function confirmSessionStopped(client, sessionID, directory, deps, deadline) {
   const abortSession = client.session.abort;
   if (abortSession === undefined) {
@@ -10843,8 +10977,8 @@ async function confirmSessionStopped(client, sessionID, directory, deps, deadlin
     if (safeGet(statuses, "error") !== undefined) {
       return { confirmed: false, cause: "status-error" };
     }
-    const snapshot = safeGet(statuses, "data");
-    if (!isSessionStatusMap(snapshot)) {
+    const snapshot = parseSessionStatusMap(safeGet(statuses, "data"));
+    if (snapshot === undefined) {
       return { confirmed: false, cause: "status-missing" };
     }
     if (!Object.hasOwn(snapshot, sessionID)) {
@@ -13174,7 +13308,6 @@ var GENERATED_OPENTEAM_STATE_GROUPS = [
   { kind: "file", paths: [SOAK_RECORDER_ID_PATH] }
 ];
 var OPENCODE_DIR = ".opencode";
-var AGENT_DIR = `${OPENCODE_DIR}/agent`;
 function splitSetupPath(path3) {
   return path3.split("/").filter((segment) => segment.length > 0);
 }
@@ -20343,6 +20476,307 @@ function createRegisterCastTool(deps) {
   });
 }
 
+// src/plugin/reloadTool.ts
+import { resolve as resolve9 } from "node:path";
+import { tool as tool7 } from "@opencode-ai/plugin/tool";
+var WAIT_MS = 30000;
+var SDK_TIMEOUT_MS = 5000;
+var POLL_MS2 = 1000;
+var schema = tool7.schema.object({
+  action: tool7.schema.enum(["request", "cancel"]).describe(reloadMessages.action),
+  confirmed: tool7.schema.boolean().describe(reloadMessages.confirmed)
+}).strict();
+function sdkData(value) {
+  if (typeof value !== "object" || value === null)
+    return;
+  try {
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null)
+      return;
+    const error = Object.getOwnPropertyDescriptor(value, "error");
+    const data = Object.getOwnPropertyDescriptor(value, "data");
+    if (error !== undefined && (!("value" in error) || error.value !== undefined))
+      return;
+    return data !== undefined && "value" in data ? data.value : undefined;
+  } catch {
+    return;
+  }
+}
+function createReloadController(deps) {
+  const scheduler = deps.scheduler ?? {
+    now: () => Date.now(),
+    schedule: (run, ms) => {
+      const timer = setTimeout(run, ms);
+      timer.unref();
+      return () => clearTimeout(timer);
+    }
+  };
+  const directory = resolve9(deps.directory);
+  let pending;
+  let authorizing;
+  let closed = false;
+  function current(request) {
+    return pending === request && !request.abort.signal.aborted;
+  }
+  function finish(request, code) {
+    if (!current(request))
+      return;
+    pending = undefined;
+    request.stopDeadline();
+    request.stopPoll?.();
+    request.unlinkCaller();
+    request.abort.abort();
+    deps.notify(code);
+  }
+  function revokeAuthorization() {
+    authorizing?.abort.abort();
+    authorizing = undefined;
+  }
+  function cancel() {
+    revokeAuthorization();
+    if (pending !== undefined)
+      finish(pending, pending.disposing ? "reload-unconfirmed" : "reload-cancelled");
+  }
+  async function requestPermission(context, authorization) {
+    let finishInterruption;
+    const interrupted = new Promise((done) => {
+      finishInterruption = done;
+    });
+    const onAbort = () => finishInterruption("cancelled");
+    const stopTimer = scheduler.schedule(() => finishInterruption("timeout"), Math.max(0, authorization.deadline - scheduler.now()));
+    context.abort.addEventListener("abort", onAbort, { once: true });
+    authorization.abort.signal.addEventListener("abort", onAbort, {
+      once: true
+    });
+    try {
+      return await Promise.race([
+        context.ask({
+          permission: "openteam-reload",
+          patterns: [directory],
+          always: [directory],
+          metadata: { directory }
+        }).then(() => "approved"),
+        interrupted
+      ]);
+    } finally {
+      stopTimer();
+      context.abort.removeEventListener("abort", onAbort);
+      authorization.abort.signal.removeEventListener("abort", onAbort);
+    }
+  }
+  function bounded(request, run) {
+    return new Promise((done) => {
+      const operation = new AbortController;
+      let settled = false;
+      const settle = (outcome) => {
+        if (settled)
+          return;
+        settled = true;
+        stopTimer();
+        request.abort.signal.removeEventListener("abort", onAbort);
+        if (outcome.kind !== "settled")
+          operation.abort();
+        done(outcome);
+      };
+      const onAbort = () => settle({ kind: "cancelled" });
+      const stopTimer = scheduler.schedule(() => settle({ kind: "timeout" }), Math.max(0, Math.min(SDK_TIMEOUT_MS, request.deadline - scheduler.now())));
+      request.abort.signal.addEventListener("abort", onAbort, { once: true });
+      try {
+        run(operation.signal).then((value) => settle({ kind: "settled", value }), () => settle({ kind: "failed" }));
+      } catch {
+        settle({ kind: "failed" });
+      }
+    });
+  }
+  function poll(request) {
+    if (!current(request) || request.stopPoll !== undefined)
+      return;
+    request.stopPoll = scheduler.schedule(() => {
+      request.stopPoll = undefined;
+      probe(request);
+    }, POLL_MS2);
+  }
+  async function probe(request) {
+    if (!current(request) || !request.callerIdle || request.probing || request.disposing)
+      return;
+    if (scheduler.now() >= request.deadline) {
+      finish(request, "reload-timeout");
+      return;
+    }
+    request.stopPoll?.();
+    request.stopPoll = undefined;
+    request.probing = true;
+    const revision = request.revision;
+    try {
+      for (let check = 0;check < 2; check++) {
+        const outcome2 = await bounded(request, (signal) => deps.client.session.status({ query: { directory }, signal }));
+        if (!current(request))
+          return;
+        if (outcome2.kind !== "settled") {
+          finish(request, "reload-status-failed");
+          return;
+        }
+        const snapshot = parseSessionStatusMap(sdkData(outcome2.value));
+        if (snapshot === undefined) {
+          finish(request, "reload-status-failed");
+          return;
+        }
+        if (revision !== request.revision || !request.callerIdle) {
+          poll(request);
+          return;
+        }
+        if (Object.values(snapshot).some((status) => status.type !== "idle")) {
+          if (Object.hasOwn(snapshot, request.sessionID) && snapshot[request.sessionID]?.type !== "idle")
+            request.callerIdle = false;
+          if (!request.waitingReported) {
+            request.waitingReported = true;
+            deps.notify("reload-waiting");
+          }
+          poll(request);
+          return;
+        }
+      }
+      if (scheduler.now() >= request.deadline) {
+        finish(request, "reload-timeout");
+        return;
+      }
+      request.disposing = true;
+      closed = true;
+      const outcome = await bounded(request, (signal) => deps.client.instance.dispose({ query: { directory }, signal }));
+      if (!current(request))
+        return;
+      finish(request, outcome.kind === "timeout" ? "reload-unconfirmed" : outcome.kind === "settled" && sdkData(outcome.value) === true ? "reload-accepted" : "reload-dispose-failed");
+    } finally {
+      request.probing = false;
+      if (current(request) && request.callerIdle && !request.disposing && revision !== request.revision)
+        probe(request);
+    }
+  }
+  const definition = {
+    description: reloadMessages.description,
+    args: schema.shape,
+    async execute(args, context) {
+      const parsed = schema.safeParse(args);
+      if (!parsed.success)
+        return reloadMessages.invalid;
+      if (context.agent !== "openteam" || resolve9(context.directory) !== directory || context.sessionID.trim().length === 0)
+        return reloadMessages.denied;
+      if (parsed.data.action === "cancel") {
+        if ((pending?.sessionID ?? authorizing?.sessionID) !== context.sessionID)
+          return reloadMessages.none;
+        const message = pending?.disposing ? reloadMessages["reload-unconfirmed"] : reloadMessages["reload-cancelled"];
+        cancel();
+        return message;
+      }
+      if (!parsed.data.confirmed) {
+        const inFlight = pending?.sessionID === context.sessionID && pending.disposing;
+        if ((pending?.sessionID ?? authorizing?.sessionID) === context.sessionID)
+          cancel();
+        return inFlight ? reloadMessages["reload-unconfirmed"] : reloadMessages.declined;
+      }
+      if (context.abort.aborted)
+        return reloadMessages["reload-cancelled"];
+      if (closed)
+        return reloadMessages.closed;
+      if (authorizing !== undefined)
+        return authorizing.sessionID === context.sessionID ? reloadMessages.authorizing : reloadMessages.other;
+      if (pending !== undefined) {
+        if (pending.sessionID !== context.sessionID)
+          return reloadMessages.other;
+        pending.toolDone = false;
+        pending.callerIdle = false;
+        pending.revision++;
+        return reloadMessages["reload-queued"];
+      }
+      const authorization = {
+        sessionID: context.sessionID,
+        deadline: scheduler.now() + WAIT_MS,
+        abort: new AbortController
+      };
+      authorizing = authorization;
+      try {
+        const permission = await requestPermission(context, authorization);
+        if (closed)
+          return reloadMessages.closed;
+        if (authorizing !== authorization || context.abort.aborted || permission === "cancelled")
+          return reloadMessages["reload-cancelled"];
+        if (permission === "timeout" || scheduler.now() >= authorization.deadline) {
+          deps.notify("reload-timeout");
+          return reloadMessages["reload-timeout"];
+        }
+        const onAbort = () => {
+          if (pending === request)
+            cancel();
+        };
+        const request = {
+          sessionID: context.sessionID,
+          deadline: authorization.deadline,
+          abort: new AbortController,
+          unlinkCaller: () => context.abort.removeEventListener("abort", onAbort),
+          stopDeadline: () => {},
+          stopPoll: undefined,
+          toolDone: false,
+          callerIdle: false,
+          probing: false,
+          disposing: false,
+          waitingReported: false,
+          revision: 0
+        };
+        pending = request;
+        context.abort.addEventListener("abort", onAbort, { once: true });
+        request.stopDeadline = scheduler.schedule(() => finish(request, request.disposing ? "reload-unconfirmed" : "reload-timeout"), request.deadline - scheduler.now());
+        deps.notify("reload-queued");
+        return reloadMessages["reload-queued"];
+      } finally {
+        if (authorizing === authorization)
+          authorizing = undefined;
+      }
+    }
+  };
+  return {
+    tool: definition,
+    toolCompleted(sessionID) {
+      if (pending?.sessionID !== sessionID)
+        return;
+      pending.unlinkCaller();
+      pending.toolDone = true;
+      pending.callerIdle = false;
+      pending.revision++;
+    },
+    userTurn(_sessionID) {
+      cancel();
+    },
+    event(event) {
+      const sessionID = pending?.sessionID ?? authorizing?.sessionID;
+      if (sessionID === undefined)
+        return;
+      if (event.type === "session.error" && (event.properties.sessionID === undefined || event.properties.sessionID === sessionID) || event.type === "session.deleted" && event.properties.info.id === sessionID) {
+        cancel();
+        return;
+      }
+      if (event.type === "session.created" || event.type === "session.status" && event.properties.status.type !== "idle")
+        revokeAuthorization();
+      const request = pending;
+      if (request === undefined)
+        return;
+      if (event.type === "session.created" || event.type === "session.status") {
+        request.revision++;
+        if (event.type === "session.status" && event.properties.sessionID === request.sessionID && event.properties.status.type !== "idle")
+          request.callerIdle = false;
+      }
+      if (event.type === "session.idle" || event.type === "session.status" && event.properties.status.type === "idle") {
+        if (event.properties.sessionID === request.sessionID && request.toolDone)
+          request.callerIdle = true;
+        probe(request);
+      }
+    },
+    dispose() {
+      closed = true;
+      cancel();
+    }
+  };
+}
+
 // src/plugin/sessionTracker.ts
 function createSessionTracker() {
   const knownSessions = new Set;
@@ -20580,7 +21014,7 @@ import {
   statSync,
   unlinkSync as unlinkSync2
 } from "node:fs";
-import { join as join15, resolve as resolve10 } from "node:path";
+import { join as join15, resolve as resolve11 } from "node:path";
 import { ZodError } from "zod";
 
 // src/storage/lifecycle/codec.ts
@@ -20699,7 +21133,7 @@ import {
   unlinkSync,
   writeSync as writeSync2
 } from "node:fs";
-import { basename as basename3, dirname as dirname7, join as join14, relative as relative3, resolve as resolve9 } from "node:path";
+import { basename as basename3, dirname as dirname7, join as join14, relative as relative3, resolve as resolve10 } from "node:path";
 var SAFE_RUN_ID = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,126}[A-Za-z0-9])?$/u;
 
 class LifecycleFsError extends Error {
@@ -20723,7 +21157,7 @@ function validateRunID(runID) {
 }
 function resolvedLifecycleRoot(root) {
   try {
-    const absolute = resolve9(root);
+    const absolute = resolve10(root);
     mkdirSync2(absolute, { recursive: true });
     const rootStat = lstatSync2(absolute);
     if (!rootStat.isDirectory() || rootStat.isSymbolicLink()) {
@@ -20766,7 +21200,7 @@ function assertExistingSafeRun(root, runID) {
     throw new LifecycleFsError("unavailable");
   }
   const child = relative3(root, real);
-  if (child === "" || child.startsWith("..") || resolve9(root, child) !== real || dirname7(real) !== root) {
+  if (child === "" || child.startsWith("..") || resolve10(root, child) !== real || dirname7(real) !== root) {
     throw new LifecycleFsError("corrupt");
   }
   return real;
@@ -21006,7 +21440,7 @@ function canDeleteTerminalRun(runDir, runID, now) {
   return now >= lease.expiresAt;
 }
 var createFsLifecycleJournal = (options) => {
-  const configuredRoot = resolve10(options.root);
+  const configuredRoot = resolve11(options.root);
   const now = options.now ?? Date.now;
   const mutateRun = options.withMutationLock ?? withRunMutationLock;
   return {
@@ -21638,8 +22072,8 @@ async function readOpencodeVersion(serverUrl, options = {}) {
 }
 var DEFAULT_OPENCODE_VERSION_BACKOFF_MS = [50, 250];
 function defaultSleep(ms) {
-  return new Promise((resolve11) => {
-    setTimeout(resolve11, ms);
+  return new Promise((resolve12) => {
+    setTimeout(resolve12, ms);
   });
 }
 function createLazyOpencodeVersionReader(serverUrl, options = {}) {
@@ -22163,8 +22597,8 @@ var server = async (ctx, rawOptions) => {
     lifecycleRecorder,
     abortGraceMs: DEFAULT_ABORT_GRACE_MS,
     statusPollMs: DEFAULT_STATUS_POLL_MS,
-    delay: (ms) => new Promise((resolve11) => {
-      setTimeout(resolve11, ms);
+    delay: (ms) => new Promise((resolve12) => {
+      setTimeout(resolve12, ms);
     }),
     warn: diagnostics.warn("unknown-role")
   });
@@ -22184,23 +22618,43 @@ var server = async (ctx, rawOptions) => {
       options: rawOptions
     })
   });
+  const reload = createReloadController({
+    directory: ctx.directory,
+    client: ctx.client,
+    notify: (code) => diagnostics.emit({
+      code,
+      level: code === "reload-timeout" || code === "reload-status-failed" || code === "reload-dispose-failed" || code === "reload-unconfirmed" ? "warn" : "info"
+    }, { toast: code !== "reload-queued" })
+  });
   return {
     ...hooks,
+    "chat.message": async (input, output) => {
+      reload.userTurn(input.sessionID);
+      await hooks["chat.message"]?.(input, output);
+    },
+    dispose: async () => {
+      reload.dispose();
+      await hooks.dispose?.();
+    },
     tool: {
       openteam: createCommandTool(cliDeps),
       "openteam-console": createConsoleTool(),
       "openteam-graph": graphSurface.definition,
       "openteam-orchestrate": orchestrateTool,
       "openteam-memory": memoryTool,
-      "openteam-register-cast": registerCastTool
+      "openteam-register-cast": registerCastTool,
+      "openteam-reload": reload.tool
     },
     "tool.execute.before": async (input) => {
       toolcalls.before(input);
     },
     "tool.execute.after": async (input) => {
       await toolcalls.after(input);
+      if (input.tool === "openteam-reload")
+        reload.toolCompleted(input.sessionID);
     },
     event: async ({ event }) => {
+      reload.event(event);
       if (event.type === "session.created" || event.type === "session.idle") {
         cache.refresh();
       }