@codions/portta 0.0.0-develop.149.sha-240655c → 0.0.0-develop.150.sha-ed65081

package/dist/host.js

@@ -23429,17 +23429,17 @@ var init_json_schema_processors = __esm({
         minItems--;
       }
       const maxItems = def.items.length;
-      const isClosed = !def.rest;
+      const isClosed2 = !def.rest;
       if (ctx.target === "draft-2020-12") {
         json3.prefixItems = prefixItems;
-        if (isClosed) {
+        if (isClosed2) {
           json3.items = false;
         } else if (rest) {
           json3.items = rest;
         }
         if (minItems > 0)
           json3.minItems = minItems;
-        if (isClosed)
+        if (isClosed2)
           json3.maxItems = maxItems;
       } else if (ctx.target === "openapi-3.0") {
         json3.items = {
@@ -23450,18 +23450,18 @@ var init_json_schema_processors = __esm({
         }
         if (minItems > 0)
           json3.minItems = minItems;
-        if (isClosed)
+        if (isClosed2)
           json3.maxItems = maxItems;
       } else {
         json3.items = prefixItems;
-        if (isClosed) {
+        if (isClosed2) {
           json3.additionalItems = false;
         } else if (rest) {
           json3.additionalItems = rest;
         }
         if (minItems > 0)
           json3.minItems = minItems;
-        if (isClosed)
+        if (isClosed2)
           json3.maxItems = maxItems;
       }
       const { minimum, maximum } = schema._zod.bag;
@@ -34015,17 +34015,17 @@ var require_fast_uri = __commonJS({
       if (baseMalformed || relativeMalformed || baseMalformedPercentEncoding || relativeMalformedPercentEncoding || baseMalformedSchemeSpecific || relativeMalformedSchemeSpecific || baseMalformedHost || relativeMalformedHost || baseMalformedScheme || relativeMalformedScheme) {
         throw new Error(baseParsed.error || relativeParsed.error || "URI is malformed.");
       }
-      const resolved = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
-      const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved.scheme);
-      const resolvedHost = resolved.host;
+      const resolved2 = resolveComponent(baseParsed, relativeParsed, schemelessOptions, true);
+      const resolvedSchemeHandler = getSchemeHandler(options && options.scheme || resolved2.scheme);
+      const resolvedHost = resolved2.host;
       const resolvedHostIsIP = resolvedHost !== void 0 && resolvedHost !== "" && (isIPv4(resolvedHost) || normalizeIPv6(resolvedHost).isIPV6);
-      canonicalizeHost(resolved, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
+      canonicalizeHost(resolved2, options || {}, resolvedSchemeHandler, resolvedHostIsIP);
       const encodedASCIIHost = resolvedHost && resolvedHost.indexOf("%") !== -1 && !new RegExp("\\P{ASCII}", "u").test(resolvedHost);
-      if (resolved.error && !encodedASCIIHost) {
-        throw new Error(resolved.error);
+      if (resolved2.error && !encodedASCIIHost) {
+        throw new Error(resolved2.error);
       }
       schemelessOptions.skipEscape = true;
-      return serialize2(resolved, schemelessOptions);
+      return serialize2(resolved2, schemelessOptions);
     }
     function resolveComponent(base, relative5, options, skipNormalization) {
       const target = {};
@@ -43704,8 +43704,8 @@ function convertBaseSchema(schema, ctx) {
       });
     }
     ctx.processing.add(refPath);
-    const resolved = resolveRef(refPath, ctx);
-    const zodSchema2 = convertSchema(resolved, ctx);
+    const resolved2 = resolveRef(refPath, ctx);
+    const zodSchema2 = convertSchema(resolved2, ctx);
     ctx.refs.set(refPath, zodSchema2);
     ctx.processing.delete(refPath);
     return zodSchema2;
@@ -44576,8 +44576,8 @@ function createHostShellPathRefresher(options = {}) {
       if (pending) return pending;
       if (expiresAt > now()) return Promise.resolve({ changed: false, path });
       pending = (async () => {
-        const resolved = await resolvePath();
-        const next = resolved ? mergePaths(path, resolved) : path;
+        const resolved2 = await resolvePath();
+        const next = resolved2 ? mergePaths(path, resolved2) : path;
         const changed = next !== path;
         path = next;
         if (path) env2.PATH = path;
@@ -44771,8 +44771,8 @@ function resolveHostTool(tool, options) {
   return defaultHostToolResolver()(tool);
 }
 function hostToolInvocation(tool, options) {
-  const resolved = resolveHostTool(tool, options) ?? tool;
-  return /[\s'"\\]/.test(resolved) ? `'${resolved.replaceAll("'", "'\\''")}'` : resolved;
+  const resolved2 = resolveHostTool(tool, options) ?? tool;
+  return /[\s'"\\]/.test(resolved2) ? `'${resolved2.replaceAll("'", "'\\''")}'` : resolved2;
 }
 function resolveWorkerBins(env2 = process.env) {
   const resolve21 = (name, override) => {
@@ -48278,9 +48278,9 @@ function sanitizeNameSegment(value, maxLength = 24) {
   return trimmed || "x";
 }
 function buildProjectSessionName(projectRoot2) {
-  const resolved = resolve4(projectRoot2);
-  const base = sanitizeNameSegment(basename2(resolved), 18);
-  const hash4 = createHash5("sha1").update(resolved).digest("hex").slice(0, 8);
+  const resolved2 = resolve4(projectRoot2);
+  const base = sanitizeNameSegment(basename2(resolved2), 18);
+  const hash4 = createHash5("sha1").update(resolved2).digest("hex").slice(0, 8);
   return `${RUNTIME_IDENTITY.tmuxPrefix}-${base}-${hash4}`;
 }
 function buildWorktreeWindowName(branch) {
@@ -48768,12 +48768,12 @@ import { spawnSync as spawnSync4 } from "node:child_process";
 import { readdirSync, realpathSync, rmSync, statSync as statSync3 } from "node:fs";
 import { basename as basename3, dirname as dirname7, join as join6, resolve as resolve6 } from "node:path";
 function canonicalizeFsPath(input2) {
-  const resolved = resolve6(input2);
+  const resolved2 = resolve6(input2);
   try {
-    return realpathSync(resolved);
+    return realpathSync(resolved2);
   } catch {
     const missing = [];
-    let current = resolved;
+    let current = resolved2;
     while (current !== dirname7(current)) {
       missing.unshift(basename3(current));
       current = dirname7(current);
@@ -48782,7 +48782,7 @@ function canonicalizeFsPath(input2) {
       } catch {
       }
     }
-    return resolved;
+    return resolved2;
   }
 }
 function sameFsPath(left, right) {
@@ -49124,20 +49124,20 @@ function loadProjectAllowlist(options = {}) {
   return [...new Set(roots.map((root) => canonicalizeFsPath(root)))];
 }
 function isPathInsideAllowlist(candidate, allowlist) {
-  const resolved = canonicalizeFsPath(candidate);
+  const resolved2 = canonicalizeFsPath(candidate);
   return allowlist.some((root) => {
     const canonicalRoot = canonicalizeFsPath(root);
-    if (resolved === canonicalRoot) return true;
+    if (resolved2 === canonicalRoot) return true;
     const prefix = canonicalRoot.endsWith("/") ? canonicalRoot : `${canonicalRoot}/`;
-    return resolved.startsWith(prefix);
+    return resolved2.startsWith(prefix);
   });
 }
 function assertProjectRootAllowed(candidate, allowlist) {
-  const resolved = canonicalizeFsPath(candidate);
-  if (!isPathInsideAllowlist(resolved, allowlist)) {
-    throw new ProjectAllowlistError(`Project root is outside the configured allowlist: ${resolved}`);
+  const resolved2 = canonicalizeFsPath(candidate);
+  if (!isPathInsideAllowlist(resolved2, allowlist)) {
+    throw new ProjectAllowlistError(`Project root is outside the configured allowlist: ${resolved2}`);
   }
-  return resolved;
+  return resolved2;
 }
 function registerableProjectRoot(inputPath, deps) {
   const trimmed = inputPath.trim();
@@ -52328,8 +52328,8 @@ var LifecycleService = class {
   }
   async openWorktree(branch, options = {}) {
     try {
-      const resolved = await this.resolveExistingWorktree(branch);
-      let initialized = resolved.meta ? await this.refreshManagedArtifacts(resolved) : await this.initializeUnmanagedWorktree(resolved);
+      const resolved2 = await this.resolveExistingWorktree(branch);
+      let initialized = resolved2.meta ? await this.refreshManagedArtifacts(resolved2) : await this.initializeUnmanagedWorktree(resolved2);
       const { profileName, profile } = this.resolveProfile(initialized.meta.profile);
       const agent = this.resolveAgentDefinition(initialized.meta.agent);
       const interfaceMode = this.resolveInterfaceMode(
@@ -52346,11 +52346,11 @@ var LifecycleService = class {
         await writeWorktreeMeta(initialized.paths.gitDir, nextMeta);
         initialized = { ...initialized, meta: nextMeta };
       }
-      const launchMode = resolved.meta && agent.capabilities.resume ? "resume" : "fresh";
+      const launchMode = resolved2.meta && agent.capabilities.resume ? "resume" : "fresh";
       const resumeConversationId = resolveCodexResumeConversationId(initialized.meta, agent, launchMode);
       await ensureAgentRuntimeArtifacts({
         gitDir: initialized.paths.gitDir,
-        worktreePath: resolved.entry.path
+        worktreePath: resolved2.entry.path
       });
       await this.materializeRuntimeSession({
         branch,
@@ -52358,7 +52358,7 @@ var LifecycleService = class {
         profile,
         agent,
         initialized,
-        worktreePath: resolved.entry.path,
+        worktreePath: resolved2.entry.path,
         launchMode,
         followUpPrompt: options.prompt,
         source: options.oneshot ? "oneshot" : initialized.meta.source,
@@ -52366,7 +52366,7 @@ var LifecycleService = class {
         interfaceMode
       });
       if (initialized.meta.agentTerminalStale === true) {
-        await writeWorktreeMeta(resolved.gitDir, {
+        await writeWorktreeMeta(resolved2.gitDir, {
           ...initialized.meta,
           agentTerminalStale: false
         });
@@ -52374,8 +52374,8 @@ var LifecycleService = class {
       if (interfaceMode === "terminal") {
         await this.restoreWorktreeTabs({
           branch,
-          gitDir: resolved.gitDir,
-          worktreePath: resolved.entry.path,
+          gitDir: resolved2.gitDir,
+          worktreePath: resolved2.entry.path,
           profile,
           profileName,
           agent,
@@ -52393,11 +52393,11 @@ var LifecycleService = class {
   }
   async refreshAgentTerminal(branch) {
     try {
-      const resolved = await this.resolveExistingWorktree(branch);
-      if (!resolved.meta) {
+      const resolved2 = await this.resolveExistingWorktree(branch);
+      if (!resolved2.meta) {
         throw new LifecycleError(`Worktree ${branch} has no managed metadata to refresh`, 409);
       }
-      const initialized = await this.refreshManagedArtifacts(resolved);
+      const initialized = await this.refreshManagedArtifacts(resolved2);
       const { profileName, profile } = this.resolveProfile(initialized.meta.profile);
       const agent = this.resolveAgentDefinition(initialized.meta.agent);
       if (agent.kind !== "builtin" || agent.implementation.agent !== "codex" && agent.implementation.agent !== "claude") {
@@ -52416,8 +52416,8 @@ var LifecycleService = class {
         resumeConversationId = await this.ensureRootSessionId({
           meta: initialized.meta,
           agentKind: agent.implementation.agent,
-          worktreePath: resolved.entry.path,
-          resolved
+          worktreePath: resolved2.entry.path,
+          resolved: resolved2
         });
         if (!resumeConversationId) {
           throw new LifecycleError(`No ${agent.label} conversation is available to refresh`, 409);
@@ -52425,7 +52425,7 @@ var LifecycleService = class {
       }
       await ensureAgentRuntimeArtifacts({
         gitDir: initialized.paths.gitDir,
-        worktreePath: resolved.entry.path
+        worktreePath: resolved2.entry.path
       });
       await this.materializeRuntimeSession({
         branch,
@@ -52433,19 +52433,19 @@ var LifecycleService = class {
         profile,
         agent,
         initialized,
-        worktreePath: resolved.entry.path,
+        worktreePath: resolved2.entry.path,
         launchMode: "resume",
         resumeConversationId
       });
-      const refreshedMeta = await this.readMetaOrThrow(resolved.gitDir);
-      await writeWorktreeMeta(resolved.gitDir, {
+      const refreshedMeta = await this.readMetaOrThrow(resolved2.gitDir);
+      await writeWorktreeMeta(resolved2.gitDir, {
         ...refreshedMeta,
         agentTerminalStale: false
       });
       await this.restoreWorktreeTabs({
         branch,
-        gitDir: resolved.gitDir,
-        worktreePath: resolved.entry.path,
+        gitDir: resolved2.gitDir,
+        worktreePath: resolved2.entry.path,
         profile,
         profileName,
         agent,
@@ -52550,27 +52550,27 @@ var LifecycleService = class {
     return meta3;
   }
   async prepareTabContext(branch) {
-    const resolved = await this.resolveExistingWorktree(branch);
-    if (!resolved.meta) throw new LifecycleError(`Worktree ${branch} has no managed metadata`, 409);
+    const resolved2 = await this.resolveExistingWorktree(branch);
+    if (!resolved2.meta) throw new LifecycleError(`Worktree ${branch} has no managed metadata`, 409);
     const sessionName = buildProjectSessionName(this.deps.projectRoot);
     const windowName = buildWorktreeWindowName(branch);
     if (!await this.deps.sessions.hasWindow(sessionName, windowName)) {
       throw new LifecycleError(`Worktree ${branch} is not open`, 409);
     }
-    const { profileName, profile } = this.resolveProfile(resolved.meta.profile);
+    const { profileName, profile } = this.resolveProfile(resolved2.meta.profile);
     if (profile.runtime === "docker") {
       throw new LifecycleError("Tabs are not supported for Docker worktrees", 409);
     }
-    const agent = this.resolveAgentDefinition(resolved.meta.agent);
+    const agent = this.resolveAgentDefinition(resolved2.meta.agent);
     if (agent.kind !== "builtin") {
       throw new LifecycleError("Tabs are only available for the built-in Claude and Codex agents", 409);
     }
-    const initialized = await this.refreshManagedArtifacts(resolved);
+    const initialized = await this.refreshManagedArtifacts(resolved2);
     return {
-      resolved,
+      resolved: resolved2,
       initialized,
       meta: initialized.meta,
-      worktreePath: resolved.entry.path,
+      worktreePath: resolved2.entry.path,
       agent,
       agentKind: agent.implementation.agent,
       profile,
@@ -52644,16 +52644,16 @@ var LifecycleService = class {
    *  Idempotent: returns true when armed state was cleared, false otherwise.
    *  The server-side oneshot watcher calls this on any browser-originated interaction. */
   async disarmOneshot(branch) {
-    let resolved;
+    let resolved2;
     try {
-      resolved = await this.resolveExistingWorktree(branch);
+      resolved2 = await this.resolveExistingWorktree(branch);
     } catch {
       return false;
     }
-    if (!resolved.meta?.oneshot) return false;
-    const nextMeta = { ...resolved.meta };
+    if (!resolved2.meta?.oneshot) return false;
+    const nextMeta = { ...resolved2.meta };
     delete nextMeta.oneshot;
-    await writeWorktreeMeta(resolved.gitDir, nextMeta);
+    await writeWorktreeMeta(resolved2.gitDir, nextMeta);
     return true;
   }
   async closeWorktree(branch) {
@@ -52666,8 +52666,8 @@ var LifecycleService = class {
   }
   async removeWorktree(branch) {
     try {
-      const resolved = await this.resolveExistingWorktree(branch);
-      await this.removeResolvedWorktree(resolved);
+      const resolved2 = await this.resolveExistingWorktree(branch);
+      await this.removeResolvedWorktree(resolved2);
     } catch (error61) {
       throw this.wrapOperationError(error61);
     }
@@ -52677,12 +52677,12 @@ var LifecycleService = class {
       const resolvedWorktrees = await this.resolveAllWorktrees();
       const sessionName = buildProjectSessionName(this.deps.projectRoot);
       const removedBranches = [];
-      for (const resolved of resolvedWorktrees) {
-        const branch = resolved.entry.branch ?? resolved.entry.path;
+      for (const resolved2 of resolvedWorktrees) {
+        const branch = resolved2.entry.branch ?? resolved2.entry.path;
         if (await this.deps.sessions.hasWindow(sessionName, buildWorktreeWindowName(branch))) {
           continue;
         }
-        await this.removeResolvedWorktree(resolved);
+        await this.removeResolvedWorktree(resolved2);
         removedBranches.push(branch);
       }
       return { removedBranches };
@@ -52692,8 +52692,8 @@ var LifecycleService = class {
   }
   async mergeWorktree(branch) {
     try {
-      const resolved = await this.resolveExistingWorktree(branch);
-      this.ensureNoUncommittedChanges(resolved.entry);
+      const resolved2 = await this.resolveExistingWorktree(branch);
+      this.ensureNoUncommittedChanges(resolved2.entry);
       mergeManagedWorktree(
         {
           repoRoot: this.deps.projectRoot,
@@ -52703,7 +52703,7 @@ var LifecycleService = class {
         this.deps.git
       );
       try {
-        await this.removeResolvedWorktree(resolved);
+        await this.removeResolvedWorktree(resolved2);
       } catch (error61) {
         throw new LifecycleError(
           `Merged ${branch} into ${this.deps.config.workspace.mainBranch} but cleanup failed: ${toErrorMessage2(error61)}`,
@@ -52716,11 +52716,11 @@ var LifecycleService = class {
   }
   async setWorktreeArchived(branch, archived) {
     try {
-      const resolved = await this.resolveExistingWorktree(branch);
+      const resolved2 = await this.resolveExistingWorktree(branch);
       if (archived) {
         await this.closeBranchWindow(branch);
       }
-      await this.updateWorktreeArchivedState(resolved.entry.path, archived);
+      await this.updateWorktreeArchivedState(resolved2.entry.path, archived);
     } catch (error61) {
       throw this.wrapOperationError(error61);
     }
@@ -52728,12 +52728,12 @@ var LifecycleService = class {
   async setWorktreeLabel(branch, label) {
     try {
       const normalizedLabel = normalizeWorktreeLabel(label);
-      const resolved = await this.resolveExistingWorktree(branch);
-      if (!resolved.meta) {
+      const resolved2 = await this.resolveExistingWorktree(branch);
+      if (!resolved2.meta) {
         throw new LifecycleError(`Worktree ${branch} has no managed metadata to label`, 409);
       }
-      const nextMeta = this.withUpdatedLabel(resolved.meta, normalizedLabel);
-      await writeWorktreeMeta(resolved.gitDir, nextMeta);
+      const nextMeta = this.withUpdatedLabel(resolved2.meta, normalizedLabel);
+      await writeWorktreeMeta(resolved2.gitDir, nextMeta);
       await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
       return { label: normalizedLabel };
     } catch (error61) {
@@ -52745,20 +52745,20 @@ var LifecycleService = class {
    *  conversation); when it is closed the new profile applies on the next open. */
   async setWorktreeProfile(branch, profileName) {
     try {
-      const resolved = await this.resolveExistingWorktree(branch);
-      if (!resolved.meta) {
+      const resolved2 = await this.resolveExistingWorktree(branch);
+      if (!resolved2.meta) {
         throw new LifecycleError(`Worktree ${branch} has no managed metadata to reprofile`, 409);
       }
       const { profileName: nextProfileName, profile } = this.resolveProfile(profileName);
       const wasOpen = await isWorktreeOpen(this.deps.sessions, this.deps.projectRoot, branch);
-      if (resolved.meta.profile === nextProfileName) {
+      if (resolved2.meta.profile === nextProfileName) {
         return { profile: nextProfileName, restarted: false };
       }
-      if (resolved.meta.runtime === "docker") {
+      if (resolved2.meta.runtime === "docker") {
         await this.deps.docker.removeContainer(branch);
       }
-      await writeWorktreeMeta(resolved.gitDir, {
-        ...resolved.meta,
+      await writeWorktreeMeta(resolved2.gitDir, {
+        ...resolved2.meta,
         profile: nextProfileName,
         runtime: profile.runtime
       });
@@ -52942,30 +52942,30 @@ var LifecycleService = class {
       })
     );
   }
-  async initializeUnmanagedWorktree(resolved) {
+  async initializeUnmanagedWorktree(resolved2) {
     const { profileName, profile } = this.resolveProfile(void 0);
-    const dotenvValues = await loadDotenvLocal(resolved.entry.path);
+    const dotenvValues = await loadDotenvLocal(resolved2.entry.path);
     return initializeManagedWorktree({
-      gitDir: resolved.gitDir,
-      branch: resolved.entry.branch ?? resolved.entry.path,
+      gitDir: resolved2.gitDir,
+      branch: resolved2.entry.branch ?? resolved2.entry.path,
       profile: profileName,
       agent: this.deps.config.workspace.defaultAgent,
       runtime: profile.runtime,
       startupEnvValues: await this.buildStartupEnvValues(void 0),
       allocatedPorts: await this.allocatePorts(),
-      runtimeEnvExtras: { [ENV_NAMES.worktreePath]: resolved.entry.path },
+      runtimeEnvExtras: { [ENV_NAMES.worktreePath]: resolved2.entry.path },
       dotenvValues,
       ...await this.controlEnvFields(profile.runtime)
     });
   }
-  async refreshManagedArtifacts(resolved) {
-    if (!resolved.meta) {
+  async refreshManagedArtifacts(resolved2) {
+    if (!resolved2.meta) {
       throw new Error("Missing managed metadata");
     }
     return await this.refreshManagedArtifactsFromMeta({
-      gitDir: resolved.gitDir,
-      meta: resolved.meta,
-      worktreePath: resolved.entry.path
+      gitDir: resolved2.gitDir,
+      meta: resolved2.meta,
+      worktreePath: resolved2.entry.path
     });
   }
   async refreshManagedArtifactsFromMeta(input2) {
@@ -53200,22 +53200,22 @@ ${oneshotPrompt}` : oneshotPrompt ?? baseSystemPrompt;
     if (!controlUrl) return {};
     return { controlUrl, controlToken: await this.deps.getControlToken() };
   }
-  async removeResolvedWorktree(resolved) {
+  async removeResolvedWorktree(resolved2) {
     await this.runLifecycleHook({
       name: "preRemove",
       command: this.deps.config.lifecycleHooks.preRemove,
-      meta: resolved.meta,
-      worktreePath: resolved.entry.path
+      meta: resolved2.meta,
+      worktreePath: resolved2.entry.path
     });
-    const branch = resolved.entry.branch ?? resolved.entry.path;
-    if (resolved.meta?.runtime === "docker") {
+    const branch = resolved2.entry.branch ?? resolved2.entry.path;
+    if (resolved2.meta?.runtime === "docker") {
       await this.deps.docker.removeContainer(branch);
     }
     await this.killWorktreeWindows(branch);
     removeManagedWorktree(
       {
         repoRoot: this.deps.projectRoot,
-        worktreePath: resolved.entry.path,
+        worktreePath: resolved2.entry.path,
         branch,
         force: true,
         deleteBranch: true,
@@ -53223,7 +53223,7 @@ ${oneshotPrompt}` : oneshotPrompt ?? baseSystemPrompt;
       },
       this.deps.git
     );
-    await this.updateWorktreeArchivedState(resolved.entry.path, false);
+    await this.updateWorktreeArchivedState(resolved2.entry.path, false);
     await this.deps.reconciliation.reconcile(this.deps.projectRoot, { force: true });
   }
   async runLifecycleHook(input2) {
@@ -55601,7 +55601,7 @@ var Hono = class _Hono {
         return this.#handleError(err2, c);
       }
       return res instanceof Promise ? res.then(
-        (resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))
+        (resolved2) => resolved2 || (c.finalized ? c.res : this.#notFoundHandler(c))
       ).catch((err2) => this.#handleError(err2, c)) : res ?? this.#notFoundHandler(c);
     }
     const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
@@ -56465,11 +56465,11 @@ function contractRoute(app, key, tag, handler) {
   app.on(route.method, route.path, describeContractRoute(key, tag), async (c, next) => {
     const params = route.pathParams ? parseValue(route.pathParams, c.req.param(), "Invalid path parameters") : { ok: true, data: void 0 };
     if (!params.ok) return params.response;
-    const query = route.query ? parseValue(route.query, readSearchParams(new URL(c.req.url)), "Invalid query") : { ok: true, data: void 0 };
-    if (!query.ok) return query.response;
+    const query2 = route.query ? parseValue(route.query, readSearchParams(new URL(c.req.url)), "Invalid query") : { ok: true, data: void 0 };
+    if (!query2.ok) return query2.response;
     const body = route.body ? parseJsonValue(route.body, await c.req.text()) : { ok: true, data: void 0 };
     if (!body.ok) return body.response;
-    const input2 = { params: params.data, query: query.data, body: body.data };
+    const input2 = { params: params.data, query: query2.data, body: body.data };
     return handler(c, input2, next);
   });
 }
@@ -56515,55 +56515,55 @@ function agentId(id) {
 }
 async function apiAttachAgentsWorktree(project, branch) {
   touchDashboardActivity();
-  const resolved = await project.resolveAgentsWorktree(branch);
-  if (!resolved.ok) return resolved.response;
-  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+  const resolved2 = await project.resolveAgentsWorktree(branch);
+  if (!resolved2.ok) return resolved2.response;
+  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved2.worktree, "chat");
   if (!chatSupport.ok) {
     return errorResponse(chatSupport.error, chatSupport.status);
   }
-  const result = chatSupport.data.provider === "claude" ? await project.claudeConversationService.attachWorktreeConversation(resolved.worktree) : await project.worktreeConversationService.attachWorktreeConversation(resolved.worktree);
+  const result = chatSupport.data.provider === "claude" ? await project.claudeConversationService.attachWorktreeConversation(resolved2.worktree) : await project.worktreeConversationService.attachWorktreeConversation(resolved2.worktree);
   return result.ok ? jsonResponse(project.withClaudeLiveConversation(result.data)) : errorResponse(result.error, result.status);
 }
 async function apiGetAgentsWorktreeHistory(project, branch) {
   touchDashboardActivity();
-  const resolved = await project.resolveAgentsWorktree(branch);
-  if (!resolved.ok) return resolved.response;
-  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+  const resolved2 = await project.resolveAgentsWorktree(branch);
+  if (!resolved2.ok) return resolved2.response;
+  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved2.worktree, "chat");
   if (!chatSupport.ok) {
     return errorResponse(chatSupport.error, chatSupport.status);
   }
-  const result = chatSupport.data.provider === "claude" ? await project.claudeConversationService.readWorktreeConversation(resolved.worktree) : await project.worktreeConversationService.readWorktreeConversation(resolved.worktree);
+  const result = chatSupport.data.provider === "claude" ? await project.claudeConversationService.readWorktreeConversation(resolved2.worktree) : await project.worktreeConversationService.readWorktreeConversation(resolved2.worktree);
   return result.ok ? jsonResponse(project.withClaudeLiveConversation(result.data)) : errorResponse(result.error, result.status);
 }
 async function apiSendAgentsWorktreeMessage(project, branch, text) {
   touchDashboardActivity();
   await project.disarmOneshotIfArmed(branch, "agents-send-message");
-  const resolved = await project.resolveAgentsWorktree(branch);
-  if (!resolved.ok) return resolved.response;
-  if (!resolved.worktree.mux) {
+  const resolved2 = await project.resolveAgentsWorktree(branch);
+  if (!resolved2.ok) return resolved2.response;
+  if (!resolved2.worktree.mux) {
     return errorResponse("Open this worktree in the main dashboard before sending messages here", 409);
   }
-  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved2.worktree, "chat");
   if (!chatSupport.ok) {
     return errorResponse(chatSupport.error, chatSupport.status);
   }
   if (chatSupport.data.provider === "codex") {
     const sendResult2 = await project.worktreeConversationService.sendWorktreeConversationMessage(
-      resolved.worktree,
+      resolved2.worktree,
       text
     );
     if (!sendResult2.ok) {
       return errorResponse(sendResult2.error, sendResult2.status);
     }
-    await project.setAgentTerminalStale(resolved.worktree, true);
+    await project.setAgentTerminalStale(resolved2.worktree, true);
     return jsonResponse(sendResult2.data);
   }
-  const conversationResult = await project.claudeConversationService.readWorktreeConversation(resolved.worktree);
+  const conversationResult = await project.claudeConversationService.readWorktreeConversation(resolved2.worktree);
   if (!conversationResult.ok) {
     return errorResponse(conversationResult.error, conversationResult.status);
   }
   const streamingResponse = await project.sendClaudeStreamingMessage({
-    worktree: resolved.worktree,
+    worktree: resolved2.worktree,
     text,
     conversationId: conversationResult.data.conversation.conversationId
   });
@@ -56591,24 +56591,24 @@ async function apiSendAgentsWorktreeMessage(project, branch, text) {
 async function apiInterruptAgentsWorktree(project, branch) {
   touchDashboardActivity();
   await project.disarmOneshotIfArmed(branch, "agents-interrupt");
-  const resolved = await project.resolveAgentsWorktree(branch);
-  if (!resolved.ok) return resolved.response;
-  if (!resolved.worktree.mux) {
+  const resolved2 = await project.resolveAgentsWorktree(branch);
+  if (!resolved2.ok) return resolved2.response;
+  if (!resolved2.worktree.mux) {
     return errorResponse("Open this worktree in the main dashboard before interrupting it here", 409);
   }
-  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved.worktree, "interrupt");
+  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved2.worktree, "interrupt");
   if (!chatSupport.ok) {
     return errorResponse(chatSupport.error, chatSupport.status);
   }
   if (chatSupport.data.provider === "codex") {
-    const interruptResult2 = await project.worktreeConversationService.interruptWorktreeConversation(resolved.worktree);
+    const interruptResult2 = await project.worktreeConversationService.interruptWorktreeConversation(resolved2.worktree);
     if (!interruptResult2.ok) {
       return errorResponse(interruptResult2.error, interruptResult2.status);
     }
-    await project.setAgentTerminalStale(resolved.worktree, true);
+    await project.setAgentTerminalStale(resolved2.worktree, true);
     return jsonResponse(interruptResult2.data);
   }
-  const conversationResult = await project.claudeConversationService.readWorktreeConversation(resolved.worktree);
+  const conversationResult = await project.claudeConversationService.readWorktreeConversation(resolved2.worktree);
   if (!conversationResult.ok) {
     return errorResponse(conversationResult.error, conversationResult.status);
   }
@@ -56616,7 +56616,7 @@ async function apiInterruptAgentsWorktree(project, branch) {
     conversationResult.data.conversation.conversationId
   );
   if (activeClaudeInterrupt.ok) {
-    await project.setAgentTerminalStale(resolved.worktree, true);
+    await project.setAgentTerminalStale(resolved2.worktree, true);
     return jsonResponse({
       conversationId: conversationResult.data.conversation.conversationId,
       turnId: activeClaudeInterrupt.turnId,
@@ -56733,8 +56733,8 @@ function branchRoutes(deps) {
     deps,
     "fetchAvailableBranches",
     "Branches",
-    ({ runtime }, { query }) => jsonResponse({
-      branches: runtime.lifecycleService.listAvailableBranches({ includeRemote: query.includeRemote === true })
+    ({ runtime }, { query: query2 }) => jsonResponse({
+      branches: runtime.lifecycleService.listAvailableBranches({ includeRemote: query2.includeRemote === true })
     })
   );
   projectRoute(
@@ -57601,7 +57601,7 @@ var CACHE_TTL_MS = 3e5;
 var issueCache = null;
 var viewerIdCache = null;
 var inProgressStateIdCache = /* @__PURE__ */ new Map();
-async function postLinearGraphql(query, variables) {
+async function postLinearGraphql(query2, variables) {
   const apiKey = process.env.LINEAR_API_KEY;
   if (!apiKey) {
     return { ok: false, error: "LINEAR_API_KEY not set" };
@@ -57613,7 +57613,7 @@ async function postLinearGraphql(query, variables) {
         "Content-Type": "application/json",
         Authorization: apiKey
       },
-      body: JSON.stringify(variables ? { query, variables } : { query })
+      body: JSON.stringify(variables ? { query: query2, variables } : { query: query2 })
     });
     if (!res.ok) {
       const text = await res.text();
@@ -58350,9 +58350,9 @@ function runRoutes(deps) {
     if (detail === null || detail.run.projectId !== project.prefix) return errorResponse("Run not found", 404);
     return jsonResponse(detail);
   });
-  projectRoute(app, deps, "fetchRunEvents", "Runs", (project, { params, query }) => {
+  projectRoute(app, deps, "fetchRunEvents", "Runs", (project, { params, query: query2 }) => {
     if (!projectRun(project, params.runId)) return errorResponse("Run not found", 404);
-    return jsonResponse(project.runs.presentation.events(params.runId, query.after));
+    return jsonResponse(project.runs.presentation.events(params.runId, query2.after));
   });
   projectRoute(app, deps, "cancelRun", "Runs", async (project, { params: { runId } }) => {
     const detail = project.runs.presentation.detail(runId);
@@ -58376,9 +58376,9 @@ function runRoutes(deps) {
     if (!result.ok) return errorResponse(result.reason, result.reason === "not_found" ? 404 : 409);
     return jsonResponse(project.runs.presentation.detail(runId));
   });
-  projectRoute(app, deps, "fetchExecutionTranscript", "Runs", async (project, { params, query }) => {
+  projectRoute(app, deps, "fetchExecutionTranscript", "Runs", async (project, { params, query: query2 }) => {
     if (!projectExecution(project, params.executionId)) return errorResponse("Execution not found", 404);
-    const result = await project.runs.transcripts.read(params.executionId, query.after);
+    const result = await project.runs.transcripts.read(params.executionId, query2.after);
     if (!result.ok)
       return errorResponse(
         result.reason === "not_found" ? "Execution not found" : "Transcript unavailable",
@@ -65202,13 +65202,13 @@ var ClaudeConversationService = class {
   async attachWorktreeConversation(worktree) {
     return await this.withResolvedConversation(
       worktree,
-      async (resolved) => ok(toWorktreeConversationResponse(worktree, resolved.conversationMeta, resolved.session))
+      async (resolved2) => ok(toWorktreeConversationResponse(worktree, resolved2.conversationMeta, resolved2.session))
     );
   }
   async readWorktreeConversation(worktree) {
     return await this.withResolvedConversation(
       worktree,
-      async (resolved) => ok(toWorktreeConversationResponse(worktree, resolved.conversationMeta, resolved.session))
+      async (resolved2) => ok(toWorktreeConversationResponse(worktree, resolved2.conversationMeta, resolved2.session))
     );
   }
   async setWorktreeConversationSession(worktree, sessionId) {
@@ -65232,9 +65232,9 @@ var ClaudeConversationService = class {
       return err(409, "Worktree chat is only available for Claude worktrees");
     }
     try {
-      const resolved = await this.resolveConversation(worktree);
-      if (!resolved.ok) return resolved;
-      return await fn(resolved.data);
+      const resolved2 = await this.resolveConversation(worktree);
+      if (!resolved2.ok) return resolved2;
+      return await fn(resolved2.data);
     } catch (error61) {
       const message = error61 instanceof Error ? error61.message : String(error61);
       return err(502, message);
@@ -65596,11 +65596,11 @@ var EnvironmentDiagnosticsService = class {
     };
   }
   async commandCheck(id, label, required2, command, args, remediation) {
-    const resolved = this.resolveCommand(command);
-    if (!resolved) {
+    const resolved2 = this.resolveCommand(command);
+    if (!resolved2) {
       return check2(id, label, "error", required2, `${command} is unavailable`, remediation);
     }
-    const result = await this.runCommand(resolved, args);
+    const result = await this.runCommand(resolved2, args);
     const summary = result.output.split("\n")[0] ?? "";
     if (result.ok) return check2(id, label, "ok", required2, summary || `${command} is available`);
     return check2(
@@ -65628,8 +65628,8 @@ var EnvironmentDiagnosticsService = class {
   }
   async codexAutoReviewCheck() {
     const required2 = this.deps.config.workspace.defaultAgent === "codex";
-    const resolved = this.resolveCommand("codex");
-    if (!resolved) {
+    const resolved2 = this.resolveCommand("codex");
+    if (!resolved2) {
       return check2(
         "codex-auto-review",
         "Codex oneshot",
@@ -65639,7 +65639,7 @@ var EnvironmentDiagnosticsService = class {
         "Install Codex CLI and ensure it is on PATH"
       );
     }
-    const result = await this.runCommand(resolved, ["--help"]);
+    const result = await this.runCommand(resolved2, ["--help"]);
     if (result.ok && codexHelpSupportsAutoReview(result.output)) {
       return check2("codex-auto-review", "Codex oneshot", "ok", required2, "Automatic approval review is supported");
     }
@@ -68432,9 +68432,9 @@ var WorkflowCatalogService = class {
     };
   }
   async createSnapshot(input2) {
-    const resolved = await this.resolve(input2.name);
-    if (!resolved.ok) return resolved;
-    const definition = resolved.definition;
+    const resolved2 = await this.resolve(input2.name);
+    if (!resolved2.ok) return resolved2;
+    const definition = resolved2.definition;
     return {
       ok: true,
       snapshot: {
@@ -69269,9 +69269,9 @@ var WorktreeConversationService = class {
       return err(409, "Worktree chat is only available for Codex worktrees");
     }
     try {
-      const resolved = await this.resolveConversation(worktree, allowCreate);
-      if (!resolved.ok) return resolved;
-      return await fn(resolved.data);
+      const resolved2 = await this.resolveConversation(worktree, allowCreate);
+      if (!resolved2.ok) return resolved2;
+      return await fn(resolved2.data);
     } catch (error61) {
       const message = error61 instanceof Error ? error61.message : String(error61);
       return err(502, message);
@@ -69529,7 +69529,7 @@ var DockerComposeEnvironmentProvider = class {
     if (result.exit.code !== 0) throw new Error(result.stderr.trim());
   }
   async resume(handle) {
-    const resolved = {
+    const resolved2 = {
       provider: this.id,
       configRef: typeof handle.providerRef.value.composeFile === "string" ? handle.providerRef.value.composeFile : null,
       configHash: "",
@@ -69560,7 +69560,7 @@ var DockerComposeEnvironmentProvider = class {
         isolationRisks: []
       }
     };
-    return this.start(resolved, handle.scope);
+    return this.start(resolved2, handle.scope);
   }
   async rebuild(environment, scope, previous) {
     if (previous) await this.destroy(previous);
@@ -70219,34 +70219,34 @@ function createProjectEnvironments(deps) {
         return { ok: false, reason: "selection_required", diagnostics: probe.configRefs };
       }
       const provider = selected === "devcontainer" ? devContainerProvider : selected === "docker" ? dockerEnvironmentProvider : selected === "compose" ? composeEnvironmentProvider : selected === "dockerfile" ? dockerfileEnvironmentProvider : hostEnvironmentProvider;
-      const resolved = await provider.resolve({
+      const resolved2 = await provider.resolve({
         ...context,
         configRef: selected === "docker" ? input2.profileName ?? void 0 : profile?.environment?.config
       });
-      const id = environmentIdFor(scope, resolved.provider, resolved.configRef);
+      const id = environmentIdFor(scope, resolved2.provider, resolved2.configRef);
       const existing = environmentStore.get(id);
       const now = (/* @__PURE__ */ new Date()).toISOString();
-      const trusted = resolved.provider !== "devcontainer" || resolved.configRef === null || environmentStore.isTrusted(scope.projectId, resolved.configRef, resolved.configHash);
+      const trusted = resolved2.provider !== "devcontainer" || resolved2.configRef === null || environmentStore.isTrusted(scope.projectId, resolved2.configRef, resolved2.configHash);
       if (!trusted) {
         environmentStore.save({
           id,
-          provider: resolved.provider,
+          provider: resolved2.provider,
           scope,
           status: "awaiting_trust",
           desiredStatus: input2.start ? "ready" : "stopped",
-          workspace: resolved.workspace,
+          workspace: resolved2.workspace,
           providerRef: { schemaVersion: 1, value: {} },
-          configRef: resolved.configRef,
-          configHash: resolved.configHash,
-          capabilities: resolved.capabilities,
-          security: { ...resolved.security, trusted: false },
+          configRef: resolved2.configRef,
+          configHash: resolved2.configHash,
+          capabilities: resolved2.capabilities,
+          security: { ...resolved2.security, trusted: false },
           error: null,
           createdAt: existing?.createdAt ?? now,
           updatedAt: now
         });
-        return { ok: false, reason: "trust_required", diagnostics: resolved.security.reasons, environmentId: id };
+        return { ok: false, reason: "trust_required", diagnostics: resolved2.security.reasons, environmentId: id };
       }
-      if (input2.start && resolved.provider !== "host" && !hasEnvironmentCapacity(projectEnvironments(), id, MAX_CONCURRENT_PROJECT_ENVIRONMENTS)) {
+      if (input2.start && resolved2.provider !== "host" && !hasEnvironmentCapacity(projectEnvironments(), id, MAX_CONCURRENT_PROJECT_ENVIRONMENTS)) {
         return {
           ok: false,
           reason: "unavailable",
@@ -70254,26 +70254,26 @@ function createProjectEnvironments(deps) {
         };
       }
       let handle;
-      const reusable = existing && existing.configHash === resolved.configHash && (existing.provider === "host" || existing.providerRef.value.containerId || existing.providerRef.value.containerName);
-      if (!input2.start && resolved.provider !== "host") {
+      const reusable = existing && existing.configHash === resolved2.configHash && (existing.provider === "host" || existing.providerRef.value.containerId || existing.providerRef.value.containerName);
+      if (!input2.start && resolved2.provider !== "host") {
         if (reusable) {
           const observed = await provider.inspect(existing);
           handle = { ...existing, scope, status: observed.status };
         } else {
           handle = {
             id,
-            provider: resolved.provider,
+            provider: resolved2.provider,
             scope,
             status: "detected",
-            workspace: resolved.workspace,
+            workspace: resolved2.workspace,
             providerRef: { schemaVersion: 1, value: {} }
           };
         }
       } else if (reusable) {
         const observed = await provider.inspect(existing);
-        handle = observed.status === "ready" ? { ...existing, scope, status: "ready" } : observed.status === "stopped" ? await provider.resume(existing) : await provider.start(resolved, scope);
+        handle = observed.status === "ready" ? { ...existing, scope, status: "ready" } : observed.status === "stopped" ? await provider.resume(existing) : await provider.start(resolved2, scope);
       } else {
-        handle = await provider.start(resolved, scope);
+        handle = await provider.start(resolved2, scope);
       }
       if (handle.provider !== "host" && handle.status === "ready") {
         try {
@@ -70285,11 +70285,11 @@ function createProjectEnvironments(deps) {
       }
       environmentStore.save({
         ...handle,
-        desiredStatus: input2.start || resolved.provider === "host" ? "ready" : "stopped",
-        configRef: resolved.configRef,
-        configHash: resolved.configHash,
-        capabilities: resolved.capabilities,
-        security: { ...resolved.security, trusted: true },
+        desiredStatus: input2.start || resolved2.provider === "host" ? "ready" : "stopped",
+        configRef: resolved2.configRef,
+        configHash: resolved2.configHash,
+        capabilities: resolved2.capabilities,
+        security: { ...resolved2.security, trusted: true },
         error: null,
         createdAt: existing?.createdAt ?? now,
         updatedAt: now
@@ -70597,22 +70597,22 @@ function createProjectEnvironments(deps) {
       };
     }
     try {
-      let resolved = resolvedFromRecord(record5);
+      let resolved2 = resolvedFromRecord(record5);
       if (action !== "stop") {
-        resolved = await provider.resolve({
+        resolved2 = await provider.resolve({
           workspacePath: record5.workspace.hostPath,
           projectPath: PROJECT_DIR,
           scope: record5.scope,
           configRef: record5.configRef ?? void 0
         });
-        if (resolved.configHash !== record5.configHash && resolved.provider === "devcontainer") {
-          const trusted = resolved.configRef !== null && environmentStore.isTrusted(record5.scope.projectId, resolved.configRef, resolved.configHash);
+        if (resolved2.configHash !== record5.configHash && resolved2.provider === "devcontainer") {
+          const trusted = resolved2.configRef !== null && environmentStore.isTrusted(record5.scope.projectId, resolved2.configRef, resolved2.configHash);
           if (!trusted) {
             saveEnvironment(record5, {
               status: "awaiting_trust",
               desiredStatus: "ready",
-              configHash: resolved.configHash,
-              security: { ...resolved.security, trusted: false }
+              configHash: resolved2.configHash,
+              security: { ...resolved2.security, trusted: false }
             });
             return { ok: false, error: "Environment configuration changed and requires trust", status: 409 };
           }
@@ -70637,13 +70637,13 @@ function createProjectEnvironments(deps) {
       } else if (action === "rebuild") {
         const rebuilding = saveEnvironment(record5, { status: "building", desiredStatus: "ready", error: null });
         await deactivateEnvironmentAccess(rebuilding, false);
-        handle = await provider.rebuild(resolved, rebuilding.scope, rebuilding);
+        handle = await provider.rebuild(resolved2, rebuilding.scope, rebuilding);
       } else {
         const observed = record5.status === "ready" ? await provider.inspect(record5) : { status: "missing" };
         if (observed.status === "ready") handle = { ...record5, status: "ready" };
         else {
           const starting = saveEnvironment(record5, { status: "starting", desiredStatus: "ready", error: null });
-          handle = observed.status === "stopped" ? await provider.resume(starting) : await provider.start(resolved, starting.scope);
+          handle = observed.status === "stopped" ? await provider.resume(starting) : await provider.start(resolved2, starting.scope);
         }
       }
       if (handle.provider !== "host") handle = await applyEnvironmentResourcePolicy(serverProcessRunner, handle);
@@ -71391,20 +71391,20 @@ function createProjectApp(runtime, instancePrefix, host) {
     await reconciliationService.reconcile(PROJECT_DIR);
     const state = projectRuntime.getWorktreeByBranch(branch);
     if (!state) return { ok: false, error: `Worktree not found: ${branch}`, status: 404 };
-    const resolved = await resolveAgentsWorktree(branch);
-    if (!resolved.ok) {
+    const resolved2 = await resolveAgentsWorktree(branch);
+    if (!resolved2.ok) {
       return { ok: false, error: `Worktree not found: ${branch}`, status: 404 };
     }
-    const chatSupport = resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+    const chatSupport = resolveWorktreeAgentChatSupport(resolved2.worktree, "chat");
     if (!chatSupport.ok) return { ok: false, error: chatSupport.error, status: chatSupport.status };
-    const conversationResult = chatSupport.data.provider === "claude" ? await claudeConversationService.readWorktreeConversation(resolved.worktree) : await worktreeConversationService.readWorktreeConversation(resolved.worktree);
+    const conversationResult = chatSupport.data.provider === "claude" ? await claudeConversationService.readWorktreeConversation(resolved2.worktree) : await worktreeConversationService.readWorktreeConversation(resolved2.worktree);
     if (!conversationResult.ok) return { ok: false, error: conversationResult.error, status: conversationResult.status };
     const prUrl = (state.prs ?? []).find((pr) => pr.state === "open" || pr.state === "merged")?.url ?? null;
     const exportInput = {
       target,
       branch,
       baseBranch: state.baseBranch ?? null,
-      agent: resolved.worktree.agentName ?? null,
+      agent: resolved2.worktree.agentName ?? null,
       prUrl,
       conversation: conversationResult.data.conversation,
       taskflowVersion: PORTTA_FLOW_VERSION
@@ -71799,21 +71799,21 @@ function nextConversationMessageOrder(messages) {
   return messages.reduce((order2, message) => Math.max(order2, message.order + 1), 0);
 }
 async function loadAgentsConversationInitialState(project, branch) {
-  const resolved = await project.resolveAgentsWorktree(branch);
-  if (!resolved.ok) {
+  const resolved2 = await project.resolveAgentsWorktree(branch);
+  if (!resolved2.ok) {
     return {
       ok: false,
-      message: await readErrorMessage(resolved.response)
+      message: await readErrorMessage(resolved2.response)
     };
   }
-  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved.worktree, "chat");
+  const chatSupport = project.resolveWorktreeAgentChatSupport(resolved2.worktree, "chat");
   if (!chatSupport.ok) {
     return {
       ok: false,
       message: chatSupport.error
     };
   }
-  const result = chatSupport.data.provider === "claude" ? await project.claudeConversationService.readWorktreeConversation(resolved.worktree) : await project.worktreeConversationService.readWorktreeConversation(resolved.worktree);
+  const result = chatSupport.data.provider === "claude" ? await project.claudeConversationService.readWorktreeConversation(resolved2.worktree) : await project.worktreeConversationService.readWorktreeConversation(resolved2.worktree);
   return result.ok ? { ok: true, data: project.withClaudeLiveConversation(result.data) } : { ok: false, message: result.error };
 }
 var agentsSocketRoute = {
@@ -72223,7 +72223,7 @@ function createDaemonTaskflowHost(context) {
       port: hostListen(env2).port,
       workflowBuiltinsDir: taskflowAssets(env2).workflowBuiltinsDir,
       version: env2.PORTTA_VERSION || "0.0.0-local",
-      buildDate: true ? "2026-09-16T03:00:29Z" : (/* @__PURE__ */ new Date()).toISOString(),
+      buildDate: true ? "2026-09-16T05:05:26Z" : (/* @__PURE__ */ new Date()).toISOString(),
       environmentStore: createEnvironmentStore(paths.database),
       hostEnvironmentProvider: new HostEnvironmentProvider(),
       devContainerProvider: new DevContainerProvider(),
@@ -73521,16 +73521,12 @@ function matchPath(pattern, path) {
 
 // ../core/src/activity.ts
 var BASE_ACTIVITY_KINDS = [
-  "task.created",
-  "task.updated",
-  "task.status",
-  "task.assigned",
-  "task.note",
-  "task.comment",
-  "task.linked",
-  "task.synced",
-  "task.conflict",
-  "task.deleted",
+  "issue.created",
+  "issue.updated",
+  "issue.state",
+  "issue.assigned",
+  "issue.comment",
+  "issue.linked",
   "session.started",
   "session.ended",
   "session.abandoned",
@@ -73557,70 +73553,9 @@ var SESSION_ABANDON_AFTER_SECONDS = 6 * 60 * 60;
 // ../core/src/repos-scan.ts
 var INSTRUCTION_MAX_BYTES = 64 * 1024;
 
-// ../core/src/tasks.ts
-var TASK_STATUSES = ["backlog", "ready", "in_progress", "review", "blocked", "done"];
-var DEFAULT_TASK_WORKFLOW = {
-  statuses: TASK_STATUSES.map((id) => ({ id, label: null })),
-  defaultStatus: "backlog"
-};
-var TASK_PRIORITIES = ["low", "medium", "high", "urgent"];
-var TASK_DRAFT_MAX_AGE_MS = 24 * 60 * 60 * 1e3;
-var TASK_TYPE_CATALOG = [
-  { id: "feature", tone: "accent", aliases: ["feat", "features", "enhancement-request", "story"] },
-  { id: "bug", tone: "danger", aliases: ["fix", "bugfix", "defect", "regression"] },
-  { id: "improvement", tone: "info", aliases: ["enhancement", "refactor", "perf", "performance"] },
-  { id: "chore", tone: "neutral", aliases: ["task", "maintenance", "build", "ci", "deps"] },
-  { id: "research", tone: "agent", aliases: ["spike", "investigation", "discovery"] },
-  { id: "documentation", tone: "outline", aliases: ["docs", "doc"] }
-];
-var TASK_TYPES = TASK_TYPE_CATALOG.map((entry) => entry.id);
-
-// ../core/src/task-example.ts
-var PortableKey = external_exports.string().min(1).max(80).regex(/^[a-z0-9][a-z0-9._-]*$/i);
-var ProjectRelativePath = external_exports.string().min(1).max(255).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/).refine((value) => !value.includes(".."));
-var RepositoryRelativePath = external_exports.string().min(1).max(255).regex(/^[A-Za-z0-9][A-Za-z0-9._-]*(\/[A-Za-z0-9][A-Za-z0-9._-]*)?$/).refine((value) => !value.includes(".."));
-var ExampleComment = external_exports.object({
-  key: PortableKey,
-  actor: external_exports.string().min(1).max(64),
-  actorKind: external_exports.enum(["human", "agent", "system"]).optional(),
-  body: external_exports.string().min(1).max(65536)
-}).strict();
-var ExampleTask = external_exports.lazy(() => external_exports.object({
-  key: PortableKey,
-  title: external_exports.string().min(1).max(200),
-  description: external_exports.string().max(65536).nullable().optional(),
-  status: external_exports.enum(TASK_STATUSES).optional(),
-  priority: external_exports.enum(TASK_PRIORITIES).nullable().optional(),
-  type: external_exports.string().max(32).nullable().optional(),
-  labels: external_exports.array(external_exports.string().min(1).max(64)).max(32).optional(),
-  assignee: external_exports.string().max(64).nullable().optional(),
-  agent: external_exports.string().max(64).nullable().optional(),
-  repository: external_exports.string().min(1).max(128).nullable().optional(),
-  environment: external_exports.string().min(1).max(255).nullable().optional(),
-  service: external_exports.string().max(64).nullable().optional(),
-  dueAt: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}(T[\d:.+-Z]+)?$/).nullable().optional(),
-  parent: PortableKey.nullable().optional(),
-  comments: external_exports.array(ExampleComment).max(32).optional(),
-  subtasks: external_exports.array(ExampleTask).max(32).optional()
-}).strict());
-var ExampleRepository = external_exports.object({
-  key: PortableKey,
-  name: external_exports.string().min(1).max(128),
-  role: external_exports.string().max(32).nullable().optional(),
-  relativePath: RepositoryRelativePath.optional(),
-  remoteUrl: external_exports.string().min(1).max(512).optional()
-}).strict();
-var ExampleDocument = external_exports.object({
-  schemaVersion: external_exports.literal(1),
-  project: external_exports.object({
-    slug: external_exports.string().min(1).max(64).regex(/^[a-z0-9][a-z0-9-]*$/),
-    name: external_exports.string().min(1).max(120),
-    description: external_exports.string().max(2e3).nullable().optional(),
-    relativePath: ProjectRelativePath.optional()
-  }).strict(),
-  repositories: external_exports.array(ExampleRepository).max(32).optional(),
-  tasks: external_exports.array(ExampleTask).max(64)
-}).strict();
+// ../core/src/database-config.ts
+import { join as join29 } from "node:path";
+var DATABASE_RELATIVE_PATH = join29("state", "panel", "portta.db");
 
 // ../../node_modules/ws/wrapper.mjs
 var import_stream = __toESM(require_stream(), 1);
@@ -73629,6 +73564,462 @@ var import_sender = __toESM(require_sender(), 1);
 var import_websocket = __toESM(require_websocket(), 1);
 var import_websocket_server = __toESM(require_websocket_server(), 1);
 
+// ../host/src/forge/gh.ts
+import { execFile as execFile2 } from "node:child_process";
+var TIMEOUT_MS = 2e4;
+var ISSUE_PAGE_LIMIT = 100;
+var ForgeError = class extends Error {
+  kind;
+  hint;
+  constructor(kind, message, hint) {
+    super(message);
+    this.name = "ForgeError";
+    this.kind = kind;
+    this.hint = hint;
+  }
+};
+var FORGE_STATUS = {
+  unavailable: 503,
+  unauthenticated: 401,
+  forbidden: 403,
+  "not-found": 404,
+  "rate-limited": 429,
+  timeout: 504,
+  failed: 502
+};
+function classify(stderr) {
+  const text = stderr.toLowerCase();
+  if (text.includes("gh auth login") || text.includes("not logged") || text.includes("authentication token")) {
+    return "unauthenticated";
+  }
+  if (text.includes("rate limit") || text.includes("secondary rate")) return "rate-limited";
+  if (text.includes("could not resolve to") || text.includes("not found") || text.includes("404")) return "not-found";
+  if (text.includes("forbidden") || text.includes("403") || text.includes("must have admin")) return "forbidden";
+  return "failed";
+}
+var resolved;
+function ghPath() {
+  if (resolved === void 0) resolved = resolveHostToolThoroughly("gh");
+  if (!resolved) {
+    throw new ForgeError(
+      "unavailable",
+      "the GitHub CLI is not installed on this host",
+      "install gh (https://cli.github.com) and run gh auth login, then reload"
+    );
+  }
+  return resolved;
+}
+function runGh2(args, options = {}) {
+  const binary = ghPath();
+  return new Promise((resolve21, reject2) => {
+    const child = execFile2(
+      binary,
+      args,
+      {
+        cwd: options.cwd,
+        timeout: TIMEOUT_MS,
+        maxBuffer: 16 * 1024 * 1024,
+        // `gh` colours and paginates when it thinks it is talking to a person.
+        // Both would end up in the JSON the panel parses.
+        env: { ...process.env, GH_PAGER: "cat", NO_COLOR: "1", GH_PROMPT_DISABLED: "1" }
+      },
+      (error61, stdout, stderr) => {
+        if (!error61) return resolve21(stdout);
+        if (error61.killed) {
+          return reject2(new ForgeError("timeout", `gh ${args[0]} ${args[1] ?? ""} took longer than ${TIMEOUT_MS / 1e3}s`));
+        }
+        const detail = (stderr || error61.message).trim();
+        reject2(new ForgeError(classify(detail), detail.split("\n")[0] ?? "gh failed", hintFor(classify(detail))));
+      }
+    );
+    if (options.stdin !== void 0) {
+      child.stdin?.end(options.stdin);
+    }
+  });
+}
+function hintFor(kind) {
+  if (kind === "unauthenticated") return "run gh auth login on this host";
+  if (kind === "rate-limited") return "GitHub is rate-limiting this account; try again shortly";
+  if (kind === "forbidden") return "this account cannot see or write that repository";
+  return void 0;
+}
+async function runGhJson(args, options) {
+  const stdout = await runGh2(args, options);
+  const text = stdout.trim();
+  if (text === "") return [];
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new ForgeError("failed", `gh answered something that is not JSON: ${text.slice(0, 200)}`);
+  }
+}
+async function ghStatus() {
+  let binary;
+  try {
+    binary = ghPath();
+  } catch (error61) {
+    return { available: false, authenticated: false, account: null, detail: error61.message };
+  }
+  try {
+    const user = await runGhJson(["api", "user", "--jq", "{login: .login}"]);
+    return { available: true, authenticated: true, account: user.login, detail: null };
+  } catch (error61) {
+    const failure = error61 instanceof ForgeError ? error61 : null;
+    return {
+      available: true,
+      authenticated: false,
+      account: null,
+      detail: failure?.message ?? `gh at ${binary} could not be asked who it is`
+    };
+  }
+}
+
+// ../host/src/forge/issues.ts
+var LIST_FIELDS = [
+  "number",
+  "title",
+  "state",
+  "stateReason",
+  "labels",
+  "assignees",
+  "milestone",
+  "author",
+  "comments",
+  "createdAt",
+  "updatedAt",
+  "url"
+].join(",");
+var VIEW_FIELDS = `${LIST_FIELDS},body`;
+function listIssues(repo, query2 = {}) {
+  const args = ["issue", "list", "--repo", repo, "--json", LIST_FIELDS, "--limit", String(query2.limit ?? ISSUE_PAGE_LIMIT)];
+  args.push("--state", query2.state ?? "open");
+  if (query2.assignee) args.push("--assignee", query2.assignee);
+  if (query2.label) args.push("--label", query2.label);
+  if (query2.milestone) args.push("--milestone", query2.milestone);
+  if (query2.search) args.push("--search", query2.search);
+  return runGhJson(args);
+}
+async function viewIssue(repo, number4) {
+  const [issue2, comments] = await Promise.all([
+    runGhJson(["issue", "view", String(number4), "--repo", repo, "--json", VIEW_FIELDS]),
+    runGhJson([
+      "api",
+      `repos/${repo}/issues/${number4}/comments`,
+      "--paginate",
+      "--jq",
+      "[.[] | {id: (.id|tostring), body: .body, createdAt: .created_at, updatedAt: .updated_at, url: .html_url, author: {login: .user.login, avatarUrl: .user.avatar_url}}]"
+    ]).catch(() => [])
+  ]);
+  return { ...issue2, comments };
+}
+async function createIssue(repo, draft) {
+  const args = ["issue", "create", "--repo", repo, "--title", draft.title, "--body", draft.body ?? ""];
+  for (const label of draft.labels ?? []) args.push("--label", label);
+  for (const assignee of draft.assignees ?? []) args.push("--assignee", assignee);
+  if (draft.milestone) args.push("--milestone", draft.milestone);
+  const url2 = (await runGh2(args)).trim().split("\n").pop() ?? "";
+  const number4 = Number(/\/(\d+)\s*$/.exec(url2)?.[1]);
+  if (!Number.isInteger(number4)) {
+    throw new Error(`gh issue create did not answer with an issue URL: ${url2.slice(0, 200)}`);
+  }
+  return viewIssue(repo, number4);
+}
+async function editIssue(repo, number4, patch) {
+  const fields = [];
+  if (patch.title !== void 0) fields.push("--title", patch.title);
+  if (patch.body !== void 0) fields.push("--body", patch.body);
+  for (const label of patch.addLabels ?? []) fields.push("--add-label", label);
+  for (const label of patch.removeLabels ?? []) fields.push("--remove-label", label);
+  for (const login of patch.addAssignees ?? []) fields.push("--add-assignee", login);
+  for (const login of patch.removeAssignees ?? []) fields.push("--remove-assignee", login);
+  if (patch.milestone !== void 0) fields.push("--milestone", patch.milestone);
+  if (fields.length === 0) return;
+  await runGh2(["issue", "edit", String(number4), "--repo", repo, ...fields]);
+}
+async function setIssueState(repo, number4, state, reason) {
+  const verb = state === "closed" ? "close" : "reopen";
+  const why = state === "closed" && reason ? ["--reason", reason] : [];
+  await runGh2(["issue", verb, String(number4), "--repo", repo, ...why]);
+}
+async function commentOnIssue(repo, number4, body) {
+  await runGh2(["issue", "comment", String(number4), "--repo", repo, "--body-file", "-"], { stdin: body });
+}
+async function issueVocabulary(repo) {
+  const [labels, assignees, milestones] = await Promise.all([
+    runGhJson(["label", "list", "--repo", repo, "--json", "name,color,description", "--limit", "200"]).catch(() => []),
+    runGhJson([
+      "api",
+      `repos/${repo}/assignees`,
+      "--paginate",
+      "--jq",
+      "[.[] | {login: .login, avatarUrl: .avatar_url}]"
+    ]).catch(() => []),
+    runGhJson([
+      "api",
+      `repos/${repo}/milestones?state=all`,
+      "--paginate",
+      "--jq",
+      "[.[] | {number: .number, title: .title, state: .state, dueOn: .due_on}]"
+    ]).catch(() => [])
+  ]);
+  return { labels, assignees, milestones };
+}
+function assignedIssues(limit = 50) {
+  return runGhJson([
+    "search",
+    "issues",
+    "--assignee",
+    "@me",
+    "--state",
+    "open",
+    "--limit",
+    String(limit),
+    "--json",
+    "number,title,state,labels,assignees,author,createdAt,updatedAt,url,repository"
+  ]);
+}
+
+// ../host/src/forge/linear.ts
+var CLOSED_TYPES = /* @__PURE__ */ new Set(["completed", "canceled"]);
+function isClosed(issue2) {
+  return CLOSED_TYPES.has(issue2.state?.type ?? "");
+}
+var ISSUE_FIELDS = `
+  id identifier title url createdAt updatedAt
+  state { name type }
+  assignee { name displayName avatarUrl }
+  creator { name displayName avatarUrl }
+  labels { nodes { name color } }
+  project { name }
+`;
+var TEAM_ISSUES_QUERY = `
+  query TeamIssues($key: String!, $first: Int!, $closed: Boolean!) {
+    issues(
+      filter: { team: { key: { eq: $key } }, state: { type: { nin: ["completed", "canceled"] } } }
+      orderBy: updatedAt
+      first: $first
+    ) @skip(if: $closed) { nodes { ${ISSUE_FIELDS} } }
+    all: issues(filter: { team: { key: { eq: $key } } }, orderBy: updatedAt, first: $first)
+      @include(if: $closed) { nodes { ${ISSUE_FIELDS} } }
+  }
+`;
+var ISSUE_QUERY = `
+  query Issue($id: String!) {
+    issue(id: $id) {
+      ${ISSUE_FIELDS}
+      description
+      comments(first: 100) { nodes { id body createdAt updatedAt url user { name avatarUrl } } }
+    }
+  }
+`;
+async function query(document, variables) {
+  const response = await postLinearGraphql(document, variables);
+  if (!response.ok) {
+    const kind = response.error.includes("LINEAR_API_KEY") ? "unauthenticated" : "failed";
+    throw new ForgeError(kind, response.error, kind === "unauthenticated" ? "set LINEAR_API_KEY on this host" : void 0);
+  }
+  const body = response.data;
+  if (body.errors?.length) throw new ForgeError("failed", body.errors.map((e) => e.message).join("; "));
+  if (!body.data) throw new ForgeError("failed", "Linear answered with no data");
+  return body.data;
+}
+var TEAM_KEY = /^[A-Z][A-Z0-9]{0,9}$/;
+function teamKeyOf(raw2) {
+  const key = (raw2 ?? "").trim().toUpperCase();
+  if (!TEAM_KEY.test(key)) throw new ForgeError("failed", `not a Linear team key: ${raw2 ?? "(none)"}`, "expected something like ENG");
+  return key;
+}
+async function listTeamIssues(teamKey, options = {}) {
+  const closed = options.state === "closed" || options.state === "all";
+  const data = await query(
+    TEAM_ISSUES_QUERY,
+    { key: teamKey, first: options.limit ?? 100, closed }
+  );
+  const nodes = (closed ? data.all?.nodes : data.issues?.nodes) ?? [];
+  return options.state === "closed" ? nodes.filter(isClosed) : nodes;
+}
+function viewIssue2(identifier) {
+  return query(ISSUE_QUERY, { id: identifier }).then((data) => {
+    if (!data.issue) throw new ForgeError("not-found", `no Linear issue ${identifier}`);
+    return data.issue;
+  });
+}
+var CREATE_MUTATION = `
+  mutation Create($input: IssueCreateInput!) {
+    issueCreate(input: $input) { success issue { identifier } }
+  }
+`;
+async function createIssue2(teamKey, draft) {
+  const team = await query(
+    "query Team($key: String!) { teams(filter: { key: { eq: $key } }, first: 1) { nodes { id } } }",
+    { key: teamKey }
+  );
+  const teamId = team.teams.nodes[0]?.id;
+  if (!teamId) throw new ForgeError("not-found", `no Linear team ${teamKey}`);
+  const created = await query(
+    CREATE_MUTATION,
+    { input: { teamId, title: draft.title, description: draft.body ?? "" } }
+  );
+  const identifier = created.issueCreate.issue?.identifier;
+  if (!created.issueCreate.success || !identifier) throw new ForgeError("failed", "Linear refused to create the issue");
+  return viewIssue2(identifier);
+}
+var UPDATE_MUTATION = `
+  mutation Update($id: String!, $input: IssueUpdateInput!) {
+    issueUpdate(id: $id, input: $input) { success }
+  }
+`;
+async function editIssue2(identifier, patch) {
+  const issue2 = await viewIssue2(identifier);
+  const input2 = {};
+  if (patch.title !== void 0) input2["title"] = patch.title;
+  if (patch.body !== void 0) input2["description"] = patch.body;
+  if (patch.state && patch.state === "closed" !== isClosed(issue2)) {
+    input2["stateId"] = await stateIdFor(identifier, patch.state);
+  }
+  if (Object.keys(input2).length > 0) {
+    const result = await query(UPDATE_MUTATION, { id: issue2.id, input: input2 });
+    if (!result.issueUpdate.success) throw new ForgeError("failed", "Linear refused the change");
+  }
+  return viewIssue2(identifier);
+}
+async function stateIdFor(identifier, state) {
+  const wanted = state === "closed" ? ["completed"] : ["unstarted", "backlog", "started"];
+  const data = await query(
+    "query States($id: String!) { issue(id: $id) { team { states { nodes { id type position } } } } }",
+    { id: identifier }
+  );
+  const states2 = data.issue?.team.states.nodes ?? [];
+  const match2 = wanted.flatMap((type) => states2.filter((s) => s.type === type)).sort((a, b) => a.position - b.position)[0];
+  if (!match2) throw new ForgeError("failed", `this Linear team has no ${state === "closed" ? "completed" : "open"} state`);
+  return match2.id;
+}
+var COMMENT_MUTATION = `
+  mutation Comment($input: CommentCreateInput!) { commentCreate(input: $input) { success } }
+`;
+async function commentOnIssue2(identifier, body) {
+  const issue2 = await viewIssue2(identifier);
+  const result = await query(COMMENT_MUTATION, {
+    input: { issueId: issue2.id, body }
+  });
+  if (!result.commentCreate.success) throw new ForgeError("failed", "Linear refused the comment");
+  return viewIssue2(identifier);
+}
+async function linearStatus() {
+  if (!process.env["LINEAR_API_KEY"]?.trim()) {
+    return { available: false, authenticated: false, account: null, detail: "LINEAR_API_KEY is not set on this host" };
+  }
+  try {
+    const data = await query("query { viewer { name } }", {});
+    return { available: true, authenticated: true, account: data.viewer.name, detail: null };
+  } catch (error61) {
+    return { available: true, authenticated: false, account: null, detail: error61.message };
+  }
+}
+
+// ../host/src/forge/routes.ts
+var REPO = /^[A-Za-z0-9][A-Za-z0-9._-]*\/[A-Za-z0-9][A-Za-z0-9._-]*$/;
+function repositoryOf(raw2) {
+  const repo = raw2?.trim() ?? "";
+  if (!REPO.test(repo)) throw new ForgeError("failed", `not a repository: ${repo || "(none)"}`, "expected owner/name");
+  return repo;
+}
+var IDENTIFIER = /^[A-Z][A-Z0-9]{0,9}-\d{1,9}$/;
+function identifierOf(raw2) {
+  const identifier = (raw2 ?? "").trim().toUpperCase();
+  if (!IDENTIFIER.test(identifier)) throw new ForgeError("not-found", `not a Linear issue: ${raw2 ?? "(none)"}`);
+  return identifier;
+}
+function numberOf(raw2) {
+  const value = Number(raw2);
+  if (!Number.isInteger(value) || value <= 0) throw new ForgeError("not-found", `not an issue number: ${raw2}`);
+  return value;
+}
+function createForgeRoutes() {
+  const api = new Hono2();
+  api.onError((error61, c) => {
+    if (error61 instanceof ForgeError) {
+      return c.json({ error: error61.message, kind: error61.kind, hint: error61.hint ?? null }, { status: FORGE_STATUS[error61.kind] });
+    }
+    return c.json({ error: String(error61), kind: "failed", hint: null }, { status: 502 });
+  });
+  api.get("/status", async (c) => {
+    const [github, linear] = await Promise.all([ghStatus(), linearStatus()]);
+    return c.json({ github, linear });
+  });
+  api.get("/linear/issues", async (c) => {
+    const state = c.req.query("state");
+    const limit = Number(c.req.query("limit"));
+    return c.json(
+      await listTeamIssues(teamKeyOf(c.req.query("team")), {
+        state: state === "closed" || state === "all" ? state : "open",
+        limit: Number.isInteger(limit) && limit > 0 ? limit : void 0
+      })
+    );
+  });
+  api.get("/linear/issues/:identifier", async (c) => c.json(await viewIssue2(identifierOf(c.req.param("identifier")))));
+  api.post("/linear/issues", async (c) => {
+    const draft = await c.req.json();
+    if (!draft?.title?.trim()) throw new ForgeError("failed", "an issue needs a title");
+    return c.json(await createIssue2(teamKeyOf(c.req.query("team")), { title: draft.title, body: draft.body }), { status: 201 });
+  });
+  api.patch(
+    "/linear/issues/:identifier",
+    async (c) => c.json(await editIssue2(identifierOf(c.req.param("identifier")), await c.req.json()))
+  );
+  api.post("/linear/issues/:identifier/comments", async (c) => {
+    const { body } = await c.req.json();
+    if (!body?.trim()) throw new ForgeError("failed", "a comment needs a body");
+    return c.json(await commentOnIssue2(identifierOf(c.req.param("identifier")), body));
+  });
+  api.get("/issues", async (c) => {
+    const query2 = c.req.query();
+    const state = query2["state"];
+    return c.json(
+      await listIssues(repositoryOf(query2["repo"]), {
+        state: state === "closed" || state === "all" ? state : "open",
+        assignee: query2["assignee"],
+        label: query2["label"],
+        milestone: query2["milestone"],
+        search: query2["q"],
+        limit: query2["limit"] ? Number(query2["limit"]) : void 0
+      })
+    );
+  });
+  api.get(
+    "/issues/:number",
+    async (c) => c.json(await viewIssue(repositoryOf(c.req.query("repo")), numberOf(c.req.param("number"))))
+  );
+  api.post("/issues", async (c) => {
+    const draft = await c.req.json();
+    if (!draft?.title?.trim()) throw new ForgeError("failed", "an issue needs a title");
+    return c.json(await createIssue(repositoryOf(c.req.query("repo")), draft), { status: 201 });
+  });
+  api.patch("/issues/:number", async (c) => {
+    const repo = repositoryOf(c.req.query("repo"));
+    const number4 = numberOf(c.req.param("number"));
+    const patch = await c.req.json();
+    const { state, stateReason, ...fields } = patch;
+    await editIssue(repo, number4, fields);
+    if (state) await setIssueState(repo, number4, state, stateReason);
+    return c.json(await viewIssue(repo, number4));
+  });
+  api.post("/issues/:number/comments", async (c) => {
+    const repo = repositoryOf(c.req.query("repo"));
+    const number4 = numberOf(c.req.param("number"));
+    const { body } = await c.req.json();
+    if (!body?.trim()) throw new ForgeError("failed", "a comment needs a body");
+    await commentOnIssue(repo, number4, body);
+    return c.json(await viewIssue(repo, number4));
+  });
+  api.get("/vocabulary", async (c) => c.json(await issueVocabulary(repositoryOf(c.req.query("repo")))));
+  api.get("/assigned", async (c) => {
+    const limit = Number(c.req.query("limit"));
+    return c.json(await assignedIssues(Number.isInteger(limit) && limit > 0 ? limit : void 0));
+  });
+  return api;
+}
+
 // ../host/src/app.ts
 var HOST_PUBLIC_ROUTES = /* @__PURE__ */ new Set(["GET /api/health"]);
 function createHostApp(options) {
@@ -73644,6 +74035,7 @@ function createHostApp(options) {
     return next();
   });
   app.get("/api/health", (c) => c.json({ ok: true }));
+  app.route("/api/forge", createForgeRoutes());
   for (const module of options.modules) {
     if (module.routes) app.route(`/api/modules/${module.manifest.id}`, module.routes(options.context));
   }