@scalequality/cli 0.4.8 → 0.4.9-rc.2

package/dist/connect.build.json

@@ -1,5 +1,5 @@
 {
   "sdkVersion": "0.3.281",
-  "sha256": "2cc2b586649f475725d306b032e821c01721bcd6bfa560f8423ad9de3e189050",
-  "sourceCommit": "b252300744f0d3132910cba3d700faf23a2c468b"
+  "sha256": "f9a1832f530428fd24a48cc17074549aab70faa7ba2f419f3f372321fbe81b0a",
+  "sourceCommit": "59a3d8bb1500daa81edb1d977bccf6a459954c5f"
 }

package/dist/connect.cjs

@@ -2602,6 +2602,28 @@ var ConsoleLog = class {
     }
   }
 };
+function turnTimingLine(ctx) {
+  if (!ctx || ctx.event !== "WORKSPACE_TURN_TIMING") return null;
+  const ms = (k) => typeof ctx[k] === "number" ? ctx[k] : null;
+  const secs = (v) => v >= 1e4 ? `${(v / 1e3).toFixed(1)} s` : `${Math.round(v)} ms`;
+  const parts = [];
+  const first = ms("firstModelEventMs");
+  parts.push(`first model event ${first === null ? "none" : secs(first)}`);
+  const phases = [
+    ms("prepareMs") !== null ? `prepare ${secs(ms("prepareMs"))}` : null,
+    ctx.warmStart === true ? "engine started ahead" : ctx.warmStart === false ? "engine started for it" : null,
+    ms("engineReadyMs") !== null ? `engine ready ${secs(ms("engineReadyMs"))}` : null,
+    ms("checkpointMs") !== null ? `saved point ${secs(ms("checkpointMs"))}` : null,
+    ms("toolWaitMs") !== null ? `tools waited ${secs(ms("toolWaitMs"))}` : null
+  ].filter(Boolean);
+  if (phases.length) parts.push(`(${phases.join(", ")})`);
+  const permissions = ms("permissions");
+  if (permissions) parts.push(`; ${permissions} permission${permissions === 1 ? "" : "s"} ${secs(ms("permissionMs") ?? 0)}`);
+  const total = ms("totalMs");
+  if (total !== null) parts.push(`; total ${secs(total)}`);
+  if (typeof ctx.outcome === "string" && ctx.outcome !== "completed") parts.push(`(${ctx.outcome})`);
+  return `Timing: ${parts.join(" ").replace(/ ;/g, ";")}`;
+}
 function banner(boot, local, style2, warnings) {
   const model = boot.runtime.primaryModel || boot.model;
   const repos = bootScopeRepos(boot);
@@ -2965,6 +2987,7 @@ function removeStableCopies(home, keep = null) {
 function serviceArgs(env, bin, api) {
   return [env.nodePath, bin, "up", "--api", api, "--service"];
 }
+var LAUNCHD_PROCESS_TYPE = "Interactive";
 var xml = (s) => s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
 function launchAgentPlist(env, bin, api) {
   const names = serviceNames(api);
@@ -2990,7 +3013,7 @@ ${args}
     <key>ThrottleInterval</key>
     <integer>10</integer>
     <key>ProcessType</key>
-    <string>Background</string>
+    <string>${LAUNCHD_PROCESS_TYPE}</string>
     <key>WorkingDirectory</key>
     <string>${xml(env.home)}</string>
     <key>EnvironmentVariables</key>
@@ -3042,18 +3065,29 @@ function writeFileSafely(file, content, mode = 420) {
   (0, import_fs5.renameSync)(tmp, file);
 }
 var failed = (r) => `${r.stderr || r.stdout}`.trim().split("\n").slice(-1)[0]?.slice(0, 200) || `exit ${r.code}`;
+var LAUNCHD_REPLACE_WAIT_MS = 3e4;
+var LAUNCHD_POLL_MS = 500;
+var LAUNCHD_BOOTSTRAP_ATTEMPTS = 6;
 async function installLaunchd(env, bin, api) {
   const names = serviceNames(api);
   const plist = launchAgentPath(env, api);
   (0, import_fs5.mkdirSync)(logDir(env), { recursive: true });
   writeFileSafely(plist, launchAgentPlist(env, bin, api));
   const domain = `gui/${env.uid}`;
-  await env.run("launchctl", ["bootout", `${domain}/${names.label}`]);
-  await env.run("launchctl", ["enable", `${domain}/${names.label}`]);
-  const boot = await env.run("launchctl", ["bootstrap", domain, plist]);
+  const sleep2 = env.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const target = `${domain}/${names.label}`;
+  const loaded = async () => (await env.run("launchctl", ["print", target])).code === 0;
+  await env.run("launchctl", ["bootout", target]);
+  for (let waited = 0; waited < LAUNCHD_REPLACE_WAIT_MS && await loaded(); waited += LAUNCHD_POLL_MS) await sleep2(LAUNCHD_POLL_MS);
+  await env.run("launchctl", ["enable", target]);
+  let boot = await env.run("launchctl", ["bootstrap", domain, plist]);
+  for (let attempt = 1; boot.code !== 0 && attempt < LAUNCHD_BOOTSTRAP_ATTEMPTS; attempt++) {
+    await sleep2(LAUNCHD_POLL_MS);
+    boot = await env.run("launchctl", ["bootstrap", domain, plist]);
+  }
   if (boot.code === 0) return { ok: true, manager: "launchd", hints: [] };
   const legacy = await env.run("launchctl", ["load", "-w", plist]);
-  if (legacy.code === 0) return { ok: true, manager: "launchd", hints: [] };
+  if (legacy.code === 0 && await loaded()) return { ok: true, manager: "launchd", hints: [] };
   (0, import_fs5.rmSync)(plist, { force: true });
   return { ok: false, code: "LAUNCHD_REFUSED", message: `macOS did not accept the background service (${failed(boot)}). A device management profile may block login items.` };
 }
@@ -4411,7 +4445,7 @@ function limitInEngineText(text3) {
 // src/application/services/workspaceSandbox/scalequalityTools.ts
 var import_crypto4 = require("crypto");
 
-// ../aigov-code-queue/node_modules/zod/v3/external.js
+// ../../../../../../../Users/erikfernandes/GIT/load-n-scale/.codex-worktrees/aigov-code-queue/node_modules/zod/v3/external.js
 var external_exports = {};
 __export(external_exports, {
   BRAND: () => BRAND,
@@ -4523,7 +4557,7 @@ __export(external_exports, {
   void: () => voidType
 });
 
-// ../aigov-code-queue/node_modules/zod/v3/helpers/util.js
+// ../../../../../../../Users/erikfernandes/GIT/load-n-scale/.codex-worktrees/aigov-code-queue/node_modules/zod/v3/helpers/util.js
 var util;
 (function(util2) {
   util2.assertEqual = (_) => {
@@ -4657,7 +4691,7 @@ var getParsedType = (data) => {
   }
 };
 
-// ../aigov-code-queue/node_modules/zod/v3/ZodError.js
+// ../../../../../../../Users/erikfernandes/GIT/load-n-scale/.codex-worktrees/aigov-code-queue/node_modules/zod/v3/ZodError.js
 var ZodIssueCode = util.arrayToEnum([
   "invalid_type",
   "invalid_literal",
@@ -4775,7 +4809,7 @@ ZodError.create = (issues) => {
   return error;
 };
 
-// ../aigov-code-queue/node_modules/zod/v3/locales/en.js
+// ../../../../../../../Users/erikfernandes/GIT/load-n-scale/.codex-worktrees/aigov-code-queue/node_modules/zod/v3/locales/en.js
 var errorMap = (issue, _ctx) => {
   let message;
   switch (issue.code) {
@@ -4878,7 +4912,7 @@ var errorMap = (issue, _ctx) => {
 };
 var en_default = errorMap;
 
-// ../aigov-code-queue/node_modules/zod/v3/errors.js
+// ../../../../../../../Users/erikfernandes/GIT/load-n-scale/.codex-worktrees/aigov-code-queue/node_modules/zod/v3/errors.js
 var overrideErrorMap = en_default;
 function setErrorMap(map) {
   overrideErrorMap = map;
@@ -4887,7 +4921,7 @@ function getErrorMap() {
   return overrideErrorMap;
 }
 
-// ../aigov-code-queue/node_modules/zod/v3/helpers/parseUtil.js
+// ../../../../../../../Users/erikfernandes/GIT/load-n-scale/.codex-worktrees/aigov-code-queue/node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
   const { data, path, errorMaps, issueData } = params;
   const fullPath = [...path, ...issueData.path || []];
@@ -4997,14 +5031,14 @@ var isDirty = (x) => x.status === "dirty";
 var isValid = (x) => x.status === "valid";
 var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
 
-// ../aigov-code-queue/node_modules/zod/v3/helpers/errorUtil.js
+// ../../../../../../../Users/erikfernandes/GIT/load-n-scale/.codex-worktrees/aigov-code-queue/node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil;
 (function(errorUtil2) {
   errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
   errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
 })(errorUtil || (errorUtil = {}));
 
-// ../aigov-code-queue/node_modules/zod/v3/types.js
+// ../../../../../../../Users/erikfernandes/GIT/load-n-scale/.codex-worktrees/aigov-code-queue/node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
   constructor(parent, value, path, key) {
     this._cachedPath = [];
@@ -9164,6 +9198,28 @@ var TurnTiming = class {
   calls = 0;
   answers = /* @__PURE__ */ new Set();
   done = false;
+  firstFrame = null;
+  phase = {};
+  permissionTotal = 0;
+  permissionCount = 0;
+  toolWaitTotal = 0;
+  /** Durations (ms) and flags of the turn's own phases. */
+  phases(p) {
+    Object.assign(this.phase, p);
+  }
+  /** Any frame from the engine process (the first one says it is up and has the message). */
+  engineFrame() {
+    if (this.firstFrame === null) this.firstFrame = this.now();
+  }
+  /** A command or change permission the engine asked for (the rules, the person's mode or the person answered). */
+  permission(ms) {
+    this.permissionTotal += ms;
+    this.permissionCount += 1;
+  }
+  /** A tool waited for the turn's saved point. */
+  toolWait(ms) {
+    this.toolWaitTotal += ms;
+  }
   /** Any frame of the main conversation that came from the model. */
   modelEvent() {
     if (this.firstModel === null) this.firstModel = this.now();
@@ -9200,6 +9256,10 @@ var TurnTiming = class {
       firstVisibleEventMs: since(this.firstVisible),
       totalMs: end - this.startedAt,
       modelCalls: this.calls,
+      ...this.phase,
+      engineReadyMs: since(this.firstFrame),
+      ...this.permissionCount ? { permissions: this.permissionCount, permissionMs: this.permissionTotal } : {},
+      ...this.toolWaitTotal ? { toolWaitMs: this.toolWaitTotal } : {},
       outcome,
       ...extra
     });
@@ -9836,6 +9896,7 @@ ${lines2.join("\n")}
 }
 
 // src/application/services/workspaceSandbox/WorkspaceEngine.ts
+var WARM_IDLE_MS = 15 * 6e4;
 var STOP_GRACE_MS = 8e3;
 var INTERRUPT_TIMEOUT_MS = 3e3;
 var MODEL_TOOLS = ["Read", "Write", "Edit", "NotebookEdit", "Glob", "Grep", "Bash", "TaskStop", "TodoWrite", "Agent", "WebFetch", "Skill"];
@@ -10032,6 +10093,14 @@ var WorkspaceEngine = class {
   envTrouble = [];
   /** The organization's approved MCP servers: their catalog and the in-process servers that forward to the API. */
   orgMcp = null;
+  /**
+   * The saved point of the turn the engine runs now: every tool waits for it (the PreToolUse hook and the permission
+   * prompt), so the engine process starts while it is taken and no tool changes a file before it is recorded.
+   */
+  toolGate = Promise.resolve();
+  /** The engine process started for the next turn (warmStart), and the start options it was given (their hash). */
+  warm = null;
+  prewarming = null;
   emit(e) {
     if (e.type === "terminal" && e.data.chunk === void 0 && this.folderBaseline) this.sweepPending = true;
     if (this.turnWatch) {
@@ -10221,6 +10290,7 @@ var WorkspaceEngine = class {
     if (this.resumedFromCheckpoint) await this.diffNow();
     this.phase("READY");
     await this.sink.flush();
+    this.prewarm();
     return true;
   }
   /** Where a background command writes its output: inside the config dir, which Read may read. */
@@ -10556,6 +10626,7 @@ var WorkspaceEngine = class {
       } finally {
         this.turnRunning = null;
       }
+      this.prewarm();
     })();
   }
   /** Waits for the current turn (test and shutdown helper). */
@@ -10839,14 +10910,16 @@ ${String(item.content)}` : String(item.content);
     this.recordCheckpoint(turnId, await this.takeSnapshot());
   }
   async takeSnapshot() {
+    const sdkSessionId = this.sdkSessionId;
+    const resumeAt = this.resumeAt ?? this.lastChainUuid;
     const trees = /* @__PURE__ */ new Map();
-    await this.folderBaseline;
+    await this.folderBaseline?.catch(() => void 0);
     for (const repo2 of this.repos.values()) {
       if (repo2.dormant) continue;
       const tree = await repo2.tracker.snapshot().catch(() => null);
       if (tree) trees.set(repo2.root, tree);
     }
-    return { trees, sdkSessionId: this.sdkSessionId, resumeAt: this.resumeAt ?? this.lastChainUuid };
+    return { trees, sdkSessionId, resumeAt };
   }
   recordCheckpoint(turnId, snap) {
     const at = iso2();
@@ -11220,9 +11293,16 @@ ${json}
     this.turnWatch = { lastExit: null, errored: false };
     if (!compact && typeof payload.turnId === "string" && payload.turnId) this.messageStatus(turnId, "started");
     this.setState("WORKING");
-    if (!compact) await this.checkpointTurn(turnId);
+    let checkpointMs = null;
+    const saved = compact ? Promise.resolve() : this.checkpointTurn(turnId).then(() => {
+      checkpointMs = Date.now() - turnStart;
+    }, (e) => {
+      this.deps.log.warn("turn checkpoint failed", { error: this.redactor.text(e.message) });
+    });
+    this.toolGate = saved;
     if (!compact) {
       await this.refreshSkills();
+      if (!this.local) await saved;
       this.startEnvSetups();
       await Promise.all(this.envSetups.values());
     }
@@ -11320,6 +11400,9 @@ ${text3}`;
       timing: new TurnTiming({ sessionId: this.deps.sessionId ?? null, turnId, model, reasoning: this.reasoningLevel }, typeof payload.receivedAt === "number" ? payload.receivedAt : null, turnStart)
     };
     this.live = live;
+    void saved.then(() => {
+      if (checkpointMs !== null) live.timing.phases({ checkpointMs });
+    });
     const attempt = async (resume, at) => {
       let sawInit = false;
       let conversation = resume;
@@ -11356,41 +11439,26 @@ ${text3}`;
       live.turnEnded = false;
       live.headResult = null;
       channel.start(userMessage(turnPrompt, context.images, messageUuid(turnId)));
-      const options = buildQueryOptions({
-        root: this.deps.root,
-        model,
-        resume,
-        resumeAt: resume ? at : null,
-        abortController: ac,
-        reasoning: reasoning.options,
-        env: buildEngineEnv(boot, this.deps.configDir, model, { local: this.local, reasoning, output, extraEnv: this.projectEnv(), plan: planMode }),
-        mcpServer: this.mcpServer,
-        systemAppend: await this.systemAppend(),
-        policy: {
-          root: this.deps.root,
-          extraReadRoots: [this.deps.configDir],
-          deniedRoots: this.deps.privateDirs,
-          local: this.local,
-          plan: planMode,
-          planDir: (0, import_path15.join)(this.deps.configDir, "plans"),
-          orgMcpTools: orgMcpToolNames(Object.keys(off.mcpServers).length ? off.mcpCatalog : null)
-        },
-        plan: planMode,
-        onPlan: (text3) => this.proposePlan(live.turnId, text3),
-        skills: { dir: this.skillsDir(), enabled: enabledSkillNames(off.skillEntries), pluginDirs: off.pluginDirs },
-        ...Object.keys(off.mcpServers).length ? { orgMcpServers: off.mcpServers } : {},
-        pathToClaudeCodeExecutable: this.deps.pathToClaudeCodeExecutable,
-        commandGate: this.deps.commandGate,
-        ...this.localFolder?.kind === "folder" ? { beforeWrite: (path) => this.beforeFolderWrite(path) } : {}
-      });
+      const inputs = await this.engineInputs({ model, reasoning, output, planMode, off, resume, resumeAt: resume ? at : null });
       if (!streaming) channel.close();
       const single = (text3) => context.images.length ? (async function* () {
         yield userMessage(text3, context.images);
       })() : text3;
-      const q = sdk.query({ prompt: streaming ? channel : single(turnPrompt), options });
+      const warm = streaming ? await this.claimWarm(spawnKey(inputs)) : (this.dropWarm(), null);
+      let q;
+      if (warm) {
+        const forward = () => warm.abort.abort();
+        if (ac.signal.aborted) forward();
+        else ac.signal.addEventListener("abort", forward, { once: true });
+        q = warm.handle.query(channel);
+      } else {
+        q = sdk.query({ prompt: streaming ? channel : single(turnPrompt), options: this.queryOptions(inputs, ac, this.mcpServer) });
+      }
+      live.timing.phases({ prepareMs: Date.now() - turnStart, warmStart: !!warm });
       live.query = q;
       try {
         for await (const msg of q) {
+          live.timing.engineFrame();
           const f = msg && typeof msg === "object" ? msg : {};
           const main2 = !f.parent_tool_use_id;
           if (f.type === "command_lifecycle") {
@@ -11445,6 +11513,7 @@ ${text3}`;
       }
     } finally {
       const stopped = ac.signal.aborted || live.interrupted;
+      await saved;
       live.timing.end(this.deps.log, stopped ? "stopped" : "failed");
       this.live = null;
       this.turnAbort = null;
@@ -11585,6 +11654,7 @@ ${text3}`;
     }
     live.between = true;
     live.snapshot = this.takeSnapshot();
+    this.toolGate = live.snapshot.then(() => void 0, () => void 0);
   }
   /** The query ended: its input closes, and a message it never read runs as the next turn (or is dropped by a rewind). */
   settleLive(live) {
@@ -11625,6 +11695,146 @@ ${text3}`;
       output: { limit: own ?? boot.runtime.maxOutputTokensCeiling ?? boot.runtime.maxOutputTokens ?? null, ceiling: own ?? boot.runtime.maxOutputTokensCeiling ?? boot.runtime.maxOutputTokens ?? null }
     };
   }
+  /** The data a turn's engine process starts with (see EngineInputs). */
+  async engineInputs(t) {
+    const boot = this.boot;
+    const org = Object.keys(t.off.mcpServers).length > 0;
+    return {
+      model: t.model,
+      resume: t.resume,
+      resumeAt: t.resumeAt,
+      reasoning: t.reasoning.options,
+      env: buildEngineEnv(boot, this.deps.configDir, t.model, { local: this.local, reasoning: t.reasoning, output: t.output, extraEnv: this.projectEnv(), plan: t.planMode }),
+      systemAppend: await this.systemAppend(),
+      policy: {
+        root: this.deps.root,
+        extraReadRoots: [this.deps.configDir],
+        deniedRoots: this.deps.privateDirs,
+        local: this.local,
+        plan: t.planMode,
+        planDir: (0, import_path15.join)(this.deps.configDir, "plans"),
+        orgMcpTools: orgMcpToolNames(org ? t.off.mcpCatalog : null)
+      },
+      plan: t.planMode,
+      skills: { dir: this.skillsDir(), enabled: enabledSkillNames(t.off.skillEntries), pluginDirs: t.off.pluginDirs },
+      skillsKey: this.skillsSent,
+      orgMcpServers: org ? t.off.mcpServers : {},
+      folderWrites: this.localFolder?.kind === "folder"
+    };
+  }
+  /**
+   * The query options of a turn's engine process. The callbacks read the engine's current turn (never one captured
+   * here), so a process started ahead serves the turn that takes it: its plan goes to that turn, and its tools wait
+   * for that turn's saved point.
+   */
+  queryOptions(i, abortController, mcpServer) {
+    const gate = this.deps.commandGate;
+    return buildQueryOptions({
+      root: this.deps.root,
+      model: i.model,
+      resume: i.resume,
+      resumeAt: i.resumeAt,
+      abortController,
+      reasoning: i.reasoning,
+      env: i.env,
+      mcpServer,
+      systemAppend: i.systemAppend,
+      policy: i.policy,
+      plan: i.plan,
+      onPlan: (text3) => {
+        const live = this.live;
+        if (live) this.proposePlan(live.turnId, text3);
+      },
+      skills: i.skills,
+      ...Object.keys(i.orgMcpServers).length ? { orgMcpServers: i.orgMcpServers } : {},
+      pathToClaudeCodeExecutable: this.deps.pathToClaudeCodeExecutable,
+      commandGate: gate ? timedGate(gate, (ms) => this.live?.timing.permission(ms)) : void 0,
+      beforeTool: async () => {
+        const t0 = Date.now();
+        await this.toolGate;
+        const waited = Date.now() - t0;
+        if (waited > 0) this.live?.timing.toolWait(waited);
+      },
+      ...i.folderWrites ? { beforeWrite: (path) => this.beforeFolderWrite(path) } : {}
+    });
+  }
+  /**
+   * The inputs of the next turn as the person would most likely send it (same model, reasoning, mode and tools as the
+   * session now, an everyday task), for the process started ahead. null when that process could not serve it safely:
+   * the organization's MCP servers are in-process objects shared by every process, and one serves one process at a time.
+   */
+  async nextTurnInputs() {
+    const boot = this.boot;
+    const off = this.turnOff(void 0);
+    if (Object.keys(off.mcpServers).length) return null;
+    const primary = boot.runtime.primaryModel || boot.model;
+    const route = routeAutoTurn(boot, {
+      content: "",
+      previousTrouble: this.previousTrouble,
+      maxMode: this.reasoningLevel === "max" || isMaxMode(this.reasoningLevel, this.reasoningCapability)
+    });
+    const { model, reasoning, output } = this.turnModel(primary, route);
+    const canResume = !!this.sdkSessionId && (this.knownSessions.has(this.sdkSessionId) || await hasLocalTranscript(this.deps.configDir, this.sdkSessionId));
+    return this.engineInputs({ model, reasoning, output, planMode: false, off, resume: canResume ? this.sdkSessionId : null, resumeAt: canResume ? this.resumeAt : null });
+  }
+  /**
+   * Starts the engine process of the next turn now (warmStart), while the session waits for the person: Claude Code
+   * keeps its process up between messages, and here the next message then goes to a ready process. Only when nothing
+   * runs or waits; a process already started with the same inputs is kept.
+   */
+  prewarm() {
+    const sdk = this.sdk;
+    if (!this.deps.warmStart || !sdk?.startup || !this.boot || this.stopping || this.turnRunning || this.queue.length || this.prewarming) return;
+    this.prewarming = (async () => {
+      const inputs = await this.nextTurnInputs();
+      if (!inputs || this.stopping || this.turnRunning || this.queue.length) return;
+      const key = spawnKey(inputs);
+      if (this.warm?.key === key) return;
+      this.dropWarm();
+      const abort = new AbortController();
+      const server = buildScaleQualityServer(sdk, this.toolHost());
+      const ready = sdk.startup({ options: this.queryOptions(inputs, abort, server) }).catch((e) => {
+        this.deps.log.warn("engine warm start failed", { error: this.redactor.text(e.message) });
+        return null;
+      });
+      const timer = setTimeout(() => {
+        if (this.warm?.abort === abort) this.dropWarm();
+      }, this.deps.warmIdleMs ?? WARM_IDLE_MS);
+      timer.unref?.();
+      this.warm = { key, abort, ready, timer };
+    })().catch((e) => {
+      this.deps.log.warn("engine warm start failed", { error: this.redactor.text(e.message) });
+    }).finally(() => {
+      this.prewarming = null;
+    });
+  }
+  /** The process started ahead, for a turn with this start key; any other is closed (the turn starts its own). */
+  async claimWarm(key) {
+    await this.prewarming;
+    const w = this.warm;
+    if (!w) return null;
+    if (w.key !== key) {
+      this.dropWarm();
+      return null;
+    }
+    this.warm = null;
+    clearTimeout(w.timer);
+    const handle = await w.ready;
+    return handle ? { handle, abort: w.abort } : null;
+  }
+  /** Closes the process started ahead, if any. */
+  dropWarm() {
+    const w = this.warm;
+    if (!w) return;
+    this.warm = null;
+    clearTimeout(w.timer);
+    void w.ready.then((h) => {
+      try {
+        h?.close();
+      } catch {
+      }
+    }).finally(() => w.abort.abort());
+  }
   /** The imported conversation as a context block (fetched once); null when there is none or it cannot be read. */
   importedHistoryBlock() {
     const info = this.boot?.imported;
@@ -11736,6 +11946,7 @@ ${patch}`;
     if (this.stopping) return;
     this.stopping = true;
     this.queue.length = 0;
+    this.dropWarm();
     this.turnAbort?.abort();
     this.pollAbort.abort();
     this.envAbort.abort();
@@ -12261,6 +12472,7 @@ function buildQueryOptions(o) {
   };
   const preToolUse = async (input) => {
     if (input.hook_event_name !== "PreToolUse") return {};
+    if (o.beforeTool) await o.beforeTool();
     const name = String(input.tool_name ?? "");
     if (name === "ExitPlanMode") return o.plan ? {} : { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: "Not in plan mode." } };
     const provenance = input.mcp_server;
@@ -12276,6 +12488,7 @@ function buildQueryOptions(o) {
     return d.behavior === "allow" ? { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "allow", updatedInput: d.updatedInput } } : { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: d.message } };
   };
   const canUseTool = async (toolName, input, opts) => {
+    if (o.beforeTool) await o.beforeTool();
     if (toolName.startsWith("mcp__") && opts?.mcpServer?.source && opts.mcpServer.source !== "sdk") {
       return { behavior: "deny", message: "Only ScaleQuality tools are available in this workspace." };
     }
@@ -12337,6 +12550,24 @@ function buildQueryOptions(o) {
     ...o.pathToClaudeCodeExecutable ? { pathToClaudeCodeExecutable: o.pathToClaudeCodeExecutable } : {}
   };
 }
+function spawnKey(i) {
+  const { orgMcpServers, ...data } = i;
+  return (0, import_crypto7.createHash)("sha256").update(JSON.stringify({ ...data, orgMcpServers: Object.keys(orgMcpServers).sort() })).digest("hex");
+}
+function timedGate(gate, took) {
+  const timed = async (run2) => {
+    const t0 = Date.now();
+    try {
+      return await run2();
+    } finally {
+      took(Date.now() - t0);
+    }
+  };
+  return {
+    check: (command, opts) => timed(() => gate.check(command, opts)),
+    ...gate.checkEdit ? { checkEdit: (path, opts) => timed(() => gate.checkEdit(path, opts)) } : {}
+  };
+}
 async function hasLocalTranscript(configDir, sessionId) {
   if (!/^[A-Za-z0-9-]{8,80}$/.test(sessionId)) return false;
   const projects = (0, import_path15.join)(configDir, "projects");
@@ -12390,6 +12621,10 @@ function createLocalEngine(o) {
   const log = {
     info: (msg, ctx) => {
       if (o.verbose) say(style.dim(`${o.prefix ?? ""}[info] ${msg} ${ctx ? JSON.stringify(ctx) : ""}`));
+      else if (msg === "WORKSPACE_TURN_TIMING") {
+        const line = turnTimingLine(ctx);
+        if (line) say(`${o.prefix ?? ""}${style.dim(`  ${line}`)}`);
+      }
     },
     warn: (msg, ctx) => {
       if (o.verbose) say(style.dim(`${o.prefix ?? ""}[warn] ${msg} ${ctx ? JSON.stringify(ctx) : ""}`));
@@ -12465,7 +12700,9 @@ function createLocalEngine(o) {
     // An imported Claude Code conversation of this computer and folder resumes from its own transcript.
     resumeImported: (externalId) => copyClaudeTranscript(sources, externalId, o.root, configDir),
     exit: (code, reason) => o.exit(code, reason, startError),
-    pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE || void 0
+    pathToClaudeCodeExecutable: process.env.CLAUDE_CODE_EXECUTABLE || void 0,
+    // The next message's engine process is started while the person reads, like Claude Code's process between messages.
+    warmStart: true
   });
 }
 async function connectMain(argv) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@scalequality/cli",
-  "version": "0.4.8",
+  "version": "0.4.9-rc.2",
   "description": "ScaleQuality CLI. Connect your computer to the ScaleQuality AI Workspace (`scalequality login`), run its coding engine in any folder of your computer, and import your Claude Code and Codex conversations.",
   "type": "module",
   "bin": {