@surething/cockpit 1.0.275 → 1.0.276

package/dist/{chunk-JJWVBF6H.mjs → chunk-BCWVTDEZ.mjs}

@@ -6912,67 +6912,67 @@ var Or = (self, that) => {
   });
   return error48;
 };
-var InvalidData = (path2, message, options = {
+var InvalidData = (path5, message, options = {
   pathDelim: "."
 }) => {
   const error48 = Object.create(proto2);
   error48._op = OP_INVALID_DATA;
-  error48.path = path2;
+  error48.path = path5;
   error48.message = message;
   Object.defineProperty(error48, "toString", {
     enumerable: false,
     value() {
-      const path3 = pipe(this.path, join(options.pathDelim));
-      return `(Invalid data at ${path3}: "${this.message}")`;
+      const path6 = pipe(this.path, join(options.pathDelim));
+      return `(Invalid data at ${path6}: "${this.message}")`;
     }
   });
   return error48;
 };
-var MissingData = (path2, message, options = {
+var MissingData = (path5, message, options = {
   pathDelim: "."
 }) => {
   const error48 = Object.create(proto2);
   error48._op = OP_MISSING_DATA;
-  error48.path = path2;
+  error48.path = path5;
   error48.message = message;
   Object.defineProperty(error48, "toString", {
     enumerable: false,
     value() {
-      const path3 = pipe(this.path, join(options.pathDelim));
-      return `(Missing data at ${path3}: "${this.message}")`;
+      const path6 = pipe(this.path, join(options.pathDelim));
+      return `(Missing data at ${path6}: "${this.message}")`;
     }
   });
   return error48;
 };
-var SourceUnavailable = (path2, message, cause3, options = {
+var SourceUnavailable = (path5, message, cause3, options = {
   pathDelim: "."
 }) => {
   const error48 = Object.create(proto2);
   error48._op = OP_SOURCE_UNAVAILABLE;
-  error48.path = path2;
+  error48.path = path5;
   error48.message = message;
   error48.cause = cause3;
   Object.defineProperty(error48, "toString", {
     enumerable: false,
     value() {
-      const path3 = pipe(this.path, join(options.pathDelim));
-      return `(Source unavailable at ${path3}: "${this.message}")`;
+      const path6 = pipe(this.path, join(options.pathDelim));
+      return `(Source unavailable at ${path6}: "${this.message}")`;
     }
   });
   return error48;
 };
-var Unsupported = (path2, message, options = {
+var Unsupported = (path5, message, options = {
   pathDelim: "."
 }) => {
   const error48 = Object.create(proto2);
   error48._op = OP_UNSUPPORTED;
-  error48.path = path2;
+  error48.path = path5;
   error48.message = message;
   Object.defineProperty(error48, "toString", {
     enumerable: false,
     value() {
-      const path3 = pipe(this.path, join(options.pathDelim));
-      return `(Unsupported operation at ${path3}: "${this.message}")`;
+      const path6 = pipe(this.path, join(options.pathDelim));
+      return `(Unsupported operation at ${path6}: "${this.message}")`;
     }
   });
   return error48;
@@ -7087,9 +7087,9 @@ var isMissingDataOnly = (self) => reduceWithContext2(self, void 0, IsMissingData
 var empty17 = {
   _tag: "Empty"
 };
-var patch5 = /* @__PURE__ */ dual(2, (path2, patch9) => {
+var patch5 = /* @__PURE__ */ dual(2, (path5, patch9) => {
   let input = of3(patch9);
-  let output = path2;
+  let output = path5;
   while (isCons(input)) {
     const patch10 = input.head;
     switch (patch10._tag) {
@@ -7156,7 +7156,7 @@ var make20 = (options) => ({
 var makeFlat = (options) => ({
   [FlatConfigProviderTypeId]: FlatConfigProviderTypeId,
   patch: options.patch,
-  load: (path2, config3, split3 = true) => options.load(path2, config3, split3),
+  load: (path5, config3, split3 = true) => options.load(path5, config3, split3),
   enumerateChildren: options.enumerateChildren
 });
 var fromFlat = (flat) => make20({
@@ -7174,29 +7174,29 @@ var fromEnv = (options) => {
     pathDelim: "_",
     seqDelim: ","
   }, options);
-  const makePathString = (path2) => pipe(path2, join(pathDelim));
+  const makePathString = (path5) => pipe(path5, join(pathDelim));
   const unmakePathString = (pathString) => pathString.split(pathDelim);
   const getEnv = () => typeof process !== "undefined" && "env" in process && typeof process.env === "object" ? process.env : {};
-  const load = (path2, primitive3, split3 = true) => {
-    const pathString = makePathString(path2);
+  const load = (path5, primitive3, split3 = true) => {
+    const pathString = makePathString(path5);
     const current2 = getEnv();
     const valueOpt = pathString in current2 ? some2(current2[pathString]) : none2();
-    return pipe(valueOpt, mapError(() => MissingData(path2, `Expected ${pathString} to exist in the process context`)), flatMap9((value) => parsePrimitive(value, path2, primitive3, seqDelim, split3)));
+    return pipe(valueOpt, mapError(() => MissingData(path5, `Expected ${pathString} to exist in the process context`)), flatMap9((value) => parsePrimitive(value, path5, primitive3, seqDelim, split3)));
   };
-  const enumerateChildren = (path2) => sync(() => {
+  const enumerateChildren = (path5) => sync(() => {
     const current2 = getEnv();
     const keys5 = Object.keys(current2);
     const keyPaths = keys5.map((value) => unmakePathString(value.toUpperCase()));
     const filteredKeyPaths = keyPaths.filter((keyPath) => {
-      for (let i = 0; i < path2.length; i++) {
-        const pathComponent = pipe(path2, unsafeGet(i));
+      for (let i = 0; i < path5.length; i++) {
+        const pathComponent = pipe(path5, unsafeGet(i));
         const currentElement = keyPath[i];
         if (currentElement === void 0 || pathComponent !== currentElement) {
           return false;
         }
       }
       return true;
-    }).flatMap((keyPath) => keyPath.slice(path2.length, path2.length + 1));
+    }).flatMap((keyPath) => keyPath.slice(path5.length, path5.length + 1));
     return fromIterable6(filteredKeyPaths);
   });
   return fromFlat(makeFlat({
@@ -7212,17 +7212,17 @@ var extend = (leftDef, rightDef, left3, right3) => {
   const rightExtension = concat(right3, rightPad);
   return [leftExtension, rightExtension];
 };
-var appendConfigPath = (path2, config3) => {
+var appendConfigPath = (path5, config3) => {
   let op = config3;
   if (op._tag === "Nested") {
-    const out = path2.slice();
+    const out = path5.slice();
     while (op._tag === "Nested") {
       out.push(op.name);
       op = op.config;
     }
     return out;
   }
-  return path2;
+  return path5;
 };
 var fromFlatLoop = (flat, prefix, config3, split3) => {
   const op = config3;
@@ -7298,8 +7298,8 @@ var fromFlatLoop = (flat, prefix, config3, split3) => {
           return fail2(right3.left);
         }
         if (isRight2(left3) && isRight2(right3)) {
-          const path2 = pipe(prefix, join("."));
-          const fail20 = fromFlatLoopFail(prefix, path2);
+          const path5 = pipe(prefix, join("."));
+          const fail20 = fromFlatLoopFail(prefix, path5);
           const [lefts, rights] = extend(fail20, fail20, pipe(left3.right, map3(right2)), pipe(right3.right, map3(right2)));
           return pipe(lefts, zip(rights), forEachSequential(([left4, right4]) => pipe(zip2(left4, right4), map10(([left5, right5]) => op.zip(left5, right5)))));
         }
@@ -7308,19 +7308,19 @@ var fromFlatLoop = (flat, prefix, config3, split3) => {
     }
   }
 };
-var fromFlatLoopFail = (prefix, path2) => (index) => left2(MissingData(prefix, `The element at index ${index} in a sequence at path "${path2}" was missing`));
+var fromFlatLoopFail = (prefix, path5) => (index) => left2(MissingData(prefix, `The element at index ${index} in a sequence at path "${path5}" was missing`));
 var splitPathString = (text, delim) => {
   const split3 = text.split(new RegExp(`\\s*${escape(delim)}\\s*`));
   return split3;
 };
-var parsePrimitive = (text, path2, primitive3, delimiter2, split3) => {
+var parsePrimitive = (text, path5, primitive3, delimiter2, split3) => {
   if (!split3) {
     return pipe(primitive3.parse(text), mapBoth2({
-      onFailure: prefixed(path2),
+      onFailure: prefixed(path5),
       onSuccess: of
     }));
   }
-  return pipe(splitPathString(text, delimiter2), forEachSequential((char) => primitive3.parse(char.trim())), mapError(prefixed(path2)));
+  return pipe(splitPathString(text, delimiter2), forEachSequential((char) => primitive3.parse(char.trim())), mapError(prefixed(path5)));
 };
 var transpose = (array7) => {
   return Object.keys(array7[0]).map((column) => array7.map((row) => row[column]));
@@ -28645,14 +28645,14 @@ import { execSync } from "child_process";
 
 // packages/shared/utils/src/encodePath.ts
 var CLAUDE_ENCODED_MAX_LEN = 200;
-function claudePathHash(path2) {
+function claudePathHash(path5) {
   let h = 0;
-  for (let i = 0; i < path2.length; i++) h = (h << 5) - h + path2.charCodeAt(i) | 0;
+  for (let i = 0; i < path5.length; i++) h = (h << 5) - h + path5.charCodeAt(i) | 0;
   return Math.abs(h).toString(36);
 }
-function encodePath(path2) {
-  const encoded = path2.replace(/[^a-zA-Z0-9]/g, "-");
-  return encoded.length <= CLAUDE_ENCODED_MAX_LEN ? encoded : `${encoded.slice(0, CLAUDE_ENCODED_MAX_LEN)}-${claudePathHash(path2)}`;
+function encodePath(path5) {
+  const encoded = path5.replace(/[^a-zA-Z0-9]/g, "-");
+  return encoded.length <= CLAUDE_ENCODED_MAX_LEN ? encoded : `${encoded.slice(0, CLAUDE_ENCODED_MAX_LEN)}-${claudePathHash(path5)}`;
 }
 
 // packages/shared/utils/src/homePath.ts
@@ -28675,12 +28675,15 @@ var NOTE_FILE = join4(COCKPIT_DIR, "note.md");
 var SCHEDULED_TASKS_FILE = join4(COCKPIT_DIR, "scheduled-tasks.json");
 var SETTINGS_FILE = join4(COCKPIT_DIR, "settings.json");
 var SKILLS_FILE = join4(COCKPIT_DIR, "skills.json");
+var BOTS_FILE = join4(COCKPIT_DIR, "bot.json");
+var BOTS_DIR = join4(COCKPIT_DIR, "bots");
 var CODEX_SESSION_INDEX_FILE = join4(COCKPIT_DIR, "codex-session-index.json");
 var HTML_APPS_FILE = join4(COCKPIT_DIR, "html.json");
 var REVIEW_DIR = join4(COCKPIT_DIR, "review");
 var REVIEW_SIGNAL_FILE = join4(REVIEW_DIR, "_signal");
 var APPS_DIR = join4(process.env.COCKPIT_ROOT || process.cwd(), "apps");
 var BUILTIN_SKILLS_SRC_DIR = join4(process.env.COCKPIT_ROOT || process.cwd(), "skills");
+var BUILTIN_BOTS_SRC_DIR = join4(process.env.COCKPIT_ROOT || process.cwd(), "bots");
 var CLAUDE_DIR = join4(HOME_DIR, ".claude");
 var CLAUDE_PROJECTS_DIR = join4(CLAUDE_DIR, "projects");
 var DEEPSEEK_DIR = join4(COCKPIT_DIR, "deepseek");
@@ -28938,6 +28941,22 @@ async function readJsonFile(filePath, defaultValue) {
     return defaultValue;
   }
 }
+async function readJsonFileForUpdate(filePath, defaultValue) {
+  let content;
+  try {
+    content = await readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err?.code === "ENOENT") return defaultValue;
+    throw err;
+  }
+  try {
+    return JSON.parse(content);
+  } catch (err) {
+    throw new Error(
+      `${filePath} is not valid JSON, refusing to overwrite it: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
 async function writeJsonFile(filePath, data) {
   await ensureParentDir(filePath);
   await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
@@ -28960,7 +28979,7 @@ function withFileLock(filePath, fn2) {
 }
 function mutateJsonFile(filePath, defaultValue, mutate5) {
   return withFileLock(filePath, async () => {
-    const current2 = await readJsonFile(filePath, defaultValue);
+    const current2 = await readJsonFileForUpdate(filePath, defaultValue);
     const next4 = await mutate5(current2);
     await writeJsonFile(filePath, next4);
     return next4;
@@ -29145,12 +29164,16 @@ var NEXT_INJECTED_ENV_KEYS = [
   "NEXT_DEPLOYMENT_ID",
   "TURBOPACK"
 ];
+var HOST_ONLY_ENV_KEYS = [
+  ...NEXT_INJECTED_ENV_KEYS,
+  "PORT"
+];
 function sanitizedSpawnEnv(overrides = {}, base = process.env) {
   const out = {};
   for (const [key, value] of Object.entries(base)) {
     if (value !== void 0) out[key] = value;
   }
-  for (const key of NEXT_INJECTED_ENV_KEYS) delete out[key];
+  for (const key of HOST_ONLY_ENV_KEYS) delete out[key];
   for (const [key, value] of Object.entries(overrides)) {
     if (value === void 0) delete out[key];
     else out[key] = value;
@@ -29305,8 +29328,8 @@ var CLAUDE_STYLE_PATHS = [
 ];
 function findClaudeStylePath(cwd, sessionId) {
   for (const resolve3 of CLAUDE_STYLE_PATHS) {
-    const path2 = resolve3(cwd, sessionId);
-    if (existsSync2(path2)) return path2;
+    const path5 = resolve3(cwd, sessionId);
+    if (existsSync2(path5)) return path5;
   }
   return null;
 }
@@ -30084,6 +30107,11 @@ var DelegationService = Context_exports.GenericTag(
   "@cockpit/DelegationService"
 );
 
+// packages/shared/effect-services/src/botRegistry.ts
+var BotRegistryService = Context_exports.GenericTag(
+  "@cockpit/BotRegistryService"
+);
+
 // packages/feature/console/src/effect/pgLive.ts
 var { Pool } = pg;
 var handleAsync = (op, f) => Effect_exports.tryPromise({
@@ -30526,10 +30554,10 @@ function serializeValue(val) {
     };
   }
   if (val && typeof val === "object" && "segments" in val) {
-    const path2 = val;
+    const path5 = val;
     return {
       _type: "path",
-      segments: path2.segments.map((s) => ({
+      segments: path5.segments.map((s) => ({
         start: serializeValue(s.start),
         relationship: serializeValue(s.relationship),
         end: serializeValue(s.end)
@@ -31281,10 +31309,10 @@ var snapshotOnce = (snapshotsRoot, maxFileBytes, trigger, kind) => Effect_export
     const addPaths = [];
     const rmPaths = [];
     for (const e of entries2) {
-      const path2 = e.slice(3);
-      if (!path2) continue;
-      if (e[0] === "D" || e[1] === "D") rmPaths.push(path2);
-      else addPaths.push(path2);
+      const path5 = e.slice(3);
+      if (!path5) continue;
+      if (e[0] === "D" || e[1] === "D") rmPaths.push(path5);
+      else addPaths.push(path5);
     }
     const sizes = yield* Effect_exports.all(
       addPaths.map(
@@ -31386,15 +31414,15 @@ var listByToolIdsImpl = (snapshotsRoot, cwd, toolIds, sessionKey) => Effect_expo
     (c) => !!c && !!c.toolId && wanted.has(c.toolId) && (!sessionKey || c.sessionKey === sessionKey)
   );
 }).pipe(Effect_exports.withSpan("snapshot.listByToolIds", { attributes: { cwd } }));
-var showFile = (repoDir, cwd, rev, path2) => runGit(repoDir, cwd, ["show", `${rev}:${path2}`]).pipe(
+var showFile = (repoDir, cwd, rev, path5) => runGit(repoDir, cwd, ["show", `${rev}:${path5}`]).pipe(
   Effect_exports.map((r) => r.code === 0 ? r.stdout : null),
   Effect_exports.orElseSucceed(() => null)
 );
-var gitShowBytes = (repoDir, cwd, rev, path2) => Effect_exports.tryPromise({
+var gitShowBytes = (repoDir, cwd, rev, path5) => Effect_exports.tryPromise({
   try: () => new Promise((resolve3, reject) => {
     execFile(
       "git",
-      ["show", `${rev}:${path2}`],
+      ["show", `${rev}:${path5}`],
       {
         env: {
           ...process.env,
@@ -31414,7 +31442,7 @@ var gitShowBytes = (repoDir, cwd, rev, path2) => Effect_exports.tryPromise({
     );
   }),
   // A miss is ordinary: the path simply doesn't exist at that revision.
-  catch: () => new NotFoundError({ resource: "snapshot-blob", id: `${rev}:${path2}` })
+  catch: () => new NotFoundError({ resource: "snapshot-blob", id: `${rev}:${path5}` })
 });
 var blobImpl = (snapshotsRoot, cwd, rev, file2) => Effect_exports.gen(function* () {
   if (!/^[0-9a-f]{6,40}$/i.test(rev)) {
@@ -31486,23 +31514,23 @@ var diffImpl = (snapshotsRoot, cwd, commitHash) => Effect_exports.gen(function*
   const files = [];
   for (let i = 0; i + 1 < tokens.length && files.length < MAX_DIFF_FILES; i += 2) {
     const st = tokens[i];
-    const path2 = tokens[i + 1];
+    const path5 = tokens[i + 1];
     const status3 = st === "A" ? "added" : st === "D" ? "deleted" : "modified";
-    const binary = binarySet.has(path2);
+    const binary = binarySet.has(path5);
     let oldContent = null;
     let newContent = null;
     if (!binary) {
-      if (status3 !== "added") oldContent = yield* showFile(repoDir, cwd, base, path2);
-      if (status3 !== "deleted") newContent = yield* showFile(repoDir, cwd, commit3.hash, path2);
+      if (status3 !== "added") oldContent = yield* showFile(repoDir, cwd, base, path5);
+      if (status3 !== "deleted") newContent = yield* showFile(repoDir, cwd, commit3.hash, path5);
       if ((oldContent?.length ?? 0) > MAX_DIFF_CONTENT_BYTES || (newContent?.length ?? 0) > MAX_DIFF_CONTENT_BYTES) {
         oldContent = null;
         newContent = null;
       }
     }
-    const stats = lineStats.get(path2);
-    const isImage = binary && isImagePath(path2);
+    const stats = lineStats.get(path5);
+    const isImage = binary && isImagePath(path5);
     files.push({
-      path: path2,
+      path: path5,
       status: status3,
       binary,
       additions: stats?.additions ?? 0,
@@ -32410,7 +32438,7 @@ var patchChanges = (item) => {
   if (Array.isArray(raw)) {
     return raw.map((c) => ({ path: c?.path || "", kind: kindOf(c) }));
   }
-  return Object.entries(raw).map(([path2, v]) => ({ path: path2, kind: kindOf(v) }));
+  return Object.entries(raw).map(([path5, v]) => ({ path: path5, kind: kindOf(v) }));
 };
 var patchResultText = (item) => {
   const cs = patchChanges(item);
@@ -33064,7 +33092,7 @@ var groupMatches = (matches, terms) => {
   }
   return byFile;
 };
-var fsTry3 = (path2, op, fn2) => Effect_exports.tryPromise({ try: fn2, catch: (cause3) => new FSError({ path: path2, op, cause: cause3 }) });
+var fsTry3 = (path5, op, fn2) => Effect_exports.tryPromise({ try: fn2, catch: (cause3) => new FSError({ path: path5, op, cause: cause3 }) });
 var readJsonOr = (file2, fallback) => fsTry3(file2, "read", () => readFile4(file2, "utf8")).pipe(
   Effect_exports.flatMap((raw) => Effect_exports.try(() => JSON.parse(raw))),
   Effect_exports.orElseSucceed(() => fallback)
@@ -33568,16 +33596,16 @@ function planPermission(toolName, input, opts) {
     };
   }
   if (PLAN_EDIT_TOOLS.has(toolName)) {
-    const path2 = [input.file_path, input.notebook_path, input.path, opts?.blockedPath].find(
+    const path5 = [input.file_path, input.notebook_path, input.path, opts?.blockedPath].find(
       (v) => typeof v === "string"
     );
-    if (path2 && isPlanFilePath(path2)) {
+    if (path5 && isPlanFilePath(path5)) {
       return { behavior: "allow", updatedInput: input };
     }
     return {
       behavior: "deny",
       // (C) read-only plan mode, no dialog → feedback instead of silent drop
-      message: `Plan mode is read-only and this environment has no approval dialog, so "${toolName}"${path2 ? ` on ${path2}` : ""} can't run. Only writes under .claude/plans/ are allowed. Capture the intended changes in your plan instead of editing files now.`
+      message: `Plan mode is read-only and this environment has no approval dialog, so "${toolName}"${path5 ? ` on ${path5}` : ""} can't run. Only writes under .claude/plans/ are allowed. Capture the intended changes in your plan instead of editing files now.`
     };
   }
   return { behavior: "allow", updatedInput: input };
@@ -33614,8 +33642,10 @@ function buildClaudeOptions(ctx, independent) {
     abortController: abort,
     // env is ALWAYS passed: without it the SDK inherits process.env verbatim,
     // handing the agent this server's NODE_ENV=production. See sanitizedSpawnEnv.
-    // COCKPIT_RUN_ID lets a skill's curl identify the session it runs in (delegation parent).
-    env: sanitizedSpawnEnv({ COCKPIT_RUN_ID: ctx.currentKey() })
+    // COCKPIT_RUN_ID lets a skill's curl identify the session it runs in (delegation parent);
+    // COCKPIT_CWD is the session's own working directory, which `pwd` stops being the moment
+    // the agent cd's somewhere (see spawnEnv.ts).
+    env: sanitizedSpawnEnv({ COCKPIT_RUN_ID: ctx.currentKey(), COCKPIT_CWD: ctx.cwd || void 0 })
   });
 }
 var claudeSpec = {
@@ -33732,9 +33762,9 @@ function getSessionPath(root, cwd, sessionId) {
   return join9(getSessionDir(root, cwd), `${sessionId}.jsonl`);
 }
 function readSessionMessages(root, cwd, sessionId) {
-  const path2 = getSessionPath(root, cwd, sessionId);
-  if (!existsSync4(path2)) return [];
-  const lines = readFileSync3(path2, "utf-8").split("\n").filter(Boolean);
+  const path5 = getSessionPath(root, cwd, sessionId);
+  if (!existsSync4(path5)) return [];
+  const lines = readFileSync3(path5, "utf-8").split("\n").filter(Boolean);
   const transcriptEntries = [];
   for (const line of lines) {
     try {
@@ -33834,8 +33864,8 @@ function readSessionMessages(root, cwd, sessionId) {
 function appendSessionLine(root, cwd, sessionId, line) {
   const dir = getSessionDir(root, cwd);
   mkdirSync3(dir, { recursive: true });
-  const path2 = getSessionPath(root, cwd, sessionId);
-  appendFileSync(path2, JSON.stringify(line) + "\n", "utf-8");
+  const path5 = getSessionPath(root, cwd, sessionId);
+  appendFileSync(path5, JSON.stringify(line) + "\n", "utf-8");
 }
 function appendUserText(root, cwd, sessionId, text, opts) {
   appendSessionLine(root, cwd, sessionId, {
@@ -34644,10 +34674,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path2) {
-  if (!path2)
+function getElementAtPath(obj, path5) {
+  if (!path5)
     return obj;
-  return path2.reduce((acc, key) => acc?.[key], obj);
+  return path5.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys5 = Object.keys(promisesObj);
@@ -35030,11 +35060,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path2, issues) {
+function prefixIssues(path5, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path2);
+    iss.path.unshift(path5);
     return iss;
   });
 }
@@ -35217,7 +35247,7 @@ function formatError(error48, mapper = (issue2) => issue2.message) {
 }
 function treeifyError(error48, mapper = (issue2) => issue2.message) {
   const result = { errors: [] };
-  const processError = (error49, path2 = []) => {
+  const processError = (error49, path5 = []) => {
     var _a2, _b;
     for (const issue2 of error49.issues) {
       if (issue2.code === "invalid_union" && issue2.errors.length) {
@@ -35227,7 +35257,7 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
       } else if (issue2.code === "invalid_element") {
         processError({ issues: issue2.issues }, issue2.path);
       } else {
-        const fullpath = [...path2, ...issue2.path];
+        const fullpath = [...path5, ...issue2.path];
         if (fullpath.length === 0) {
           result.errors.push(mapper(issue2));
           continue;
@@ -35259,8 +35289,8 @@ function treeifyError(error48, mapper = (issue2) => issue2.message) {
 }
 function toDotPath(_path) {
   const segs = [];
-  const path2 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
-  for (const seg of path2) {
+  const path5 = _path.map((seg) => typeof seg === "object" ? seg.key : seg);
+  for (const seg of path5) {
     if (typeof seg === "number")
       segs.push(`[${seg}]`);
     else if (typeof seg === "symbol")
@@ -47237,13 +47267,13 @@ function resolveRef(ref, ctx) {
   if (!ref.startsWith("#")) {
     throw new Error("External $ref is not supported, only local refs (#/...) are allowed");
   }
-  const path2 = ref.slice(1).split("/").filter(Boolean);
-  if (path2.length === 0) {
+  const path5 = ref.slice(1).split("/").filter(Boolean);
+  if (path5.length === 0) {
     return ctx.rootSchema;
   }
   const defsKey = ctx.version === "draft-2020-12" ? "$defs" : "definitions";
-  if (path2[0] === defsKey) {
-    const key = path2[1];
+  if (path5[0] === defsKey) {
+    const key = path5[1];
     if (!key || !ctx.defs[key]) {
       throw new Error(`Reference not found: ${ref}`);
     }
@@ -47824,7 +47854,14 @@ function createTools(context7) {
             encoding: "utf-8",
             timeout: timeout5 ?? 6e4,
             maxBuffer: 10 * 1024 * 1024,
-            env: sanitizedSpawnEnv({ FORCE_COLOR: "0", CI: "1", COCKPIT_RUN_ID: context7.runId })
+            env: sanitizedSpawnEnv({
+              FORCE_COLOR: "0",
+              CI: "1",
+              COCKPIT_RUN_ID: context7.runId,
+              // The session's own cwd, which survives a `cd` in an earlier command
+              // the way `pwd` does not (see spawnEnv.ts).
+              COCKPIT_CWD: context7.cwd || void 0
+            })
           });
           if (stdout.length === 0) {
             if (stderr.length === 0) {
@@ -47890,14 +47927,14 @@ ${stderrCapped}`;
       ),
       execute: async ({
         pattern,
-        path: path2,
+        path: path5,
         ignore_case,
         output_mode,
         "-n": showLineNumbers
       }) => {
         try {
-          if (path2 && !isAbsolute2(path2)) return "Error: path must be an absolute path.";
-          const target = path2 || context7.cwd;
+          if (path5 && !isAbsolute2(path5)) return "Error: path must be an absolute path.";
+          const target = path5 || context7.cwd;
           const args2 = [
             "--no-heading",
             "--color",
@@ -49133,9 +49170,9 @@ function createCodexEventAdapter(ctx) {
       rolloutPath = null;
     }
   }
-  const bindRollout = (path2) => {
-    if (!path2 || path2 === rolloutPath) return;
-    rolloutPath = path2;
+  const bindRollout = (path5) => {
+    if (!path5 || path5 === rolloutPath) return;
+    rolloutPath = path5;
     basesReady = false;
     initBases();
   };
@@ -49153,8 +49190,8 @@ function createCodexEventAdapter(ctx) {
   };
   const emitSpawn = (item) => {
     const agentIds = item.receiver_thread_ids ?? [];
-    const path2 = rolloutPath;
-    const entry = path2 ? resolveCodexSpawnCall(readRollout(path2).spawn, spawnBase + spawnSeen, agentIds[0]) : null;
+    const path5 = rolloutPath;
+    const entry = path5 ? resolveCodexSpawnCall(readRollout(path5).spawn, spawnBase + spawnSeen, agentIds[0]) : null;
     spawnSeen += 1;
     const toolUseId = toolUseIdFor(item);
     if (spawnEmitted.has(toolUseId)) return;
@@ -49167,9 +49204,9 @@ function createCodexEventAdapter(ctx) {
     emitSpawnBubble(toolUseId, input, entry?.agentPath);
   };
   const syncSubAgents = (flushPending = false) => {
-    const path2 = rolloutPath;
-    if (!path2) return;
-    const { spawn: spawn2, reports } = readRollout(path2);
+    const path5 = rolloutPath;
+    if (!path5) return;
+    const { spawn: spawn2, reports } = readRollout(path5);
     for (let i = spawnBase; i < spawn2.length; i += 1) {
       const s = spawn2[i];
       if (!s.callId || spawnEmitted.has(s.callId)) continue;
@@ -49326,7 +49363,7 @@ function cleanupImageFiles(imageFiles) {
 function codexTurnInput(prompt, imageFiles) {
   return [
     { type: "text", text: imageFiles.length > 0 ? prompt || CODEX_IMAGE_ONLY_TEXT : prompt },
-    ...imageFiles.map((path2) => ({ type: "localImage", path: path2 }))
+    ...imageFiles.map((path5) => ({ type: "localImage", path: path5 }))
   ];
 }
 function codexThreadParams(ctx) {
@@ -49393,8 +49430,9 @@ async function runCodexAppServer(ctx) {
   let client;
   try {
     client = CodexAppServerClient.start({
-      // COCKPIT_RUN_ID lets a skill's curl identify the session it runs in (delegation parent).
-      env: sanitizedSpawnEnv({ COCKPIT_RUN_ID: ctx.currentKey() }),
+      // COCKPIT_RUN_ID lets a skill's curl identify the session it runs in (delegation parent);
+      // COCKPIT_CWD is the session's own working directory (see spawnEnv.ts).
+      env: sanitizedSpawnEnv({ COCKPIT_RUN_ID: ctx.currentKey(), COCKPIT_CWD: ctx.cwd || void 0 }),
       ...ctx.cwd ? { cwd: ctx.cwd } : {},
       onNotification,
       // Permitted `console.error` under EFFECT.md §0 (subprocess IPC adapter gateway).
@@ -49811,6 +49849,388 @@ var DelegationServiceLive = Layer_exports.effect(
   })
 );
 
+// packages/feature/agent/src/effect/botRegistryLive.ts
+import { randomUUID as randomUUID5 } from "crypto";
+import { readFileSync as readFileSync7, realpathSync as realpathSync3 } from "fs";
+import path3 from "path";
+
+// packages/feature/agent/src/shared/bots.ts
+import yaml from "js-yaml";
+var BOT_MANIFEST_FILE = "BOT.md";
+var BOT_NAME = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var isBotName = (name) => BOT_NAME.test(name);
+var isManifestPath = (path5, target) => path5.basename(target).toLowerCase() === BOT_MANIFEST_FILE.toLowerCase();
+var botPaths = (path5, target) => {
+  const dir = isManifestPath(path5, target) ? path5.dirname(target) : path5.join(target);
+  return { dir, manifest: path5.join(dir, BOT_MANIFEST_FILE) };
+};
+var parseBotDocument = (path5, content, dir) => {
+  const match21 = content.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/);
+  let fields = {};
+  if (match21) {
+    const raw = yaml.load(match21[1]);
+    if (raw !== void 0 && raw !== null) {
+      if (typeof raw !== "object" || Array.isArray(raw)) throw new Error("BOT.md frontmatter must be a mapping");
+      fields = raw;
+    }
+  }
+  const fallback = path5.basename(dir).toLowerCase();
+  const name = typeof fields.name === "string" && fields.name.trim() ? fields.name.trim() : fallback;
+  if (!isBotName(name)) throw new Error(`Bot name "${name}" must match [a-z0-9][a-z0-9-]*`);
+  const description = typeof fields.description === "string" ? fields.description.trim() : "";
+  return { name, description };
+};
+var messageOf = (cause3) => cause3 instanceof Error ? cause3.message : String(cause3);
+var resolveBot = (path5, record2, read) => {
+  const { dir, manifest } = botPaths(path5, record2.path);
+  try {
+    return { ...record2, valid: true, ...parseBotDocument(path5, read(manifest), dir) };
+  } catch (cause3) {
+    return { ...record2, valid: false, name: path5.basename(dir), error: messageOf(cause3) };
+  }
+};
+var mentionableBots = (path5, bots) => {
+  const out = /* @__PURE__ */ new Map();
+  for (const bot of bots) {
+    if (bot.valid && !out.has(bot.name)) out.set(bot.name, botPaths(path5, bot.path).manifest);
+  }
+  return out;
+};
+var findNameClash = (bots, name, dir) => bots.find((bot) => bot.valid && bot.name === name && bot.path !== dir);
+
+// packages/feature/agent/src/server/lib/builtinBots.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  cpSync,
+  existsSync as existsSync8,
+  mkdirSync as mkdirSync6,
+  readFileSync as readFileSync6,
+  readdirSync as readdirSync4,
+  realpathSync as realpathSync2,
+  renameSync as renameSync4,
+  rmdirSync,
+  rmSync,
+  statSync as statSync5,
+  writeFileSync as writeFileSync6
+} from "fs";
+import path2, { join as join14 } from "path";
+var BUILTIN_BOT_ID_PREFIX = "builtin:";
+var isBuiltinBotId = (id3) => id3.startsWith(BUILTIN_BOT_ID_PREFIX);
+var builtinBotNameFromId = (id3) => isBuiltinBotId(id3) ? id3.slice(BUILTIN_BOT_ID_PREFIX.length) : "";
+var builtinBotSeedDir = (name) => join14(BUILTIN_BOTS_SRC_DIR, name);
+var builtinBotUserDir = (name) => join14(BOTS_DIR, name);
+var hasManifest = (dir) => {
+  try {
+    return statSync5(join14(dir, BOT_MANIFEST_FILE)).isFile();
+  } catch {
+    return false;
+  }
+};
+var INSTALL_STATE_FILE = join14(BOTS_DIR, ".builtin-installs.json");
+var readInstallState = () => {
+  try {
+    const raw = JSON.parse(readFileSync6(INSTALL_STATE_FILE, "utf-8"));
+    return raw && typeof raw === "object" && !Array.isArray(raw) ? raw : {};
+  } catch {
+    return {};
+  }
+};
+var writeInstallState = (state) => {
+  try {
+    mkdirSync6(BOTS_DIR, { recursive: true });
+    const tmp = `${INSTALL_STATE_FILE}.${process.pid}.tmp`;
+    writeFileSync6(tmp, `${JSON.stringify(state, null, 2)}
+`);
+    renameSync4(tmp, INSTALL_STATE_FILE);
+  } catch (err) {
+    console.error(`[bots] cannot record builtin Bot installs in ${INSTALL_STATE_FILE}:`, err);
+  }
+};
+var hashFile = (file2) => createHash2("sha256").update(readFileSync6(file2)).digest("hex");
+function fileHashes(dir) {
+  const out = /* @__PURE__ */ new Map();
+  const walk = (rel) => {
+    for (const entry of readdirSync4(join14(dir, rel), { withFileTypes: true })) {
+      const child = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) walk(child);
+      else if (entry.isFile()) out.set(child, hashFile(join14(dir, child)));
+    }
+  };
+  walk("");
+  return out;
+}
+var treeHash = (files) => {
+  const hash3 = createHash2("sha256");
+  for (const rel of [...files.keys()].sort()) hash3.update(`${rel}\0${files.get(rel)}\0`);
+  return hash3.digest("hex");
+};
+function swapIn(staging, dest) {
+  const retired = `${staging}.old`;
+  let moved = false;
+  try {
+    try {
+      renameSync4(dest, retired);
+      moved = true;
+    } catch (err) {
+      if (err?.code !== "ENOENT") throw err;
+    }
+    renameSync4(staging, dest);
+    if (moved) rmSync(retired, { recursive: true, force: true });
+  } catch (err) {
+    if (moved && !existsSync8(dest)) renameSync4(retired, dest);
+    throw err;
+  } finally {
+    rmSync(staging, { recursive: true, force: true });
+  }
+}
+var stagingDir = (label) => {
+  const staging = join14(BOTS_DIR, `.${label}.installing-${process.pid}-${Date.now()}`);
+  mkdirSync6(BOTS_DIR, { recursive: true });
+  rmSync(staging, { recursive: true, force: true });
+  return staging;
+};
+function removeAndPrune(root, rel) {
+  rmSync(join14(root, rel), { force: true });
+  for (let dir = path2.dirname(rel); dir && dir !== "."; dir = path2.dirname(dir)) {
+    try {
+      if (readdirSync4(join14(root, dir)).length > 0) return;
+      rmdirSync(join14(root, dir));
+    } catch {
+      return;
+    }
+  }
+}
+function refreshInstalled(name, dest, installed) {
+  const seed = builtinBotSeedDir(name);
+  const seedFiles = fileHashes(seed);
+  const copyFiles = fileHashes(dest);
+  const next4 = { ...installed };
+  const writes = [];
+  const deletes = [];
+  for (const rel of /* @__PURE__ */ new Set([...Object.keys(installed), ...seedFiles.keys()])) {
+    const ours = installed[rel];
+    const shipped = seedFiles.get(rel);
+    const current2 = copyFiles.get(rel);
+    if (ours === void 0) {
+      if (shipped !== void 0 && current2 === void 0) {
+        writes.push(rel);
+        next4[rel] = shipped;
+      }
+      continue;
+    }
+    if (current2 !== ours) continue;
+    if (shipped === void 0) {
+      deletes.push(rel);
+      delete next4[rel];
+    } else if (shipped !== ours) {
+      writes.push(rel);
+      next4[rel] = shipped;
+    }
+  }
+  if (writes.length === 0 && deletes.length === 0) return next4;
+  const staging = stagingDir(name);
+  try {
+    cpSync(dest, staging, { recursive: true });
+    for (const rel of deletes) removeAndPrune(staging, rel);
+    for (const rel of writes) {
+      mkdirSync6(join14(staging, path2.dirname(rel)), { recursive: true });
+      cpSync(join14(seed, rel), join14(staging, rel));
+    }
+    swapIn(staging, dest);
+  } catch (err) {
+    rmSync(staging, { recursive: true, force: true });
+    throw err;
+  }
+  return next4;
+}
+function syncBuiltinBot(name, state) {
+  if (!isBotName(name)) throw new Error(`"${name}" is not a valid built-in Bot name`);
+  const dest = builtinBotUserDir(name);
+  const seed = builtinBotSeedDir(name);
+  if (!hasManifest(seed)) throw new Error(`no built-in Bot named "${name}"`);
+  if (!hasManifest(dest)) {
+    const seedFiles = fileHashes(seed);
+    const staging = stagingDir(name);
+    try {
+      cpSync(seed, staging, { recursive: true });
+      swapIn(staging, dest);
+    } catch (err) {
+      if (!hasManifest(dest)) throw err;
+    }
+    state[name] = { seed: treeHash(seedFiles), files: Object.fromEntries(seedFiles) };
+    return { dir: dest, changed: true };
+  }
+  const record2 = state[name];
+  if (!record2?.files) return { dir: dest, changed: false };
+  const seedHash = treeHash(fileHashes(seed));
+  if (record2.seed === seedHash) return { dir: dest, changed: false };
+  if (existsSync8(join14(dest, ".locks", "write"))) return { dir: dest, changed: false };
+  state[name] = { seed: seedHash, files: refreshInstalled(name, dest, record2.files) };
+  return { dir: dest, changed: true };
+}
+var messageOf2 = (cause3) => cause3 instanceof Error ? cause3.message : String(cause3);
+function parseManifestIn(dir) {
+  try {
+    const content = readFileSync6(join14(dir, BOT_MANIFEST_FILE), "utf-8");
+    return { ok: true, ...parseBotDocument(path2, content, dir) };
+  } catch (err) {
+    return { ok: false, error: messageOf2(err) };
+  }
+}
+function builtinBotHome(name, state) {
+  try {
+    return { ...syncBuiltinBot(name, state), installed: true };
+  } catch (err) {
+    console.error(`[bots] cannot install builtin Bot "${name}" into ${BOTS_DIR} \u2014 using the read-only copy:`, err);
+    return { dir: builtinBotSeedDir(name), installed: false, changed: false };
+  }
+}
+function listBuiltinBots() {
+  let dirs;
+  try {
+    dirs = readdirSync4(BUILTIN_BOTS_SRC_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort();
+  } catch (err) {
+    const code = err?.code;
+    if (code !== "ENOENT") {
+      console.error(
+        `[bots] cannot read builtin bots dir ${BUILTIN_BOTS_SRC_DIR} \u2014 all builtin Bots are unavailable:`,
+        err
+      );
+    }
+    return [];
+  }
+  const state = readInstallState();
+  let stateChanged = false;
+  const bots = [];
+  for (const dir of dirs) {
+    if (!hasManifest(builtinBotSeedDir(dir))) continue;
+    if (!isBotName(dir)) {
+      console.error(`[bots] builtin Bot directory "${dir}" is not a usable Bot name and was skipped`);
+      continue;
+    }
+    if (!hasManifest(builtinBotUserDir(dir))) {
+      const seed = parseManifestIn(builtinBotSeedDir(dir));
+      if (!seed.ok) {
+        console.error(`[bots] builtin Bot "${dir}" is not usable and was skipped: ${seed.error}`);
+        continue;
+      }
+    }
+    const { dir: home, installed, changed } = builtinBotHome(dir, state);
+    stateChanged ||= changed;
+    const manifest = parseManifestIn(home);
+    const base = { id: `${BUILTIN_BOT_ID_PREFIX}${dir}`, path: home, addedAt: "", builtin: true };
+    if (manifest.ok) {
+      bots.push({ ...base, valid: true, name: manifest.name, description: manifest.description });
+    } else if (installed) {
+      bots.push({ ...base, valid: false, name: dir, error: manifest.error });
+    } else {
+      console.error(`[bots] builtin Bot "${dir}" became unreadable and was skipped: ${manifest.error}`);
+    }
+  }
+  if (stateChanged) writeInstallState(state);
+  return bots;
+}
+var realpathOr = (target) => {
+  try {
+    return realpathSync2.native(target);
+  } catch {
+    return target;
+  }
+};
+function findBuiltinBotByPath(dir) {
+  const target = realpathOr(dir);
+  return listBuiltinBots().find((bot) => {
+    const candidates = [bot.path, builtinBotSeedDir(builtinBotNameFromId(bot.id))];
+    return candidates.some((candidate) => candidate === dir || realpathOr(candidate) === target);
+  });
+}
+
+// packages/feature/agent/src/effect/botRegistryLive.ts
+var EMPTY_REGISTRY = { bots: [] };
+var readRegistry = () => readJsonFileForUpdate(BOTS_FILE, EMPTY_REGISTRY);
+var readManifest = (manifestPath) => readFileSync7(manifestPath, "utf8");
+var resolveRegisteredBots = (registry3) => registry3.bots.map((record2) => resolveBot(path3, record2, readManifest));
+var invalidPath = (reason) => new ValidationError({ field: "path", reason });
+var fsReason = (what, target, cause3) => {
+  const code = cause3?.code;
+  if (!code || code === "ENOENT") return invalidPath(`${what} not found: ${target}`);
+  const detail = cause3 instanceof Error ? cause3.message : String(cause3);
+  return invalidPath(`cannot read ${target} (${code}): ${detail}`);
+};
+var mergeBuiltins = (registered) => {
+  const builtins = listBuiltinBots();
+  const builtinPaths = new Set(
+    builtins.flatMap((bot) => [bot.path, builtinBotSeedDir(builtinBotNameFromId(bot.id))])
+  );
+  return [...builtins, ...registered.filter((bot) => !builtinPaths.has(bot.path))];
+};
+var listBots = Effect_exports.tryPromise({
+  try: async () => mergeBuiltins(resolveRegisteredBots(await readRegistry())),
+  catch: (cause3) => new FSError({ path: BOTS_FILE, op: "read", cause: cause3 })
+});
+var addBot = (inputPath) => Effect_exports.gen(function* () {
+  const trimmed = inputPath.trim();
+  if (!trimmed) return yield* Effect_exports.fail(invalidPath("missing"));
+  if (!path3.isAbsolute(trimmed)) return yield* Effect_exports.fail(invalidPath("must be absolute"));
+  const requested = botPaths(path3, trimmed).dir;
+  const dir = yield* Effect_exports.try({
+    try: () => realpathSync3.native(requested),
+    catch: (cause3) => fsReason("directory", requested, cause3)
+  });
+  const builtin = findBuiltinBotByPath(dir);
+  if (builtin) return { ...builtin, alreadyExists: true };
+  const manifestPath = botPaths(path3, dir).manifest;
+  const content = yield* Effect_exports.try({
+    try: () => readManifest(manifestPath),
+    catch: (cause3) => fsReason("BOT.md", manifestPath, cause3)
+  });
+  const manifest = yield* Effect_exports.try({
+    try: () => parseBotDocument(path3, content, dir),
+    catch: (cause3) => invalidPath(cause3 instanceof Error ? cause3.message : String(cause3))
+  });
+  const outcome = yield* Effect_exports.tryPromise({
+    try: () => withFileLock(BOTS_FILE, async () => {
+      const registry3 = await readRegistry();
+      const existing = registry3.bots.find((bot) => bot.path === dir);
+      if (existing) return { kind: "existing", bot: resolveBot(path3, existing, readManifest) };
+      const clash = findNameClash(mergeBuiltins(resolveRegisteredBots(registry3)), manifest.name, dir);
+      if (clash) return { kind: "clash", bot: clash };
+      const record2 = { id: `bot-${randomUUID5()}`, path: dir, addedAt: (/* @__PURE__ */ new Date()).toISOString() };
+      await writeJsonFile(BOTS_FILE, { bots: [...registry3.bots, record2] });
+      return { kind: "added", record: record2 };
+    }),
+    catch: (cause3) => new FSError({ path: BOTS_FILE, op: "write", cause: cause3 })
+  });
+  switch (outcome.kind) {
+    case "existing":
+      return { ...outcome.bot, alreadyExists: true };
+    case "clash":
+      return yield* Effect_exports.fail(invalidPath(`@${manifest.name} is already registered at ${outcome.bot.path}`));
+    case "added":
+      return { ...outcome.record, valid: true, ...manifest, alreadyExists: false };
+  }
+});
+var removeBot = (id3) => Effect_exports.gen(function* () {
+  if (isBuiltinBotId(id3)) {
+    return yield* Effect_exports.fail(new ValidationError({ field: "id", reason: "built-in Bots cannot be removed" }));
+  }
+  const removed = yield* Effect_exports.tryPromise({
+    try: () => withFileLock(BOTS_FILE, async () => {
+      const registry3 = await readRegistry();
+      if (!registry3.bots.some((bot) => bot.id === id3)) return false;
+      await writeJsonFile(BOTS_FILE, { bots: registry3.bots.filter((bot) => bot.id !== id3) });
+      return true;
+    }),
+    catch: (cause3) => new FSError({ path: BOTS_FILE, op: "write", cause: cause3 })
+  });
+  if (!removed) return yield* Effect_exports.fail(new NotFoundError({ resource: "bot", id: id3 }));
+});
+var BotRegistryServiceLive = Layer_exports.succeed(BotRegistryService, {
+  list: listBots,
+  add: addBot,
+  remove: removeBot
+});
+
 // packages/shared/effect-runtime/src/server/runtime.ts
 var isDev = process.env.COCKPIT_ENV === "dev";
 var ServerBaseLayer = Layer_exports.unwrapEffect(
@@ -49840,7 +50260,9 @@ var AppLayer = Layer_exports.mergeAll(
   // Cross-project session search (/api/sessions/search)
   SessionSearchServiceLive,
   // Fire-and-forget sub-task sessions + session status (/api/sessions/delegate, /status)
-  DelegationServiceLive
+  DelegationServiceLive,
+  // User-registered Bot directories (bot.json)
+  BotRegistryServiceLive
 );
 var AppRuntime = ManagedRuntime_exports.make(AppLayer);
 
@@ -49947,16 +50369,16 @@ function snapshotOnRunEvent(cwd, sessionKey, provider, event) {
 }
 
 // packages/feature/agent/src/server/lib/slashCommands.ts
-import { mkdirSync as mkdirSync6, writeFileSync as writeFileSync6, readFileSync as readFileSync7 } from "fs";
-import { join as join15 } from "path";
+import { mkdirSync as mkdirSync7, writeFileSync as writeFileSync7, readFileSync as readFileSync9 } from "fs";
+import path4, { join as join16 } from "path";
 
 // packages/feature/agent/src/server/lib/builtinSkills.ts
-import { readFileSync as readFileSync6, readdirSync as readdirSync4, statSync as statSync5 } from "fs";
-import { join as join14 } from "path";
+import { readFileSync as readFileSync8, readdirSync as readdirSync5, statSync as statSync6 } from "fs";
+import { join as join15 } from "path";
 function listBuiltinSkillNames() {
   let entries2;
   try {
-    entries2 = readdirSync4(BUILTIN_SKILLS_SRC_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+    entries2 = readdirSync5(BUILTIN_SKILLS_SRC_DIR, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
   } catch (err) {
     console.error(
       `[skills] cannot read builtin skills dir ${BUILTIN_SKILLS_SRC_DIR} \u2014 all builtin slash commands are unavailable:`,
@@ -49966,18 +50388,32 @@ function listBuiltinSkillNames() {
   }
   return entries2.filter((name) => {
     try {
-      return statSync5(builtinSkillPath(name)).isFile();
+      return statSync6(builtinSkillPath(name)).isFile();
     } catch {
       return false;
     }
   }).sort();
 }
 function builtinSkillPath(name) {
-  return join14(BUILTIN_SKILLS_SRC_DIR, name, "SKILL.md");
+  return join15(BUILTIN_SKILLS_SRC_DIR, name, "SKILL.md");
+}
+function listBuiltinSkillExtras(name) {
+  try {
+    return readdirSync5(join15(BUILTIN_SKILLS_SRC_DIR, name), { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".md") && e.name !== "SKILL.md").map((e) => e.name).sort();
+  } catch {
+    return [];
+  }
+}
+function readBuiltinSkillExtra(name, file2) {
+  try {
+    return readFileSync8(join15(BUILTIN_SKILLS_SRC_DIR, name, file2), "utf-8");
+  } catch {
+    return null;
+  }
 }
 function readBuiltinSkill(name) {
   try {
-    return readFileSync6(builtinSkillPath(name), "utf-8");
+    return readFileSync8(builtinSkillPath(name), "utf-8");
   } catch {
     return null;
   }
@@ -49990,27 +50426,39 @@ function readFrontmatterField(text, field) {
 }
 
 // packages/feature/agent/src/server/lib/slashCommands.ts
-var BUILTIN_SKILLS_OUT_DIR = join15(COCKPIT_DIR, "skills");
+var BUILTIN_SKILLS_OUT_DIR = join16(COCKPIT_DIR, "skills");
 function deriveBaseUrl() {
   const port3 = process.env.COCKPIT_PORT || process.env.PORT || "3457";
   return `http://localhost:${port3}`;
 }
-var COMMAND_LINE_RE = /^\s*([/@])(\S+?)(?:\s+|$)/;
+var COMMAND_LINE_RE = /^\s*(\/@|\/|@)(\S+?)(?:\s+|$)/;
 function resolveCommandPrompt(prompt, language = "en", _req) {
   const lang = language.startsWith("zh") ? "zh" : "en";
   const userSkills = listUserSkills();
   const builtins = new Set(listBuiltinSkillNames());
-  const isKnown = (cmd) => builtins.has(cmd) || userSkills.some((s) => s.name === cmd);
+  const { bots, corrupt: registryCorrupt } = listRegisteredBots();
+  const isKnown = (marker, cmd) => marker === "@" ? bots.has(cmd) : builtins.has(cmd) || userSkills.some((s) => s.name === cmd);
+  const unresolved = [];
   const lines = prompt.split("\n");
   const cmds = [];
   lines.forEach((line, i) => {
     const m = line.match(COMMAND_LINE_RE);
-    if (m && isKnown(m[2])) {
-      cmds.push({ i, marker: m[1], cmd: m[2], rest: line.slice(m[0].length).trim() });
+    if (!m) return;
+    const marker = m[1];
+    if (isKnown(marker, m[2])) {
+      cmds.push({ i, marker, cmd: m[2], rest: line.slice(m[0].length).trim() });
+      return;
+    }
+    if (marker !== "@") return;
+    if (builtins.has(m[2]) || userSkills.some((s) => s.name === m[2])) {
+      console.warn(`[skills] "@${m[2]}" is not a registered Bot; the subagent form is now "/@${m[2]}" \u2014 left as plain text`);
+      unresolved.push(`@${m[2]} \u2192 the subagent form for a skill is now /@${m[2]}`);
+    } else if (registryCorrupt) {
+      unresolved.push(`@${m[2]} \u2192 could not be resolved: ${BOTS_FILE} does not parse`);
     }
   });
-  if (cmds.length === 0) return prompt;
-  const showLocus = cmds.length >= 2 || cmds.some((c) => c.marker === "@");
+  if (cmds.length === 0) return appendUnresolvedNote(prompt, unresolved, lang);
+  const showLocus = cmds.length >= 2 || cmds.some((c) => c.marker !== "/");
   const baseUrl = deriveBaseUrl();
   const rendered = /* @__PURE__ */ new Map();
   const consumed = /* @__PURE__ */ new Set();
@@ -50025,29 +50473,58 @@ function resolveCommandPrompt(prompt, language = "en", _req) {
       bodyLines.push(lines[j].trim());
       consumed.add(j);
     }
-    const ref = resolveSkillRef(c.cmd, baseUrl, userSkills);
+    const ref = c.marker === "@" ? { name: `@${c.cmd}`, path: bots.get(c.cmd), content: null } : resolveSkillRef(c.cmd, baseUrl, userSkills);
     rendered.set(c.i, renderCommandLine(c.marker, ref, bodyLines.join("\n"), lang, showLocus));
     if (ref.path && !seen.has(ref.name)) {
       seen.add(ref.name);
-      listed.push({ name: ref.name, path: ref.path });
+      listed.push({ name: ref.name, path: ref.path, kind: c.marker === "@" ? "handoff" : "read" });
     }
   });
+  let botRunInline = null;
+  if (cmds.some((c) => c.marker === "@")) {
+    const run6 = resolveSkillRef("bot-run", baseUrl, userSkills);
+    if (run6.path && !seen.has(run6.name)) {
+      seen.add(run6.name);
+      listed.push({ name: run6.name, path: run6.path, kind: "read" });
+    } else if (!run6.path) {
+      botRunInline = run6.content;
+    }
+    const turn = resolveSkillRef("bot-turn", baseUrl, userSkills);
+    if (turn.path && !seen.has(turn.name)) {
+      seen.add(turn.name);
+      listed.unshift({ name: turn.name, path: turn.path, kind: "handoff" });
+    }
+  }
   const out = [];
   for (let i = 0; i < lines.length; i++) {
     if (consumed.has(i)) continue;
     out.push(rendered.get(i) ?? lines[i]);
   }
   let result = out.join("\n");
-  if (listed.length > 0) {
-    const header = lang === "zh" ? "\u8BF7\u5148\u8BFB\u53D6\u4EE5\u4E0B skill \u6587\u4EF6\uFF0C\u518D\u636E\u6B64\u6267\u884C\uFF1A" : "Read these skill files first, then act accordingly:";
+  const block = (kind, header) => {
+    const items = listed.filter((s) => s.kind === kind);
+    if (items.length === 0) return null;
     const sep2 = lang === "zh" ? "\uFF1A" : ": ";
-    const entries2 = listed.map((s) => `- ${s.name}${sep2}${s.path}`).join("\n");
-    result = `${result}
+    return `${header}
+${items.map((s) => `- ${s.name}${sep2}${s.path}`).join("\n")}`;
+  };
+  const blocks = [
+    block("read", lang === "zh" ? "\u8BF7\u5148\u8BFB\u53D6\u4EE5\u4E0B skill \u6587\u4EF6\uFF0C\u518D\u636E\u6B64\u6267\u884C\uFF1A" : "Read these skill files first, then act accordingly:"),
+    block("handoff", lang === "zh" ? "\u4EE5\u4E0B\u6587\u4EF6\u4EA4\u7ED9\u4F60\u6D3E\u53D1\u7684\u5B50\u4F1A\u8BDD\u53BB\u8BFB\uFF0C\u4F60\u53EA\u8F6C\u4EA4\u8DEF\u5F84\uFF0C\u4E0D\u8981\u81EA\u5DF1\u6253\u5F00\uFF1A" : "These files are for the session you delegate to. Pass the paths along; do not open them yourself:"),
+    botRunInline
+  ].filter((b) => b !== null);
+  if (blocks.length > 0) result = `${result}
+
+${blocks.join("\n\n")}`;
+  return appendUnresolvedNote(result, unresolved, lang);
+}
+function appendUnresolvedNote(result, unresolved, lang) {
+  if (unresolved.length === 0) return result;
+  const header = lang === "zh" ? "\u4EE5\u4E0B @ \u5F00\u5934\u7684\u884C\u6CA1\u6709\u88AB\u8BC6\u522B\uFF0C\u5DF2\u6309\u666E\u901A\u6587\u672C\u5904\u7406\uFF0C\u8BF7\u544A\u77E5\u7528\u6237\uFF1A" : "These @ lines were not recognised and were left as plain text. Tell the user:";
+  return `${result}
 
 ${header}
-${entries2}`;
-  }
-  return result;
+${unresolved.map((u) => `- ${u}`).join("\n")}`;
 }
 function renderCommandLine(marker, ref, body, lang, showLocus) {
   if (ref.path) {
@@ -50059,7 +50536,7 @@ function renderCommandLine(marker, ref, body, lang, showLocus) {
   return `${locus}${ref.content ?? ""}${then}`;
 }
 function locusWord(marker, lang) {
-  if (marker === "@") return "subagent";
+  if (marker !== "/") return "subagent";
   return lang === "zh" ? "\u4E3B\u4F1A\u8BDD" : "main session";
 }
 function resolveSkillRef(cmd, baseUrl, userSkills) {
@@ -50070,13 +50547,13 @@ function resolveSkillRef(cmd, baseUrl, userSkills) {
     console.error(`[skills] builtin "${cmd}" disappeared while resolving it`);
     return { name: cmd, path: null, content: null };
   }
-  const content = source.replaceAll("{{BASE_URL}}", baseUrl);
-  const skillPath = writeBuiltinSkill(cmd, content);
+  const content = substitute(source, baseUrl);
+  const skillPath = writeBuiltinSkill(cmd, content, baseUrl);
   return skillPath ? { name: cmd, path: skillPath, content: null } : { name: cmd, path: null, content };
 }
 function listUserSkills() {
   try {
-    const data = JSON.parse(readFileSync7(SKILLS_FILE, "utf-8"));
+    const data = JSON.parse(readFileSync9(SKILLS_FILE, "utf-8"));
     const out = [];
     for (const s of data.skills ?? []) {
       const name = readSkillName(s.path);
@@ -50087,28 +50564,58 @@ function listUserSkills() {
     return [];
   }
 }
-function readSkillName(path2) {
+function listRegisteredBots() {
+  const builtins = listBuiltinBots();
+  const withBuiltins = (registered) => mentionableBots(path4, [...builtins, ...registered]);
+  let raw;
   try {
-    return readFrontmatterField(readFileSync7(path2, "utf-8"), "name");
+    raw = readFileSync9(BOTS_FILE, "utf-8");
+  } catch {
+    return { bots: withBuiltins([]), corrupt: false };
+  }
+  try {
+    const data = JSON.parse(raw);
+    const read = (manifest) => readFileSync9(manifest, "utf-8");
+    return { bots: withBuiltins((data.bots ?? []).map((r) => resolveBot(path4, r, read))), corrupt: false };
+  } catch (err) {
+    console.error(`[skills] ${BOTS_FILE} does not parse \u2014 every registered @bot line is left as plain text:`, err);
+    return { bots: withBuiltins([]), corrupt: true };
+  }
+}
+function readSkillName(path5) {
+  try {
+    return readFrontmatterField(readFileSync9(path5, "utf-8"), "name");
   } catch {
     return null;
   }
 }
-function writeBuiltinSkill(cmd, content) {
+function writeBuiltinSkill(cmd, content, baseUrl) {
   try {
-    const dir = join15(BUILTIN_SKILLS_OUT_DIR, cmd);
-    mkdirSync6(dir, { recursive: true });
-    const filePath = join15(dir, "SKILL.md");
-    writeFileSync6(filePath, content.endsWith("\n") ? content : `${content}
+    const dir = join16(BUILTIN_SKILLS_OUT_DIR, cmd);
+    mkdirSync7(dir, { recursive: true });
+    const filePath = join16(dir, "SKILL.md");
+    writeFileSync7(filePath, content.endsWith("\n") ? content : `${content}
 `, "utf-8");
+    for (const file2 of listBuiltinSkillExtras(cmd)) {
+      const extra = readBuiltinSkillExtra(cmd, file2);
+      if (extra === null) continue;
+      try {
+        writeFileSync7(join16(dir, file2), substitute(extra, baseUrl), "utf-8");
+      } catch (err) {
+        console.error(`[skills] builtin "${cmd}": cannot write reference file ${file2}:`, err);
+      }
+    }
     return filePath;
   } catch {
     return null;
   }
 }
+function substitute(text, baseUrl) {
+  return text.replaceAll("{{BASE_URL}}", baseUrl).replaceAll("{{COCKPIT_DIR}}", COCKPIT_DIR);
+}
 
 // packages/feature/agent/src/server/engines/orchestrator.ts
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 async function dispatchChat2(spec, body, request2) {
   const { sessionId, images, cwd, language } = body;
   if (sessionId && isRunActive(sessionId)) {
@@ -50126,7 +50633,7 @@ async function dispatchChat2(spec, body, request2) {
   }
   const promptText = typeof prompt === "string" ? prompt : void 0;
   const abort = new AbortController();
-  const runId = typeof body.runId === "string" && body.runId || randomUUID5();
+  const runId = typeof body.runId === "string" && body.runId || randomUUID6();
   let currentKey = sessionId || runId;
   let actualSessionId = sessionId;
   let isClosed = false;
@@ -50231,6 +50738,7 @@ export {
   findCodexSessionPath,
   ensureParentDir,
   readJsonFile,
+  readJsonFileForUpdate,
   writeJsonFile,
   withFileLock,
   mutateJsonFile,