@mclawnet/agent 0.6.35 → 0.6.36

package/dist/{chunk-B733MQCA.js → chunk-GOCWMRBB.js}

@@ -1,10 +1,14 @@
+import {
+  collectAgentManifest
+} from "./chunk-VAEFJLPL.js";
 import {
   loadConfig
-} from "./chunk-PJ5M6Q36.js";
+} from "./chunk-376QZ7JB.js";
 
 // src/start.ts
 import { homedir as homedir5 } from "os";
-import { join as join6 } from "path";
+import { join as join7 } from "path";
+import { existsSync as existsSync8 } from "fs";
 
 // src/hub-connection.ts
 import { hostname as osHostname } from "os";
@@ -248,24 +252,164 @@ async function handleLoadSessionHistory(workDir, backendSessionId, opts) {
 
 // src/projects-handler.ts
 import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
-import { existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
-import { TaskStore, projectRoot } from "@mclawnet/task";
+import { dirname, isAbsolute, join as join2, parse, resolve } from "path";
+import { existsSync as existsSync2, mkdirSync, readdirSync as readdirSync2, readFileSync as readFileSync2, statSync as statSync2 } from "fs";
+import { TaskStore, projectRoot, ensureProjectMeta, metaFile, encodeCwd } from "@mclawnet/task";
+import { createLogger } from "@mclawnet/logger";
 import {
   listAllProjectSummaries,
   loadProjectSummary,
   loadSwarmSummaries,
   resolveWorkDir,
   loadSwarmSnapshot,
+  loadShipmentResult,
   InboxStore,
   listProjectFiles,
   readProjectFile,
   writeProjectFile,
-  ProjectFilesError
+  ProjectFilesError,
+  applyShipment,
+  mergeShipment,
+  discardShipment,
+  loadAlwaysOnConfig,
+  saveAlwaysOnConfig,
+  mergeAlwaysOnConfig
 } from "@mclawnet/swarm";
+var log = createLogger({ module: "projects-handler" });
+var FORBIDDEN_WORKDIR_PREFIXES = [
+  "/etc",
+  "/usr",
+  "/bin",
+  "/sbin",
+  "/var",
+  "/private",
+  "/System",
+  "/Library",
+  "/proc",
+  "/sys",
+  "/boot"
+];
+function forbiddenWorkDirPrefix(workDir) {
+  for (const forbidden of FORBIDDEN_WORKDIR_PREFIXES) {
+    if (workDir === forbidden) return forbidden;
+    if (workDir.startsWith(`${forbidden}/`)) return forbidden;
+  }
+  return null;
+}
 function getHome() {
   return process.env.CLAWNET_HOME ?? homedir2();
 }
+function ensureError(status, code, message, details) {
+  return { status, code, message, ...details ? { details } : {} };
+}
+function normalizeExistingWorkDir(input) {
+  const normalized = normalizeAbsoluteNonRootPath(input);
+  if (normalized.error || !normalized.workDir) return normalized;
+  let st;
+  try {
+    st = statSync2(normalized.workDir);
+  } catch (err) {
+    return {
+      error: ensureError(
+        404,
+        "workdir_not_found",
+        "workDir does not exist on disk",
+        { workDir: normalized.workDir, cause: err instanceof Error ? err.message : String(err) }
+      )
+    };
+  }
+  if (!st.isDirectory()) {
+    return { error: ensureError(400, "not_directory", "workDir is not a directory", { workDir: normalized.workDir }) };
+  }
+  return { workDir: normalized.workDir };
+}
+function normalizeAbsoluteNonRootPath(input) {
+  const trimmed = typeof input === "string" ? input.trim() : "";
+  if (!trimmed) return { error: ensureError(400, "invalid_path", "workDir is required") };
+  if (trimmed.length > 4096) {
+    return { error: ensureError(400, "invalid_path", "workDir is too long") };
+  }
+  if (trimmed.includes("\0")) {
+    return { error: ensureError(400, "invalid_path", "workDir contains NUL byte") };
+  }
+  if (!isAbsolute(trimmed)) {
+    return { error: ensureError(400, "invalid_path", "workDir must be an absolute path") };
+  }
+  const parsed = parse(trimmed);
+  const normalized = resolve(trimmed);
+  if (normalized === parsed.root) {
+    return { error: ensureError(400, "root_forbidden", "filesystem root cannot be used as a project") };
+  }
+  const forbiddenPrefix = forbiddenWorkDirPrefix(normalized);
+  if (forbiddenPrefix) {
+    return {
+      error: ensureError(
+        400,
+        "path_forbidden",
+        "workDir is inside a protected system path",
+        { workDir: normalized, forbiddenPrefix }
+      )
+    };
+  }
+  return { workDir: normalized };
+}
+async function handleWorkdirMkdir(workDirInput) {
+  const normalized = normalizeAbsoluteNonRootPath(workDirInput);
+  if (normalized.error || !normalized.workDir) {
+    return { ok: false, error: normalized.error ?? ensureError(400, "invalid_path", "invalid workDir") };
+  }
+  const workDir = normalized.workDir;
+  const parsed = parse(workDir);
+  if (!parsed.base || parsed.base === "." || parsed.base === "..") {
+    return { ok: false, error: ensureError(400, "invalid_path", "invalid directory name", { workDir }) };
+  }
+  let st;
+  try {
+    st = statSync2(workDir);
+    if (st.isDirectory()) {
+      return { ok: true, workDir, created: false, error: null };
+    }
+    return { ok: false, error: ensureError(400, "not_directory", "workDir exists and is not a directory", { workDir }) };
+  } catch {
+  }
+  const parent = dirname(workDir);
+  try {
+    st = statSync2(parent);
+  } catch (err) {
+    return {
+      ok: false,
+      error: ensureError(
+        404,
+        "parent_not_found",
+        "parent directory does not exist",
+        { workDir, parent, cause: err instanceof Error ? err.message : String(err) }
+      )
+    };
+  }
+  if (!st.isDirectory()) {
+    return { ok: false, error: ensureError(400, "parent_not_directory", "parent path is not a directory", { workDir, parent }) };
+  }
+  try {
+    mkdirSync(workDir);
+  } catch (err) {
+    try {
+      if (statSync2(workDir).isDirectory()) {
+        return { ok: true, workDir, created: false, error: null };
+      }
+    } catch {
+    }
+    return {
+      ok: false,
+      error: ensureError(
+        500,
+        "mkdir_failed",
+        "failed to create directory",
+        { workDir, cause: err instanceof Error ? err.message : String(err) }
+      )
+    };
+  }
+  return { ok: true, workDir, created: true, error: null };
+}
 async function handleProjectsList() {
   return { projects: listAllProjectSummaries(getHome()) };
 }
@@ -276,6 +420,61 @@ async function handleProjectsGet(encodedCwd) {
   const swarms = loadSwarmSummaries(home, summary.workDir);
   return { project: { ...summary, swarms } };
 }
+async function handleProjectsEnsureProject(workDirInput, opts = {}) {
+  if (opts.createDir) {
+    return {
+      ok: false,
+      project: null,
+      error: ensureError(
+        400,
+        "create_dir_unsupported",
+        "createDir is not supported by this agent; create/select an existing directory first"
+      )
+    };
+  }
+  const normalized = normalizeExistingWorkDir(workDirInput);
+  if (normalized.error || !normalized.workDir) {
+    return { ok: false, project: null, error: normalized.error ?? ensureError(400, "invalid_path", "invalid workDir") };
+  }
+  const home = getHome();
+  const encodedCwd = encodeCwd(normalized.workDir);
+  const metaPath = metaFile(normalized.workDir, home);
+  const existedBefore = existsSync2(metaPath);
+  try {
+    ensureProjectMeta(normalized.workDir, home);
+  } catch (err) {
+    return {
+      ok: false,
+      project: null,
+      encodedCwd,
+      workDir: normalized.workDir,
+      error: ensureError(
+        500,
+        "meta_write_failed",
+        "failed to write project meta",
+        { cause: err instanceof Error ? err.message : String(err) }
+      )
+    };
+  }
+  const project = loadProjectSummary(home, encodedCwd);
+  if (!project) {
+    return {
+      ok: false,
+      project: null,
+      encodedCwd,
+      workDir: normalized.workDir,
+      error: ensureError(500, "project_load_failed", "project meta was written but summary could not be loaded")
+    };
+  }
+  return {
+    ok: true,
+    project,
+    encodedCwd,
+    workDir: normalized.workDir,
+    createdMeta: !existedBefore,
+    error: null
+  };
+}
 async function handleProjectsTasks(encodedCwd, filters = {}) {
   const home = getHome();
   const workDir = resolveWorkDir(home, encodedCwd);
@@ -412,12 +611,247 @@ async function handleProjectsFileWrite(encodedCwd, relPath, content, ifMatchEtag
     };
   }
 }
+var SHIPMENT_INLINE_MAX_BYTES = 1024 * 1024;
+function tryReadInline(path) {
+  if (!path) return void 0;
+  try {
+    const st = statSync2(path);
+    if (!st.isFile() || st.size >= SHIPMENT_INLINE_MAX_BYTES) return void 0;
+    return readFileSync2(path, "utf-8");
+  } catch {
+    return void 0;
+  }
+}
+async function handleProjectsShipmentGet(encodedCwd, swarmId) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, shipment: null };
+  const shipment = loadShipmentResult(workDir, swarmId);
+  if (!shipment) {
+    return { projectFound: true, shipment: null };
+  }
+  const diffContent = tryReadInline(shipment.diffPath);
+  const reportContent = tryReadInline(shipment.reportPath);
+  return {
+    projectFound: true,
+    shipment,
+    ...diffContent !== void 0 ? { diffContent } : {},
+    ...reportContent !== void 0 ? { reportContent } : {}
+  };
+}
+async function handleProjectsShipmentDiffFull(encodedCwd, swarmId) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, content: null };
+  const shipment = loadShipmentResult(workDir, swarmId);
+  if (!shipment || !shipment.diffPath) {
+    return { projectFound: true, content: null };
+  }
+  try {
+    const st = statSync2(shipment.diffPath);
+    if (!st.isFile()) return { projectFound: true, content: null };
+    return { projectFound: true, content: readFileSync2(shipment.diffPath, "utf-8") };
+  } catch {
+    return { projectFound: true, content: null };
+  }
+}
+var inflightShipmentActions = /* @__PURE__ */ new Map();
+async function handleProjectsShipmentAction(encodedCwd, swarmId, action, force) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, ok: false, error: "project not found" };
+  const existing = inflightShipmentActions.get(swarmId);
+  if (existing) {
+    const r2 = await existing;
+    return { projectFound: true, ...r2 };
+  }
+  const runAction = async () => {
+    if (action === "merge") return mergeShipment({ workDir, swarmId });
+    if (action === "apply") return applyShipment({ workDir, swarmId, force });
+    if (action === "discard") return discardShipment({ workDir, swarmId });
+    return { ok: false, error: `unknown action: ${action}` };
+  };
+  const promise = runAction().finally(() => {
+    inflightShipmentActions.delete(swarmId);
+  });
+  inflightShipmentActions.set(swarmId, promise);
+  const r = await promise;
+  return { projectFound: true, ...r };
+}
+async function handleProjectsShipmentsList(encodedCwd) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false, shipments: [] };
+  const swarmsDir = join2(projectRoot(workDir, home), "swarms");
+  if (!existsSync2(swarmsDir)) return { projectFound: true, shipments: [] };
+  let entries;
+  try {
+    entries = readdirSync2(swarmsDir, { withFileTypes: true });
+  } catch (err) {
+    log.warn(
+      { err: err instanceof Error ? err.message : String(err), swarmsDir },
+      "shipments_list: readdir failed; returning empty list"
+    );
+    return { projectFound: true, shipments: [] };
+  }
+  const shipments = [];
+  for (const ent of entries) {
+    if (!ent.isDirectory()) continue;
+    const shipmentPath = join2(swarmsDir, ent.name, "shipment.json");
+    if (!existsSync2(shipmentPath)) continue;
+    try {
+      const data = JSON.parse(readFileSync2(shipmentPath, "utf-8"));
+      shipments.push({ swarmId: ent.name, shipment: data });
+    } catch (err) {
+      log.warn(
+        { err: err instanceof Error ? err.message : String(err), swarmId: ent.name },
+        "shipments_list: parse failed for one swarm; skipping"
+      );
+    }
+  }
+  shipments.sort((a, b) => {
+    const aT = a.shipment.createdAt ?? "";
+    const bT = b.shipment.createdAt ?? "";
+    return bT.localeCompare(aT);
+  });
+  return { projectFound: true, shipments };
+}
+var EMPTY_ALWAYS_ON_SNAPSHOT = {
+  mode: "off",
+  ticksToday: 0,
+  lastFireAt: null,
+  nextTickAt: null,
+  recentTicks: []
+};
+var alwaysOnHooks = {
+  getSnapshot: () => null,
+  applyConfig: () => {
+  },
+  recordActivity: () => {
+  }
+  // forceTick left undefined: handler returns projectFound=false when null
+};
+function _registerAlwaysOnHooks(hooks) {
+  alwaysOnHooks = {
+    getSnapshot: hooks.getSnapshot ?? (() => null),
+    applyConfig: hooks.applyConfig ?? (() => void 0),
+    recordActivity: hooks.recordActivity ?? (() => void 0),
+    ...hooks.forceTick ? { forceTick: hooks.forceTick } : {}
+  };
+}
+function _recordAlwaysOnActivity() {
+  try {
+    alwaysOnHooks.recordActivity();
+  } catch (err) {
+    log.warn(
+      { err: err instanceof Error ? err.message : String(err) },
+      "always-on recordActivity hook threw; ignored"
+    );
+  }
+}
+function snapshotForProject(workDir) {
+  const live = alwaysOnHooks.getSnapshot(workDir);
+  return live ?? EMPTY_ALWAYS_ON_SNAPSHOT;
+}
+async function handleProjectsAlwaysOnGet(encodedCwd) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) {
+    return {
+      projectFound: false,
+      config: { mode: "off", dailyBudget: 3 },
+      snapshot: EMPTY_ALWAYS_ON_SNAPSHOT
+    };
+  }
+  const config = loadAlwaysOnConfig(workDir, home);
+  return { projectFound: true, config, snapshot: snapshotForProject(workDir) };
+}
+async function handleProjectsAlwaysOnSet(encodedCwd, patch) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) {
+    return {
+      projectFound: false,
+      config: { mode: "off", dailyBudget: 3 },
+      snapshot: EMPTY_ALWAYS_ON_SNAPSHOT
+    };
+  }
+  const current = loadAlwaysOnConfig(workDir, home);
+  const next = mergeAlwaysOnConfig(current, patch);
+  try {
+    saveAlwaysOnConfig(workDir, home, next);
+  } catch (err) {
+    return {
+      projectFound: true,
+      config: current,
+      snapshot: snapshotForProject(workDir),
+      error: err instanceof Error ? err.message : String(err)
+    };
+  }
+  try {
+    alwaysOnHooks.applyConfig(workDir, next);
+  } catch (err) {
+    log.warn(
+      { err: err instanceof Error ? err.message : String(err) },
+      "always-on applyConfig hook threw; config was persisted"
+    );
+  }
+  return {
+    projectFound: true,
+    config: next,
+    snapshot: snapshotForProject(workDir)
+  };
+}
+async function handleProjectsAlwaysOnTickNow(encodedCwd) {
+  const home = getHome();
+  const workDir = resolveWorkDir(home, encodedCwd);
+  if (!workDir) return { projectFound: false };
+  if (!alwaysOnHooks.forceTick) {
+    return {
+      projectFound: true,
+      error: "always-on manager not wired (forceTick unavailable)"
+    };
+  }
+  try {
+    const out = await alwaysOnHooks.forceTick(workDir);
+    if (!out) {
+      return {
+        projectFound: true,
+        error: "always-on scheduler not booted for this project (enable always-on via PATCH /api/projects/:id/always-on first)"
+      };
+    }
+    return {
+      projectFound: true,
+      decision: out.record.decision,
+      gateBreakdown: out.record.gateBreakdown,
+      snapshot: out.snapshot
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (msg.includes("no scheduler for")) {
+      return {
+        projectFound: true,
+        error: "always-on scheduler not booted for this project (enable always-on via PATCH /api/projects/:id/always-on first)"
+      };
+    }
+    if (msg.includes("tick is already in progress")) {
+      return {
+        projectFound: true,
+        error: `another tick is currently in flight \u2014 wait for the runner to finish or check the agent log (underlying: ${msg})`
+      };
+    }
+    return {
+      projectFound: true,
+      error: `force-tick failed: ${msg}`
+    };
+  }
+}
 
 // src/swarm-control-dispatch.ts
 import { randomUUID } from "crypto";
-import { createLogger } from "@mclawnet/logger";
+import { createLogger as createLogger2 } from "@mclawnet/logger";
 import { InboxStore as InboxStore2 } from "@mclawnet/swarm";
-var log = createLogger({ module: "agent/swarm-control" });
+var log2 = createLogger2({ module: "agent/swarm-control" });
 var MAX_ROLES_PER_SWARM = 20;
 async function handleSwarmControl(coord, msg, opts) {
   if (!msg || msg.type !== "swarm_spawn" && msg.type !== "swarm_resume" && msg.type !== "swarm_add_role") {
@@ -426,11 +860,11 @@ async function handleSwarmControl(coord, msg, opts) {
   if (msg.type === "swarm_resume") {
     try {
       await coord.recover(msg.swarmId);
-      log.info({ swarmId: msg.swarmId }, "swarm_resume: recovered");
+      log2.info({ swarmId: msg.swarmId }, "swarm_resume: recovered");
       return { ok: true, swarmId: msg.swarmId };
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
-      log.error({ err, swarmId: msg.swarmId }, "swarm_resume failed");
+      log2.error({ err, swarmId: msg.swarmId }, "swarm_resume failed");
       return { ok: false, error };
     }
   }
@@ -467,14 +901,14 @@ async function handleSwarmControl(coord, msg, opts) {
         taskPrompt: msg.taskPrompt,
         isDynamicAdd: true
       });
-      log.info(
+      log2.info(
         { swarmId: msg.swarmId, roleName: msg.roleName, instanceId: role.instanceId },
         "swarm_add_role: spawned"
       );
       return { ok: true, swarmId: msg.swarmId, instanceId: role.instanceId };
     } catch (err) {
       const error = err instanceof Error ? err.message : String(err);
-      log.error({ err, swarmId: msg.swarmId, roleName: msg.roleName }, "swarm_add_role failed");
+      log2.error({ err, swarmId: msg.swarmId, roleName: msg.roleName }, "swarm_add_role failed");
       return { ok: false, error };
     }
   }
@@ -484,7 +918,7 @@ async function handleSwarmControl(coord, msg, opts) {
     await coord.create(swarmId, { workDir, templateName: msg.teamName, displayName: msg.displayName });
   } catch (err) {
     const error = err instanceof Error ? err.message : String(err);
-    log.error({ err, teamName: msg.teamName }, "swarm_spawn: create failed");
+    log2.error({ err, teamName: msg.teamName }, "swarm_spawn: create failed");
     return { ok: false, error };
   }
   if (msg.msg && msg.msg.length > 0) {
@@ -503,20 +937,28 @@ async function handleSwarmControl(coord, msg, opts) {
         });
         await coord.inboxRelay.deliver(swarmId, queen.instanceId);
       } catch (err) {
-        log.warn({ err, swarmId }, "swarm_spawn: inbox seed failed (non-fatal)");
+        log2.warn({ err, swarmId }, "swarm_spawn: inbox seed failed (non-fatal)");
       }
     } else {
-      log.warn({ swarmId, hasSwarm: !!swarm, hasQueen: !!queen }, "swarm_spawn: queen instance not found, skipping inbox seed");
+      log2.warn({ swarmId, hasSwarm: !!swarm, hasQueen: !!queen }, "swarm_spawn: queen instance not found, skipping inbox seed");
     }
   }
