@bojackduy/opencode-loopd 1.11.2 → 1.12.2

package/dist/server.js

@@ -129,6 +129,7 @@ var PARENT_NOTIFY_DEDUPE_MS = 60000;
 import { promises as fs } from "fs";
 import path from "path";
 import os from "os";
+import { createHash } from "crypto";
 function emptyState() {
   return { version: CURRENT_VERSION, revision: 0, goals: [], runtimes: [], commandLedger: [], commands: [] };
 }
@@ -142,23 +143,32 @@ function eventsFile(directory) {
   return path.join(loopDir(directory), "events.ndjson");
 }
 function lockDir(directory) {
-  const projectHash = Buffer.from(directory).toString("base64url").slice(0, 32);
+  const projectHash = createHash("sha256").update(path.resolve(directory)).digest("hex");
   return path.join(os.tmpdir(), "loopd-locks", projectHash);
 }
 function lockFile(directory, key) {
   return path.join(lockDir(directory), `${key}.lock`);
 }
+function processIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error?.code !== "ESRCH";
+  }
+}
 async function acquireLock(directory, key, operation) {
   const dir = lockDir(directory);
   await fs.mkdir(dir, { recursive: true });
   const lockPath = lockFile(directory, key);
-  for (let attempt = 0;attempt < 10; attempt++) {
+  const deadline = performance.now() + LOCK_TIMEOUT_MS;
+  for (let attempt = 0;performance.now() < deadline; attempt++) {
     try {
       try {
         const raw = await fs.readFile(lockPath, "utf8");
         const meta = JSON.parse(raw);
         const age = Date.now() - Date.parse(meta.acquiredAt);
-        if (age > LOCK_STALE_MS) {
+        if (age > LOCK_STALE_MS && !processIsAlive(meta.pid)) {
           await fs.rm(lockPath, { force: true });
         }
       } catch {}
@@ -178,17 +188,16 @@ async function acquireLock(directory, key, operation) {
         throw error;
       }
     }
-    await delay(25 * (attempt + 1));
+    await delay(Math.min(25 * (attempt + 1), 250, Math.max(0, deadline - performance.now())));
   }
-  throw new Error(`failed to acquire lock "${key}" for "${operation}" after retries`);
+  throw new Error(`failed to acquire lock "${key}" for "${operation}" after ${LOCK_TIMEOUT_MS}ms`);
 }
 async function releaseLock(directory, key) {
   const lockPath = lockFile(directory, key);
   try {
     const raw = await fs.readFile(lockPath, "utf8");
     const meta = JSON.parse(raw);
-    const age = Date.now() - Date.parse(meta.acquiredAt);
-    const shouldRelease = meta.pid === process.pid || age > LOCK_STALE_MS;
+    const shouldRelease = meta.pid === process.pid;
     if (!shouldRelease)
       return;
     try {
@@ -563,7 +572,7 @@ async function removeCommandLog(directory, commandID) {
 function delay(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-var CURRENT_VERSION = 9, LOCK_STALE_MS = 1e4;
+var CURRENT_VERSION = 9, LOCK_TIMEOUT_MS = 30000, LOCK_STALE_MS = 1e4;
 var init_state_repository = () => {};
 
 // src/domain/command-await.ts
@@ -1545,29 +1554,34 @@ function createControlWorker(options) {
         };
         break;
       }
-      case "switch_goal_model": {
+      case "list_agents": {
+        const catalog = await goalSvc.listAgents();
+        const state = await readState(directory);
+        response = { ...base, ok: catalog.capability === "supported", stateRevision: state.revision, message: `Agents [${catalog.capability}/${catalog.switching}]: ${catalog.agents.map((a) => `${a.name} (${a.mode})`).join(", ") || "none"}` };
+        break;
+      }
+      case "switch_goal_identity": {
         if (!request.goalID) {
           response = { ...base, ok: false, message: "goalID is required", errorCode: "bad_request" };
           break;
         }
         const args = request.args;
-        const model = args?.model;
-        if (typeof model !== "string" || model.trim().length === 0) {
-          response = { ...base, ok: false, message: "model (providerID/modelID) is required", errorCode: "bad_request" };
+        if (args?.model === undefined && args?.agent === undefined || args?.model !== undefined && (typeof args.model !== "string" || !args.model.trim()) || args?.agent !== undefined && (typeof args.agent !== "string" || !args.agent.trim())) {
+          response = { ...base, ok: false, message: "At least one of model (providerID/modelID) or agent is required; provided fields must be non-empty strings.", errorCode: "bad_request" };
           break;
         }
         const ownerForSwitch = (await readState(directory)).goals.find((g) => g.id === request.goalID)?.ownerSessionID ?? "";
-        const result = await goalSvc.switchModel(directory, request.goalID, ownerForSwitch, model.trim(), { resume: args?.resume === true });
+        const result = await goalSvc.switchIdentity(directory, request.goalID, ownerForSwitch, { model: args?.model, agent: args?.agent, resume: args?.resume === true });
         const state = await readState(directory);
         const outcomeMessage = {
-          applied: `Model switched to ${result.model} on the same worker/session.`,
-          deferred: `Worker busy \u2014 switch to ${result.model} queued; applies on the next turn.`,
-          unsupported: `Model switch unsupported on this host (see loopd_list_models). Goal/session retained.`
+          applied: `Identity switched to ${[result.model, result.agent].filter(Boolean).join(" / ")} on the same worker/session.`,
+          deferred: `Identity switch deferred until the next permitted idle turn/prompt; no implicit wake.`,
+          unsupported: `Identity switch unsupported on this host (see loopd_list_models). Goal/session retained.`
         };
         response = {
           ...base,
           ok: result.outcome !== "unsupported",
-          message: outcomeMessage[result.outcome] ?? `Model switch ${result.outcome}.`,
+          message: outcomeMessage[result.outcome] ?? `Identity switch ${result.outcome}.`,
           stateRevision: state.revision
         };
         break;
@@ -3034,6 +3048,25 @@ function normalizeV2Catalog(rawProviders, rawModels) {
   return result;
 }
 
+// src/server/agent-catalog.ts
+function emptyAgentCatalog(source, switching, capability = "unsupported") {
+  return { capability, source, observedAt: new Date().toISOString(), switching, agents: [] };
+}
+function normalizeAgentCatalog(raw, source, switching) {
+  const result = emptyAgentCatalog(source, switching, "unavailable");
+  if (!Array.isArray(raw))
+    return result;
+  result.capability = "supported";
+  for (const value of raw) {
+    if (!value || typeof value !== "object" || typeof value.name !== "string" || !value.name.trim())
+      continue;
+    if (value.mode !== "primary" && value.mode !== "subagent" && value.mode !== "all")
+      continue;
+    result.agents.push({ name: value.name, mode: value.mode, ...typeof value.description === "string" ? { description: value.description } : {} });
+  }
+  return result;
+}
+
 // src/server/host-adapter.ts
 function parseModelRef(value) {
   if (value === undefined)
@@ -3077,6 +3110,27 @@ function markParentNotified2(ownerSessionID, message) {
 }
 function createRealHost(client, directory) {
   return {
+    async listAgents() {
+      const switching = typeof client.session?.switchAgent === "function" ? "session" : "next-prompt";
+      if (typeof client.agent?.list !== "function")
+        return emptyAgentCatalog("v1 agent.list", switching);
+      try {
+        const result = await withTimeout(client.agent.list({ query: { directory } }), 1e4, "OpenCode agent.list");
+        if (result?.error)
+          return emptyAgentCatalog("v1 agent.list", switching, "unavailable");
+        return normalizeAgentCatalog(result?.data, "v1 agent.list", switching);
+      } catch {
+        return emptyAgentCatalog("v1 agent.list", switching, "unavailable");
+      }
+    },
+    async switchSessionAgent(sessionID, agent) {
+      if (typeof client.session?.switchAgent !== "function")
+        return "next-prompt";
+      const result = await withTimeout(client.session.switchAgent({ path: { id: sessionID }, body: { agent } }), 1e4, "OpenCode session.switchAgent");
+      if (result?.error)
+        throw new Error("OpenCode session.switchAgent rejected the agent.");
+      return "applied";
+    },
     async listModels() {
       if (typeof client.provider?.list !== "function")
         return emptyCatalog("v1 provider.list", "next-prompt");
@@ -3278,6 +3332,23 @@ function toWorkerCreation(result) {
 function createV2Host(context, statuses, options = {}) {
   const directory = context.location.directory;
   return {
+    async listAgents() {
+      const switching = typeof context.session.switchAgent === "function" ? "session" : "unsupported";
+      if (typeof context.agent?.list !== "function")
+        return emptyAgentCatalog("v2 agent.list", switching);
+      try {
+        const result = await context.agent.list({ location: { directory } });
+        return normalizeAgentCatalog(result.data, "v2 agent.list", switching);
+      } catch {
+        return emptyAgentCatalog("v2 agent.list", switching, "unavailable");
+      }
+    },
+    async switchSessionAgent(sessionID, agent) {
+      if (typeof context.session.switchAgent !== "function")
+        return "unsupported";
+      await context.session.switchAgent({ sessionID, agent });
+      return "applied";
+    },
     async listModels() {
       if (typeof context.provider?.list !== "function" || typeof context.model?.list !== "function") {
         return emptyCatalog("v2 provider.list + model.list", typeof context.session.switchModel === "function" ? "session" : "unsupported");
@@ -3712,6 +3783,130 @@ function createGoalService(host) {
   async function listModels() {
     return host.listModels ? host.listModels() : emptyCatalog("host catalog capability absent", "unsupported");
   }
+  async function listAgents() {
+    return host.listAgents ? host.listAgents() : emptyAgentCatalog("host agent catalog capability absent", "unsupported");
+  }
+  async function validateAgent(value) {
+    const agent = value.trim();
+    if (!agent)
+      throw new Error("Agent name is required.");
+    const catalog = await listAgents();
+    if (catalog.capability === "supported" && !catalog.agents.some((a) => a.name === agent)) {
+      throw new Error("Agent is unavailable. Discover agents with loopd_list_models first.");
+    }
+    return { agent, catalog };
+  }
+  async function applyAgent(directory, goal, agent, persist = true) {
+    if (!goal.workerSessionID || !host.switchSessionAgent)
+      return "unsupported";
+    const previousAgent = goal.config.agent ?? (await host.readSession(goal.workerSessionID))?.agent;
+    const outcome = await host.switchSessionAgent(goal.workerSessionID, agent);
+    if (outcome === "unsupported")
+      return outcome;
+    if (!persist)
+      return outcome;
+    try {
+      await mutateState(directory, `goal.agent-switch:${goal.id}`, async (s) => {
+        const current = s.goals.find((g) => g.id === goal.id);
+        if (!current)
+          throw new Error("Goal removed during agent switch.");
+        current.config.agent = agent;
+        current.agentSwitch = { pending: undefined, lastFailure: undefined, last: { from: goal.config.agent, to: agent, at: new Date().toISOString(), outcome } };
+        current.updatedAt = new Date().toISOString();
+        return s;
+      });
+    } catch (error) {
+      if (outcome === "applied") {
+        if (!previousAgent)
+          throw new Error("Host accepted agent switch but persistence failed; previous host agent unknown, rollback unavailable.");
+        await host.switchSessionAgent(goal.workerSessionID, previousAgent);
+      }
+      throw error;
+    }
+    await logServerEvent(directory, "goal.agent-switched", { goalID: goal.id, workerSessionID: goal.workerSessionID, from: goal.config.agent, to: agent, outcome });
+    return outcome;
+  }
+  function switchAgent(directory, goalID, ownerSessionID, value, opts) {
+    return withGoalOperation(goalID, () => switchAgentUnlocked(directory, goalID, ownerSessionID, value, opts));
+  }
+  async function switchAgentUnlocked(directory, goalID, ownerSessionID, value, opts) {
+    const state = await readState(directory);
+    const goal = state.goals.find((g) => g.id === goalID);
+    if (!goal || !ownerSessionID || goal.ownerSessionID !== ownerSessionID)
+      throw new Error("Goal not found or not owned by this session.");
+    if (goal.status === "complete")
+      throw new Error("Cannot switch a completed goal.");
+    if (opts?.resume && goal.status !== "blocked")
+      throw new Error("resume is only valid for a blocked goal.");
+    if (opts?.resume)
+      assertWorkspaceWriteAvailable(state, goal, ownerSessionID);
+    const { agent, catalog } = await validateAgent(value);
+    if (catalog.capability !== "supported" || catalog.switching === "unsupported" || !host.switchSessionAgent || !goal.workerSessionID) {
+      return { outcome: "unsupported", agent };
+    }
+    const runtime = state.runtimes.find((r) => r.goalID === goalID);
+    if (await host.sessionStatus(goal.workerSessionID) !== "idle" || runtime?.phase === "running" && leaseIsValid(runtime)) {
+      if (opts?.persist === false)
+        throw new Error("Worker became busy during identity switch.");
+      await mutateState(directory, `goal.agent-deferred:${goalID}`, async (s) => {
+        const current = s.goals.find((g) => g.id === goalID);
+        if (current) {
+          current.agentSwitch = { ...current.agentSwitch, pending: { agent, requestedAt: new Date().toISOString() } };
+          current.updatedAt = new Date().toISOString();
+        }
+        return s;
+      });
+      return { outcome: "deferred", agent };
+    }
+    const applied = await applyAgent(directory, goal, agent, opts?.persist !== false);
+    if (opts?.resume && applied !== "unsupported") {
+      await mutateState(directory, `goal.agent-resume:${goalID}`, async (s) => {
+        const current = s.goals.find((g) => g.id === goalID);
+        if (current?.status === "blocked") {
+          assertWorkspaceWriteAvailable(s, current, ownerSessionID);
+          current.status = "active";
+          current.blocker = undefined;
+          current.updatedAt = new Date().toISOString();
+        }
+        return s;
+      });
+      await continueTurnUnlocked(directory, goalID);
+    }
+    return { outcome: applied === "next-prompt" ? "deferred" : applied, agent, ...opts?.resume && applied !== "unsupported" ? { resumed: true } : {} };
+  }
+  async function applyPendingAgent(directory, goal) {
+    const pending = goal.agentSwitch?.pending;
+    if (!pending)
+      return;
+    let reason = "catalog-unavailable";
+    try {
+      const { catalog } = await validateAgent(pending.agent);
+      if (catalog.capability !== "supported" || catalog.switching === "unsupported")
+        throw new Error("Agent catalog unavailable.");
+      reason = "host-rejected";
+      if (await applyAgent(directory, goal, pending.agent) === "unsupported")
+        throw new Error("Agent switching unsupported.");
+    } catch {
+      await mutateState(directory, `goal.agent-switch-failed:${goal.id}`, async (s) => {
+        const current = s.goals.find((g) => g.id === goal.id);
+        const runtime = s.runtimes.find((r) => r.goalID === goal.id);
+        if (current) {
+          current.agentSwitch = { ...current.agentSwitch, pending: undefined, lastFailure: { at: new Date().toISOString(), reason } };
+          if (current.status === "active") {
+            current.status = "blocked";
+            current.blocker = { reason: "Pending agent switch was not accepted.", needed: "Discover agents, switch the same goal explicitly, then retry when safe.", at: new Date().toISOString() };
+          }
+          current.updatedAt = new Date().toISOString();
+        }
+        if (runtime) {
+          Object.assign(runtime, releaseLease(runtime));
+          runtime.retryAfter = undefined;
+        }
+        return s;
+      });
+      throw new Error("Pending agent switch was not accepted; goal blocked without replacing its worker.");
+    }
+  }
   async function validateModel(value) {
     const ref = parseModelRef(value);
     if (!ref)
@@ -3726,13 +3921,15 @@ function createGoalService(host) {
     }
     return { model, catalog };
   }
-  async function applyModel(directory, goal, model, reason) {
+  async function applyModel(directory, goal, model, reason, persist = true) {
     if (!goal.workerSessionID || !host.switchSessionModel)
       return "unsupported";
     const previousModel = parseModelRef(goal.config.model) ?? (await host.readSession(goal.workerSessionID))?.model;
     const outcome = await host.switchSessionModel(goal.workerSessionID, parseModelRef(model));
     if (outcome === "unsupported")
       return outcome;
+    if (!persist)
+      return outcome;
     try {
       await mutateState(directory, `goal.model-switch:${goal.id}`, async (s) => {
         const current = s.goals.find((g) => g.id === goal.id);
@@ -3760,51 +3957,172 @@ function createGoalService(host) {
     return outcome;
   }
   function switchModel(directory, goalID, ownerSessionID, value, opts) {
-    return withGoalOperation(goalID, async () => {
-      const state = await readState(directory);
-      const goal = state.goals.find((g) => g.id === goalID);
-      if (!goal || !ownerSessionID || goal.ownerSessionID !== ownerSessionID)
-        throw new Error("Goal not found or not owned by this session.");
-      if (goal.status === "complete")
-        throw new Error("Cannot switch a completed goal.");
-      if (opts?.resume && (goal.status !== "blocked" || goal.blocker?.kind !== "provider-limit")) {
-        throw new Error("resume is only valid for a provider-limit-blocked goal.");
-      }
-      if (opts?.resume)
-        assertWorkspaceWriteAvailable(state, goal, ownerSessionID);
-      const { model, catalog } = await validateModel(value);
-      if (catalog.capability !== "supported" || catalog.switching === "unsupported" || !host.switchSessionModel || !goal.workerSessionID) {
-        return { outcome: "unsupported", model };
-      }
-      const runtime = state.runtimes.find((r) => r.goalID === goalID);
-      const status = await host.sessionStatus(goal.workerSessionID);
-      if (status !== "idle" || runtime?.phase === "running" && leaseIsValid(runtime)) {
-        await mutateState(directory, `goal.model-deferred:${goalID}`, async (s) => {
-          const current = s.goals.find((g) => g.id === goalID);
-          if (current) {
-            current.modelSwitch = { ...current.modelSwitch, pending: { model, requestedAt: new Date().toISOString(), reason: "owner" } };
-            current.updatedAt = new Date().toISOString();
-          }
-          return s;
-        });
-        return { outcome: "deferred", model };
-      }
-      const applied = await applyModel(directory, goal, model, "owner");
-      if (opts?.resume && applied !== "unsupported") {
-        await mutateState(directory, `goal.model-resume:${goalID}`, async (s) => {
-          const g = s.goals.find((g) => g.id === goalID);
-          if (g?.status === "blocked" && g.blocker?.kind === "provider-limit") {
-            assertWorkspaceWriteAvailable(s, g, ownerSessionID);
-            g.status = "active";
-            g.blocker = undefined;
-            g.updatedAt = new Date().toISOString();
-          }
-          return s;
-        });
-        await continueTurnUnlocked(directory, goalID);
+    return withGoalOperation(goalID, () => switchModelUnlocked(directory, goalID, ownerSessionID, value, opts));
+  }
+  async function switchModelUnlocked(directory, goalID, ownerSessionID, value, opts) {
+    const state = await readState(directory);
+    const goal = state.goals.find((g) => g.id === goalID);
+    if (!goal || !ownerSessionID || goal.ownerSessionID !== ownerSessionID)
+      throw new Error("Goal not found or not owned by this session.");
+    if (goal.status === "complete")
+      throw new Error("Cannot switch a completed goal.");
+    if (opts?.resume && (goal.status !== "blocked" || goal.blocker?.kind !== "provider-limit")) {
+      throw new Error("resume is only valid for a provider-limit-blocked goal.");
+    }
+    if (opts?.resume)
+      assertWorkspaceWriteAvailable(state, goal, ownerSessionID);
+    const { model, catalog } = await validateModel(value);
+    if (catalog.capability !== "supported" || catalog.switching === "unsupported" || !host.switchSessionModel || !goal.workerSessionID) {
+      return { outcome: "unsupported", model };
+    }
+    const runtime = state.runtimes.find((r) => r.goalID === goalID);
+    const status = await host.sessionStatus(goal.workerSessionID);
+    if (status !== "idle" || runtime?.phase === "running" && leaseIsValid(runtime)) {
+      if (opts?.persist === false)
+        throw new Error("Worker became busy during identity switch.");
+      await mutateState(directory, `goal.model-deferred:${goalID}`, async (s) => {
+        const current = s.goals.find((g) => g.id === goalID);
+        if (current) {
+          current.modelSwitch = { ...current.modelSwitch, pending: { model, requestedAt: new Date().toISOString(), reason: "owner" } };
+          current.updatedAt = new Date().toISOString();
+        }
+        return s;
+      });
+      return { outcome: "deferred", model };
+    }
+    const applied = await applyModel(directory, goal, model, "owner", opts?.persist !== false);
+    if (opts?.resume && applied !== "unsupported") {
+      await mutateState(directory, `goal.model-resume:${goalID}`, async (s) => {
+        const g = s.goals.find((g) => g.id === goalID);
+        if (g?.status === "blocked" && g.blocker?.kind === "provider-limit") {
+          assertWorkspaceWriteAvailable(s, g, ownerSessionID);
+          g.status = "active";
+          g.blocker = undefined;
+          g.updatedAt = new Date().toISOString();
+        }
+        return s;
+      });
+      await continueTurnUnlocked(directory, goalID);
+    }
+    return { outcome: applied === "next-prompt" ? "deferred" : applied, model, ...opts?.resume && applied !== "unsupported" ? { resumed: true } : {} };
+  }
+  function switchIdentity(directory, goalID, ownerSessionID, opts) {
+    return withGoalOperation(goalID, () => switchIdentityUnlocked(directory, goalID, ownerSessionID, opts));
+  }
+  async function switchIdentityUnlocked(directory, goalID, ownerSessionID, opts) {
+    if (opts.model === undefined && opts.agent === undefined)
+      throw new Error("At least one of model or agent is required.");
+    const pending = (await readState(directory)).goals.find((g) => g.id === goalID)?.pendingIdentity;
+    if (pending)
+      opts = { model: opts.model ?? pending.model, agent: opts.agent ?? pending.agent, resume: opts.resume };
+    if (opts.agent === undefined)
+      return switchModelUnlocked(directory, goalID, ownerSessionID, opts.model, opts);
+    if (opts.model === undefined)
+      return switchAgentUnlocked(directory, goalID, ownerSessionID, opts.agent, opts);
+    const state = await readState(directory);
+    const goal = state.goals.find((g) => g.id === goalID);
+    if (!goal || !ownerSessionID || goal.ownerSessionID !== ownerSessionID)
+      throw new Error("Goal not found or not owned by this session.");
+    if (goal.status === "complete")
+      throw new Error("Cannot switch a completed goal.");
+    if (opts.resume && goal.status !== "blocked")
+      throw new Error("resume is only valid for a blocked goal.");
+    if (opts.resume)
+      assertWorkspaceWriteAvailable(state, goal, ownerSessionID);
+    const { model, catalog: models } = await validateModel(opts.model);
+    const { agent, catalog: agents } = await validateAgent(opts.agent);
+    if (models.capability !== "supported" || models.switching === "unsupported" || agents.capability !== "supported" || agents.switching === "unsupported" || !host.switchSessionModel || !host.switchSessionAgent || !goal.workerSessionID) {
+      return { outcome: "unsupported", model, agent };
+    }
+    const runtime = state.runtimes.find((r) => r.goalID === goalID);
+    if (await host.sessionStatus(goal.workerSessionID) !== "idle" || runtime?.phase === "running" && leaseIsValid(runtime)) {
+      await mutateState(directory, `goal.identity-deferred:${goalID}`, async (s) => {
+        const current = s.goals.find((g) => g.id === goalID);
+        current.pendingIdentity = { model, agent };
+        current.modelSwitch = { ...current.modelSwitch, pending: undefined };
+        current.agentSwitch = { ...current.agentSwitch, pending: undefined };
+        current.updatedAt = new Date().toISOString();
+        return s;
+      });
+      return { outcome: "deferred", model, agent };
+    }
+    const live = await host.readSession(goal.workerSessionID);
+    const previousModel = parseModelRef(goal.config.model) ?? live?.model;
+    const previousAgent = goal.config.agent ?? live?.agent;
+    if (!previousModel || !previousAgent)
+      throw new Error("Combined switch requires a known previous identity for rollback.");
+    let modelChanged = false;
+    let agentChanged = false;
+    let outcome = "applied";
+    try {
+      const changedModel = await switchModelUnlocked(directory, goalID, ownerSessionID, model, { persist: false });
+      if (changedModel.outcome === "unsupported")
+        return { outcome: "unsupported", model, agent };
+      modelChanged = true;
+      const changedAgent = await switchAgentUnlocked(directory, goalID, ownerSessionID, agent, { persist: false });
+      if (changedAgent.outcome === "unsupported")
+        throw new Error("Agent switch unsupported after model switch.");
+      agentChanged = true;
+      if (changedModel.outcome === "deferred" || changedAgent.outcome === "deferred")
+        outcome = "deferred";
+      await mutateState(directory, `goal.identity-switched:${goalID}`, async (s) => {
+        const current = s.goals.find((g) => g.id === goalID);
+        const at = new Date().toISOString();
+        current.config.model = model;
+        current.config.agent = agent;
+        current.modelSwitch = { ...current.modelSwitch, pending: undefined, lastFailure: undefined, last: { from: goal.config.model, to: model, at, outcome: changedModel.outcome === "deferred" ? "next-prompt" : "applied", reason: "owner" } };
+        current.agentSwitch = { pending: undefined, lastFailure: undefined, last: { from: goal.config.agent, to: agent, at, outcome: changedAgent.outcome === "deferred" ? "next-prompt" : "applied" } };
+        current.pendingIdentity = undefined;
+        current.updatedAt = at;
+        return s;
+      });
+    } catch (error) {
+      const rollbacks = await Promise.allSettled([
+        ...agentChanged ? [host.switchSessionAgent(goal.workerSessionID, previousAgent)] : [],
+        ...modelChanged ? [host.switchSessionModel(goal.workerSessionID, previousModel)] : []
+      ]);
+      if (rollbacks.some((result) => result.status === "rejected" || result.value === "unsupported")) {
+        throw new Error("Identity switch failed and host rollback failed; inspect the existing session before retrying.");
       }
-      return { outcome: applied === "next-prompt" ? "deferred" : applied, model, ...opts?.resume && applied !== "unsupported" ? { resumed: true } : {} };
-    });
+      throw error;
+    }
+    if (opts.resume) {
+      await mutateState(directory, `goal.identity-resume:${goalID}`, async (s) => {
+        const current = s.goals.find((g) => g.id === goalID);
+        assertWorkspaceWriteAvailable(s, current, ownerSessionID);
+        current.status = "active";
+        current.blocker = undefined;
+        current.updatedAt = new Date().toISOString();
+        return s;
+      });
+      await continueTurnUnlocked(directory, goalID);
+    }
+    return { outcome, model, agent, ...opts.resume ? { resumed: true } : {} };
+  }
+  async function applyPendingIdentity(directory, goal) {
+    if (!goal.pendingIdentity)
+      return;
+    try {
+      const result = await switchIdentityUnlocked(directory, goal.id, goal.ownerSessionID, goal.pendingIdentity);
+      if (result.outcome === "unsupported")
+        throw new Error("Identity switching unsupported.");
+    } catch {
+      await mutateState(directory, `goal.identity-switch-failed:${goal.id}`, async (s) => {
+        const current = s.goals.find((g) => g.id === goal.id);
+        current.pendingIdentity = undefined;
+        if (current.status === "active") {
+          current.status = "blocked";
+          current.blocker = { reason: "Pending identity switch was not accepted.", needed: "Inspect the existing session, switch identity explicitly, then retry when safe.", at: new Date().toISOString() };
+        }
+        const runtime = s.runtimes.find((r) => r.goalID === goal.id);
+        if (runtime) {
+          Object.assign(runtime, releaseLease(runtime));
+          runtime.retryAfter = undefined;
+        }
+        return s;
+      });
+      throw new Error("Pending identity switch was not accepted; goal blocked without replacing its worker.");
+    }
   }
   async function applyPendingModel(directory, goal) {
     const pending = goal.modelSwitch?.pending;
@@ -3857,7 +4175,7 @@ function createGoalService(host) {
     const runtime = state.runtimes.find((r) => r.goalID === goalID);
     const quotaBlocked = goal.status === "blocked" && runtime?.lastError === describeError(error);
     const sameModel = expectedModel === undefined || expectedModel === goal.config.model;
-    const eligible = sameModel && (goal.status === "active" || quotaBlocked) && (!goal.modelSwitch?.pending || goal.modelSwitch.pending.reason === "quota");
+    const eligible = sameModel && !goal.pendingIdentity && (goal.status === "active" || quotaBlocked) && (!goal.modelSwitch?.pending || goal.modelSwitch.pending.reason === "quota");
     if (eligible && goal.modelSwitch?.pending?.reason === "quota") {
       pending = { ...goal.modelSwitch.pending, reason: "quota" };
       status = "prepared";
@@ -3914,7 +4232,9 @@ function createGoalService(host) {
         return;
       if (await host.sessionStatus(goal.workerSessionID) !== "idle")
         return;
+      await applyPendingIdentity(directory, goal);
       await applyPendingModel(directory, goal);
+      await applyPendingAgent(directory, goal);
       const fresh = (await readState(directory)).goals.find((g) => g.id === goalID);
       if (fresh?.workerSessionID)
         await host.compactSession(fresh.workerSessionID, parseModelRef(fresh.config.model));
@@ -4256,10 +4576,12 @@ function createGoalService(host) {
       return;
     if (!opts?.force && !await workers.isIdle(session.workerSessionID))
       return;
-    if (goal.modelSwitch?.pending) {
+    if (goal.pendingIdentity || goal.modelSwitch?.pending || goal.agentSwitch?.pending) {
       if (await host.sessionStatus(session.workerSessionID) !== "idle")
         return;
+      await applyPendingIdentity(directory, goal);
       await applyPendingModel(directory, goal);
+      await applyPendingAgent(directory, goal);
     }
     let acquired = false;
     const state = await mutateState(directory, `turn.acquire:${goalID}`, async (s) => {
@@ -4757,7 +5079,7 @@ function createGoalService(host) {
   function accountUsage(directory, goalID) {
     return withGoalOperation(goalID, () => accountUsageUnlocked(directory, goalID));
   }
-  return { start, continueTurn, nudge, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile, accountUsage, abortWorker, sendUserMessage, setInteractive, listModels, switchModel, observeProviderError, compact };
+  return { start, continueTurn, nudge, pause, resume, retry, clear, getWorker, getActiveWorkers, reconcile, accountUsage, abortWorker, sendUserMessage, setInteractive, listModels, switchModel, listAgents, switchAgent, switchIdentity, observeProviderError, compact };
 }
 
 // src/application/schedule-worker.ts
@@ -6114,7 +6436,8 @@ function createCommandService(host, opts) {
       c.exitCode = info.exitCode;
       if (info.signal && (c.signal === "SIGKILL" || c.signal === "SIGTERM")) {
         c.status = "terminated";
-        c.endReason = "terminate";
+        if (c.endReason !== "until")
+          c.endReason = "terminate";
       } else {
         c.status = "exited";
         c.endReason = "exit";
@@ -6410,6 +6733,9 @@ function createCommandService(host, opts) {
         const c = (s.commands ?? []).find((x) => x.id === id);
         if (c && c.ownerSessionID === ownerSessionID && c.status === "running") {
           c.signal = "SIGTERM";
+          if (c.endReason !== "timeout" && c.watchState?.state === "until-matched" && c.watchUntilAction === "stop") {
+            c.endReason = "until";
+          }
           c.updatedAt = new Date().toISOString();
         }
         return s;
@@ -6448,8 +6774,9 @@ function createCommandService(host, opts) {
           return s;
         if (c.status === "running") {
           c.status = status;
-          if (c.endReason !== "timeout")
-            c.endReason = status === "terminated" ? "terminate" : "exit";
+          if (c.endReason !== "timeout") {
+            c.endReason = status === "terminated" ? c.endReason === "until" ? "until" : "terminate" : "exit";
+          }
           if (exitCode !== undefined)
             c.exitCode = c.exitCode ?? exitCode;
           c.signal = c.signal ?? "SIGTERM";
@@ -7957,20 +8284,25 @@ function ownerTools(options) {
   const { directory, host, goalService } = options;
   return {
     loopd_list_models: tool2({
-      description: "Discover host providers/models usable by this agent and inspect quota limitations plus assigned identities of this session's existing goals. " + "Remaining quota is unknown unless a supported integration reports it; connected/enabled is not remaining balance. " + "Workflow: discover -> inspect_background_goal for last local quota error -> switch_goal_model on the SAME goal, never create a duplicate to change provider. No secrets/auth data are returned.",
+      description: "Discover host providers/models and available OpenCode agents, inspect quota limitations plus assigned identities of this session's existing goals. " + "Remaining quota is unknown unless a supported integration reports it; connected/enabled is not remaining balance. " + "Workflow: discover -> inspect_background_goal for last local quota error -> switch_goal_identity on the SAME goal, never create a duplicate to change provider. No secrets/auth data are returned.",
       args: {},
       execute: async (_args, context) => {
         if (!context?.sessionID)
           return { title: "No session", output: JSON.stringify({ ok: false, message: "No session context available." }) };
-        const [catalog, state] = await Promise.all([goalService.listModels(), readState(directory)]);
+        const [catalog, agentCatalog, state] = await Promise.all([goalService.listModels(), goalService.listAgents(), readState(directory)]);
         return {
           title: "Provider/model capabilities",
           output: JSON.stringify({
             ok: true,
             ...catalog,
+            agents: agentCatalog.agents,
+            agentCatalog,
             assignedGoals: state.goals.filter((g) => g.ownerSessionID === context.sessionID).map((g) => ({
               id: g.id,
               model: g.config.model,
+              agent: g.config.agent,
+              agentSwitch: g.agentSwitch,
+              pendingIdentity: g.pendingIdentity,
               workerSessionID: g.workerSessionID,
               modelSwitch: g.modelSwitch,
               modelFallback: g.modelFallback,
@@ -7981,25 +8313,28 @@ function ownerTools(options) {
         };
       }
     }),
-    switch_goal_model: tool2({
-      description: "Switch provider/model for an EXISTING goal owned by this session, preserving goal ID, worker session, transcript, checks and budgets. " + "First discover usable models with loopd_list_models, then inspect_background_goal for quota/error information. " + "Busy workers defer to the next safe turn; v1 changes apply on the next prompt. No abort, duplicate worker, budget reset, unpause or interactive wake. " + "Returns applied/deferred/unsupported honestly; an unsupported catalog cannot validate a switch. resume=true explicitly resumes ONLY a provider-limit-blocked goal and requests its next turn (including interactive); never resets budgets.",
+    switch_goal_identity: tool2({
+      description: "Switch an EXISTING owned goal's model, agent, or both atomically, preserving the same worker/session, transcript, progress, inbox, checks, budgets and topology. At least one of model or agent is required. Discover identities with loopd_list_models first. Busy workers defer until the next permitted idle turn; legacy hosts apply on the next prompt. No implicit unpause or interactive wake. resume=true explicitly resumes only a blocked goal after a safe switch (model-only requires a provider-limit blocker); busy requests remain blocked until explicitly retried/resumed when idle. Combined host failures roll back successful changes; rollback failure requires inspecting the existing session.",
       args: {
-        goal_id: tool2.schema.string().describe("Existing owned goal ID; never create a replacement goal to switch models."),
-        model: tool2.schema.string().describe("Available providerID/modelID from loopd_list_models."),
-        resume: tool2.schema.boolean().optional().describe("Explicitly resume only a quota/rate-limit-blocked goal after a safe switch. Default false. Paused/budget-limited/unrelated-blocked goals are not resumed.")
+        goal_id: tool2.schema.string().describe("Existing owned goal ID."),
+        agent: tool2.schema.string().optional().describe("Available agent name from loopd_list_models."),
+        model: tool2.schema.string().optional().describe("Available providerID/modelID from loopd_list_models. Provide model, agent, or both."),
+        resume: tool2.schema.boolean().optional().describe("Explicitly resume a blocked goal after a safe switch. Default false.")
       },
       execute: async (args, context) => {
         if (!context?.sessionID)
           return { title: "No session", output: JSON.stringify({ ok: false, message: "No session context available." }) };
+        if (args.model === undefined && args.agent === undefined)
+          return { title: "Identity switch failed", output: JSON.stringify({ ok: false, message: "At least one of model or agent is required." }) };
         const state = await readState(directory);
         if (!state.goals.some((g) => g.id === args.goal_id && g.ownerSessionID === context.sessionID)) {
           return { title: "Switch denied", output: JSON.stringify({ ok: false, message: "Goal not found or not owned by this session." }) };
         }
         try {
-          const result = await goalService.switchModel(directory, args.goal_id, context.sessionID, args.model, { resume: args.resume });
-          return { title: `Model switch: ${result.outcome}`, output: JSON.stringify({ ok: result.outcome !== "unsupported", ...result, goalID: args.goal_id, message: "Same goal and worker retained. Deferred requests require the next permitted turn; no automatic interactive wake." }) };
+          const result = await goalService.switchIdentity(directory, args.goal_id, context.sessionID, args);
+          return { title: `Identity switch: ${result.outcome}`, output: JSON.stringify({ ok: result.outcome !== "unsupported", ...result, goalID: args.goal_id, message: "Same goal and worker retained. Deferred requests require the next permitted idle turn; no automatic interactive wake." }) };
         } catch {
-          return { title: "Model switch failed", output: JSON.stringify({ ok: false, message: "Switch rejected: verify ownership, model availability and host capability with loopd_list_models and inspect_background_goal. Existing goal/session retained." }) };
+          return { title: "Identity switch failed", output: JSON.stringify({ ok: false, message: "Switch rejected: verify ownership, identity availability, resume eligibility and host capability with loopd_list_models and inspect_background_goal. Existing goal/session retained. Inspect live session identity before retrying if host rollback failed." }) };
         }
       }
     }),
@@ -8045,6 +8380,8 @@ function ownerTools(options) {
             agent: g.config.agent,
             model: g.config.model,
             modelSwitch: g.modelSwitch,
+            agentSwitch: g.agentSwitch,
+            pendingIdentity: g.pendingIdentity,
             modelFallback: g.modelFallback,
             lastProviderLimit: g.lastProviderLimit,
             fallbackModels: g.config.fallbackModels ?? [],
@@ -8152,6 +8489,8 @@ function ownerTools(options) {
             },
             lastProgress: goal.lastProgress,
             modelSwitch: goal.modelSwitch,
+            agentSwitch: goal.agentSwitch,
+            pendingIdentity: goal.pendingIdentity,
             modelFallback: goal.modelFallback,
             lastProviderLimit: goal.lastProviderLimit,
             quotaLimitation: "Remaining provider quota unknown; local quota errors are observations, not balance data. See loopd_list_models.",
@@ -8636,7 +8975,7 @@ function commandTools(options) {
   const sizeNote = capabilities.resize ? "applied live to the PTY winsize" : "stored; resize is unsupported by the pipe host";
   return {
     loopd_command_start: tool3({
-      description: "PREFER THIS over the built-in shell/bash tool whenever a command might take a while or never return: installs (npm/pip/brew/cargo...), builds, test suites, downloads, migrations, dev servers, watchers, log tails, REPLs, or anything interactive. The built-in shell BLOCKS your whole turn until the process exits \u2014 a long install freezes you (and can time out); this returns immediately with a command_id and pushes you a message on exit or pattern match, so you stay responsive and can do other work meanwhile. Only use the built-in shell for quick one-shots (ls, git status, a single fast test) that finish in seconds. " + "Start a standalone interactive OS process (arbitrary shell command) in the background \u2014 a dev server, `npm test --watch`, a REPL, a log tail, a build, or a one-off script. This is a raw process, NOT an AI worker: no agent, no checks, no turn loop. For multi-turn autonomous AI work with completion criteria, use loopd_create_goal instead. " + "Returns a command_id for loopd_command_get (read output)/loopd_command_write (send stdin)/loopd_command_interrupt (Ctrl+C)/loopd_command_terminate (kill)/loopd_command_remove (delete). " + "The user can also open it live: /loop or /commands \u2192 Tab/l to the Commands tab \u2192 select it \u2192 `o` opens a fullscreen interactive terminal page (type directly, Ctrl+C interrupts, Ctrl+] detaches without stopping it). " + "Independent from goals: an optional goal_id is display-only metadata and never couples lifecycles \u2014 pausing/clearing a goal never touches the command, and terminating a command never touches the goal. " + "To make a specific goal wake up when this command finishes, call loopd_command_await separately after starting it (linking alone does not wake anything). " + "The OWNER session gets a notification on natural exit (including code 0), missing process, or timeout \u2014 no polling required for completion. Manual terminate stays silent by default. Raw PTY output stays in the log; any short tail included in the notification is sanitized for chat. Set notify_on_exit:false to suppress owner exit notifications.",
+      description: "PREFER THIS over the built-in shell/bash tool whenever a command might take a while or never return: installs (npm/pip/brew/cargo...), builds, test suites, downloads, migrations, dev servers, watchers, log tails, REPLs, or anything interactive. The built-in shell BLOCKS your whole turn until the process exits \u2014 a long install freezes you (and can time out); this returns immediately with a command_id and pushes you a message on exit or pattern match, so you stay responsive and can do other work meanwhile. Only use the built-in shell for quick one-shots (ls, git status, a single fast test) that finish in seconds. " + "Start a standalone interactive OS process (arbitrary shell command) in the background \u2014 a dev server, `npm test --watch`, a REPL, a log tail, a build, or a one-off script. This is a raw process, NOT an AI worker: no agent, no checks, no turn loop. For multi-turn autonomous AI work with completion criteria, use loopd_create_goal instead. " + "Returns a command_id for loopd_command_get (read output)/loopd_command_write (send stdin)/loopd_command_interrupt (Ctrl+C)/loopd_command_terminate (kill)/loopd_command_remove (delete). " + "The user can also open it live: /loop or /commands \u2192 Tab/l to the Commands tab \u2192 select it \u2192 `o` opens a fullscreen interactive terminal page (type directly, Ctrl+C interrupts, Ctrl+] detaches without stopping it). " + "Independent from goals: an optional goal_id is display-only metadata and never couples lifecycles \u2014 pausing/clearing a goal never touches the command, and terminating a command never touches the goal. " + "To make a specific goal wake up when this command finishes, call loopd_command_await separately after starting it (linking alone does not wake anything). " + "The OWNER session gets a notification on natural exit (including code 0), missing process, or timeout \u2014 no polling required for completion. Manual terminate stays silent by default. Raw PTY output stays in the log; any short tail included in the notification is sanitized for chat. Set notify_on_exit:false to suppress owner exit notifications." + " HOW TO WAIT \u2014 declare your wake upfront, then go do other work; you will be pushed. Never poll loopd_command_get in a loop and never sleep-then-read: quick one-shot finishing in seconds \u2192 built-in bash, or start here and read once. " + "Minutes-long or never-exiting where only FINISHING matters \u2192 just start it; the automatic exit/timeout notification is your wake. " + "Never-exiting where a LINE appearing matters (dev-server READY, deploy COMPLETED) \u2192 pass watch_until (+ watch_filter to cut noise); stop (default) ends the command with exactly one message, keep lets it run on. " + "A GOAL worker that must block until that happens \u2192 call loopd_command_await (passing goal_id alone never wakes anything). " + "Polling the WORLD inside the command (a shell loop curling an endpoint until it flips) is fine and costs no turns; polling loopd from YOUR side is the forbidden pattern \u2014 one mid-run peek is fine, a timer loop is not. " + "Emit a printed marker line for EVERY outcome (DONE and FAILED), or a silent failure wakes nobody. " + "Watches longer than ~30min are fragile (in-memory only, die on restart) \u2014 prefer a scheduled goal that checks state and completes.",
       args: {
         title: tool3.schema.string().describe("Short human label for the session."),
         command: tool3.schema.string().describe('Executable to spawn (e.g. "bun", "python3").'),
@@ -8897,7 +9236,7 @@ function commandTools(options) {
 // src/server/plugin.ts
 init_state_repository();
 // package.json
-var version = "1.11.2";
+var version = "1.12.2";
 
 // src/server/plugin.ts
 var PLUGIN_ID = "opencode-loopd.server";