-  log.info({ swarmId, teamName: msg.teamName }, "swarm_spawn: created");
+  log2.info({ swarmId, teamName: msg.teamName }, "swarm_spawn: created");
   return { ok: true, swarmId };
 }
 
 // src/hub-connection.ts
-import { createLogger as createLogger2, previewFields } from "@mclawnet/logger";
+import { createLogger as createLogger3, previewFields } from "@mclawnet/logger";
 import { DEFAULT_ASSISTANT_ROLE_ID } from "@mclawnet/memory";
-var log2 = createLogger2({ module: "agent" });
+var log3 = createLogger3({ module: "agent" });
+var WAKE_WATCH_INTERVAL_MS = 1e3;
+var WAKE_WATCH_JUMP_THRESHOLD_MS = 15e3;
+function extractErrorCode(err) {
+  if (err && typeof err === "object" && "code" in err && typeof err.code === "string") {
+    return err.code;
+  }
+  return void 0;
+}
 var HubConnection = class {
   ws = null;
   heartbeatTimer = null;
@@ -556,6 +998,9 @@ var HubConnection = class {
   onConnectCb;
   onDisconnect;
   onError;
+  onActivity;
+  /** (N5) Shared WorkspaceManager for chat `useWorktree` flow. */
+  workspaceManager;
   constructor(opts) {
     this.hubUrl = opts.hubUrl;
     this.token = opts.token;
@@ -569,6 +1014,8 @@ var HubConnection = class {
     this.onConnectCb = opts.onConnect;
     this.onDisconnect = opts.onDisconnect;
     this.onError = opts.onError;
+    this.onActivity = opts.onActivity;
+    this.workspaceManager = opts.workspaceManager;
     this.startWakeWatch();
   }
   setSessionManager(manager) {
@@ -620,7 +1067,7 @@ var HubConnection = class {
         return;
       }
       if (this.authState === "pending" && data.type === "auth_required") {
-        log2.info("hub requires auth, sending credentials");
+        log3.info("hub requires auth, sending credentials");
         this.authState = "authenticating";
         this.sendRaw({
           type: "auth",
@@ -632,11 +1079,17 @@ var HubConnection = class {
         return;
       }
       if (this.authState === "authenticating" && data.type === "registered") {
-        log2.info({ agentId: data.agentId }, "registered with hub");
+        log3.info({ agentId: data.agentId }, "registered with hub");
         this.authState = "authenticated";
         this.agentId = data.agentId ?? null;
         this.reconnectDelay = DEFAULT_RECONNECT_MS;
         this.startHeartbeat();
+        collectAgentManifest().then((payload) => {
+          log3.debug({ backends: payload.backends.length }, "sending agent.manifest");
+          this.send({ type: "agent.manifest", payload });
+        }).catch((err) => {
+          log3.warn({ err }, "failed to collect agent manifest \u2014 skipping upload");
+        });
         this.onConnectCb?.(this.agentId);
         this.tryRecoverSwarms();
         this.reportLiveSessions();
@@ -644,9 +1097,20 @@ var HubConnection = class {
       }
       if (this.authState === "authenticated") {
         this.lastAckAt = Date.now();
-        if (data && data.type === "heartbeat_ack") {
+        const protocolType = data.type;
+        if (protocolType === "heartbeat_ack") {
           return;
         }
+        if (protocolType === "ack") {
+          return;
+        }
+        if (this.onActivity) {
+          try {
+            this.onActivity();
+          } catch (err) {
+            log3.warn({ err }, "onActivity callback threw; ignored");
+          }
+        }
         if (this.handleSessionMessage(data)) return;
         this.onMessage?.(data);
       }
@@ -655,19 +1119,19 @@ var HubConnection = class {
       this.lastAckAt = Date.now();
     });
     this.ws.on("close", (code, reason) => {
-      log2.warn({ code, reason: reason.toString() }, "disconnected from hub");
+      log3.warn({ code, reason: reason.toString() }, "disconnected from hub");
       this.stopHeartbeat();
       this.ws = null;
       this.authState = "pending";
       this.onDisconnect?.(code, reason.toString());
       if (code === WS_CLOSE_INVALID_TOKEN) {
-        log2.error("auth failed \u2014 not reconnecting, check your token");
+        log3.error("auth failed \u2014 not reconnecting, check your token");
         return;
       }
       this.scheduleReconnect();
     });
     this.ws.on("error", (err) => {
-      log2.error({ err }, "ws connection error");
+      log3.error({ err }, "ws connection error");
       this.onError?.(err);
       if (this.ws) {
         const dying = this.ws;
@@ -702,11 +1166,11 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "fs.list_dir") {
-      log2.info({ path: msg.path }, "fs.list_dir");
+      log3.info({ path: msg.path }, "fs.list_dir");
       handleListDir(msg.path).then((result) => {
         this.send({ type: "fs.list_dir_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log2.error({ err, path: msg.path }, "fs.list_dir failed");
+        log3.error({ err, path: msg.path }, "fs.list_dir failed");
         this.send({
           type: "fs.list_dir_result",
           requestId: msg.requestId,
@@ -717,21 +1181,21 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "list_folders") {
-      log2.info("list_folders");
+      log3.info("list_folders");
       handleListFolders().then((result) => {
         this.send({ type: "folders_list_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log2.error({ err }, "list_folders failed");
+        log3.error({ err }, "list_folders failed");
         this.send({ type: "folders_list_result", requestId: msg.requestId, folders: [] });
       });
       return true;
     }
     if (msg.type === "list_history_sessions") {
-      log2.info({ workDir: msg.workDir }, "list_history_sessions");
+      log3.info({ workDir: msg.workDir }, "list_history_sessions");
       handleListHistorySessions(msg.workDir).then((result) => {
         this.send({ type: "history_sessions_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log2.error({ err, workDir: msg.workDir }, "list_history_sessions failed");
+        log3.error({ err, workDir: msg.workDir }, "list_history_sessions failed");
         this.send({
           type: "history_sessions_result",
           requestId: msg.requestId,
@@ -742,70 +1206,70 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "load_session_history") {
-      log2.info(
+      log3.info(
         { workDir: msg.workDir, backendSessionId: msg.backendSessionId, before: msg.before, limit: msg.limit },
         "load_session_history"
       );
       handleLoadSessionHistory(msg.workDir, msg.backendSessionId, { before: msg.before, limit: msg.limit }).then((result) => {
         this.send({ type: "session_history_result", requestId: msg.requestId, ...result });
       }).catch((err) => {
-        log2.error({ err, workDir: msg.workDir }, "load_session_history failed");
+        log3.error({ err, workDir: msg.workDir }, "load_session_history failed");
         this.send({ type: "session_history_result", requestId: msg.requestId, messages: [], oldestSeq: 0, hasMore: false });
       });
       return true;
     }
     if (msg.type === "projects.list") {
-      log2.info("projects.list");
+      log3.info("projects.list");
       handleProjectsList().then((r) => this.send({ type: "projects.list_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err }, "projects.list failed");
+        log3.error({ err }, "projects.list failed");
         this.send({ type: "projects.list_result", requestId: msg.requestId, projects: [] });
       });
       return true;
     }
     if (msg.type === "projects.get") {
-      log2.info({ encodedCwd: msg.encodedCwd }, "projects.get");
+      log3.info({ encodedCwd: msg.encodedCwd }, "projects.get");
       handleProjectsGet(msg.encodedCwd).then((r) => this.send({ type: "projects.get_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd }, "projects.get failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd }, "projects.get failed");
         this.send({ type: "projects.get_result", requestId: msg.requestId, project: null });
       });
       return true;
     }
     if (msg.type === "projects.tasks") {
-      log2.info({ encodedCwd: msg.encodedCwd, status: msg.status, swarmId: msg.swarmId, owner: msg.owner }, "projects.tasks");
+      log3.info({ encodedCwd: msg.encodedCwd, status: msg.status, swarmId: msg.swarmId, owner: msg.owner }, "projects.tasks");
       handleProjectsTasks(msg.encodedCwd, { status: msg.status, swarmId: msg.swarmId, owner: msg.owner }).then((r) => this.send({ type: "projects.tasks_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd, status: msg.status, swarmId: msg.swarmId, owner: msg.owner }, "projects.tasks failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd, status: msg.status, swarmId: msg.swarmId, owner: msg.owner }, "projects.tasks failed");
         this.send({ type: "projects.tasks_result", requestId: msg.requestId, tasks: [] });
       });
       return true;
     }
     if (msg.type === "projects.task") {
-      log2.info({ encodedCwd: msg.encodedCwd, taskId: msg.taskId }, "projects.task");
+      log3.info({ encodedCwd: msg.encodedCwd, taskId: msg.taskId }, "projects.task");
       handleProjectsTask(msg.encodedCwd, msg.taskId).then((r) => this.send({ type: "projects.task_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd, taskId: msg.taskId }, "projects.task failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd, taskId: msg.taskId }, "projects.task failed");
         this.send({ type: "projects.task_result", requestId: msg.requestId, task: null });
       });
       return true;
     }
     if (msg.type === "projects.swarms") {
-      log2.info({ encodedCwd: msg.encodedCwd }, "projects.swarms");
+      log3.info({ encodedCwd: msg.encodedCwd }, "projects.swarms");
       handleProjectsSwarms(msg.encodedCwd).then((r) => this.send({ type: "projects.swarms_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd }, "projects.swarms failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd }, "projects.swarms failed");
         this.send({ type: "projects.swarms_result", requestId: msg.requestId, swarms: [] });
       });
       return true;
     }
     if (msg.type === "projects.swarm") {
-      log2.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm");
+      log3.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm");
       handleProjectsSwarm(msg.encodedCwd, msg.swarmId).then((r) => this.send({ type: "projects.swarm_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm failed");
         this.send({ type: "projects.swarm_result", requestId: msg.requestId, snapshot: null, tasks: [] });
       });
       return true;
     }
     if (msg.type === "projects.inboxes") {
-      log2.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.inboxes");
+      log3.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.inboxes");
       handleProjectsInboxes(msg.encodedCwd, msg.swarmId).then((r) => this.send({ type: "projects.inboxes_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.inboxes failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.inboxes failed");
         this.send({
           type: "projects.inboxes_result",
           requestId: msg.requestId,
@@ -817,9 +1281,9 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "projects.inbox") {
-      log2.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId, instanceId: msg.instanceId }, "projects.inbox");
+      log3.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId, instanceId: msg.instanceId }, "projects.inbox");
       handleProjectsInbox(msg.encodedCwd, msg.swarmId, msg.instanceId).then((r) => this.send({ type: "projects.inbox_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId, instanceId: msg.instanceId }, "projects.inbox failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId, instanceId: msg.instanceId }, "projects.inbox failed");
         this.send({
           type: "projects.inbox_result",
           requestId: msg.requestId,
@@ -831,9 +1295,9 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "projects.swarm_session_id") {
-      log2.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm_session_id");
+      log3.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm_session_id");
       handleProjectsSwarmSessionId(msg.encodedCwd, msg.swarmId).then((r) => this.send({ type: "projects.swarm_session_id_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm_session_id failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.swarm_session_id failed");
         this.send({
           type: "projects.swarm_session_id_result",
           requestId: msg.requestId,
@@ -845,17 +1309,17 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "projects.files_list") {
-      log2.info({ encodedCwd: msg.encodedCwd }, "projects.files_list");
+      log3.info({ encodedCwd: msg.encodedCwd }, "projects.files_list");
       handleProjectsFilesList(msg.encodedCwd).then((r) => this.send({ type: "projects.files_list_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd }, "projects.files_list failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd }, "projects.files_list failed");
         this.send({ type: "projects.files_list_result", requestId: msg.requestId, projectFound: false, files: [] });
       });
       return true;
     }
     if (msg.type === "projects.file_read") {
-      log2.info({ encodedCwd: msg.encodedCwd, relPath: msg.relPath }, "projects.file_read");
+      log3.info({ encodedCwd: msg.encodedCwd, relPath: msg.relPath }, "projects.file_read");
       handleProjectsFileRead(msg.encodedCwd, msg.relPath).then((r) => this.send({ type: "projects.file_read_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd, relPath: msg.relPath }, "projects.file_read failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd, relPath: msg.relPath }, "projects.file_read failed");
         this.send({
           type: "projects.file_read_result",
           requestId: msg.requestId,
@@ -867,9 +1331,9 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "projects.file_write") {
-      log2.info({ encodedCwd: msg.encodedCwd, relPath: msg.relPath, hasIfMatch: !!msg.ifMatchEtag }, "projects.file_write");
+      log3.info({ encodedCwd: msg.encodedCwd, relPath: msg.relPath, hasIfMatch: !!msg.ifMatchEtag }, "projects.file_write");
       handleProjectsFileWrite(msg.encodedCwd, msg.relPath, msg.content, msg.ifMatchEtag).then((r) => this.send({ type: "projects.file_write_result", requestId: msg.requestId, ...r })).catch((err) => {
-        log2.error({ err, encodedCwd: msg.encodedCwd, relPath: msg.relPath }, "projects.file_write failed");
+        log3.error({ err, encodedCwd: msg.encodedCwd, relPath: msg.relPath }, "projects.file_write failed");
         this.send({
           type: "projects.file_write_result",
           requestId: msg.requestId,
@@ -880,8 +1344,193 @@ var HubConnection = class {
       });
       return true;
     }
+    if (msg.type === "projects.ensure_project") {
+      log3.info({ workDir: msg.workDir, createDir: msg.createDir }, "projects.ensure_project");
+      handleProjectsEnsureProject(msg.workDir, { createDir: msg.createDir }).then((r) => this.send({ type: "projects.ensure_project_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log3.error({ err, workDir: msg.workDir }, "projects.ensure_project failed");
+        this.send({
+          type: "projects.ensure_project_result",
+          requestId: msg.requestId,
+          ok: false,
+          project: null,
+          error: { status: 500, code: "agent_error", message: "agent error" }
+        });
+      });
+      return true;
+    }
+    if (msg.type === "workdir.mkdir") {
+      log3.info({ workDir: msg.workDir }, "workdir.mkdir");
+      handleWorkdirMkdir(msg.workDir).then((r) => this.send({ type: "workdir.mkdir_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log3.error({ err, workDir: msg.workDir }, "workdir.mkdir failed");
+        this.send({
+          type: "workdir.mkdir_result",
+          requestId: msg.requestId,
+          ok: false,
+          error: { status: 500, code: "agent_error", message: "agent error" }
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.shipment_get") {
+      log3.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.shipment_get");
+      handleProjectsShipmentGet(msg.encodedCwd, msg.swarmId).then((r) => this.send({ type: "projects.shipment_get_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log3.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.shipment_get failed");
+        this.send({
+          type: "projects.shipment_get_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          shipment: null
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.shipment_diff") {
+      log3.info({ encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.shipment_diff");
+      handleProjectsShipmentDiffFull(msg.encodedCwd, msg.swarmId).then((r) => this.send({ type: "projects.shipment_diff_result", requestId: msg.requestId, ...r })).catch((err) => {
+        log3.error({ err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId }, "projects.shipment_diff failed");
+        this.send({
+          type: "projects.shipment_diff_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          content: null
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.shipment_action") {
+      log3.info(
+        { encodedCwd: msg.encodedCwd, swarmId: msg.swarmId, action: msg.action, force: msg.force },
+        "projects.shipment_action"
+      );
+      handleProjectsShipmentAction(msg.encodedCwd, msg.swarmId, msg.action, msg.force).then(
+        (r) => this.send({
+          type: "projects.shipment_action_result",
+          requestId: msg.requestId,
+          ...r
+        })
+      ).catch((err) => {
+        log3.error(
+          { err, encodedCwd: msg.encodedCwd, swarmId: msg.swarmId, action: msg.action },
+          "projects.shipment_action failed"
+        );
+        this.send({
+          type: "projects.shipment_action_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          ok: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.shipments_list") {
+      log3.info({ encodedCwd: msg.encodedCwd }, "projects.shipments_list");
+      handleProjectsShipmentsList(msg.encodedCwd).then(
+        (r) => this.send({
+          type: "projects.shipments_list_result",
+          requestId: msg.requestId,
+          ...r
+        })
+      ).catch((err) => {
+        log3.error(
+          { err, encodedCwd: msg.encodedCwd },
+          "projects.shipments_list failed"
+        );
+        this.send({
+          type: "projects.shipments_list_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          shipments: []
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.always_on_get") {
+      log3.info({ encodedCwd: msg.encodedCwd }, "projects.always_on_get");
+      handleProjectsAlwaysOnGet(msg.encodedCwd).then(
+        (r) => this.send({
+          type: "projects.always_on_get_result",
+          requestId: msg.requestId,
+          ...r
+        })
+      ).catch((err) => {
+        log3.error(
+          { err, encodedCwd: msg.encodedCwd },
+          "projects.always_on_get failed"
+        );
+        this.send({
+          type: "projects.always_on_get_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          config: { mode: "off", dailyBudget: 3 },
+          snapshot: {
+            mode: "off",
+            ticksToday: 0,
+            lastFireAt: null,
+            nextTickAt: null,
+            recentTicks: []
+          }
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.always_on_set") {
+      log3.info(
+        { encodedCwd: msg.encodedCwd, patch: msg.config },
+        "projects.always_on_set"
+      );
+      handleProjectsAlwaysOnSet(msg.encodedCwd, msg.config).then(
+        (r) => this.send({
+          type: "projects.always_on_set_result",
+          requestId: msg.requestId,
+          ...r
+        })
+      ).catch((err) => {
+        log3.error(
+          { err, encodedCwd: msg.encodedCwd },
+          "projects.always_on_set failed"
+        );
+        this.send({
+          type: "projects.always_on_set_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          config: { mode: "off", dailyBudget: 3 },
+          snapshot: {
+            mode: "off",
+            ticksToday: 0,
+            lastFireAt: null,
+            nextTickAt: null,
+            recentTicks: []
+          },
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      return true;
+    }
+    if (msg.type === "projects.always_on_tick_now") {
+      log3.info({ encodedCwd: msg.encodedCwd }, "projects.always_on_tick_now");
+      handleProjectsAlwaysOnTickNow(msg.encodedCwd).then(
+        (r) => this.send({
+          type: "projects.always_on_tick_now_result",
+          requestId: msg.requestId,
+          ...r
+        })
+      ).catch((err) => {
+        log3.error(
+          { err, encodedCwd: msg.encodedCwd },
+          "projects.always_on_tick_now failed"
+        );
+        this.send({
+          type: "projects.always_on_tick_now_result",
+          requestId: msg.requestId,
+          projectFound: false,
+          error: err instanceof Error ? err.message : String(err)
+        });
+      });
+      return true;
+    }
     if (msg.type === "list_roles") {
-      log2.info("list_roles");
+      log3.info("list_roles");
       const roleNames = listRoles();
       const roles = roleNames.map((name) => {
         try {
@@ -907,7 +1556,7 @@ var HubConnection = class {
       return true;
     }
     if (msg.type === "list_templates") {
-      log2.info("list_templates");
+      log3.info("list_templates");
       try {
         const names = listTemplates();
         const templates = names.map((name) => {
@@ -926,7 +1575,7 @@ var HubConnection = class {
           templates
         });
       } catch (err) {
-        log2.error({ err }, "list_templates failed");
+        log3.error({ err }, "list_templates failed");
         this.send({
           type: "templates_list_result",
           sessionId: msg.sessionId,
@@ -938,9 +1587,9 @@ var HubConnection = class {
     if (msg.type === "generic.request") {
       const handler = this.namespaceHandlers.get(msg.namespace);
       if (handler) {
-        log2.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request received");
+        log3.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request received");
         handler(msg).then((result) => {
-          log2.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request handled OK");
+          log3.info({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request handled OK");
           this.send({
             type: "generic.response",
             namespace: msg.namespace,
@@ -949,7 +1598,7 @@ var HubConnection = class {
             requestId: msg.requestId
           });
         }).catch((err) => {
-          log2.error({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId, err }, "generic.request handler error");
+          log3.error({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId, err }, "generic.request handler error");
           this.send({
             type: "generic.response",
             namespace: msg.namespace,
@@ -961,7 +1610,7 @@ var HubConnection = class {
         });
         return true;
       }
-      log2.warn({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request unknown namespace");
+      log3.warn({ namespace: msg.namespace, action: msg.action, requestId: msg.requestId }, "generic.request unknown namespace");
       this.send({
         type: "generic.response",
         namespace: msg.namespace,
@@ -978,9 +1627,9 @@ var HubConnection = class {
         defaultWorkDir: process.cwd(),
         home: process.env.CLAWNET_HOME
       }).then((result) => {
-        log2.info({ type: msg.type, ok: result.ok, swarmId: result.swarmId, error: result.error }, "swarm control handled");
+        log3.info({ type: msg.type, ok: result.ok, swarmId: result.swarmId, error: result.error }, "swarm control handled");
       }).catch((err) => {
-        log2.error({ err, type: msg.type }, "swarm control crashed");
+        log3.error({ err, type: msg.type }, "swarm control crashed");
       });
       return true;
     }
@@ -1009,7 +1658,7 @@ var HubConnection = class {
           ...result.error ? { error: result.error } : {}
         });
       }).catch((err) => {
-        log2.error({ err, swarmId: msg.swarmId }, "projects.swarm_add_role crashed");
+        log3.error({ err, swarmId: msg.swarmId }, "projects.swarm_add_role crashed");
         this.send({
           type: "projects.swarm_add_role_result",
           requestId,
@@ -1022,12 +1671,13 @@ var HubConnection = class {
     if (msg.type === "swarm.execute" && this.swarmCoordinator) {
       const { sessionId, content, workDir, targetInstance, crewConfig } = msg;
       if (this.swarmCoordinator.hasSwarm(sessionId)) {
-        log2.info({ sessionId, targetInstance }, "swarm.execute: forwarding to existing swarm");
+        log3.info({ sessionId, targetInstance }, "swarm.execute: forwarding to existing swarm");
         this.swarmCoordinator.handleUserMessage(sessionId, content, targetInstance).catch((err) => {
           this.send({
             type: "session.error",
             sessionId,
-            error: err instanceof Error ? err.message : String(err)
+            error: err instanceof Error ? err.message : String(err),
+            code: extractErrorCode(err)
           });
         });
       } else if (this.finishedSwarms.has(sessionId)) {
@@ -1036,16 +1686,17 @@ var HubConnection = class {
           const templateName = crewConfig.templateName;
           const roles = crewConfig.roles;
           const displayName = crewConfig.displayName;
-          log2.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: continuing finished swarm");
+          log3.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: continuing finished swarm");
           this.swarmCoordinator.create(sessionId, { workDir, templateName, displayName, roles, task: content, isContinuation: true }).catch((err) => {
             this.send({
               type: "session.error",
               sessionId,
-              error: err instanceof Error ? err.message : String(err)
+              error: err instanceof Error ? err.message : String(err),
+              code: extractErrorCode(err)
             });
           });
         } else {
-          log2.info({ sessionId }, "swarm.execute ignored: swarm finished, no config to recreate");
+          log3.info({ sessionId }, "swarm.execute ignored: swarm finished, no config to recreate");
           this.send({
             type: "session.error",
             sessionId,
@@ -1056,16 +1707,17 @@ var HubConnection = class {
         const templateName = crewConfig.templateName;
         const roles = crewConfig.roles;
         const displayName = crewConfig.displayName;
-        log2.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: creating new swarm");
+        log3.info({ sessionId, templateName, rolesCount: roles?.length }, "swarm.execute: creating new swarm");
         this.swarmCoordinator.create(sessionId, { workDir, templateName, displayName, roles, task: content }).catch((err) => {
           this.send({
             type: "session.error",
             sessionId,
-            error: err instanceof Error ? err.message : String(err)
+            error: err instanceof Error ? err.message : String(err),
+            code: extractErrorCode(err)
           });
         });
       } else {
-        log2.info({ sessionId }, "swarm.execute ignored: swarm not found, no config");
+        log3.info({ sessionId }, "swarm.execute ignored: swarm not found, no config");
         this.send({
           type: "session.error",
           sessionId,
@@ -1077,7 +1729,7 @@ var HubConnection = class {
     if (!this.sessionManager) return false;
     if (msg.type === "abort_execution") {
       const { sessionId } = msg;
-      log2.info({ sessionId }, "abort_execution");
+      log3.info({ sessionId }, "abort_execution");
       if (this.sessionManager?.hasSession(sessionId)) {
         this.sessionManager.abortSession(sessionId).then(() => {
           this.send({ type: "execution_aborted", sessionId });
@@ -1093,11 +1745,11 @@ var HubConnection = class {
       const { sessionId, content, workDir, backendSessionId, useBrainCore } = msg;
       const sm = this.sessionManager;
       const spawnAndSend = (resumeId, label, maxOutputTokens) => {
-        log2.info(
+        log3.info(
           { sessionId, backendSessionId: resumeId, workDir, label, maxOutputTokens },
           "claude.execute: spawning"
         );
-        log2.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
+        log3.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
         sm.createSession({
           sessionId,
           workDir,
@@ -1107,47 +1759,260 @@ var HubConnection = class {
           maxOutputTokens
         }).then(() => {
           sm.sendUserInput(sessionId, content).catch((err) => {
-            log2.warn({ err, sessionId }, "sendUserInput failed");
+            log3.warn({ err, sessionId }, "sendUserInput failed");
           });
         }).catch((err) => {
           this.send({
             type: "session.error",
             sessionId,
-            error: err instanceof Error ? err.message : String(err)
+            error: err instanceof Error ? err.message : String(err),
+            code: extractErrorCode(err)
+          });
+        });
+      };
+      if (sm.isHealthy(sessionId)) {
+        log3.info({ sessionId }, "claude.execute: reusing healthy session");
+        log3.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
+        sm.sendUserInput(sessionId, content).catch((err) => {
+          log3.warn({ err, sessionId }, "sendUserInput failed");
+        });
+      } else if (sm.hasSession(sessionId) && backendSessionId) {
+        const recommendedMax = sm.getRecommendedMaxOutputTokens(sessionId);
+        log3.warn({ sessionId, backendSessionId }, "claude.execute: session unhealthy, recreating with --resume");
+        this.send({
+          type: "session.died",
+          sessionId,
+          reason: "unhealthy_before_input"
+        });
+        sm.abortSession(sessionId).catch((err) => {
+          log3.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during unhealthy fallback, proceeding to respawn");
+        }).then(() => spawnAndSend(backendSessionId, "unhealthy_fallback_resume", recommendedMax));
+      } else if (backendSessionId) {
+        spawnAndSend(backendSessionId, "fresh_resume", sm.getRecommendedMaxOutputTokens(sessionId));
+      } else {
+        log3.warn(
+          { sessionId, workDir },
+          "claude.execute: entering brand_new spawn path \u2014 no backendSessionId from hub; if this sessionId already has prior turns in db, upstream hub\u2192agent hydration is broken"
+        );
+        spawnAndSend(void 0, "brand_new", void 0);
+      }
+      return true;
+    }
+    if (msg.type === "session.create") {
+      const {
+        sessionId,
+        workDir,
+        backend,
+        sticky,
+        systemPrompt,
+        useBrainCore,
+        initialInput,
+        backendSessionId,
+        useWorktree,
+        worktreeBranchName
+      } = msg;
+      const sm = this.sessionManager;
+      log3.info(
+        {
+          sessionId,
+          backend,
+          hasSticky: !!sticky,
+          hasInitialInput: !!initialInput,
+          useWorktree: !!useWorktree
+        },
+        "session.create"
+      );
+      if (sm.hasSession(sessionId)) {
+        log3.warn({ sessionId }, "session.create: session already exists, ignoring");
+        return true;
+      }
+      (async () => {
+        let effectiveWorkDir = workDir;
+        let workspaceHandle;
+        let workspaceEnv;
+        if (useWorktree && workDir && this.workspaceManager) {
+          try {
+            const swarmId = `chat-${sessionId.slice(0, 8)}`;
+            workspaceHandle = await this.workspaceManager.prepare({
+              swarmId,
+              projectRoot: workDir,
+              // PR-A: forward user-supplied branch hint (hub already prepended
+              // `clawnet/chat-` so this is the fully-qualified name). When
+              // omitted, GitWorktreeProvider falls back to
+              // `clawnet/swarm-chat-<sid8>` (its own default).
+              ...worktreeBranchName ? { branchName: worktreeBranchName } : {}
+            });
+            effectiveWorkDir = workspaceHandle.cwd;
+            workspaceEnv = { CLAWNET_PROJECT_ROOT: workDir };
+            this.send({
+              type: "session.worktree_ready",
+              sessionId,
+              cwd: workspaceHandle.cwd,
+              strategy: workspaceHandle.strategy,
+              branchName: workspaceHandle.metadata.branchName ?? null,
+              // PR-A review fix I3: forward the real base branch so ship
+              // can target it instead of guessing "main".
+              baseBranch: workspaceHandle.metadata.baseBranch ?? null,
+              projectRoot: workDir
+            });
+          } catch (err) {
+            log3.warn(
+              {
+                err: err instanceof Error ? err.message : String(err),
+                sessionId,
+                workDir
+              },
+              "session.create: workspace prepare failed, falling back to direct workDir"
+            );
+            workspaceHandle = void 0;
+            workspaceEnv = void 0;
+            effectiveWorkDir = workDir;
+          }
+        }
+        try {
+          await sm.createSession({
+            sessionId,
+            workDir: effectiveWorkDir,
+            resumeId: backendSessionId,
+            backend,
+            model: sticky?.model,
+            mode: sticky?.mode,
+            systemPrompt,
+            useBrainCore,
+            roleId: DEFAULT_ASSISTANT_ROLE_ID,
+            initialUserInput: initialInput,
+            ...workspaceEnv ? { env: workspaceEnv } : {}
+          });
+          if (workspaceHandle) {
+            sm.attachWorkspace(sessionId, workspaceHandle);
+          }
+          if (initialInput !== void 0) {
+            await sm.sendUserInput(sessionId, initialInput);
+          }
+        } catch (err) {
+          if (workspaceHandle && this.workspaceManager && sm.getWorkspaceHandle(sessionId) === void 0) {
+            this.workspaceManager.dispose(workspaceHandle.swarmId, { keep: false }).catch(
+              (e) => log3.warn(
+                { err: e instanceof Error ? e.message : String(e), sessionId },
+                "best-effort workspace dispose after createSession failure"
+              )
+            );
+          }
+          this.send({
+            type: "session.error",
+            sessionId,
+            error: err instanceof Error ? err.message : String(err),
+            code: extractErrorCode(err)
           });
-        });
-      };
-      if (sm.isHealthy(sessionId)) {
-        log2.info({ sessionId }, "claude.execute: reusing healthy session");
-        log2.debug({ sessionId, ...previewFields(content) }, "claude.execute: input");
-        sm.sendUserInput(sessionId, content).catch((err) => {
-          log2.warn({ err, sessionId }, "sendUserInput failed");
-        });
-      } else if (sm.hasSession(sessionId) && backendSessionId) {
-        const recommendedMax = sm.getRecommendedMaxOutputTokens(sessionId);
-        log2.warn({ sessionId, backendSessionId }, "claude.execute: session unhealthy, recreating with --resume");
+        }
+      })().catch((err) => {
+        log3.error(
+          { sessionId, err: err instanceof Error ? err.message : String(err) },
+          "session.create IIFE unexpectedly threw"
+        );
+      });
+      return true;
+    }
+    if (msg.type === "session.input") {
+      const { sessionId, content, messageMeta, backendSessionId, workDir, useBrainCore } = msg;
+      const sm = this.sessionManager;
+      log3.debug(
+        {
+          sessionId,
+          hasMessageMeta: !!messageMeta,
+          hasBackendSessionId: !!backendSessionId,
+          ...previewFields(content)
+        },
+        "session.input"
+      );
+      if (!sm.isHealthy(sessionId)) {
+        if (backendSessionId) {
+          log3.info(
+            { sessionId, backendSessionId, hadSession: sm.hasSession(sessionId) },
+            "session.input: auto-recovering via --resume"
+          );
+          (async () => {
+            try {
+              if (sm.hasSession(sessionId)) {
+                this.send({
+                  type: "session.died",
+                  sessionId,
+                  reason: "unhealthy_before_input"
+                });
+                await sm.abortSession(sessionId).catch((err) => {
+                  log3.warn(
+                    { sessionId, err: err instanceof Error ? err.message : String(err) },
+                    "abortSession failed during session.input recovery, continuing"
+                  );
+                });
+              }
+              if (messageMeta) {
+                sm.setTurnOverride(sessionId, {
+                  model: messageMeta.model,
+                  mode: messageMeta.mode
+                });
+              }
+              await sm.createSession({
+                sessionId,
+                resumeId: backendSessionId,
+                roleId: DEFAULT_ASSISTANT_ROLE_ID,
+                // (Fix Important #2) Recovery spawn needs cwd + braincore mounts.
+                // Hub forwards these from chat_sessions.{work_dir,use_brain_core}
+                // on the session.input frame. The healthy path doesn't need them
+                // (existing process has its own cwd already).
+                workDir,
+                useBrainCore
+              });
+              await sm.sendUserInput(sessionId, content);
+            } catch (err) {
+              this.send({
+                type: "session.error",
+                sessionId,
+                error: err instanceof Error ? err.message : String(err),
+                code: extractErrorCode(err)
+              });
+            }
+          })().catch((err) => {
+            log3.error(
+              { sessionId, err: err instanceof Error ? err.message : String(err) },
+              "session.input recovery IIFE unexpectedly threw"
+            );
+          });
+          return true;
+        }
+        log3.warn(
+          { sessionId, hasSession: sm.hasSession(sessionId) },
+          "session.input: session not healthy and no backendSessionId \u2014 cannot recover"
+        );
         this.send({
-          type: "session.died",
+          type: "session.error",
           sessionId,
-          reason: "unhealthy_before_input"
+          error: "session.input received but session not healthy and no backendSessionId provided for recovery"
         });
-        sm.abortSession(sessionId).catch((err) => {
-          log2.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during unhealthy fallback, proceeding to respawn");
-        }).then(() => spawnAndSend(backendSessionId, "unhealthy_fallback_resume", recommendedMax));
-      } else if (backendSessionId) {
-        spawnAndSend(backendSessionId, "fresh_resume", sm.getRecommendedMaxOutputTokens(sessionId));
-      } else {
-        log2.warn(
-          { sessionId, workDir },
-          "claude.execute: entering brand_new spawn path \u2014 no backendSessionId from hub; if this sessionId already has prior turns in db, upstream hub\u2192agent hydration is broken"
-        );
-        spawnAndSend(void 0, "brand_new", void 0);
+        return true;
+      }
+      if (messageMeta) {
+        sm.setTurnOverride(sessionId, { model: messageMeta.model, mode: messageMeta.mode });
       }
+      sm.sendUserInput(sessionId, content).catch((err) => {
+        this.send({
+          type: "session.error",
+          sessionId,
+          error: err instanceof Error ? err.message : String(err),
+          code: extractErrorCode(err)
+        });
+      });
+      return true;
+    }
+    if (msg.type === "session.update_sticky") {
+      const { sessionId, sticky } = msg;
+      log3.info({ sessionId, sticky }, "session.update_sticky");
+      this.sessionManager.updateSticky(sessionId, sticky);
       return true;
     }
     if (msg.type === "session.force_restart") {
       const { sessionId, reason } = msg;
-      log2.warn({ sessionId, reason }, "session.force_restart received");
+      log3.warn({ sessionId, reason }, "session.force_restart received");
       const sm = this.sessionManager;
       const reply = {
         type: "session.died",
@@ -1156,7 +2021,7 @@ var HubConnection = class {
       };
       if (sm.hasSession(sessionId)) {
         sm.abortSession(sessionId).catch((err) => {
-          log2.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during force_restart");
+          log3.warn({ sessionId, err: err instanceof Error ? err.message : String(err) }, "abortSession failed during force_restart");
         }).finally(() => {
           this.send(reply);
         });
@@ -1165,49 +2030,27 @@ var HubConnection = class {
       }
       return true;
     }
-    if (msg.type === "session.create") {
-      log2.info({ sessionId: msg.sessionId, roleId: DEFAULT_ASSISTANT_ROLE_ID }, "session.create with memory injection");
-      this.sessionManager.createSession({
-        sessionId: msg.sessionId,
-        workDir: msg.workDir,
-        resumeId: msg.resumeId,
-        roleId: DEFAULT_ASSISTANT_ROLE_ID
-      }).then((backendSessionId) => {
-        this.send({
-          type: "session.created",
-          sessionId: msg.sessionId,
-          backendSessionId
-        });
-      }).catch((err) => {
-        this.send({
-          type: "session.error",
-          sessionId: msg.sessionId,
-          error: err instanceof Error ? err.message : String(err)
-        });
-      });
-      return true;
-    }
     if (msg.type === "session.close") {
-      log2.info({ sessionId: msg.sessionId }, "session.close");
+      log3.info({ sessionId: msg.sessionId }, "session.close");
       this.sessionManager.closeSession(msg.sessionId).catch(() => {
       });
       return true;
     }
     if (msg.type === "claude.input") {
-      log2.debug(
+      log3.debug(
         { sessionId: msg.sessionId, ...previewFields(msg.content) },
         "claude.input"
       );
       this.sessionManager.sendUserInput(msg.sessionId, msg.content).catch((err) => {
-        log2.warn({ err, sessionId: msg.sessionId }, "sendUserInput failed");
+        log3.warn({ err, sessionId: msg.sessionId }, "sendUserInput failed");
       });
       return true;
     }
     if (msg.type === "client.permission_decision") {
       const { sessionId, requestId, decision, reason } = msg;
-      log2.info({ sessionId, requestId, decision }, "client.permission_decision");
+      log3.info({ sessionId, requestId, decision }, "client.permission_decision");
       this.sessionManager.respondToPermission(sessionId, { callId: requestId, decision, reason }).catch((err) => {
-        log2.warn({ err, sessionId, requestId }, "respondToPermission failed");
+        log3.warn({ err, sessionId, requestId }, "respondToPermission failed");
       });
       return true;
     }
@@ -1222,24 +2065,24 @@ var HubConnection = class {
       const recoverableIds = new Set(snapshots.map((s) => s.id));
       for (const { swarmId } of allIds) {
         if (!recoverableIds.has(swarmId)) {
-          log2.info({ swarmId }, "skipping non-recoverable swarm snapshot (kept on disk)");
+          log3.info({ swarmId }, "skipping non-recoverable swarm snapshot (kept on disk)");
         }
       }
       for (const snap of snapshots) {
-        log2.info({ swarmId: snap.id }, "recovering swarm");
+        log3.info({ swarmId: snap.id }, "recovering swarm");
         recoverSwarm(this.swarmCoordinator, snap).catch((err) => {
-          log2.error({ err, swarmId: snap.id }, "failed to recover swarm");
+          log3.error({ err, swarmId: snap.id }, "failed to recover swarm");
         });
       }
     } catch (err) {
-      log2.error({ err }, "swarm recovery failed");
+      log3.error({ err }, "swarm recovery failed");
     }
   }
   reportLiveSessions() {
     if (!this.sessionManager) return;
     const ids = this.sessionManager.getActiveSessionIds();
     if (ids.length === 0) return;
-    log2.info({ count: ids.length }, "reporting live sessions to hub after reconnect");
+    log3.info({ count: ids.length }, "reporting live sessions to hub after reconnect");
     for (const sessionId of ids) {
       this.send({
         type: "session.state",
@@ -1259,7 +2102,7 @@ var HubConnection = class {
     this.heartbeatTimer = setInterval(() => {
       const sinceAck = Date.now() - this.lastAckAt;
       if (sinceAck > this.heartbeatInterval * 2.5) {
-        log2.warn(
+        log3.warn(
           { sinceAckMs: sinceAck, heartbeatIntervalMs: this.heartbeatInterval },
           "no ack from hub \u2014 terminating dead socket"
         );
@@ -1289,15 +2132,15 @@ var HubConnection = class {
    */
   startWakeWatch() {
     this.stopWakeWatch();
-    const intervalMs = 1e3;
-    const jumpThresholdMs = 5e3;
+    const intervalMs = WAKE_WATCH_INTERVAL_MS;
+    const jumpThresholdMs = WAKE_WATCH_JUMP_THRESHOLD_MS;
     this.lastWakeTickAt = Date.now();
     this.wakeWatchTimer = setInterval(() => {
       const now = Date.now();
       const drift = now - this.lastWakeTickAt - intervalMs;
       this.lastWakeTickAt = now;
       if (drift <= jumpThresholdMs) return;
-      log2.warn(
+      log3.warn(
         { driftMs: drift, hasSocket: !!this.ws },
         "wake detected (clock jump) \u2014 forcing reconnect"
       );
@@ -1352,7 +2195,7 @@ var HubConnection = class {
       }
       this.ws = null;
     }
-    log2.warn({ reason }, "forced reconnect");
+    log3.warn({ reason }, "forced reconnect");
     this.authState = "pending";
     this.scheduleReconnect();
   }
@@ -1362,7 +2205,7 @@ var HubConnection = class {
     const cap = Math.min(this.reconnectDelay, this.maxReconnectDelay);
     const base = Math.min(DEFAULT_RECONNECT_MS, cap);
     const delay = Math.floor(base + Math.random() * Math.max(0, cap - base));
-    log2.warn({ delayMs: delay, capMs: cap }, "reconnecting to hub...");
+    log3.warn({ delayMs: delay, capMs: cap }, "reconnecting to hub...");
     this.reconnectTimer = setTimeout(() => {
       this.reconnectTimer = null;
       this.connect();
@@ -1401,8 +2244,8 @@ import {
   MAX_STDOUT_BYTES,
   MAX_STDERR_BYTES
 } from "@mclawnet/scheduler";
-import { createLogger as createLogger3 } from "@mclawnet/logger";
-var log3 = createLogger3({ module: "agent/schedule-runtime" });
+import { createLogger as createLogger4 } from "@mclawnet/logger";
+var log4 = createLogger4({ module: "agent/schedule-runtime" });
 var SPAWN_STDOUT_CAP_BYTES = 1024 * 1024;
 var SPAWN_STDERR_CAP_BYTES = 256 * 1024;
 var ScheduleRuntime = class {
@@ -1512,7 +2355,7 @@ var ScheduleRuntime = class {
         void this.track(this.handleLog(m, requestId));
         return;
       default:
-        log3.warn({ type: msg.type }, "schedule-runtime: unknown message type");
+        log4.warn({ type: msg.type }, "schedule-runtime: unknown message type");
         if (requestId !== void 0) {
           this.safeSend({
             type: "schedule:error",
@@ -1645,7 +2488,7 @@ var ScheduleRuntime = class {
   }
   sendError(requestId, err) {
     const message = err instanceof Error ? err.message : String(err);
-    log3.warn({ err: message, requestId }, "schedule-runtime: branch failed");
+    log4.warn({ err: message, requestId }, "schedule-runtime: branch failed");
     this.safeSend({
       type: "schedule:error",
       requestId,
@@ -1775,7 +2618,7 @@ function makeRealOneShotSpawn() {
     };
     if (opts.signal.aborted) onAbort();
     else opts.signal.addEventListener("abort", onAbort, { once: true });
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve3, reject) => {
       proc.once("error", (err) => {
         opts.signal.removeEventListener("abort", onAbort);
         reject(err);
@@ -1786,7 +2629,7 @@ function makeRealOneShotSpawn() {
           tryExtractAssistant(stdoutLineResidual);
           stdoutLineResidual = "";
         }
-        resolve({
+        resolve3({
           exitCode: code ?? -1,
           stdout: stdoutBuf.toString(),
           stderr: stderrBuf.toString(),
@@ -1803,7 +2646,7 @@ function makeRealSwarmStarter(_deps) {
 }
 
 // src/session-manager.ts
-import { createLogger as createLogger5, previewFields as previewFields2 } from "@mclawnet/logger";
+import { createLogger as createLogger6, previewFields as previewFields2 } from "@mclawnet/logger";
 import { existsSync as existsSync4 } from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
@@ -1816,15 +2659,15 @@ import {
 import { MAX_TOKENS_LADDER, clampLadderIndex } from "@mclawnet/shared";
 
 // src/skill-loader.ts
-import { existsSync as existsSync3, mkdirSync, readdirSync as readdirSync3, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { existsSync as existsSync3, mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
 import { createHash } from "crypto";
-import { join as join3, dirname } from "path";
+import { join as join3, dirname as dirname2 } from "path";
 import { homedir as homedir3 } from "os";
 import { createRequire } from "module";
 import { fileURLToPath } from "url";
-import { createLogger as createLogger4 } from "@mclawnet/logger";
+import { createLogger as createLogger5 } from "@mclawnet/logger";
 import { ManifestManager, mergeSkillSections } from "@mclawnet/skill-manager";
-var log4 = createLogger4({ module: "agent/skill-loader" });
+var log5 = createLogger5({ module: "agent/skill-loader" });
 var CLAWNET_DIR = join3(homedir3(), ".clawnet");
 var SKILLS_DIR = join3(CLAWNET_DIR, ".claude", "skills");
 var MCP_CONFIG_PATH = join3(CLAWNET_DIR, "mcp.json");
@@ -1836,7 +2679,7 @@ async function initSkills() {
 }
 function defaultBuiltinSourceDir() {
   const thisFile = fileURLToPath(import.meta.url);
-  return join3(dirname(thisFile), "..", "skills");
+  return join3(dirname2(thisFile), "..", "skills");
 }
 function sha256(s) {
   return createHash("sha256").update(s).digest("hex");
@@ -1847,9 +2690,9 @@ function readBuiltinVersion(content) {
 }
 function syncBuiltinSkills(rootDir, srcDir) {
   const skillsDir = join3(rootDir, ".claude", "skills");
-  if (!existsSync3(skillsDir)) mkdirSync(skillsDir, { recursive: true });
+  if (!existsSync3(skillsDir)) mkdirSync2(skillsDir, { recursive: true });
   if (!existsSync3(srcDir)) {
-    log4.debug({ srcDir }, "no built-in skills directory found, skipping");
+    log5.debug({ srcDir }, "no built-in skills directory found, skipping");
     return;
   }
   const manifest = new ManifestManager(rootDir);
@@ -1857,7 +2700,7 @@ function syncBuiltinSkills(rootDir, srcDir) {
   try {
     entries = readdirSync3(srcDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
-    log4.warn({ srcDir }, "failed to read built-in skills directory");
+    log5.warn({ srcDir }, "failed to read built-in skills directory");
     return;
   }
   for (const skillName of entries) {
@@ -1868,26 +2711,26 @@ function syncBuiltinSkills(rootDir, srcDir) {
     const baseSnapshotPath = join3(destDir, ".base.md");
     let officialContent;
     try {
-      officialContent = readFileSync2(srcSkillMd, "utf-8");
+      officialContent = readFileSync3(srcSkillMd, "utf-8");
     } catch (err) {
-      log4.warn({ skill: skillName, err }, "failed to read built-in skill");
+      log5.warn({ skill: skillName, err }, "failed to read built-in skill");
       continue;
     }
     const officialHash = sha256(officialContent);
     const officialVersion = readBuiltinVersion(officialContent);
     if (!existsSync3(destSkillMd)) {
       try {
-        mkdirSync(destDir, { recursive: true });
+        mkdirSync2(destDir, { recursive: true });
         writeFileSync(destSkillMd, officialContent);
         writeFileSync(baseSnapshotPath, officialContent);
         manifest.register(skillName, officialHash, officialVersion);
-        log4.info({ skill: skillName, version: officialVersion }, "installed built-in skill");
+        log5.info({ skill: skillName, version: officialVersion }, "installed built-in skill");
       } catch (err) {
-        log4.warn({ skill: skillName, err }, "failed to install built-in skill");
+        log5.warn({ skill: skillName, err }, "failed to install built-in skill");
       }
       continue;
     }
-    const userContent = readFileSync2(destSkillMd, "utf-8");
+    const userContent = readFileSync3(destSkillMd, "utf-8");
     const userHash = sha256(userContent);
     manifest.refresh(skillName, userHash);
     if (!existsSync3(baseSnapshotPath)) {
@@ -1896,27 +2739,27 @@ function syncBuiltinSkills(rootDir, srcDir) {
         try {
           writeFileSync(baseSnapshotPath, userContent);
         } catch (err) {
-          log4.debug({ skill: skillName, err }, "failed to write lazy .base.md");
+          log5.debug({ skill: skillName, err }, "failed to write lazy .base.md");
         }
       }
     }
     const action = manifest.determineSyncAction(skillName, officialHash, officialVersion);
     switch (action) {
       case "skip":
-        log4.debug({ skill: skillName }, "skill already up to date");
+        log5.debug({ skill: skillName }, "skill already up to date");
         break;
       case "direct-overwrite":
         try {
           writeFileSync(destSkillMd, officialContent);
           writeFileSync(baseSnapshotPath, officialContent);
           manifest.markSynced(skillName, officialHash, officialHash, officialVersion);
-          log4.info({ skill: skillName, version: officialVersion }, "upgraded built-in skill");
+          log5.info({ skill: skillName, version: officialVersion }, "upgraded built-in skill");
         } catch (err) {
-          log4.warn({ skill: skillName, err }, "failed to overwrite skill");
+          log5.warn({ skill: skillName, err }, "failed to overwrite skill");
         }
         break;
       case "keep-user":
-        log4.debug({ skill: skillName }, "keeping user-modified skill");
+        log5.debug({ skill: skillName }, "keeping user-modified skill");
         break;
       case "needs-merge": {
         if (!existsSync3(baseSnapshotPath)) {
@@ -1931,16 +2774,16 @@ function syncBuiltinSkills(rootDir, srcDir) {
                 }
               ])
             );
-            log4.warn(
+            log5.warn(
               { skill: skillName },
               "missing .base.md snapshot \u2014 skipping auto-merge, wrote .conflict advisory"
             );
           } catch (err) {
-            log4.warn({ skill: skillName, err }, "failed to write .conflict advisory");
+            log5.warn({ skill: skillName, err }, "failed to write .conflict advisory");
           }
           break;
         }
-        const baseContent = readFileSync2(baseSnapshotPath, "utf-8");
+        const baseContent = readFileSync3(baseSnapshotPath, "utf-8");
         const merged = mergeSkillSections(baseContent, officialContent, userContent);
         if (merged.success && merged.content) {
           try {
@@ -1948,9 +2791,9 @@ function syncBuiltinSkills(rootDir, srcDir) {
             writeFileSync(baseSnapshotPath, officialContent);
             const newCurrentHash = sha256(merged.content);
             manifest.markSynced(skillName, officialHash, newCurrentHash, officialVersion);
-            log4.info({ skill: skillName }, "auto-merged skill upgrade");
+            log5.info({ skill: skillName }, "auto-merged skill upgrade");
           } catch (err) {
-            log4.warn({ skill: skillName, err }, "failed to write merged skill");
+            log5.warn({ skill: skillName, err }, "failed to write merged skill");
           }
         } else {
           try {
@@ -1958,12 +2801,12 @@ function syncBuiltinSkills(rootDir, srcDir) {
               destSkillMd + ".conflict",
               renderConflictFile(skillName, officialContent, merged.conflicts ?? [])
             );
-            log4.warn(
+            log5.warn(
               { skill: skillName, conflicts: merged.conflicts?.length },
               "skill merge conflict \u2014 user version kept, .conflict file written"
             );
           } catch (err) {
-            log4.warn({ skill: skillName, err }, "failed to write .conflict file");
+            log5.warn({ skill: skillName, err }, "failed to write .conflict file");
           }
         }
         break;
@@ -2003,8 +2846,8 @@ function renderConflictFile(skillName, officialContent, conflicts) {
 }
 function ensureSkillsDir() {
   if (!existsSync3(SKILLS_DIR)) {
-    mkdirSync(SKILLS_DIR, { recursive: true });
-    log4.info({ dir: SKILLS_DIR }, "created skills directory");
+    mkdirSync2(SKILLS_DIR, { recursive: true });
+    log5.info({ dir: SKILLS_DIR }, "created skills directory");
   }
 }
 var cachedSkills = [];
@@ -2014,7 +2857,7 @@ function scanSkills() {
   try {
     dirs = readdirSync3(SKILLS_DIR, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
   } catch {
-    log4.warn("failed to read skills directory for scanning");
+    log5.warn("failed to read skills directory for scanning");
     return [];
   }
   const skills = [];
@@ -2022,7 +2865,7 @@ function scanSkills() {
     const skillMd = join3(SKILLS_DIR, dirName, "SKILL.md");
     if (!existsSync3(skillMd)) continue;
     try {
-      const content = readFileSync2(skillMd, "utf-8");
+      const content = readFileSync3(skillMd, "utf-8");
       const parsed = parseFrontmatter(content);
       if (parsed.name) {
         skills.push({
@@ -2031,11 +2874,11 @@ function scanSkills() {
         });
       }
     } catch (err) {
-      log4.debug({ skill: dirName, err }, "failed to parse SKILL.md frontmatter");
+      log5.debug({ skill: dirName, err }, "failed to parse SKILL.md frontmatter");
     }
   }
   cachedSkills = skills;
-  log4.info({ count: skills.length }, "scanned skills");
+  log5.info({ count: skills.length }, "scanned skills");
   return skills;
 }
 function getSkillList() {
@@ -2045,7 +2888,7 @@ function getPendingNotification() {
   const pendingPath = join3(CLAWNET_DIR, ".claude", "pending-evolutions.json");
   if (!existsSync3(pendingPath)) return null;
   try {
-    const raw = JSON.parse(readFileSync2(pendingPath, "utf-8"));
+    const raw = JSON.parse(readFileSync3(pendingPath, "utf-8"));
     const pending = Array.isArray(raw?.pending) ? raw.pending : [];
     if (pending.length === 0) return null;
     const lines = pending.map(
@@ -2056,7 +2899,7 @@ ${lines.join("\n")}
 \u4F7F\u7528 skill_pending_list \u67E5\u770B\u8BE6\u60C5\uFF0Cskill_pending_approve / skill_pending_reject \u5904\u7406\u3002`;
     return { count: pending.length, text };
   } catch (err) {
-    log4.debug({ err }, "failed to read pending-evolutions.json");
+    log5.debug({ err }, "failed to read pending-evolutions.json");
     return null;
   }
 }
@@ -2076,10 +2919,10 @@ function ensureMcpConfig() {
   let mcpServerPath;
   try {
     const req = createRequire(import.meta.url);
-    const mcpPkgDir = dirname(req.resolve("@mclawnet/mcp-server/package.json"));
+    const mcpPkgDir = dirname2(req.resolve("@mclawnet/mcp-server/package.json"));
     mcpServerPath = join3(mcpPkgDir, "dist", "server.js");
   } catch {
-    log4.warn("could not resolve @mclawnet/mcp-server package path, skipping mcp.json generation");
+    log5.warn("could not resolve @mclawnet/mcp-server package path, skipping mcp.json generation");
     return;
   }
   const desired = { command: "node", args: [mcpServerPath] };
@@ -2088,9 +2931,9 @@ function ensureMcpConfig() {
   if (existsSync3(MCP_CONFIG_PATH)) {
     fileExists = true;
     try {
-      config = JSON.parse(readFileSync2(MCP_CONFIG_PATH, "utf-8"));
+      config = JSON.parse(readFileSync3(MCP_CONFIG_PATH, "utf-8"));
     } catch (err) {
-      log4.warn({ err, path: MCP_CONFIG_PATH }, "mcp.json malformed \u2014 leaving alone");
+      log5.warn({ err, path: MCP_CONFIG_PATH }, "mcp.json malformed \u2014 leaving alone");
       return;
     }
     if (!config.mcpServers || typeof config.mcpServers !== "object") {
@@ -2115,18 +2958,18 @@ function ensureMcpConfig() {
     changed = true;
   }
   if (!changed) {
-    log4.debug("mcp.json already up-to-date \u2014 no write");
+    log5.debug("mcp.json already up-to-date \u2014 no write");
     return;
   }
   try {
-    mkdirSync(CLAWNET_DIR, { recursive: true });
+    mkdirSync2(CLAWNET_DIR, { recursive: true });
     writeFileSync(MCP_CONFIG_PATH, JSON.stringify(config, null, 2) + "\n");
-    log4.info(
+    log5.info(
       { path: MCP_CONFIG_PATH, fresh: !fileExists },
       fileExists ? "updated mcp.json (clawnet-mcp ensured)" : "generated default mcp.json"
     );
   } catch (err) {
-    log4.warn({ err }, "failed to write mcp.json");
+    log5.warn({ err }, "failed to write mcp.json");
   }
 }
 
@@ -2139,6 +2982,23 @@ var SessionLimitReachedError = class extends Error {
   }
   code = "SESSION_LIMIT_REACHED";
 };
+var RespawnRequiredError = class extends Error {
+  code = "RESPAWN_REQUIRED";
+  sessionId;
+  newModel;
+  currentModel;
+  backendSessionId;
+  constructor(args) {
+    super(
+      `per-turn model change to "${args.newModel}" requires session respawn; caller should retry as session.create with resumeId=${args.backendSessionId ?? "<unknown>"}`
+    );
+    this.name = "RespawnRequiredError";
+    this.sessionId = args.sessionId;
+    this.newModel = args.newModel;
+    this.currentModel = args.currentModel;
+    this.backendSessionId = args.backendSessionId;
+  }
+};
 function buildMessage(d) {
   const kindParts = Object.entries(d.byKind).map(([k, n]) => `${k}=${n}`).join(", ");
   const oldest = d.oldestIdleSessionId ? `Oldest idle: ${d.oldestIdleSessionId} (${d.oldestIdleKind}, idle ${Math.round(
@@ -2243,7 +3103,7 @@ function getSharedEmbeddingService() {
   sharedEmbeddingService = new EmbeddingService(db, createEmbeddingProviders());
   return sharedEmbeddingService;
 }
-var log5 = createLogger5({ module: "agent/session-manager" });
+var log6 = createLogger6({ module: "agent/session-manager" });
 var DEFAULT_MAX_PROCESSES = 30;
 var MAX_PROCESSES = Number(process.env.CLAWNET_MAX_PROCESSES) || DEFAULT_MAX_PROCESSES;
 var DEFAULT_CHAT_IDLE_TTL_MS = 60 * 60 * 1e3;
@@ -2265,6 +3125,9 @@ var SessionManager = class {
   conversationBuffer = /* @__PURE__ */ new Map();
   // PR-A: parallel metadata map (kind, timestamps). See SessionMeta jsdoc.
   sessionMeta = /* @__PURE__ */ new Map();
+  // (N3) Sticky/turn-override state keyed by sessionId. See StickyState jsdoc
+  // for the lifecycle rationale (it's intentionally NOT cleared by abort).
+  stickyState = /* @__PURE__ */ new Map();
   // PR-A: sessions currently inside a sendInput→turn_complete window. Idle
   // sweeper must skip these even if lastActivityAt looks ancient — a
   // long-running deep-research turn would otherwise be killed mid-flight.
@@ -2348,6 +3211,14 @@ var SessionManager = class {
    */
   onSessionExit;
   onPermissionRequest;
+  /**
+   * (N5) Fires when `closeSession` runs against a session that had a
+   * workspace handle attached via {@link SessionManager.attachWorkspace}.
+   * Receives the original handle so the host can dispose it (keep=true) and
+   * notify hub via `session.worktree_closed`. Never blocks the close path —
+   * exceptions are caught and logged.
+   */
+  onWorkspaceClose;
   // PR-A: classifies a sessionId as 'chat' or 'swarm-role'. Injected by
   // start.ts via SwarmCoordinator.isSwarmSession to keep SessionManager
   // independent of the swarm package. Defaults to 'chat' if absent — safe
@@ -2364,6 +3235,7 @@ var SessionManager = class {
     this.onBeforeClose = options.onBeforeClose;
     this.onSessionExit = options.onSessionExit;
     this.onPermissionRequest = options.onPermissionRequest;
+    this.onWorkspaceClose = options.onWorkspaceClose;
     this.classify = options.classify ?? (() => "chat");
     this.checkpointPath = options.checkpointPath ?? null;
     this.checkpointDebounceMs = options.checkpointDebounceMs ?? 5e3;
@@ -2386,12 +3258,12 @@ var SessionManager = class {
         options.systemPrompt = options.systemPrompt ? `${memorySection}
 
 ${options.systemPrompt}` : memorySection;
-        log5.debug({ workDir: options.workDir, sessionId: options.sessionId }, "memory prompt injected");
+        log6.debug({ workDir: options.workDir, sessionId: options.sessionId }, "memory prompt injected");
       } catch (err) {
-        log5.warn({ err, workDir: options.workDir }, "failed to build memory section, proceeding without");
+        log6.warn({ err, workDir: options.workDir }, "failed to build memory section, proceeding without");
       }
     } else {
-      log5.warn(
+      log6.warn(
         { sessionId: options.sessionId, roleId: options.roleId },
         "session created without workDir \u2014 memory injection skipped (all memories would be cross-workdir; pass workDir to enable scoped retrieval)"
       );
@@ -2404,13 +3276,13 @@ ${options.systemPrompt}` : memorySection;
 [Skill \u8FDB\u5316\u63D0\u6848]
 ${notice.text}`;
         options.systemPrompt = options.systemPrompt ? `${options.systemPrompt}${noticeBlock}` : noticeBlock.trimStart();
-        log5.debug(
+        log6.debug(
           { sessionId: options.sessionId, pending: notice.count },
           "pending skill evolution notice injected"
         );
       }
     } catch (err) {
-      log5.debug({ err }, "failed to inject pending notification");
+      log6.debug({ err }, "failed to inject pending notification");
     }
     if (this.classify(options.sessionId) === "chat") {
       const ideaHint = `
@@ -2422,7 +3294,7 @@ ${notice.text}`;
       let spawnAdapter = this.adapter;
       if (options.backend && this.resolveAdapter) {
         const resolved = await this.resolveAdapter(options.backend);
-        log5.info(
+        log6.info(
           {
             sessionId: options.sessionId,
             requested: options.backend,
@@ -2436,7 +3308,7 @@ ${notice.text}`;
           spawnAdapter = resolved;
         }
       } else {
-        log5.info(
+        log6.info(
           {
             sessionId: options.sessionId,
             requestedBackend: options.backend,
@@ -2446,7 +3318,24 @@ ${notice.text}`;
           "createSession: using default adapter"
         );
       }
-      const process2 = await spawnAdapter.spawn(options);
+      const sticky = this.stickyState.get(options.sessionId);
+      const effectiveModel = sticky?.pendingTurnOverride?.model ?? sticky?.model ?? options.model;
+      const effectiveMode = sticky?.pendingTurnOverride?.mode ?? sticky?.mode ?? options.mode;
+      const effectiveOptions = {
+        ...options,
+        model: effectiveModel,
+        mode: effectiveMode
+      };
+      if (sticky?.pendingTurnOverride) {
+        log6.debug(
+          { sessionId: options.sessionId, override: sticky.pendingTurnOverride },
+          "N3: consuming pendingTurnOverride for spawn"
+        );
+        delete sticky.pendingTurnOverride;
+        const prevMeta = this.sessionMeta.get(options.sessionId);
+        if (prevMeta) delete prevMeta.pendingTurnOverride;
+      }
+      const process2 = await spawnAdapter.spawn(effectiveOptions);
       if (spawnAdapter !== this.adapter) {
         this.processAdapters.set(process2, spawnAdapter);
       }
@@ -2464,12 +3353,22 @@ ${notice.text}`;
         // Restore ladder index if this sessionId was carried over from the
         // previous run's checkpoint. drain-on-read so a future re-creation of
         // a different session with the same id starts fresh.
-        currentLadderIndex: this.recoveredLadderIndex.get(options.sessionId)
+        currentLadderIndex: this.recoveredLadderIndex.get(options.sessionId),
+        // (N3) Mirror sticky model/mode onto meta so existing meta-readers
+        // (debug snapshots, future PR consumers) see the resolved value.
+        stickyModel: sticky?.model,
+        stickyMode: sticky?.mode
       });
       this.recoveredLadderIndex.delete(options.sessionId);
+      let postSpawnSticky = this.stickyState.get(options.sessionId);
+      if (!postSpawnSticky) {
+        postSpawnSticky = {};
+        this.stickyState.set(options.sessionId, postSpawnSticky);
+      }
+      postSpawnSticky.lastSpawnModel = effectiveModel;
       this.scheduleCheckpoint();
       spawnAdapter.onOutput(process2, (rawData) => {
-        const data = normalizeBackendOutput(rawData, log5);
+        const data = normalizeBackendOutput(rawData, log6);
         if (data === null) return;
         const msg = data;
         if (msg?.type === "assistant" && msg?.message?.content) {
@@ -2502,7 +3401,7 @@ ${notice.text}`;
         const currentIndex = clampLadderIndex(meta.currentLadderIndex);
         const atFloor = currentIndex >= MAX_TOKENS_LADDER.length - 1;
         if (atFloor) {
-          log5.warn(
+          log6.warn(
             {
               sessionId: options.sessionId,
               used: info.used,
@@ -2515,7 +3414,7 @@ ${notice.text}`;
         }
         const nextIndex = currentIndex + 1;
         meta.currentLadderIndex = nextIndex;
-        log5.warn(
+        log6.warn(
           {
             sessionId: options.sessionId,
             used: info.used,
@@ -2531,7 +3430,7 @@ ${notice.text}`;
       if (this.onSessionStarted) {
         spawnAdapter.onSessionStarted?.(process2, (info) => {
           if (this.aborting.has(options.sessionId)) {
-            log5.debug(
+            log6.debug(
               { sessionId: options.sessionId },
               "suppressing late session_started \u2014 session is aborting"
             );
@@ -2555,7 +3454,7 @@ ${notice.text}`;
               `${sid}.jsonl`
             );
             if (!existsSync4(jsonlPath)) {
-              log5.warn(
+              log6.warn(
                 {
                   sessionId: options.sessionId,
                   backendSessionId: sid,
@@ -2592,10 +3491,10 @@ ${notice.text}`;
           this.conversationBuffer.delete(options.sessionId);
           this.scheduleCheckpoint();
           if (!expected) {
-            log5.warn({ sessionId: options.sessionId, exitCode: code, reason: enriched }, "backend process exited unexpectedly, evicted from session map");
+            log6.warn({ sessionId: options.sessionId, exitCode: code, reason: enriched }, "backend process exited unexpectedly, evicted from session map");
             this.onSessionError(options.sessionId, `backend process exited (code=${code ?? "null"})`);
           } else {
-            log5.debug({ sessionId: options.sessionId, exitCode: code }, "backend process exited as expected");
+            log6.debug({ sessionId: options.sessionId, exitCode: code }, "backend process exited as expected");
           }
           try {
             this.onSessionExit?.(options.sessionId, {
@@ -2604,7 +3503,7 @@ ${notice.text}`;
               ...expected ? {} : { reason: reasonText }
             });
           } catch (err) {
-            log5.warn({ err, sessionId: options.sessionId }, "onSessionExit listener threw");
+            log6.warn({ err, sessionId: options.sessionId }, "onSessionExit listener threw");
           }
         } else {
           const expected = this.expectedExits.delete(options.sessionId);
@@ -2614,7 +3513,7 @@ ${notice.text}`;
               expected
             });
           } catch (err) {
-            log5.warn({ err, sessionId: options.sessionId }, "onSessionExit listener threw");
+            log6.warn({ err, sessionId: options.sessionId }, "onSessionExit listener threw");
           }
         }
       });
@@ -2634,7 +3533,7 @@ ${notice.text}`;
     this.activelyExecuting.add(sessionId);
     const meta = this.sessionMeta.get(sessionId);
     if (meta) meta.lastActivityAt = Date.now();
-    log5.debug(
+    log6.debug(
       { sessionId, ...previewFields2(input) },
       "sendInput \u2192 backend stdin"
     );
@@ -2649,6 +3548,17 @@ ${notice.text}`;
   async sendUserInput(sessionId, content) {
     const meta = this.sessionMeta.get(sessionId);
     const workDir = meta?.workDir;
+    const st = this.stickyState.get(sessionId);
+    const effectiveModel = st?.pendingTurnOverride?.model ?? st?.model;
+    if (effectiveModel !== void 0 && st?.lastSpawnModel !== void 0 && effectiveModel !== st.lastSpawnModel) {
+      const backendSessionId = meta?.backendSessionId;
+      throw new RespawnRequiredError({
+        sessionId,
+        newModel: effectiveModel,
+        currentModel: st.lastSpawnModel,
+        backendSessionId
+      });
+    }
     let prefixed = content;
     try {
       const section = await Promise.race([
@@ -2658,7 +3568,7 @@ ${notice.text}`;
           embeddingService: getSharedEmbeddingService()
         }),
         new Promise(
-          (resolve) => setTimeout(() => resolve(""), 200)
+          (resolve3) => setTimeout(() => resolve3(""), 200)
         )
       ]);
       if (section && section.trim().length > 0) {
@@ -2669,10 +3579,84 @@ ${section}
 ${content}`;
       }
     } catch (err) {
-      log5.debug({ err, sessionId }, "sendUserInput: memory retrieval skipped");
+      log6.debug({ err, sessionId }, "sendUserInput: memory retrieval skipped");
     }
     this.sendInput(sessionId, prefixed);
   }
+  /**
+   * (N2/N3) Update sticky model/mode on a session. Survives abort/respawn
+   * because it writes to `stickyState`, which is independent of `sessionMeta`
+   * (cleared on abort). Partial: fields with `undefined` are not touched.
+   *
+   * Valid use cases:
+   * - patch sticky on a live session (mutates meta + stickyState)
+   * - stage sticky BEFORE the first session.create lands (writes only to
+   *   stickyState — meta is created later by createSession, which mirrors
+   *   from stickyState)
+   *
+   * No-throw on missing session; this method is best-effort state staging.
+   */
+  updateSticky(sessionId, sticky) {
+    const meta = this.sessionMeta.get(sessionId);
+    if (meta) {
+      if (sticky.model !== void 0) meta.stickyModel = sticky.model;
+      if (sticky.mode !== void 0) meta.stickyMode = sticky.mode;
+    }
+    let st = this.stickyState.get(sessionId);
+    if (!st) {
+      st = {};
+      this.stickyState.set(sessionId, st);
+    }
+    if (sticky.model !== void 0) st.model = sticky.model;
+    if (sticky.mode !== void 0) st.mode = sticky.mode;
+    log6.debug(
+      { sessionId, stickyModel: st.model, stickyMode: st.mode, hadMeta: !!meta },
+      "updateSticky applied"
+    );
+  }
+  /**
+   * (N2/N3) Stage a per-turn override for the very next spawn. Consumed
+   * (and deleted from stickyState) by the next `createSession` for this
+   * sessionId. Survives abort/respawn until consumed — so a hub-side
+   * abort+recreate driven by a model switch still carries the override.
+   *
+   * No-throw on missing session: same staging-before-alive use case as
+   * `updateSticky`.
+   */
+  setTurnOverride(sessionId, override) {
+    const meta = this.sessionMeta.get(sessionId);
+    if (meta) {
+      meta.pendingTurnOverride = { model: override.model, mode: override.mode };
+    }
+    let st = this.stickyState.get(sessionId);
+    if (!st) {
+      st = {};
+      this.stickyState.set(sessionId, st);
+    }
+    st.pendingTurnOverride = { model: override.model, mode: override.mode };
+    log6.debug({ sessionId, override, hadMeta: !!meta }, "setTurnOverride staged");
+  }
+  /**
+   * (N5) Attach a workspace handle to an existing session's meta so that a
+   * later `closeSession` can fire `onWorkspaceClose` with it. Idempotent: a
+   * second call overwrites the existing handle (acceptable since the host
+   * never adopts two workspaces for the same session in practice). No-op
+   * with a warn when the session is unknown — the caller's prepare succeeded
+   * before createSession failed, so the workspace is already cleaning itself
+   * up via the error path in hub-connection.
+   */
+  attachWorkspace(sessionId, handle) {
+    const meta = this.sessionMeta.get(sessionId);
+    if (!meta) {
+      log6.warn({ sessionId }, "attachWorkspace: session not in meta map, ignoring");
+      return;
+    }
+    meta.workspaceHandle = handle;
+  }
+  /** (N5) Inspect the attached workspace handle for a session, if any. */
+  getWorkspaceHandle(sessionId) {
+    return this.sessionMeta.get(sessionId)?.workspaceHandle;
+  }
   async abortSession(sessionId) {
     const process2 = this.sessions.get(sessionId);
     if (!process2) return;
@@ -2711,10 +3695,20 @@ ${content}`;
       });
     }
     this.conversationBuffer.delete(sessionId);
+    const meta = this.sessionMeta.get(sessionId);
+    const handle = meta?.workspaceHandle;
+    if (handle && this.onWorkspaceClose) {
+      try {
+        this.onWorkspaceClose(sessionId, handle);
+      } catch (err) {
+        log6.warn({ err, sessionId }, "onWorkspaceClose callback threw");
+      }
+    }
     this.expectedExits.add(sessionId);
     this.sessions.delete(sessionId);
     this.sessionMeta.delete(sessionId);
     this.activelyExecuting.delete(sessionId);
+    this.stickyState.delete(sessionId);
     this.scheduleCheckpoint();
     await this.getAdapterFor(process2).stop(process2);
   }
@@ -2732,6 +3726,7 @@ ${content}`;
         this.sessions.delete(sessionId);
         this.sessionMeta.delete(sessionId);
         this.activelyExecuting.delete(sessionId);
+        this.stickyState.delete(sessionId);
         await this.getAdapterFor(process2).stop(process2).catch(() => {
         });
       }
@@ -2743,7 +3738,7 @@ ${content}`;
         this.checkpointDebouncer = null;
       }
       await this.flushCheckpoint().catch(
-        (err) => log5.warn({ err }, "checkpoint: final flushCheckpoint failed")
+        (err) => log6.warn({ err }, "checkpoint: final flushCheckpoint failed")
       );
     }
   }
@@ -2800,16 +3795,16 @@ ${content}`;
       this.idleSweepIntervalMs = overrides.intervalMs;
     if (this.idleSweepTimer) return;
     if (this.idleTtlMs <= 0) {
-      log5.info("idleSweeper disabled (ttlMs <= 0)");
+      log6.info("idleSweeper disabled (ttlMs <= 0)");
       return;
     }
     this.idleSweepTimer = setInterval(() => {
       this.sweepIdleSessions().catch(
-        (err) => log5.warn({ err }, "idleSweeper: tick failed")
+        (err) => log6.warn({ err }, "idleSweeper: tick failed")
       );
     }, this.idleSweepIntervalMs);
     this.idleSweepTimer.unref?.();
-    log5.info(
+    log6.info(
       { ttlMs: this.idleTtlMs, intervalMs: this.idleSweepIntervalMs },
       "idleSweeper started"
     );
@@ -2840,12 +3835,12 @@ ${content}`;
     }
     for (const sid of victims) {
       const idleMs = now - (this.sessionMeta.get(sid)?.lastActivityAt ?? now);
-      log5.info(
+      log6.info(
         { sessionId: sid, idleMs, ttlMs: ttl },
         "idleSweeper: closing idle chat session"
       );
       await this.closeSession(sid).catch(
-        (err) => log5.warn({ err, sessionId: sid }, "idleSweeper: closeSession failed, continuing")
+        (err) => log6.warn({ err, sessionId: sid }, "idleSweeper: closeSession failed, continuing")
       );
     }
   }
@@ -2899,7 +3894,7 @@ ${content}`;
     this.checkpointDebouncer = setTimeout(() => {
       this.checkpointDebouncer = null;
       this.flushCheckpoint().catch(
-        (err) => log5.warn({ err }, "checkpoint: flush failed")
+        (err) => log6.warn({ err }, "checkpoint: flush failed")
       );
     }, this.checkpointDebounceMs);
     this.checkpointDebouncer.unref?.();
@@ -2963,7 +3958,7 @@ ${content}`;
       }
       if (isPidAlive(entry.pid)) {
         orphan.push(entry);
-        log5.warn(
+        log6.warn(
           { sessionId: entry.sessionId, pid: entry.pid },
           "recover: pid still alive but not owned by current agent (orphan)"
         );
@@ -2984,14 +3979,97 @@ function ensureRuntimeEnvDefaults() {
 }
 
 // src/start.ts
-import { SwarmCoordinator, initRoles, WakeupScheduler, listRecoverableSwarmIds as listRecoverableSwarmIds2 } from "@mclawnet/swarm";
+import { SwarmCoordinator, initRoles, WakeupScheduler, listRecoverableSwarmIds as listRecoverableSwarmIds2, AlwaysOnManager, listProjectDirs, resolveWorkDir as resolveWorkDir2, alwaysOnConfigPath, WorkspaceManager, createIdeaTodoSource, createIdeaResearchSource, createIntrospectionSource, loadAlwaysOnConfig as loadAlwaysOnConfig2, mergeAlwaysOnConfig as mergeAlwaysOnConfig2, saveAlwaysOnConfig as saveAlwaysOnConfig2, reconcileOrphanedResearching } from "@mclawnet/swarm";
 import { TaskStore as TaskStore2 } from "@mclawnet/task";
 
+// src/ideas-rest-client.ts
+function normalizeHubUrlToHttp(hubUrl) {
+  let url = hubUrl;
+  url = url.replace(/^wss:\/\//i, "https://").replace(/^ws:\/\//i, "http://");
+  url = url.replace(/\/ws\/agent\/?$/i, "");
+  if (url.endsWith("/")) url = url.slice(0, -1);
+  return url;
+}
+function createIdeasRestClient(opts) {
+  const base = normalizeHubUrlToHttp(opts.hubUrl);
+  const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+  if (typeof fetchImpl !== "function") {
+    throw new Error("createIdeasRestClient: no fetch implementation available");
+  }
+  async function authHeaders() {
+    const token = await opts.getAuthToken();
+    if (!token) {
+      throw new Error("ideas-rest-client: no auth token available");
+    }
+    return { Authorization: `Bearer ${token}` };
+  }
+  async function request(path, init = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...await authHeaders(),
+      ...init.headers ?? {}
+    };
+    const res = await fetchImpl(`${base}${path}`, { ...init, headers });
+    if (!res.ok) {
+      let detail = "";
+      try {
+        const body = await res.json();
+        if (body && typeof body.error === "string") detail = body.error;
+      } catch {
+      }
+      throw new Error(
+        `ideas-rest-client: ${init.method ?? "GET"} ${path} \u2192 ${res.status}${detail ? ` (${detail})` : ""}`
+      );
+    }
+    return await res.json();
+  }
+  function buildListQuery(filter) {
+    const p = new URLSearchParams();
+    if (filter.status) p.set("status", filter.status);
+    if (filter.priority) p.set("priority", filter.priority);
+    if (filter.projectId) p.set("projectId", filter.projectId);
+    if (filter.tag) p.set("tag", filter.tag);
+    if (filter.q) p.set("q", filter.q);
+    if (typeof filter.limit === "number") p.set("limit", String(filter.limit));
+    const s = p.toString();
+    return s ? `?${s}` : "";
+  }
+  return {
+    async list(filter) {
+      const res = await request(`/api/ideas${buildListQuery(filter)}`);
+      return res.items ?? [];
+    },
+    async get(id) {
+      try {
+        const res = await request(`/api/ideas/${encodeURIComponent(id)}`);
+        return res.idea ?? null;
+      } catch (err) {
+        if (err instanceof Error && /→\s*404/.test(err.message)) return null;
+        throw err;
+      }
+    },
+    async patch(id, partial) {
+      const res = await request(`/api/ideas/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body: JSON.stringify(partial)
+      });
+      return res.idea;
+    },
+    async create(input) {
+      const res = await request(`/api/ideas`, {
+        method: "POST",
+        body: JSON.stringify(input)
+      });
+      return res.idea;
+    }
+  };
+}
+
 // src/brain-bridge.ts
-import { existsSync as existsSync5, readFileSync as readFileSync3, readdirSync as readdirSync4 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4, readdirSync as readdirSync4 } from "fs";
 import { join as join5 } from "path";
-import { createLogger as createLogger6 } from "@mclawnet/logger";
-var log6 = createLogger6({ module: "brain-bridge" });
+import { createLogger as createLogger7 } from "@mclawnet/logger";
+var log7 = createLogger7({ module: "brain-bridge" });
 var BrainBridge = class {
   constructor(hub, options) {
     this.hub = hub;
@@ -2999,7 +4077,7 @@ var BrainBridge = class {
     this.brainHome = options?.brainHomePath || process.env.BRAIN_HOME || join5(home, "BrainData");
     this.brainCorePath = options?.brainCorePath || join5(home, ".brain", "BrainCore");
     this.hub.registerNamespace("brain", (msg) => this.handleRequest(msg));
-    log6.info(
+    log7.info(
       { brainHome: this.brainHome, brainCorePath: this.brainCorePath },
       "BrainBridge initialized"
     );
@@ -3007,11 +4085,11 @@ var BrainBridge = class {
   brainHome;
   brainCorePath;
   async handleRequest(msg) {
-    log6.info({ action: msg.action, requestId: msg.requestId }, "brain request");
+    log7.info({ action: msg.action, requestId: msg.requestId }, "brain request");
     switch (msg.action) {
       case "setup_status": {
         const status = this.checkSetup();
-        log6.info({ status }, "setup_status result");
+        log7.info({ status }, "setup_status result");
         return { status };
       }
       case "get_briefing":
@@ -3019,7 +4097,7 @@ var BrainBridge = class {
       case "get_meeting_recap":
         return await this.getMeetingRecap(msg.params.recapPath);
       default:
-        log6.warn({ action: msg.action }, "unknown brain action");
+        log7.warn({ action: msg.action }, "unknown brain action");
         throw new Error(`Unknown brain action: ${msg.action}`);
     }
   }
@@ -3042,23 +4120,23 @@ var BrainBridge = class {
     const targetDate = date || (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
     const reportsDir = join5(this.brainHome, "reports", "daily");
     if (!existsSync5(reportsDir)) {
-      log6.info({ reportsDir }, "get_briefing: reports dir not found");
+      log7.info({ reportsDir }, "get_briefing: reports dir not found");
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
     const files = readdirSync4(reportsDir).filter((f) => f.includes(targetDate) && f.endsWith(".md")).sort().reverse();
     if (files.length === 0) {
-      log6.info({ targetDate }, "get_briefing: no report for date");
+      log7.info({ targetDate }, "get_briefing: no report for date");
       return { briefing: null, actions: [], projects: [], meetings: [], feed: [] };
     }
-    log6.info({ targetDate, file: files[0] }, "get_briefing: reading report");
-    const content = readFileSync3(join5(reportsDir, files[0]), "utf-8");
+    log7.info({ targetDate, file: files[0] }, "get_briefing: reading report");
+    const content = readFileSync4(join5(reportsDir, files[0]), "utf-8");
     const tldrMatch = content.match(/## TL;DR\n([\s\S]*?)(?=\n---|\n## )/);
     const tldr = tldrMatch ? tldrMatch[1].trim() : content.slice(0, 200);
     const actions = this.parseActions(content);
     const projects = this.parseProjects(content);
     const meetings = this.parseMeetings(content);
     const feed = this.parseFeed(content);
-    log6.info(
+    log7.info(
       { actions: actions.length, projects: projects.length, meetings: meetings.length, feed: feed.length },
       "get_briefing: parsed"
     );
@@ -3252,10 +4330,10 @@ var BrainBridge = class {
     }
     const fullPath = join5(this.brainHome, recapPath);
     if (!existsSync5(fullPath)) {
-      log6.warn({ fullPath }, "meeting recap file not found");
+      log7.warn({ fullPath }, "meeting recap file not found");
       return { error: "Recap file not found" };
     }
-    const content = readFileSync3(fullPath, "utf-8");
+    const content = readFileSync4(fullPath, "utf-8");
     return { recap: this.parseRecapMarkdown(content) };
   }
   /** Parse meeting recap markdown into structured sections */
@@ -3288,10 +4366,10 @@ var BrainBridge = class {
 };
 
 // src/fs-bridge.ts
-import { existsSync as existsSync6, readFileSync as readFileSync4, statSync as statSync2 } from "fs";
-import { extname, isAbsolute } from "path";
-import { createLogger as createLogger7 } from "@mclawnet/logger";
-var log7 = createLogger7({ module: "fs-bridge" });
+import { existsSync as existsSync6, readFileSync as readFileSync5, statSync as statSync3 } from "fs";
+import { extname, isAbsolute as isAbsolute2 } from "path";
+import { createLogger as createLogger8 } from "@mclawnet/logger";
+var log8 = createLogger8({ module: "fs-bridge" });
 var MAX_TEXT_SIZE = 5 * 1024 * 1024;
 var MIME_MAP = {
   ".ts": "text/typescript",
@@ -3329,10 +4407,10 @@ var FsBridge = class {
   constructor(hub) {
     this.hub = hub;
     this.hub.registerNamespace("fs", (msg) => this.handleRequest(msg));
-    log7.info("FsBridge initialized");
+    log8.info("FsBridge initialized");
   }
   async handleRequest(msg) {
-    log7.info({ action: msg.action, requestId: msg.requestId }, "fs request");
+    log8.info({ action: msg.action, requestId: msg.requestId }, "fs request");
     switch (msg.action) {
       case "read":
         return this.readFile(msg.params);
@@ -3343,33 +4421,292 @@ var FsBridge = class {
   readFile(params) {
     const filePath = params.path;
     if (!filePath) throw new Error("Missing path parameter");
-    if (!isAbsolute(filePath)) {
+    if (!isAbsolute2(filePath)) {
       throw new Error(`Access denied: only absolute paths allowed`);
     }
     if (!existsSync6(filePath)) {
       throw new Error(`File not found: ${filePath}`);
     }
-    const stat2 = statSync2(filePath);
+    const stat2 = statSync3(filePath);
     if (!stat2.isFile()) {
       throw new Error(`Not a file: ${filePath}`);
     }
     const mimeType = getMimeType(filePath);
     const totalSize = stat2.size;
     if (isTextMime(mimeType)) {
-      const raw = readFileSync4(filePath, "utf-8");
+      const raw = readFileSync5(filePath, "utf-8");
       const truncated2 = raw.length > MAX_TEXT_SIZE;
       const content = truncated2 ? raw.slice(0, MAX_TEXT_SIZE) : raw;
       return { content, encoding: "utf-8", size: content.length, totalSize, mimeType, truncated: truncated2 };
     }
-    const buf = readFileSync4(filePath);
+    const buf = readFileSync5(filePath);
     const truncated = buf.length > MAX_TEXT_SIZE;
     const slice = truncated ? buf.subarray(0, MAX_TEXT_SIZE) : buf;
     return { content: slice.toString("base64"), encoding: "base64", size: slice.length, totalSize, mimeType, truncated };
   }
 };
 
+// src/worktree-bridge.ts
+import { spawn as spawn2 } from "child_process";
+import { existsSync as existsSync7 } from "fs";
+import { writeFile, rm } from "fs/promises";
+import { resolve as resolve2, isAbsolute as isAbsolute3, normalize, join as join6 } from "path";
+import { createLogger as createLogger9 } from "@mclawnet/logger";
+import { createDraftPR } from "@mclawnet/swarm";
+var log9 = createLogger9({ module: "worktree-bridge" });
+var WorktreeBridge = class {
+  constructor(hub) {
+    this.hub = hub;
+    this.hub.registerNamespace("worktree", (msg) => this.handle(msg));
+    log9.info("WorktreeBridge initialized");
+  }
+  async handle(msg) {
+    log9.info({ action: msg.action, requestId: msg.requestId }, "worktree request");
+    switch (msg.action) {
+      case "delete":
+        return this.deleteWorktree(msg.params);
+      case "ship":
+        return this.shipWorktree(msg.params);
+      default:
+        throw new Error(`Unknown worktree action: ${msg.action}`);
+    }
+  }
+  async deleteWorktree(params) {
+    const worktreePath = params.worktreePath;
+    const projectRoot2 = params.projectRoot;
+    const branchName = params.branchName;
+    const sessionId = params.sessionId;
+    const force = params.force === true;
+    if (typeof worktreePath !== "string" || !worktreePath.trim()) {
+      throw new Error("worktreePath required");
+    }
+    if (typeof projectRoot2 !== "string" || !projectRoot2.trim()) {
+      throw new Error("projectRoot required (used to find the repo root)");
+    }
+    if (!isAbsolute3(worktreePath) || !isAbsolute3(projectRoot2)) {
+      throw new Error("worktreePath and projectRoot must be absolute");
+    }
+    const expectedPrefix = normalize(resolve2(projectRoot2, ".worktrees")) + "/";
+    const candidate = normalize(resolve2(worktreePath));
+    if (!candidate.startsWith(expectedPrefix)) {
+      throw new Error(
+        `worktreePath ${worktreePath} is not under ${projectRoot2}/.worktrees/`
+      );
+    }
+    if (!existsSync7(candidate)) {
+      log9.info({ worktreePath: candidate }, "worktree path already gone");
+    } else {
+      const rm1 = await runGit(projectRoot2, ["worktree", "remove", "--force", candidate]);
+      if (rm1.exitCode !== 0) {
+        log9.warn(
+          { stderr: rm1.stderr, worktreePath: candidate },
+          "git worktree remove failed; falling back to rm -rf"
+        );
+        await rm(candidate, { recursive: true, force: true }).catch((err) => {
+          log9.warn({ err, worktreePath: candidate }, "rm -rf fallback also failed");
+        });
+        await runGit(projectRoot2, ["worktree", "prune"]).catch(() => null);
+      }
+    }
+    let branchDeleted = false;
+    if (typeof branchName === "string" && branchName.trim()) {
+      const branchFlag = force ? "-D" : "-d";
+      const br = await runGit(projectRoot2, ["branch", branchFlag, branchName]).catch(() => null);
+      if (br && br.exitCode === 0) {
+        branchDeleted = true;
+      } else if (br) {
+        log9.warn(
+          { branchName, stderr: br.stderr, force },
+          "branch delete refused; caller can retry with force=true"
+        );
+      }
+    }
+    const worktreeRemoved = !existsSync7(candidate);
+    this.maybeEmitDeleted(sessionId, candidate);
+    return {
+      ok: true,
+      worktreePath: candidate,
+      worktreeRemoved,
+      branchDeleted
+    };
+  }
+  /**
+   * Emit a session.worktree_deleted push frame after a successful delete so
+   * the hub can clear the DB columns and broadcast to other tabs. Caller
+   * passes sessionId via params; missing sessionId silently skips the push
+   * (delete still works — just no DB sync, used by cleanup tooling that
+   * doesn't have a session context).
+   */
+  maybeEmitDeleted(sessionId, cwd) {
+    if (typeof sessionId === "string" && sessionId) {
+      this.hub.send({
+        type: "session.worktree_deleted",
+        sessionId,
+        cwd
+      });
+    }
+  }
+  /**
+   * Ship a chat-session worktree: stage all changes, commit if dirty, then
+   * either push + open draft PR (when `gh` CLI is available) or fall back to
+   * writing diff.patch + report.md inside the worktree for manual `git apply`.
+   *
+   * Result shape mirrors M6 swarm ShipmentResult so the UI can render both
+   * with the same component (Banner + future shipment list view).
+   *
+   * No LLM involvement (chat sessions don't have a queen role to generate
+   * report bodies). Title/body are caller-provided (UI) or default to the
+   * branch name + short stat summary.
+   */
+  async shipWorktree(params) {
+    const worktreePath = params.worktreePath;
+    const projectRoot2 = params.projectRoot;
+    const branchName = params.branchName;
+    const sessionId = params.sessionId;
+    const hintedBaseBranch = typeof params.baseBranch === "string" ? params.baseBranch : null;
+    const title = params.title?.trim();
+    const body = params.body?.trim();
+    if (typeof worktreePath !== "string" || !isAbsolute3(worktreePath)) {
+      throw new Error("worktreePath required (absolute)");
+    }
+    if (typeof projectRoot2 !== "string" || !isAbsolute3(projectRoot2)) {
+      throw new Error("projectRoot required (absolute)");
+    }
+    if (typeof branchName !== "string" || !branchName.trim()) {
+      throw new Error("branchName required");
+    }
+    const expectedPrefix = normalize(resolve2(projectRoot2, ".worktrees")) + "/";
+    const cwd = normalize(resolve2(worktreePath));
+    if (!cwd.startsWith(expectedPrefix)) {
+      throw new Error(`worktreePath not under ${projectRoot2}/.worktrees/`);
+    }
+    if (!existsSync7(cwd)) {
+      throw new Error(`Worktree no longer exists at ${cwd}`);
+    }
+    const add = await runGit(cwd, ["add", "-A"]);
+    if (add.exitCode !== 0) {
+      throw new Error(`git add failed: ${add.stderr || add.stdout}`);
+    }
+    const status = await runGit(cwd, ["status", "--porcelain"]);
+    const dirty = status.exitCode === 0 && status.stdout.trim().length > 0;
+    if (dirty) {
+      const commitMsg = title || `chat: ${branchName.replace(/^clawnet\/chat-/, "")}`;
+      const commit = await runGit(cwd, ["commit", "-m", commitMsg]);
+      if (commit.exitCode !== 0) {
+        log9.warn(
+          { stderr: commit.stderr },
+          "chat ship: git commit failed (pre-commit hook?); retrying --no-verify"
+        );
+        const retry = await runGit(cwd, ["commit", "--no-verify", "-m", commitMsg]);
+        if (retry.exitCode !== 0) {
+          throw new Error(`git commit failed even with --no-verify: ${retry.stderr || retry.stdout}`);
+        }
+      }
+    }
+    let baseBranch = hintedBaseBranch ?? "main";
+    if (!hintedBaseBranch) {
+      const baseRes = await runGit(projectRoot2, [
+        "symbolic-ref",
+        "--short",
+        "refs/remotes/origin/HEAD"
+      ]).catch(() => null);
+      if (baseRes && baseRes.exitCode === 0) {
+        const trimmed = baseRes.stdout.trim();
+        const m = trimmed.match(/^origin\/(.+)$/);
+        if (m) baseBranch = m[1];
+      }
+    }
+    const ghCheck = await new Promise((res) => {
+      const c = spawn2("gh", ["--version"], { stdio: "ignore" });
+      c.on("error", () => res(false));
+      c.on("close", (code) => res(code === 0));
+    });
+    const finalTitle = title || `Chat session: ${branchName.replace(/^clawnet\/chat-/, "")}`;
+    const finalBody = body || `Automated ship of chat-session worktree \`${branchName}\`.
+
+Review the diff before merging.
+`;
+    if (ghCheck) {
+      const pr = await createDraftPR({
+        cwd,
+        branchName,
+        baseBranch,
+        title: finalTitle,
+        bodyMarkdown: finalBody
+      });
+      if (pr.ok) {
+        const result = {
+          ok: true,
+          strategy: "pr",
+          prUrl: pr.url,
+          branchName,
+          baseBranch,
+          dirty,
+          mergedAt: null
+        };
+        if (typeof sessionId === "string" && sessionId) {
+          this.hub.send({
+            type: "session.shipment_updated",
+            sessionId,
+            result
+          });
+        }
+        return result;
+      }
+      log9.warn(
+        { step: pr.step, error: pr.error, branchName },
+        "chat ship: PR creation failed, falling back to diff.patch"
+      );
+    }
+    const diffRes = await runGit(cwd, ["diff", baseBranch + "...HEAD"]);
+    const diff = diffRes.exitCode === 0 ? diffRes.stdout : "";
+    const diffPath = join6(cwd, "diff.patch");
+    const reportPath = join6(cwd, "report.md");
+    await writeFile(diffPath, diff, "utf-8");
+    await writeFile(reportPath, `# ${finalTitle}
+
+${finalBody}
+
+## Stats
+
+- Branch: \`${branchName}\`
+- Base: \`${baseBranch}\`
+- Diff size: ${diff.length} bytes
+`, "utf-8");
+    const fallbackResult = {
+      ok: true,
+      strategy: "diff-only",
+      branchName,
+      baseBranch,
+      dirty,
+      diffPath,
+      reportPath,
+      prUrl: null,
+      mergedAt: null
+    };
+    if (typeof sessionId === "string" && sessionId) {
+      this.hub.send({
+        type: "session.shipment_updated",
+        sessionId,
+        result: fallbackResult
+      });
+    }
+    return fallbackResult;
+  }
+};
+function runGit(cwd, args) {
+  return new Promise((resolveR) => {
+    const child = spawn2("git", ["-C", cwd, ...args], { stdio: ["ignore", "pipe", "pipe"] });
+    let stdout = "", stderr = "";
+    child.stdout?.on("data", (c) => stdout += c.toString("utf-8"));
+    child.stderr?.on("data", (c) => stderr += c.toString("utf-8"));
+    child.on("error", (e) => resolveR({ exitCode: -1, stdout, stderr: e.message }));
+    child.on("close", (code) => resolveR({ exitCode: code ?? -1, stdout, stderr }));
+  });
+}
+
 // src/templates-roles-bridge.ts
-import { createLogger as createLogger8 } from "@mclawnet/logger";
+import { createLogger as createLogger10 } from "@mclawnet/logger";
 import {
   listTemplatesWithSource,
   getTemplateRaw,
@@ -3384,7 +4721,7 @@ import {
   deleteRole,
   loadRole as loadRole2
 } from "@mclawnet/swarm";
-var log8 = createLogger8({ module: "templates-roles-bridge" });
+var log10 = createLogger10({ module: "templates-roles-bridge" });
 function requireStringParam(params, key) {
   const v = params[key];
   if (typeof v !== "string" || !v) throw new Error(`Missing '${key}' parameter`);
@@ -3395,10 +4732,10 @@ var TemplatesRolesBridge = class {
     this.hub = hub;
     this.hub.registerNamespace("templates", (msg) => this.handleTemplates(msg));
     this.hub.registerNamespace("roles", (msg) => this.handleRoles(msg));
-    log8.info("TemplatesRolesBridge initialized");
+    log10.info("TemplatesRolesBridge initialized");
   }
   async handleTemplates(msg) {
-    log8.info({ action: msg.action, requestId: msg.requestId }, "templates request");
+    log10.info({ action: msg.action, requestId: msg.requestId }, "templates request");
     switch (msg.action) {
       case "list":
         return { items: listTemplatesWithSource() };
@@ -3426,7 +4763,7 @@ var TemplatesRolesBridge = class {
     }
   }
   async handleRoles(msg) {
-    log8.info({ action: msg.action, requestId: msg.requestId }, "roles request");
+    log10.info({ action: msg.action, requestId: msg.requestId }, "roles request");
     switch (msg.action) {
       case "list":
         return { items: listRolesWithSource() };
@@ -3456,8 +4793,8 @@ var TemplatesRolesBridge = class {
 };
 
 // src/swarm-session-bridge.ts
-import { createLogger as createLogger9 } from "@mclawnet/logger";
-var log9 = createLogger9({ module: "agent:swarm-bridge" });
+import { createLogger as createLogger11 } from "@mclawnet/logger";
+var log11 = createLogger11({ module: "agent:swarm-bridge" });
 function createSwarmAwareSessionStartedHandler(deps) {
   return (sessionId, info) => {
     deps.hub.send({
@@ -3472,20 +4809,20 @@ function createSwarmAwareSessionStartedHandler(deps) {
           info.backendSessionId
         );
         if (!ok) {
-          log9.debug(
+          log11.debug(
             { sessionId },
             "session_started for swarm-shaped sessionId, but no matching role (already destroyed?)"
           );
         }
       } catch (err) {
-        log9.warn({ err, sessionId }, "failed to bridge session_started into swarm");
+        log11.warn({ err, sessionId }, "failed to bridge session_started into swarm");
       }
     }
   };
 }
 
 // src/start.ts
-import { createLogger as createLogger10 } from "@mclawnet/logger";
+import { createLogger as createLogger12 } from "@mclawnet/logger";
 import {
   initDatabase as initDatabase2,
   MemoryStore,
@@ -3500,30 +4837,31 @@ import {
   AccumulationScanner,
   triggerFromAccumulation
 } from "@mclawnet/skill-manager";
-import { PROJECTS_RPC_CAPABILITY } from "@mclawnet/shared";
-var log10 = createLogger10({ module: "agent" });
+import { PROJECTS_RPC_CAPABILITY, WORKDIR_RPC_CAPABILITY } from "@mclawnet/shared";
+var log12 = createLogger12({ module: "agent" });
 async function startAgent(options) {
   ensureRuntimeEnvDefaults();
   const config = loadConfig(options.config);
   if (!config.token) {
-    log10.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
+    log12.error("no token configured \u2014 set CLAWNET_TOKEN or use --token");
     process.exit(1);
   }
-  log10.info({ backend: options.adapter.type }, "starting agent");
-  log10.info({ hubUrl: config.hubUrl }, "connecting to hub");
+  log12.info({ backend: options.adapter.type }, "starting agent");
+  log12.info({ hubUrl: config.hubUrl }, "connecting to hub");
+  const workspaceManager = new WorkspaceManager();
   await initRoles();
   await initSkills();
   const hub = new HubConnection({
     hubUrl: config.hubUrl,
     token: config.token,
     hostname: config.name,
-    capabilities: [PROJECTS_RPC_CAPABILITY],
+    capabilities: [PROJECTS_RPC_CAPABILITY, WORKDIR_RPC_CAPABILITY],
     onConnect: (agentId) => {
-      log10.info({ agentId }, "connected to hub");
+      log12.info({ agentId }, "connected to hub");
       const skills = getSkillList();
       if (skills.length > 0) {
         hub.sendSkillList(skills);
-        log10.info({ count: skills.length }, "pushed skill list to hub");
+        log12.info({ count: skills.length }, "pushed skill list to hub");
       }
       void sessionManager.recoverFromCheckpoint().then((report) => {
         for (const entry of report.dead) {
@@ -3534,24 +4872,30 @@ async function startAgent(options) {
             backendSessionId: entry.backendSessionId
           });
         }
-        log10.info(
+        log12.info(
           { deadCount: report.dead.length, orphanCount: report.orphan.length },
           "checkpoint recover: cleanup complete"
         );
       }).catch((err) => {
-        log10.warn({ err }, "checkpoint recover: failed (degrading to no-op)");
+        log12.warn({ err }, "checkpoint recover: failed (degrading to no-op)");
       });
     },
     onDisconnect: (code, reason) => {
-      log10.info({ code, reason }, "disconnected from hub");
+      log12.info({ code, reason }, "disconnected from hub");
     },
     onError: (err) => {
-      log10.error({ err }, "hub connection error");
-    }
+      log12.error({ err }, "hub connection error");
+    },
+    // M7.3 user-active signal: route every inbound hub message through the
+    // projects-handler shim — at boot the AlwaysOnManager isn't constructed
+    // yet, but _registerAlwaysOnHooks (called below) backs the indirection.
+    onActivity: () => _recordAlwaysOnActivity(),
+    // (N5) Shared workspace manager for chat `useWorktree` prepare/dispose.
+    workspaceManager
   });
   let swarmCoordinator;
-  const clawnetDir = process.env.CLAWNET_DIR ?? join6(homedir5(), ".clawnet");
-  const dbPath = process.env.CLAWNET_MEMORY_DB ?? join6(clawnetDir, "memory.db");
+  const clawnetDir = process.env.CLAWNET_DIR ?? join7(homedir5(), ".clawnet");
+  const dbPath = process.env.CLAWNET_MEMORY_DB ?? join7(clawnetDir, "memory.db");
   let memoryStore = null;
   let embeddingService = null;
   let evolutionPipeline = null;
@@ -3564,7 +4908,7 @@ async function startAgent(options) {
     skillStore = new SkillStore(clawnetDir);
     evolutionPipeline = new EvolutionPipeline(clawnetDir);
   } catch (err) {
-    log10.warn({ err }, "failed to init memory/skill infra; distillation disabled");
+    log12.warn({ err }, "failed to init memory/skill infra; distillation disabled");
   }
   const onBeforeClose = async (sessionId, messages) => {
     if (messages.length === 0) return;
@@ -3577,7 +4921,7 @@ async function startAgent(options) {
         embeddingService
       );
     } catch (err) {
-      log10.warn({ err, sessionId }, "distillation failed (non-fatal)");
+      log12.warn({ err, sessionId }, "distillation failed (non-fatal)");
     }
     try {
       if (!skillStore || !evolutionPipeline) return;
@@ -3599,13 +4943,13 @@ async function startAgent(options) {
         await triggerFromAccumulation(signals, evolutionPipeline);
       }
     } catch (err) {
-      log10.warn({ err, sessionId }, "accumulation scan failed (non-fatal)");
+      log12.warn({ err, sessionId }, "accumulation scan failed (non-fatal)");
     }
   };
   const sessionManager = new SessionManager({
     adapter: options.adapter,
     resolveAdapter: async (kind) => {
-      const { createBackendAdapter } = await import("./backend-factory-VRPU3534.js");
+      const { createBackendAdapter } = await import("./backend-factory-AFF6I7YF.js");
       return createBackendAdapter(kind);
     },
     onOutput: (sessionId, data) => {
@@ -3647,7 +4991,7 @@ async function startAgent(options) {
       try {
         swarmCoordinator.handleRoleCrashed(sessionId, info.reason ?? `exit code=${info.code ?? "null"}`);
       } catch (err) {
-        log10.warn({ err, sessionId }, "swarmCoordinator.handleRoleCrashed threw");
+        log12.warn({ err, sessionId }, "swarmCoordinator.handleRoleCrashed threw");
       }
     },
     onBeforeClose,
@@ -3663,6 +5007,28 @@ async function startAgent(options) {
         meta: req.meta
       });
     },
+    // (N5) Chat session close → dispose the attached workspace (keep=true)
+    // and notify hub so the browser can render the "worktree retained" toast.
+    // dispose accepts swarmId, not the handle itself (see
+    // packages/@clawnet/swarm/src/workspace/workspace-manager.ts:75).
+    onWorkspaceClose: (sessionId, handle) => {
+      log12.info(
+        { sessionId, swarmId: handle.swarmId, cwd: handle.cwd, strategy: handle.strategy },
+        "N5: disposing workspace (keep=true) for chat session close"
+      );
+      workspaceManager.dispose(handle.swarmId, { keep: true }).catch((err) => {
+        log12.warn(
+          { err, sessionId, swarmId: handle.swarmId, cwd: handle.cwd },
+          "workspace dispose failed (best-effort)"
+        );
+      });
+      hub.send({
+        type: "session.worktree_closed",
+        sessionId,
+        cwd: handle.cwd,
+        branchName: handle.metadata.branchName ?? null
+      });
+    },
     // PR-A: classify session kind for the idle sweeper. SessionManager stays
     // independent of the swarm package; we hand it a closure that defers to
     // SwarmCoordinator (created below) at call time. Lazy-read is safe because
@@ -3672,7 +5038,7 @@ async function startAgent(options) {
     // PR-C: enable logical-state checkpoint. Lives next to memory.db under
     // CLAWNET_DIR so backup/wipe affects both consistently. Per-call writes
     // are debounced to 5s by SessionManager itself.
-    checkpointPath: join6(clawnetDir, "agent-sessions.json")
+    checkpointPath: join7(clawnetDir, "agent-sessions.json")
   });
   swarmCoordinator = new SwarmCoordinator(sessionManager, hub, (workDir) => {
     try {
@@ -3680,10 +5046,10 @@ async function startAgent(options) {
       const home = env ? env.replace(/\/\.clawnet\/?$/, "") : homedir5();
       return new TaskStore2({ workDir, home });
     } catch (err) {
-      log10.warn({ err, workDir }, "TaskStore factory failed");
+      log12.warn({ err, workDir }, "TaskStore factory failed");
       return void 0;
     }
-  }, process.env.CLAWNET_HOME ?? homedir5());
+  }, process.env.CLAWNET_HOME ?? homedir5(), workspaceManager);
   hub.setSessionManager(sessionManager);
   hub.setSwarmCoordinator(swarmCoordinator);
   const wakeupHome = process.env.CLAWNET_HOME ?? homedir5();
@@ -3695,18 +5061,140 @@ async function startAgent(options) {
     }));
     await wakeupScheduler.restoreFromInbox(wakeupHome, knownSwarms);
   } catch (err) {
-    log10.warn({ err }, "WakeupScheduler.restoreFromInbox failed (non-fatal)");
+    log12.warn({ err }, "WakeupScheduler.restoreFromInbox failed (non-fatal)");
   }
   const scheduleRuntime = new ScheduleRuntime({ hub, sessionManager, swarmCoordinator });
   hub.setScheduleRuntime(scheduleRuntime);
   await scheduleRuntime.start();
+  const alwaysOnHome = process.env.CLAWNET_HOME ?? homedir5();
+  const taskStoreFactory = (projectRoot2) => {
+    try {
+      return new TaskStore2({ workDir: projectRoot2, home: alwaysOnHome });
+    } catch (err) {
+      log12.warn(
+        { err: err instanceof Error ? err.message : String(err), projectRoot: projectRoot2 },
+        "TaskStore factory failed (always-on)"
+      );
+      return void 0;
+    }
+  };
+  let ideasClient = null;
+  try {
+    ideasClient = createIdeasRestClient({
+      hubUrl: config.hubUrl,
+      getAuthToken: () => config.token || null
+    });
+  } catch (err) {
+    log12.warn(
+      { err: err instanceof Error ? err.message : String(err) },
+      "ideas REST client init failed \u2014 IdeaTodoSource will be skipped"
+    );
+  }
+  const taskSources = [];
+  if (ideasClient) {
+    taskSources.push(
+      createIdeaTodoSource({
+        ideasClient,
+        warn: (obj, msg) => log12.warn(obj, msg),
+        info: (obj, msg) => log12.info(obj, msg)
+      }),
+      // M8.1 — research cycle source. Consumes status="idea" ideas, runs the
+      // `research-only` template, and writes a ResearchRef + transitions the
+      // idea status per the report's frontmatter `conclusion`.
+      createIdeaResearchSource({
+        ideasClient,
+        warn: (obj, msg) => log12.warn(obj, msg),
+        info: (obj, msg) => log12.info(obj, msg)
+      }),
+      // M8.2 — queen self-introspection (opt-in via
+      // always-on.json `taskSources.introspection: true`). Pick() side-effects
+      // a small introspection swarm that POSTs new ideas to /api/ideas and
+      // always returns null — the cycle "skips" from the runner's perspective
+      // and the user reviews the auto-discovered ideas next time. Independent
+      // 24h cooldown; self-suppresses when the prior cohort was all archived.
+      createIntrospectionSource({
+        ideasClient,
+        swarmCoordinator,
+        getConfig: (projectRoot2) => loadAlwaysOnConfig2(projectRoot2, alwaysOnHome),
+        updateConfig: async (projectRoot2, patch) => {
+          const current = loadAlwaysOnConfig2(projectRoot2, alwaysOnHome);
+          const next = mergeAlwaysOnConfig2(current, patch);
+          saveAlwaysOnConfig2(projectRoot2, alwaysOnHome, next);
+        },
+        warn: (obj, msg) => log12.warn(obj, msg),
+        info: (obj, msg) => log12.info(obj, msg)
+      })
+    );
+  }
+  const alwaysOnManager = new AlwaysOnManager({
+    home: alwaysOnHome,
+    swarmCoordinator,
+    taskSources
+  });
+  _registerAlwaysOnHooks({
+    getSnapshot: (workDir) => alwaysOnManager.snapshot(workDir),
+    applyConfig: (workDir) => {
+      void alwaysOnManager.refreshFromDisk(workDir).catch((err) => {
+        log12.warn({ err, workDir }, "always-on refreshFromDisk failed");
+      });
+    },
+    recordActivity: () => alwaysOnManager.recordActivity(),
+    // B6 — dev-only force-tick. Hub gates the HTTP route on
+    // NODE_ENV !== "production", so this hook is only reachable from
+    // localhost dev tooling. Errors propagate verbatim so the handler can
+    // classify them (no scheduler / tick already in flight / other) and
+    // return an actionable message to the dev tool. The previous version
+    // caught everything and returned null, which made the handler always
+    // report "scheduler not booted" even when the real cause differed.
+    forceTick: async (workDir) => alwaysOnManager.forceTick(workDir)
+  });
+  const bootedProjectRoots = [];
+  try {
+    const dirs = listProjectDirs(alwaysOnHome);
+    for (const encoded of dirs) {
+      const workDir = resolveWorkDir2(alwaysOnHome, encoded);
+      if (!workDir) continue;
+      const cfgPath = alwaysOnConfigPath(workDir, alwaysOnHome);
+      if (!existsSync8(cfgPath)) continue;
+      try {
+        await alwaysOnManager.start(workDir);
+        bootedProjectRoots.push(workDir);
+      } catch (err) {
+        log12.warn(
+          { err: err instanceof Error ? err.message : String(err), workDir },
+          "always-on scheduler boot failed for project (continuing with others)"
+        );
+      }
+    }
+  } catch (err) {
+    log12.warn({ err }, "always-on boot scan failed (non-fatal)");
+  }
+  if (ideasClient && bootedProjectRoots.length > 0) {
+    void reconcileOrphanedResearching({
+      ideasClient,
+      getProjectRoots: () => bootedProjectRoots,
+      listRecoverableSwarmIds: listRecoverableSwarmIds2,
+      log: {
+        warn: (obj, msg) => log12.warn(obj, msg),
+        info: (obj, msg) => log12.info(obj, msg)
+      }
+    }).catch((err) => {
+      log12.warn({ err: err instanceof Error ? err.message : String(err) }, "reconcile sweep threw");
+    });
+  }
   const brainBridge = new BrainBridge(hub);
   const fsBridge = new FsBridge(hub);
+  new WorktreeBridge(hub);
   const templatesRolesBridge = new TemplatesRolesBridge(hub);
   sessionManager.startIdleSweeper();
   const shutdown = async () => {
-    log10.info("shutting down");
+    log12.info("shutting down");
     wakeupScheduler.dispose();
+    try {
+      await alwaysOnManager.disposeAll();
+    } catch (err) {
+      log12.warn({ err }, "alwaysOnManager.disposeAll failed");
+    }
     await sessionManager.closeAll();
     await scheduleRuntime.stop();
     hub.destroy();
@@ -3714,7 +5202,7 @@ async function startAgent(options) {
       try {
         memoryDb.close();
       } catch (err) {
-        log10.warn({ err }, "failed to close memory db");
+        log12.warn({ err }, "failed to close memory db");
       }
     }
     process.exit(0);
@@ -3732,4 +5220,4 @@ export {
   FsBridge,
   startAgent
 };
-//# sourceMappingURL=chunk-B733MQCA.js.map
+//# sourceMappingURL=chunk-GOCWMRBB.js.map