@bendyline/gezel-service 1.0.3 → 1.0.5

package/dist/index.js

@@ -320,6 +320,13 @@ function queryInstruction() {
   if (/bge-/i.test(model)) return "Represent this sentence for searching relevant passages: ";
   return "";
 }
+function isRetryablePipelineLoadFailure(error) {
+  const message = error instanceof Error ? `${error.name}: ${error.message}` : String(error);
+  const code = error?.code ?? "";
+  return /(?:ECONNRESET|ECONNREFUSED|ETIMEDOUT|ENOTFOUND|EAI_AGAIN|UND_ERR_|fetch failed|network(?: request)? failed|socket hang up|timed?\s*out|HTTP\s+(?:408|425|429|5\d\d)|TLS|SSL|certificate)/i.test(
+    `${code} ${message}`
+  );
+}
 async function loadPipeline() {
   if (!pipelinePromise) {
     pipelinePromise = (async () => {
@@ -333,7 +340,11 @@ async function loadPipeline() {
       } catch (err) {
         const missing = isMissingModule(err, TRANSFORMERS_MODULE);
         const message = missing ? "Local memory embeddings are an optional npm feature. Install @huggingface/transformers@^3.8.1 alongside @bendyline/gezel-service (see the service README)." : err instanceof Error ? err.message : String(err);
-        throw new PipelineLoadError(message, missing);
+        throw new PipelineLoadError(
+          message,
+          missing,
+          !missing && isRetryablePipelineLoadFailure(err)
+        );
       }
     })();
     pipelinePromise.catch(() => {
@@ -374,10 +385,17 @@ var init_embed_core = __esm({
        * damaged runtime.
        */
       optionalPeerMissing;
-      constructor(message, optionalPeerMissing = false) {
+      /**
+       * Network/model-registry failures can clear without a process restart. The
+       * host uses this bit to apply a short retry cooldown instead of permanently
+       * disabling embeddings after one failed first-use download.
+       */
+      retryable;
+      constructor(message, optionalPeerMissing = false, retryable = false) {
         super(message);
         this.name = "PipelineLoadError";
         this.optionalPeerMissing = optionalPeerMissing;
+        this.retryable = retryable;
       }
     };
     pipelinePromise = null;
@@ -388,6 +406,7 @@ var init_embed_core = __esm({
 var embeddings_exports = {};
 __export(embeddings_exports, {
   EmbeddingsDisabledError: () => EmbeddingsDisabledError,
+  EmbeddingsUnavailableError: () => EmbeddingsUnavailableError,
   embed: () => embed,
   embedBatch: () => embedBatch,
   embedQuery: () => embedQuery,
@@ -400,7 +419,7 @@ function disabledByEnv() {
   return raw === "1" || raw?.toLowerCase() === "true";
 }
 function embeddingsDisabledReason() {
-  return disabledByEnv() ? ENV_DISABLED_REASON : disabledReason;
+  return disabledByEnv() ? ENV_DISABLED_REASON : disabledReason ?? currentUnavailableReason();
 }
 function workerEntry() {
   if (process.env.VITEST) return null;
@@ -436,7 +455,12 @@ function onMessage(msg) {
   pending.delete(msg.id);
   if (msg.error) {
     if (msg.fatal) markDisabled(msg.error, msg.optionalPeerMissing ?? false);
-    p.reject(new Error(msg.error));
+    if (msg.retryable) {
+      markTemporarilyUnavailable(msg.error);
+      p.reject(new EmbeddingsUnavailableError(unavailableReason ?? msg.error));
+    } else {
+      p.reject(new Error(msg.error));
+    }
     return;
   }
   p.resolve(msg.vectors ?? []);
@@ -469,12 +493,31 @@ async function embedInProcess(texts) {
     return await runEmbed(texts);
   } catch (err) {
     if (err instanceof PipelineLoadError) {
+      if (err.retryable) {
+        markTemporarilyUnavailable(err.message);
+        throw new EmbeddingsUnavailableError(unavailableReason ?? err.message);
+      }
       markDisabled(err.message, err.optionalPeerMissing);
       throw new EmbeddingsDisabledError(disabledReason ?? err.message);
     }
     throw err;
   }
 }
+function currentUnavailableReason() {
+  if (!unavailableReason) return null;
+  if (Date.now() < unavailableUntil) return unavailableReason;
+  unavailableReason = null;
+  unavailableUntil = 0;
+  return null;
+}
+function markTemporarilyUnavailable(message) {
+  unavailableReason = firstLine(message);
+  unavailableUntil = Date.now() + EMBEDDING_RETRY_COOLDOWN_MS;
+  log10.warn(
+    `[memory] embedding model load failed; semantic search will retry after ${Math.ceil(EMBEDDING_RETRY_COOLDOWN_MS / 1e3)}s.`
+  );
+  log10.warn("[memory] underlying transient error:", message);
+}
 function markDisabled(message, optionalPeerMissing = false) {
   if (disabledReason) return;
   disabledReason = firstLine(message);
@@ -490,11 +533,14 @@ function markDisabled(message, optionalPeerMissing = false) {
 async function embedMany(texts) {
   if (disabledByEnv()) throw new EmbeddingsDisabledError(ENV_DISABLED_REASON);
   if (disabledReason) throw new EmbeddingsDisabledError(disabledReason);
+  const temporaryReason = currentUnavailableReason();
+  if (temporaryReason) throw new EmbeddingsUnavailableError(temporaryReason);
   const w = ensureWorker();
   if (w) {
     try {
       return await sendToWorker(w, texts);
     } catch (err) {
+      if (err instanceof EmbeddingsUnavailableError) throw err;
       if (disabledReason) throw new EmbeddingsDisabledError(disabledReason);
       log10.warn(`[memory] embed via worker failed; retrying in-process: ${describe(err)}`);
     }
@@ -519,7 +565,7 @@ async function embedBatch(texts) {
   if (texts.length === 0) return [];
   return embedMany(texts);
 }
-var log10, EmbeddingsDisabledError, disabledReason, ENV_DISABLED_REASON, worker, workerUsable, crashCount, nextId, pending;
+var log10, EmbeddingsDisabledError, EmbeddingsUnavailableError, disabledReason, unavailableReason, unavailableUntil, EMBEDDING_RETRY_COOLDOWN_MS, ENV_DISABLED_REASON, worker, workerUsable, crashCount, nextId, pending;
 var init_embeddings = __esm({
   "src/memory/embeddings.ts"() {
     "use strict";
@@ -528,12 +574,25 @@ var init_embeddings = __esm({
     log10 = createLogger10("memory");
     EmbeddingsDisabledError = class extends Error {
       code = "EMBEDDINGS_DISABLED";
+      retryable = false;
       constructor(reason) {
         super(`memory embeddings disabled: ${reason}`);
         this.name = "EmbeddingsDisabledError";
       }
     };
+    EmbeddingsUnavailableError = class extends EmbeddingsDisabledError {
+      code = "EMBEDDINGS_UNAVAILABLE";
+      retryable = true;
+      constructor(reason) {
+        super(reason);
+        this.name = "EmbeddingsUnavailableError";
+        this.message = `memory embeddings temporarily unavailable: ${reason}`;
+      }
+    };
     disabledReason = null;
+    unavailableReason = null;
+    unavailableUntil = 0;
+    EMBEDDING_RETRY_COOLDOWN_MS = 6e4;
     ENV_DISABLED_REASON = "disabled by GEZEL_DISABLE_EMBEDDINGS";
     worker = null;
     workerUsable = true;
@@ -9500,7 +9559,7 @@ __export(bootstrap_exports, {
   reconcileSystemToolsetFromDisk: () => reconcileSystemToolsetFromDisk,
   runSystemBootstrap: () => runSystemBootstrap
 });
-import { createHash as createHash38, randomUUID as randomUUID25 } from "crypto";
+import { createHash as createHash39, randomUUID as randomUUID25 } from "crypto";
 import { existsSync as existsSync23 } from "fs";
 import { mkdir as mkdir51, open as open5, readFile as readFile62, rm as rm34, writeFile as writeFile23 } from "fs/promises";
 import { join as join85 } from "path";
@@ -9896,7 +9955,7 @@ async function downloadWithIntegrity(url, dest, integrity, opts = {}) {
   if (!["sha256", "sha384", "sha512"].includes(algo)) {
     throw new Error(`unsupported integrity algorithm: ${algo}`);
   }
-  const hash = createHash38(algo);
+  const hash = createHash39(algo);
   const request = await fetchBounded(url, DOWNLOAD_TIMEOUT_MS, opts.signal);
   const handle = await open5(dest, "wx", 384);
   try {
@@ -11690,7 +11749,7 @@ var ChatEventBus = class {
 };
 
 // src/chat/manager.ts
-import { randomUUID as randomUUID7 } from "crypto";
+import { createHash as createHash12, randomUUID as randomUUID7 } from "crypto";
 import { createRequire } from "module";
 import { join as join28 } from "path";
 import {
@@ -14085,15 +14144,13 @@ import { createLogger as createLogger4 } from "@bendyline/gezel";
 // src/model-profile/behaviors/fabrication-detect-claim-without-tool.ts
 var PROJECT_CREATION_VERBS = [
   "created",
-  "initiated",
   "initialized",
   "set\\s+up",
   "spun\\s+up",
-  "started",
   "made",
-  "bootstrapped",
-  "kicked\\s+off"
+  "bootstrapped"
 ].join("|");
+var PROJECT_WORK_START_VERBS = ["initiated", "started", "kicked\\s+off"].join("|");
 var TASK_CREATION_VERBS = ["created", "added", "queued", "set\\s+up"].join("|");
 var GEZEL_CREATION_VERBS = [
   "created",
@@ -14154,6 +14211,18 @@ var CLAIM_RULES = [
     claim: "recruited a voorman",
     nudge: "You told the user you recruited a voorman, but you did not call `create_gezel`, `ensure_gezel`, or `start_project` this turn. Call the right one now, and only report recruitment after it succeeds."
   },
+  {
+    // Ambiguous kickoff verbs only become a container-creation claim when
+    // the prose explicitly says this is a new/separate project. Otherwise
+    // the next rule treats them as starting work in the current project.
+    pattern: new RegExp(
+      String.raw`\bI(?:'ve|\s+have|\s+just|\s+already)?\s+(?:` + PROJECT_WORK_START_VERBS + String.raw`)\s+(?:the|a|an)\s+(?:new|fresh|separate|another|dedicated)\s+project\b`,
+      "i"
+    ),
+    requiredTools: ["start_project"],
+    claim: "created a project",
+    nudge: "You told the user you started a new project, but you did not call `start_project` this turn. Call it now with the user-intended name and project brief, or correct the claim."
+  },
   {
     pattern: new RegExp(
       String.raw`\bI(?:'ve|\s+have|\s+just|\s+already)?\s+(?:` + PROJECT_CREATION_VERBS + String.raw`)\s+(?:the|a|an)\s+` + // Optional name placed between "the" and "project". Forms
@@ -14175,6 +14244,15 @@ var CLAIM_RULES = [
     claim: "created a project",
     nudge: "You told the user you created the project, but you did not call `start_project` this turn. Call it now with the user-intended name and a real `about` + `missionObjectives` derived from their request."
   },
+  {
+    pattern: new RegExp(
+      String.raw`\bI(?:'ve|\s+have|\s+just|\s+already)?\s+(?:` + PROJECT_WORK_START_VERBS + String.raw`)\s+(?:(?:work|the\s+work)\s+(?:on|for)\s+)?(?:the|this|that|our|your|a|an)\s+project\b`,
+      "i"
+    ),
+    requiredTools: ["invoke_craftbook", "create_task", "start_project"],
+    claim: "started work in the current project",
+    nudge: "You told the user project work started, but no project-local action succeeded this turn. Use `invoke_craftbook` for a selected procedure, `create_task` for an ad-hoc task, or `start_project` only when the user explicitly requested a separate project. Do not repeat the kickoff claim until the action returns successfully."
+  },
   {
     pattern: new RegExp(
       String.raw`\bI(?:'ve|\s+have|\s+just|\s+already)?\s+(?:` + GEZEL_CREATION_VERBS + String.raw`)\s+(?:the|a|an)\s+(?:new\s+)?gezel\b`,
@@ -15097,13 +15175,26 @@ var BUILD_REQUEST_RE = new RegExp(
 function looksLikeNewBuildRequest(text) {
   return BUILD_REQUEST_RE.test(text);
 }
+function explicitlyRequestsSeparateProject(text) {
+  return /\b(?:new|fresh|separate|another|dedicated)\s+(?:(?:standalone|independent)\s+)?(?:project|workspace)\b/i.test(
+    text
+  ) || /\b(?:as|in|into|under|for)\s+(?:a|an)\s+(?:new|fresh|separate|another|dedicated)\s+(?:project|workspace)\b/i.test(
+    text
+  );
+}
 var MEESTER_BUILD_PRELUDE = '(System note for this turn: the user is asking for a new substantive build. Make ONE tool call:\n \u2022 `start_project({ name, about, missionObjectives, taskDescription })`. Creates a fresh project, selects an appropriate lead/team for the effective execution mode, creates the kickoff task, and hands it off (the work starts in a task-scoped session). Use this for every "build me a website / game / app / dashboard" request, from a single-file prototype through multimodal work. `taskDescription` must ask the lead to ship the actual requested deliverable, not to create a plan. For browser games/sites, name `index.html` and the acceptance criteria (workspace-relative path; do not prefix `workspace/`).\nAfter the macro returns, your turn is done \u2014 tell the user the lead is on it. Do NOT call `create_gezel`, `update_project`, `create_task`, or `message_gezel` separately \u2014 the macro handles them. Do NOT reuse the existing "Default" project; the macro creates a fresh dedicated one.)';
 var PromptMeesterBuildPrelude = {
   id: "prompt.meester-build-prelude",
   description: 'Prepends a system note to the user prompt when the active gezel is the Meester and the message looks like a "build me X" request, anchoring the first-call expectation on `start_project`.',
   userPromptPrelude(ctx) {
     if (!ctx.isMeester) return null;
+    if (ctx.messageOrigin !== "direct-user") return null;
+    if (/^\s*\[Answer to:/i.test(ctx.userText)) return null;
     if (!looksLikeNewBuildRequest(ctx.userText)) return null;
+    if (ctx.projectId !== "default" && !explicitlyRequestsSeparateProject(ctx.userText)) {
+      return null;
+    }
+    if (!ctx.availableToolNames.includes("start_project")) return null;
     return MEESTER_BUILD_PRELUDE;
   }
 };
@@ -18152,6 +18243,12 @@ var AnthropicCliSession = class extends StreamingSessionBase {
   providerState() {
     return this.claudeSessionIdCache ? { claudeCliSessionId: this.claudeSessionIdCache } : {};
   }
+  getRegisteredToolNames() {
+    const context = this.deps.context;
+    return [
+      .../* @__PURE__ */ new Set([...context.allowedBuiltinTools ?? [], ...context.allowedMcpTools ?? []])
+    ];
+  }
   async disconnect() {
     this.aborted = true;
     try {
@@ -19700,6 +19797,10 @@ var AnthropicSession = class extends StreamingSessionBase {
    * resolves and persisted on `ChatMessage.reasoning`.
    */
   lastTurnReasoning = "";
+  getRegisteredToolNames() {
+    const bridgeNames = this.deps.bridges.isEmpty() ? [] : this.deps.bridges.getAnthropicTools().map((tool) => tool.name);
+    return [.../* @__PURE__ */ new Set([...bridgeNames, ...this.externalToolNames])];
+  }
   capturedToolCalls() {
     return [...this.capturedCalls];
   }
@@ -26964,7 +27065,12 @@ var LlamaCppSession = class extends StreamingSessionBase {
         if (toolCalls.length > 0) {
           const normalized2 = normalizeMalformedStructuredToolCalls(
             toolCalls,
-            collectKnownToolNames()
+            collectKnownToolNames(),
+            // A malformed write at the output ceiling is not repairable: the
+            // missing JSON tail may also be missing file bytes. Executing the
+            // loose prefix can silently replace a complete file with a
+            // truncated one. Valid, fully parseable calls remain eligible.
+            finishReason !== "length"
           );
           toolCalls = normalized2.toolCalls;
           malformedStructuredCallIds = new Set(normalized2.sanitizedIds);
@@ -27841,7 +27947,7 @@ var ToolCallAccumulator = class {
     }));
   }
 };
-function normalizeMalformedStructuredToolCalls(toolCalls, knownToolNames) {
+function normalizeMalformedStructuredToolCalls(toolCalls, knownToolNames, allowMalformedWriteRepair = true) {
   const repaired = [];
   const sanitized = [];
   const sanitizedIds = [];
@@ -27852,11 +27958,7 @@ function normalizeMalformedStructuredToolCalls(toolCalls, knownToolNames) {
       if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) return call;
     } catch {
     }
-    const repairedArgs = tryRepairMalformedWriteToolArguments(
-      call.function.name,
-      raw,
-      knownToolNames
-    );
+    const repairedArgs = allowMalformedWriteRepair ? tryRepairMalformedWriteToolArguments(call.function.name, raw, knownToolNames) : null;
     if (repairedArgs) {
       repaired.push({
         name: call.function.name,
@@ -32018,6 +32120,7 @@ function buildLlamaCppEngineArgs(input) {
     ggufHasMtp,
     installedDraftModelPath,
     reasoningFormat,
+    reasoningPreserve,
     architecture,
     modelId,
     swaFullAutoFits
@@ -32065,6 +32168,7 @@ function buildLlamaCppEngineArgs(input) {
     if (typeof nMax === "number") args.push("--spec-draft-n-max", String(nMax));
   }
   if (reasoningFormat) args.push("--reasoning-format", reasoningFormat);
+  if (reasoningPreserve) args.push("--reasoning-preserve");
   if (config.llamaCppExtraArgs) {
     for (const [rawKey, value] of Object.entries(config.llamaCppExtraArgs)) {
       if (value === false) continue;
@@ -32385,6 +32489,31 @@ function fitsSwaFullInFastMemory(input) {
   return Number.isFinite(required) && Number.isFinite(available) && required <= available;
 }
 
+// src/providers/llama-cpp/reasoning-launch.ts
+var POSITIVE_INTEGER = /^[1-9]\d*$/;
+function parseReasoningPreserveEnv(raw) {
+  const normalized2 = raw?.trim().toLowerCase();
+  return normalized2 === "1" || normalized2 === "true";
+}
+function parseReasoningBudgetEnv(raw) {
+  const normalized2 = raw?.trim();
+  if (!normalized2) return void 0;
+  if (!POSITIVE_INTEGER.test(normalized2)) {
+    throw new Error("GEZEL_LLAMA_REASONING_BUDGET_TOKENS must be a positive integer");
+  }
+  const parsed = Number(normalized2);
+  if (!Number.isSafeInteger(parsed)) {
+    throw new Error("GEZEL_LLAMA_REASONING_BUDGET_TOKENS exceeds the safe integer range");
+  }
+  return parsed;
+}
+function reasoningLaunchOverridesFromEnv(env = process.env) {
+  return {
+    preserve: parseReasoningPreserveEnv(env.GEZEL_LLAMA_REASONING_PRESERVE),
+    budgetTokens: parseReasoningBudgetEnv(env.GEZEL_LLAMA_REASONING_BUDGET_TOKENS)
+  };
+}
+
 // src/providers/llama-cpp/spec-draft.ts
 async function resolveSpecDraft(input) {
   const { perModel, configSpecType, configDraftModelPath, resolveDraftPath } = input;
@@ -32443,6 +32572,8 @@ async function buildLlamaCppProvider(opts) {
   const { config, affinity, home } = opts;
   const externalBaseUrl = opts.modelOverride ? void 0 : process.env.GEZEL_LLAMA_SERVER_URL ?? config.llamaCppBaseUrl;
   const binary = process.env.GEZEL_LLAMA_SERVER_BIN;
+  const reasoningLaunchOverrides = reasoningLaunchOverridesFromEnv();
+  const reasoningPreserve = reasoningLaunchOverrides.preserve;
   const defaultModelId = opts.modelOverride?.modelId ?? config.defaultModel?.["llama-cpp"];
   const configuredSlots = config.providerConcurrency?.["llama-cpp"];
   const envNumCtx = (() => {
@@ -32465,6 +32596,7 @@ async function buildLlamaCppProvider(opts) {
     // rate for its own default engine — throughput was reachable only by
     // scraping stdout from the eval harness.
     includeUsageInStream: true,
+    replayReasoningContent: reasoningPreserve,
     // External-baseUrl default; the supervised path overrides this with the
     // auto-sized `slots` computed below (after the model resolves).
     concurrency: configuredSlots ?? 2,
@@ -32655,10 +32787,12 @@ async function buildLlamaCppProvider(opts) {
   const slotSavePath = replicaSuffix ? join18(llamaCacheRoot, llamaFingerprint, replicaSuffix) : join18(llamaCacheRoot, llamaFingerprint);
   await mkdirAsync(slotSavePath, { recursive: true }).catch(() => {
   });
-  const reasoningBudgetTokens = opts.catalog ? await resolveCatalogReasoningBudget(
+  const catalogReasoningBudgetTokens = opts.catalog ? await resolveCatalogReasoningBudget(
     opts.catalog,
     opts.modelOverride?.modelId ?? defaultModelId
   ) : void 0;
+  const reasoningBudgetTokens = reasoningLaunchOverrides.budgetTokens ?? catalogReasoningBudgetTokens;
+  const reasoningBudgetSource = reasoningLaunchOverrides.budgetTokens !== void 0 ? "env" : catalogReasoningBudgetTokens !== void 0 ? "catalog" : "unbounded";
   const specDraft = await resolveSpecDraft({
     perModel: manifestEngineConfig,
     configSpecType: config.llamaCppSpecType,
@@ -33048,6 +33182,7 @@ async function buildLlamaCppProvider(opts) {
         // disables llama-server's chat-template output parsing so mangled
         // model output reaches `delta.content` for provider-side salvage.
         reasoningFormat: process.env.GEZEL_LLAMA_REASONING_FORMAT?.trim() || void 0,
+        reasoningPreserve,
         architecture: modelCatalogInfo?.architecture,
         modelId: defaultModelId ?? void 0,
         swaFullAutoFits
@@ -33156,6 +33291,9 @@ async function buildLlamaCppProvider(opts) {
           batchSize: lastArgValue(resolvedAdvancedArgs, "--batch-size") ?? "default",
           ubatchSize: lastArgValue(resolvedAdvancedArgs, "--ubatch-size") ?? "default",
           flashAttention: lastArgValue(resolvedAdvancedArgs, "--flash-attn") ?? "default",
+          reasoningBudgetTokens: reasoningBudgetTokens ?? "unbounded",
+          reasoningBudgetSource,
+          reasoningPreserve,
           cudaGraphs: process.env.GGML_CUDA_DISABLE_GRAPHS ? "disabled-by-env" : "default"
         },
         env: {
@@ -33321,7 +33459,7 @@ var PROJECT_MACRO_INTERCEPT_CAP = 2;
 var PROJECT_MACRO_FAILURE_CAP = 2;
 function deriveProjectMacroClosing(firstResult) {
   const projectMatch = firstResult.match(/Started (?:project|job) "([^"]+)"/);
-  const leadMatch = firstResult.match(/Recruited (\S+) as (voorman|ambachtsman|lead)/);
+  const leadMatch = firstResult.match(/Recruited (\S+) as (voorman|builder|lead)/i);
   const projectName = projectMatch?.[1];
   const leadName = leadMatch?.[1];
   const leadRole = leadMatch?.[2];
@@ -35944,14 +36082,14 @@ async function buildMlxProvider(opts) {
   const cacheBudgetMb = Math.min(config.cacheBudgetMb?.mlx ?? ramAwareDefaultMb, mlxKvHeadroomMb);
   const mlxReplicaSuffix = opts.modelOverride && opts.modelOverride.replicaIdx > 0 ? `replica-${opts.modelOverride.replicaIdx}` : "";
   const cacheRoot = mlxReplicaSuffix ? join21(store.homePath, "engines", "mlx", "cache", mlxReplicaSuffix) : join21(store.homePath, "engines", "mlx", "cache");
-  const { createHash: createHash47 } = await import("crypto");
+  const { createHash: createHash48 } = await import("crypto");
   const fingerprintInput = [
     modelCatalogInfo?.id ?? defaultModelId ?? modelDir,
     modelCatalogInfo?.catalogVersion ?? "",
     modelCatalogInfo?.installedAt ?? "",
     modelDir
   ].join("::");
-  const modelFingerprint = createHash47("sha256").update(fingerprintInput, "utf8").digest("hex").slice(0, 24);
+  const modelFingerprint = createHash48("sha256").update(fingerprintInput, "utf8").digest("hex").slice(0, 24);
   const diskCacheBudgetMb = config.mlxDiskCacheBudgetMb ?? 8192;
   const mlxIdleMs = config.localEngineIdleTimeoutMs ?? DEFAULT_LOCAL_ENGINE_IDLE_TIMEOUT_MS3;
   const mlxFreezeMs = Math.floor(mlxIdleMs / 2);
@@ -37273,6 +37411,10 @@ var OpenAISession = class extends StreamingSessionBase {
   capturedToolCalls() {
     return [...this.capturedCalls];
   }
+  getRegisteredToolNames() {
+    const bridgeNames = this.deps.bridges.isEmpty() ? [] : this.deps.bridges.getOpenAITools().map((tool) => tool.name);
+    return [.../* @__PURE__ */ new Set([...bridgeNames, ...this.externalToolNames])];
+  }
   async sendAndWait(prompt, opts) {
     return runInQueue(this.deps.queue, opts?.queue, () => this.sendAndWaitInner(prompt, opts));
   }
@@ -40190,14 +40332,15 @@ async function evalCheck(c, ws, deps) {
 }
 async function evalCheckInner(c, ws, deps) {
   const usesArtifact = c.artifact === true;
-  const reader = usesArtifact ? {
+  const artifactReader = {
     read: ws.readArtifact ?? (async () => null),
     list: ws.listArtifacts ?? (async () => []),
     // Carry the byte reader across the artifact swap; without it a
     // `verifyImageBytes` check on an artifact deliverable would report
     // "no binary reads" even though the surface supports them.
     ...ws.readArtifactBytes ? { readBytes: ws.readArtifactBytes.bind(ws) } : {}
-  } : ws;
+  };
+  const reader = usesArtifact ? artifactReader : ws;
   switch (c.kind) {
     case "minBytes": {
       const r = await fileMinBytes(reader, c.file, c.bytes);
@@ -40625,7 +40768,12 @@ ${hint}` : ""}`,
       };
     }
     case "markdownHeadingsMatch": {
-      const result = await markdownHeadingsMatch(reader, c.file, c.outlineFile);
+      const result = await markdownHeadingsMatch(
+        reader,
+        c.file,
+        c.outlineFile,
+        c.outlineArtifact ? artifactReader : ws
+      );
       return {
         ok: result.ok,
         detail: result.detail,
@@ -42540,6 +42688,11 @@ function filterPromptToolDirectives(args) {
   if (rejectedLines.size === 0) return args.prompt;
   return args.prompt.split("\n").filter((_, index) => !rejectedLines.has(index + 1)).join("\n").replace(/\n{4,}/g, "\n\n\n");
 }
+function capabilitySafeCorrectivePrompt(args) {
+  const filtered = filterPromptToolDirectives(args).trim();
+  if (filtered) return filtered;
+  return "Your previous reply claimed an action succeeded without live evidence. Use only an appropriate action tool visible in your current roster, or explain that the action cannot be performed here. Do not repeat the success claim until an available action returns successfully.";
+}
 
 // src/chat/provider-capabilities.ts
 function providerUsesManagedMcpBridge(name) {
@@ -46378,6 +46531,21 @@ function sameFromBucket(a, b) {
   if (!a || !b) return false;
   return a.gezelId === b.gezelId;
 }
+function resolveTurnMessageOrigin(opts) {
+  if (opts?.messageOrigin) return opts.messageOrigin;
+  if (opts?.from) return "cross-gezel";
+  if (opts?.ambient || opts?.nudge || opts?.lane === "background") return "background-nudge";
+  return "direct-user";
+}
+function liveTurnToolNames(session) {
+  const names = /* @__PURE__ */ new Set();
+  for (const name of session?.getRegisteredToolNames?.() ?? []) {
+    names.add(name);
+    const qualified = name.match(/^mcp__.+?__(.+)$/)?.[1];
+    if (qualified && qualified !== "*") names.add(qualified);
+  }
+  return [...names];
+}
 async function resolveCatalogParameterSize(catalog, catalogId) {
   if (!catalogId) return void 0;
   try {
@@ -46519,10 +46687,12 @@ var ChatManager = class {
    */
   afterSessionIdle = /* @__PURE__ */ new Map();
   /**
-   * One live async file handoff per sender/target/project/path. Models can
+   * One live async file handoff per sender/target/project/path/intent. Models can
    * emit the same `message_gezel` call several times while the sender turn
    * is still active; joining that work prevents a parked-send burst from
-   * replaying the same assignment into the recipient session.
+   * replaying the same assignment into the recipient session. A later
+   * validator repair for a file that was originally missing is distinct work
+   * and must never join the older create request.
    */
   inflightFileHandoffs = /* @__PURE__ */ new Map();
   /** Set once {@link shutdown} starts so deferred watchdogs don't fire into a tearing-down manager. */
@@ -47779,6 +47949,7 @@ ${JSON.stringify(run.output, null, 2)}`;
         coalescable: false,
         lane: void 0,
         ambient: false,
+        messageOrigin: "direct-user",
         continuationMaxTokens: void 0,
         hidden: false,
         nudge: false,
@@ -48084,11 +48255,14 @@ ${JSON.stringify(run.output, null, 2)}`;
       const full = await this.store.getSession(args.gezelId, active.id);
       if (full) return full;
     }
+    const parsedTaskRef = parseTaskRef2(args.taskRef);
+    const task = parsedTaskRef ? await this.store.readTask(parsedTaskRef.projectId, parsedTaskRef.num).catch(() => null) : null;
     return this.createSession({
       gezelId: args.gezelId,
       projectId: args.projectId,
       taskRef: args.taskRef,
-      ...args.stepId ? { stepId: args.stepId } : {}
+      ...args.stepId ? { stepId: args.stepId } : {},
+      ...task?.roleBasedNameOnlyMode !== void 0 ? { roleBasedNameOnlyMode: task.roleBasedNameOnlyMode } : {}
     });
   }
   /** Late-bind the fitness manager (see the field's docblock). */
@@ -48215,6 +48389,7 @@ ${JSON.stringify(run.output, null, 2)}`;
    */
   async startHandoffSession(args) {
     const dispatchConfig = await this.store.readConfig();
+    const roleBasedNameOnlyMode = args.roleBasedNameOnlyMode ?? dispatchConfig.roleBasedNameOnlyMode ?? false;
     const dispatchGezel = await this.store.getGezel(args.gezelId);
     const dispatchProviderName = await this.resolveProviderName(
       args.gezelId,
@@ -48263,6 +48438,7 @@ ${JSON.stringify(run.output, null, 2)}`;
       projectId: args.projectId,
       taskRef: args.taskRef,
       stepId: dispatchStepId,
+      roleBasedNameOnlyMode,
       ...args.nightShift ? { nightShift: true } : {},
       ...routed && args.capabilityFloor ? {
         routedModel: {
@@ -48319,9 +48495,15 @@ ${stepArc}
       }
     }
     const selfHandoff = args.fromGezelId !== void 0 && args.fromGezelId === args.gezelId;
-    const seed = args.kind === "entry" ? `${entryPreface}You've been assigned task ${args.taskRef} (step \`${dispatchStepId}\`). Follow the step instructions already in your prompt \u2014 make the first tool call they name this turn. Append focused notes with \`write_task_note\` as you go. When the step is done, call \`advance_task_step\` to hand off to whoever's next.` : selfHandoff ? `Task ${args.taskRef} has advanced to the next step \u2014 \`${dispatchStepId}\`, which is yours as well. Please continue: follow the step instructions already in your prompt \u2014 make the first tool call they name this turn. Append focused notes with \`write_task_note\` as you go so the next gezel can pick up where you left off. When the step is done, call \`advance_task_step\` to hand off to whoever's next.` : `${args.fromGezelName ? `${args.fromGezelName} has` : "The previous step has been completed and"} handed step \`${dispatchStepId}\` of task ${args.taskRef} to you. Follow the step instructions already in your prompt \u2014 make the first tool call they name this turn. Append focused notes with \`write_task_note\` as you go so the next gezel can pick up where you left off. When the step is done, call \`advance_task_step\` to hand off to whoever's next.`;
+    const previousGezel = !selfHandoff && args.fromGezelId ? await this.store.getGezel(args.fromGezelId).catch(() => null) : null;
+    const fromGezelDisplayName = previousGezel ? displayName2(
+      { name: previousGezel.name, roleBasedName: previousGezel.roleBasedName },
+      roleBasedNameOnlyMode
+    ) : roleBasedNameOnlyMode ? void 0 : args.fromGezelName;
+    const seed = args.kind === "entry" ? `${entryPreface}You've been assigned task ${args.taskRef} (step \`${dispatchStepId}\`). Follow the step instructions already in your prompt \u2014 make the first tool call they name this turn. Append focused notes with \`write_task_note\` as you go. When the step is done, call \`advance_task_step\` to hand off to whoever's next.` : selfHandoff ? `Task ${args.taskRef} has advanced to the next step \u2014 \`${dispatchStepId}\`, which is yours as well. Please continue: follow the step instructions already in your prompt \u2014 make the first tool call they name this turn. Append focused notes with \`write_task_note\` as you go so the next gezel can pick up where you left off. When the step is done, call \`advance_task_step\` to hand off to whoever's next.` : `${fromGezelDisplayName ? `${fromGezelDisplayName} has` : "The previous step has been completed and"} handed step \`${dispatchStepId}\` of task ${args.taskRef} to you. Follow the step instructions already in your prompt \u2014 make the first tool call they name this turn. Append focused notes with \`write_task_note\` as you go so the next gezel can pick up where you left off. When the step is done, call \`advance_task_step\` to hand off to whoever's next.`;
     this.trackBackground(
       this.sendWithBusyRetry(session.id, seed, {
+        messageOrigin: "system",
         ...args.lane ? { lane: args.lane } : {},
         ...args.ambient ? { ambient: true } : {}
       }).catch((err) => {
@@ -48390,7 +48572,8 @@ ${stepArc}
       args.fromSessionId ?? args.fromGezelId,
       target.id,
       projectId,
-      normalizeExpectedDeliverablePath(requestedFilePath)
+      normalizeExpectedDeliverablePath(requestedFilePath),
+      fileHandoffIntentKey(args.text)
     ].join("\0") : null;
     const pendingHandoff = fileHandoffKey ? this.inflightFileHandoffs.get(fileHandoffKey) : void 0;
     if (pendingHandoff) return { ...pendingHandoff, deduplicated: true };
@@ -48431,7 +48614,7 @@ ${stepArc}
     const seed = `[Message from ${fromName}]: ${args.text}${deliverableAnnotation}`;
     const failureNotice = { sent: false };
     const resolvedFromSessionId = args.fromSessionId ?? (target.id === args.fromGezelId ? null : await this.ensureOrCreateSession({ gezelId: args.fromGezelId, projectId }).then((s) => s.id).catch(() => null));
-    if (resolvedFromSessionId && resolvedFromSessionId !== session.id) {
+    if (!args.suppressReply && resolvedFromSessionId && resolvedFromSessionId !== session.id) {
       this.attachReplyListener({
         targetSessionId: session.id,
         fromSessionId: resolvedFromSessionId,
@@ -49167,11 +49350,10 @@ ${stepArc}
     log52.info(
       `[questions] delivering answer to session ${args.sessionId.slice(0, 8)} (gezel ${session.gezelId}, project ${session.projectId})`
     );
-    await this.sendWithBusyRetry(
-      args.sessionId,
-      args.seed,
-      args.coalescable ? { coalescable: true } : void 0
-    );
+    await this.sendWithBusyRetry(args.sessionId, args.seed, {
+      messageOrigin: "question-answer",
+      ...args.coalescable ? { coalescable: true } : {}
+    });
   }
   /**
    * System-authored reaction seed into a gezel's live (gezel, project)
@@ -49197,6 +49379,7 @@ ${stepArc}
       this.send(session.id, args.seed, {
         coalescable: true,
         lane: "background",
+        messageOrigin: "system",
         ...leanReactionCap ? { continuationMaxTokens: leanReactionCap } : {},
         ...args.hidden ? { hidden: true } : {}
       }).catch((err) => {
@@ -49671,12 +49854,13 @@ ${stepArc}
       throw new Error("engagement-off: AI is disabled in settings; re-enable to send");
     }
     const existingQueue = this.pendingSends.get(sessionId2);
+    const messageOrigin = resolveTurnMessageOrigin(opts);
     const shouldQueue = this.inflight.has(sessionId2) || existingQueue !== void 0 && existingQueue.length > 0;
     if (shouldQueue) {
       return new Promise((resolve18, reject) => {
         const q2 = this.pendingSends.get(sessionId2) ?? [];
         const tail = q2.length > 0 ? q2[q2.length - 1] : void 0;
-        const canMerge = opts?.coalescable === true && opts?.nudge !== true && tail?.coalescable === true && tail.nudge !== true && sameFromBucket(tail.from, opts.from);
+        const canMerge = opts?.coalescable === true && opts?.nudge !== true && tail?.coalescable === true && tail.nudge !== true && tail.messageOrigin === messageOrigin && sameFromBucket(tail.from, opts.from);
         if (canMerge && tail) {
           tail.userText = `${tail.userText}
 
@@ -49703,6 +49887,7 @@ ${userText}`;
           coalescable: opts?.coalescable === true,
           lane: opts?.lane,
           ambient: opts?.ambient === true,
+          messageOrigin,
           continuationMaxTokens: opts?.continuationMaxTokens,
           hidden: opts?.hidden === true,
           nudge: opts?.nudge === true,
@@ -49719,7 +49904,7 @@ ${userText}`;
     return this.runSendAndDrain(
       sessionId2,
       userText,
-      opts?.nudge ? { ...opts, nudge: false } : opts
+      opts?.nudge ? { ...opts, nudge: false, messageOrigin } : { ...opts, messageOrigin }
     );
   }
   /**
@@ -49818,7 +50003,7 @@ ${userText}`;
     if (next.nudge) {
       while (q2.length > 0) {
         const peek = q2[0];
-        if (!peek.nudge || peek.hidden !== next.hidden || !sameFromBucket(peek.from, next.from)) {
+        if (!peek.nudge || peek.hidden !== next.hidden || peek.messageOrigin !== next.messageOrigin || !sameFromBucket(peek.from, next.from)) {
           break;
         }
         q2.shift();
@@ -49841,6 +50026,7 @@ ${peek.userText}`;
     if (next.continuationMaxTokens) runOpts.continuationMaxTokens = next.continuationMaxTokens;
     if (next.hidden) runOpts.hidden = true;
     if (next.nudge) runOpts.nudge = true;
+    runOpts.messageOrigin = next.messageOrigin;
     void this.runSendAndDrain(sessionId2, next.userText, runOpts).then((msg) => {
       for (const w of next.waiters) {
         try {
@@ -49871,20 +50057,36 @@ ${peek.userText}`;
         return this.runFixedFunctionSend(sessionId2, userText, opts);
       }
     }
+    const preflightScope = ffRecord ? {
+      sessionId: sessionId2,
+      gezelId: ffRecord.gezelId,
+      projectId: ffRecord.projectId
+    } : void 0;
+    const coldStartPending = preflightScope && !this.states.get(sessionId2)?.session;
+    if (preflightScope && coldStartPending) {
+      this.events.publish(preflightScope, {
+        type: "user_message_pending",
+        preview: userText.length > 160 ? `${userText.slice(0, 157)}\u2026` : userText
+      });
+    }
     const fail2 = (err) => {
       const message = err instanceof Error ? err.message : String(err);
       log52.error("error:", message);
+      const publish = (event) => {
+        if (preflightScope) this.events.publish(preflightScope, event);
+        else this.events.publishSessionOnly(sessionId2, event);
+      };
       if (inflightTurn.cancelled) {
-        this.events.publishSessionOnly(sessionId2, { type: "cancelled" });
+        publish({ type: "cancelled" });
       } else {
         const detail = describeTurnError(err);
-        this.events.publishSessionOnly(sessionId2, {
+        publish({
           type: "error",
           error: redactCredentials4(message),
           ...detail ? { errorDetail: detail } : {}
         });
       }
-      this.events.publishSessionOnly(sessionId2, { type: "done" });
+      publish({ type: "done" });
       throw err;
     };
     if (ffRecord) {
@@ -50171,6 +50373,18 @@ ${peek.userText}`;
     try {
       let lastAssistantMessage = null;
       let promptForTurn = spliceIntoText(userText, pendingDigests);
+      const correctivePromptForLiveRoster = (prompt, source) => {
+        const safe = capabilitySafeCorrectivePrompt({
+          prompt,
+          availableTools: liveTurnToolNames(liveSession)
+        });
+        if (safe !== prompt.trim()) {
+          log52.warn(
+            `session ${sessionId2}: filtered ${source} corrective against the live tool roster`
+          );
+        }
+        return safe;
+      };
       const freshGameState = await this.refreshLeanGameState(state.record, userText);
       if (freshGameState) {
         promptForTurn = `${freshGameState}
@@ -50181,7 +50395,8 @@ ${promptForTurn}`;
         this.taskBudget.reset(state.record.taskRef);
         this.pendingBudgetNudge.delete(state.record.taskRef);
       }
-      const preludeForTurn = await this.resolveUserPromptPrelude(state, userText);
+      const messageOrigin = resolveTurnMessageOrigin(opts);
+      const preludeForTurn = await this.resolveUserPromptPrelude(state, userText, messageOrigin);
       if (preludeForTurn) {
         promptForTurn = `${preludeForTurn.text}
 
@@ -50204,7 +50419,7 @@ ${promptForTurn}`;
       }
       if (state.record.taskRef && this.pendingBudgetNudge.has(state.record.taskRef)) {
         this.pendingBudgetNudge.delete(state.record.taskRef);
-        promptForTurn = `${TASK_BUDGET_NUDGE}
+        promptForTurn = `${correctivePromptForLiveRoster(TASK_BUDGET_NUDGE, "task-budget")}
 
 ${promptForTurn}`;
         log52.info(
@@ -50213,6 +50428,7 @@ ${promptForTurn}`;
       }
       let continuations = 0;
       const maxContinuations = resolveContinuationBudget(state);
+      let voormanIdleNudged = false;
       const toolsAcrossContinuations = [];
       let compactionsThisSend = 0;
       let keurmeesterConsultedThisSend = false;
@@ -50476,6 +50692,7 @@ ${state.aboutSnapshot}`);
         const detectorVerdict = runPostTurnDetectors(state, {
           sessionId: sessionId2,
           isMeester: cfgForDetector?.meesterGezelId === state.record.gezelId,
+          messageOrigin,
           userText,
           drained: toolsAcrossContinuations,
           assistantContent: assistantMessage.content,
@@ -50489,7 +50706,10 @@ ${state.aboutSnapshot}`);
           this.events.publish(scope, { type: "warning", message: warningMessage });
         }
         if (detectorVerdict?.promptForNextTurn) {
-          detectorReprompt = detectorVerdict.promptForNextTurn;
+          detectorReprompt = correctivePromptForLiveRoster(
+            detectorVerdict.promptForNextTurn,
+            "post-turn detector"
+          );
         }
         const advanceOutcome = await this.maybeAutoAdvanceOnObservableProgress(
           state,
@@ -50640,7 +50860,10 @@ ${state.aboutSnapshot}`);
               log52.info(
                 `session ${sessionId2}: keurmeester intervention applied (case ${consult.caseId}) \u2014 granting one recovery continuation`
               );
-              promptForTurn = consult.correctivePrompt;
+              promptForTurn = correctivePromptForLiveRoster(
+                consult.correctivePrompt,
+                "keurmeester"
+              );
               continue;
             }
           }
@@ -50658,7 +50881,10 @@ ${state.aboutSnapshot}`);
             log52.info(
               `session ${sessionId2}: ${detectorVerdict?.reason ?? "detector"} \u2014 re-prompting`
             );
-            promptForTurn = detectorReprompt;
+            promptForTurn = correctivePromptForLiveRoster(
+              detectorReprompt,
+              detectorVerdict ? "post-turn detector" : "deliverable salvage"
+            );
             continue;
           }
           if (advanceOutcome.gateRejected && !advanceOutcome.gateRejected.paused && advanceOutcome.gateRejected.fingerprint !== state.lastGateNudgeFingerprint && !drained.some((d) => d.name === "ask_user_question" && d.success)) {
@@ -50668,7 +50894,10 @@ ${state.aboutSnapshot}`);
             log52.info(
               `session ${sessionId2}: ${advanceOutcome.gateRejected.taskRef} step "${advanceOutcome.gateRejected.stepId}" gate rejected \u2014 re-prompting with the verdict${stage > 0 ? ` (escalation stage ${stage})` : ""}`
             );
-            promptForTurn = stage >= 1 ? advanceOutcome.gateRejected.message : buildGateRejectionNudge(advanceOutcome.gateRejected.message);
+            promptForTurn = correctivePromptForLiveRoster(
+              stage >= 1 ? advanceOutcome.gateRejected.message : buildGateRejectionNudge(advanceOutcome.gateRejected.message),
+              "task-gate"
+            );
             continue;
           }
           if (deliverableOutcome.deliverableRejected?.stopRetrying) {
@@ -50719,7 +50948,10 @@ ${state.aboutSnapshot}`);
                 log52.info(
                   `session ${sessionId2}: keurmeester intervention applied on deliverable plateau (case ${consult.caseId}) \u2014 granting one recovery continuation`
                 );
-                promptForTurn = consult.correctivePrompt;
+                promptForTurn = correctivePromptForLiveRoster(
+                  consult.correctivePrompt,
+                  "keurmeester deliverable-plateau"
+                );
                 continue;
               }
             }
@@ -50743,7 +50975,10 @@ ${rej.message.split("\n").slice(0, 4).join("\n")}`;
               ...dRej.filePath ? { filePath: dRej.filePath } : {},
               failingVerdict: dRej.message
             });
-            promptForTurn = clampNudge ?? (dStage >= 1 ? dRej.message : buildGateRejectionNudge(dRej.message));
+            promptForTurn = correctivePromptForLiveRoster(
+              clampNudge ?? (dStage >= 1 ? dRej.message : buildGateRejectionNudge(dRej.message)),
+              "deliverable-gate"
+            );
             continue;
           }
           if (advanceOutcome.unmetEditGate && (looksStalled(finalContent) || claimsCompletion(finalContent)) && !drained.some((d) => d.name === "ask_user_question" && d.success)) {
@@ -50751,7 +50986,10 @@ ${rej.message.split("\n").slice(0, 4).join("\n")}`;
             log52.info(
               `session ${sessionId2}: ${advanceOutcome.unmetEditGate.taskRef} edit gate unmet (${advanceOutcome.unmetEditGate.file} not written) but reply claims progress \u2014 nudging to edit`
             );
-            promptForTurn = buildDeliverableEditNudge(advanceOutcome.unmetEditGate.file);
+            promptForTurn = correctivePromptForLiveRoster(
+              buildDeliverableEditNudge(advanceOutcome.unmetEditGate.file),
+              "deliverable-edit"
+            );
             continue;
           }
           const unresolvedToolFailures = unresolvedFailedToolCalls(drained);
@@ -50795,7 +51033,7 @@ ${rej.message.split("\n").slice(0, 4).join("\n")}`;
             // the hot path synchronous for the common non-voorman case.
             // Also requires `proactive` — voorman idle nudges advance
             // project work past what the user asked for.
-            isProactiveAllowed(nudgeConfig) && state.record.providerName !== "copilot"
+            isProactiveAllowed(nudgeConfig) && state.record.providerName !== "copilot" && !voormanIdleNudged
           ) {
             voormanIdleVerdict = await this.didVoormanIdleStall(state.record, drained, sessionId2);
             if (voormanIdleVerdict !== null) {
@@ -50813,15 +51051,19 @@ ${rej.message.split("\n").slice(0, 4).join("\n")}`;
               );
               break;
             }
+            if (stallReason === "voorman-idle") voormanIdleNudged = true;
             continuations++;
             log52.info(
-              `session ${sessionId2}: response looks stalled (${stallReason}) \u2014 nudging the model to actually execute`
+              `session ${sessionId2}: response looks stalled (${stallReason}) \u2014 requesting one recovery pass`
+            );
+            promptForTurn = correctivePromptForLiveRoster(
+              stallReason === "voorman-idle" ? buildContinuationNudge(
+                finalContent,
+                state.record.messages,
+                voormanIdleVerdict === "nothing-built" ? VOORMAN_NOT_DONE_NUDGE : VOORMAN_IDLE_NUDGE
+              ) : stallReason === "tool-only" ? CLOSING_SUMMARY_NUDGE : stallReason === "tool-read-only" ? READ_ONLY_PROGRESS_NUDGE : stallReason === "tool-failed" ? buildFailedToolRecoveryNudge(unresolvedToolFailures) : buildContinuationNudge(finalContent, state.record.messages),
+              `stall-${stallReason}`
             );
-            promptForTurn = stallReason === "voorman-idle" ? buildContinuationNudge(
-              finalContent,
-              state.record.messages,
-              voormanIdleVerdict === "nothing-built" ? VOORMAN_NOT_DONE_NUDGE : VOORMAN_IDLE_NUDGE
-            ) : stallReason === "tool-only" ? CLOSING_SUMMARY_NUDGE : stallReason === "tool-read-only" ? READ_ONLY_PROGRESS_NUDGE : stallReason === "tool-failed" ? buildFailedToolRecoveryNudge(unresolvedToolFailures) : buildContinuationNudge(finalContent, state.record.messages);
             continue;
           }
         }
@@ -51387,7 +51629,7 @@ ${rej.message.split("\n").slice(0, 4).join("\n")}`;
       return null;
     }
     const tasks = await this.store.listProjectTasks(record.projectId).catch(() => []);
-    if (tasks.length > 0 && !tasks.some((t) => t.status === "active")) {
+    if (tasks.length === 0 || !tasks.some((t) => t.status === "active")) {
       return null;
     }
     const workspaceFiles = await this.store.listProjectWorkspaceRecursive(record.projectId).catch(() => []);
@@ -54138,7 +54380,7 @@ ${baseSystem}` : baseSystem;
       return { modelId };
     }
   }
-  async resolveUserPromptPrelude(state, userText) {
+  async resolveUserPromptPrelude(state, userText, messageOrigin) {
     const profile = state.profile;
     if (!profile) return null;
     const cfg = await this.store.readConfig().catch(() => null);
@@ -54147,6 +54389,9 @@ ${baseSystem}` : baseSystem;
       ...modelCtxFromProfile(profile, state),
       sessionId: state.record.id,
       isMeester,
+      projectId: state.record.projectId,
+      messageOrigin,
+      availableToolNames: liveTurnToolNames(state.session),
       userText,
       drained: [],
       assistantContent: "",
@@ -55467,6 +55712,7 @@ Allow **${info.toolName}** this time?`,
         GEZEL_SESSION_ID: record.id,
         GEZEL_HOME: this.home,
         GEZEL_EXECUTION_DENSITY: executionDensity,
+        GEZEL_ROLE_BASED_NAME_ONLY_MODE: record.roleBasedNameOnlyMode ?? globalConfig.roleBasedNameOnlyMode ?? false ? "1" : "0",
         ...record.expectedDeliverable ? { GEZEL_EXPECTED_DELIVERABLE: JSON.stringify(record.expectedDeliverable) } : {},
         ...record.stepId ? { GEZEL_STEP_ID: record.stepId } : {},
         // Scope task: lets the MCP task tools default to / recover toward
@@ -55906,6 +56152,9 @@ function runPostTurnDetectors(state, args) {
     ...modelCtxFromProfile(profile, state),
     sessionId: args.sessionId,
     isMeester: args.isMeester,
+    projectId: state.record.projectId,
+    messageOrigin: args.messageOrigin,
+    availableToolNames: liveTurnToolNames(state.session),
     userText: args.userText,
     drained: args.drained,
     assistantContent: args.assistantContent,
@@ -56154,6 +56403,14 @@ function messageExpressesModifyIntent(text) {
     )
   );
 }
+function fileHandoffIntentKey(text) {
+  const repair = messageExpressesModifyIntent(text) || /\[scenario check\]|\b(?:specific failure|signals? that (?:didn't|did not) fire|success criteria (?:aren't|are not) met|repeat miss|gate_full_rewrite|rejected)\b/i.test(
+    text
+  );
+  if (!repair) return "create";
+  const normalized2 = text.toLowerCase().replace(/\s+/g, " ").trim();
+  return `repair:${createHash12("sha256").update(normalized2).digest("hex").slice(0, 16)}`;
+}
 function isSubstantiveExistingWorkspaceFile(filePath2, content) {
   const trimmed = content.trim();
   if (!trimmed) return false;
@@ -56438,13 +56695,18 @@ Drop conversational filler, pleasantries, and verbatim tool outputs (just note "
 Earlier conversation:
 
 `;
-var VOORMAN_IDLE_NUDGE = 'You\'re the project voorman and this turn ended with no handoff or proactive tool. If there is live work to move, pick one now: `advance_task_step` (next step), `message_gezel` (ping the next gezel), `assign_task` / `ensure_gezel` (wire up an assignee), or `ask_user_question` (surface a real blocker). But if the project is finished, or stable, or waiting on the user, that is already a COMPLETE turn \u2014 reply with ONE short sentence saying so (e.g. "From my perspective the project is done / in a stable state.") and stop. A plain "it\'s done" with no tool call is the correct answer there: it is not an idle failure and not a fabrication. Do not re-verify, do not relitigate the options, do not promise future action.';
+var VOORMAN_IDLE_NUDGE = "Before you finish, make one quick project check: is there concrete work already in flight that this turn should move? If yes, take the natural next action with the most relevant available tool \u2014 advance a ready step, message or assign the right gezel, or surface a real blocker. If no \u2014 because the project is complete, stable, or waiting on the user \u2014 say that once in one short sentence and end the turn. Do not invent work or call a tool merely to satisfy this check. Do not re-verify or promise future action.";
 var BOOTSTRAP_WORKSPACE_FILES = /* @__PURE__ */ new Set([
   "package.json",
+  "package-lock.json",
+  "pnpm-lock.yaml",
+  "yarn.lock",
+  "bun.lock",
+  "bun.lockb",
   "tsconfig.json",
   ".gitignore"
 ]);
-var VOORMAN_NOT_DONE_NUDGE = "You're the project voorman and this turn ended with no handoff or proactive tool. The workspace still holds only its bootstrap files \u2014 nothing has been built yet, so the project is NOT done, complete, or stable. Do NOT reply that it is. Move the work this turn: `message_gezel` the Builder/Developer who owns this task (or `ensure_gezel` for one first if none exists), with the exact deliverable path and acceptance criteria, and ask them to write the file and reply with the path; or `advance_task_step` if a step is genuinely ready; or, if you are truly blocked on a decision, `ask_user_question` to surface it. Pick one tool \u2014 a prose \"it's stable / done\" over an empty workspace is a false claim, not a complete turn.";
+var VOORMAN_NOT_DONE_NUDGE = "One project-state check before you finish: an active task remains, but the workspace still contains only setup files, so no deliverable has been built yet. If the user only asked for status or conversation, answer accurately and stop; a tool is not required. If this turn is supposed to move the active work, take one natural next action: message or assign the specialist who owns the deliverable, advance a genuinely ready step, or surface a real blocker with `ask_user_question`. Do not invent work or call a tool merely to appear busy, and do not describe an active empty project as done or stable.";
 var READ_ONLY_MCP_TOOLS = /* @__PURE__ */ new Set([
   "search_memory",
   "list_memories",
@@ -56645,7 +56907,7 @@ function growthSignature(gezel) {
 
 // src/codex-setup/manager.ts
 init_atomic();
-import { createHash as createHash12 } from "crypto";
+import { createHash as createHash13 } from "crypto";
 import { realpathSync as realpathSync2 } from "fs";
 import { chmod as chmod4, mkdir as mkdir15, readFile as readFile16, rm as rm6 } from "fs/promises";
 import { homedir as homedir3 } from "os";
@@ -57396,7 +57658,7 @@ function canonicalPath(path2) {
   }
 }
 function sha256(value) {
-  return createHash12("sha256").update(value).digest("hex");
+  return createHash13("sha256").update(value).digest("hex");
 }
 function catalogModelFor(model) {
   const contextWindow = model.contextWindow ?? 32768;
@@ -57821,7 +58083,7 @@ init_mcp_bridge();
 
 // src/connectors/writer.ts
 init_atomic();
-import { createHash as createHash13 } from "crypto";
+import { createHash as createHash14 } from "crypto";
 import { mkdir as mkdir16, readFile as readFile17, readdir as readdir9, rm as rm7, stat as stat11 } from "fs/promises";
 import { basename as basename7, join as join30 } from "path";
 import { projectLocalQuarantineDir } from "@bendyline/gezel/paths";
@@ -58094,7 +58356,7 @@ var StaticContentScanner = class {
 var contentScanner = new StaticContentScanner();
 
 // src/connectors/writer.ts
-var sha8 = (s) => createHash13("sha256").update(s).digest("hex").slice(0, 8);
+var sha8 = (s) => createHash14("sha256").update(s).digest("hex").slice(0, 8);
 function slug(input, max = 48) {
   const s = input.normalize("NFKD").replace(/[^\x20-\x7E]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, max).replace(/-+$/g, "");
   return s || "x";
@@ -58111,7 +58373,7 @@ function contentHash(record) {
   const attachments = (record.attachments ?? []).map((attachment) => ({
     filename: attachment.filename,
     size: attachment.size ?? attachment.content?.byteLength ?? 0,
-    sha256: attachment.sha256 ?? createHash13("sha256").update(attachment.content).digest("hex")
+    sha256: attachment.sha256 ?? createHash14("sha256").update(attachment.content).digest("hex")
   }));
   return sha8(
     `${JSON.stringify(sortedFrontmatter)}
@@ -59182,10 +59444,10 @@ var SpectralConnectorAdapter = class {
 };
 
 // src/connectors/oauth.ts
-import { createHash as createHash14, randomBytes as randomBytes3 } from "crypto";
+import { createHash as createHash15, randomBytes as randomBytes3 } from "crypto";
 function createPkce() {
   const verifier = randomBytes3(32).toString("base64url");
-  const challenge = createHash14("sha256").update(verifier).digest("base64url");
+  const challenge = createHash15("sha256").update(verifier).digest("base64url");
   return { verifier, challenge };
 }
 function randomState() {
@@ -63870,7 +64132,7 @@ function registerGitHubPullsAdapters(runtime) {
 }
 
 // src/connectors/natives/github-releases.ts
-import { createHash as createHash15 } from "crypto";
+import { createHash as createHash16 } from "crypto";
 import { mkdir as mkdir21, mkdtemp as mkdtemp3, open as open2, rm as rm13 } from "fs/promises";
 import { tmpdir as tmpdir3 } from "os";
 import { basename as basename8, join as join35 } from "path";
@@ -64063,7 +64325,7 @@ var GitHubReleasesAdapter = class {
       }
     }
     this.releases = releases;
-    this.fingerprint = createHash15("sha256").update(JSON.stringify(releases)).digest("hex");
+    this.fingerprint = createHash16("sha256").update(JSON.stringify(releases)).digest("hex");
   }
   apiHeaders(accept) {
     return {
@@ -64126,7 +64388,7 @@ var GitHubReleasesAdapter = class {
 };
 async function streamResponseToFile(response, path2) {
   const handle = await open2(path2, "wx");
-  const hash = createHash15("sha256");
+  const hash = createHash16("sha256");
   let size = 0;
   try {
     for await (const raw of response.body) {
@@ -66506,7 +66768,7 @@ var DebugFlag = class {
 
 // src/digest/generator.ts
 init_atomic();
-import { createHash as createHash16 } from "crypto";
+import { createHash as createHash17 } from "crypto";
 import { readFile as readFile25 } from "fs/promises";
 import { join as join40 } from "path";
 import {
@@ -69655,7 +69917,7 @@ var ProjectDigestGenerator = class {
     if (commits.length === 0 && sessions.length === 0 && events.length < MIN_EVENTS_FOR_DIGEST) {
       return false;
     }
-    const inputHash = createHash16("sha256").update(
+    const inputHash = createHash17("sha256").update(
       [
         week,
         ...commits,
@@ -69812,7 +70074,7 @@ function describe4(err) {
 }
 
 // src/engines/electron-native-reuse.ts
-import { createHash as createHash17 } from "crypto";
+import { createHash as createHash18 } from "crypto";
 import { createReadStream as createReadStream3 } from "fs";
 import { lstat as lstat2, readdir as readdir13, readlink } from "fs/promises";
 import { basename as basename11, join as join41, posix, relative as relative5, resolve as resolve8, sep as sep5 } from "path";
@@ -71432,7 +71694,7 @@ function enclosingMacApp(path2) {
 var HASH_READ_BUFFER_BYTES = 16 * 1024 * 1024;
 function sha256File2(path2) {
   return new Promise((resolveHash, reject) => {
-    const hash = createHash17("sha256");
+    const hash = createHash18("sha256");
     const stream = createReadStream3(path2, { highWaterMark: HASH_READ_BUFFER_BYTES });
     stream.on("data", (chunk2) => hash.update(chunk2));
     stream.on("error", reject);
@@ -71444,7 +71706,7 @@ function sha256File2(path2) {
 import { createLogger as createLogger69 } from "@bendyline/gezel";
 
 // src/engines/resolver.ts
-import { createHash as createHash18 } from "crypto";
+import { createHash as createHash19 } from "crypto";
 import { createReadStream as createReadStream4, existsSync as existsSync7 } from "fs";
 import { chmod as chmod5, mkdir as mkdir24, readFile as readFile26, rename as rename7, rm as rm16, writeFile as writeFile9 } from "fs/promises";
 import { join as join42 } from "path";
@@ -71568,7 +71830,7 @@ async function* resolveEngine(opts) {
     );
   }
   const sumsBytes = await ghBytes(sumsAsset.url, baseFetch, token);
-  const sumsDigest = createHash18("sha256").update(sumsBytes).digest("hex");
+  const sumsDigest = createHash19("sha256").update(sumsBytes).digest("hex");
   if (!unpinned && sumsDigest !== expectedDigest) {
     yield* fail(
       `SHA256SUMS digest mismatch for ${tag}: this build pins ${expectedDigest.slice(0, 16)}\u2026 but the release served ${sumsDigest.slice(0, 16)}\u2026. Refusing \u2014 the release may have been tampered with or re-cut.`
@@ -71818,7 +72080,7 @@ function parseSums(text) {
 }
 var HASH_READ_BUFFER_BYTES2 = 16 * 1024 * 1024;
 async function sha256File3(path2) {
-  const hash = createHash18("sha256");
+  const hash = createHash19("sha256");
   await new Promise((resolve18, reject) => {
     const stream = createReadStream4(path2, { highWaterMark: HASH_READ_BUFFER_BYTES2 });
     stream.on("data", (chunk2) => hash.update(chunk2));
@@ -72701,7 +72963,7 @@ function safeBasename(name) {
 }
 
 // src/fs/store.ts
-import { createHash as createHash20, randomUUID as randomUUID10 } from "crypto";
+import { createHash as createHash21, randomUUID as randomUUID10 } from "crypto";
 import {
   appendFile as appendFile4,
   chmod as chmod7,
@@ -73110,7 +73372,7 @@ function countDiffLines(diff) {
 }
 
 // src/workspace/journal.ts
-import { createHash as createHash19 } from "crypto";
+import { createHash as createHash20 } from "crypto";
 import { appendFile as appendFile2, mkdir as mkdir27, readFile as readFile29 } from "fs/promises";
 import { dirname as dirname26, join as join43 } from "path";
 import { projectPrivateDir as projectPrivateDir2 } from "@bendyline/gezel/paths";
@@ -73153,7 +73415,7 @@ async function readJournalTail(home, projectId, limit = 100) {
   }
 }
 function sha2562(content) {
-  return createHash19("sha256").update(content).digest("hex");
+  return createHash20("sha256").update(content).digest("hex");
 }
 
 // src/workspace/template.ts
@@ -74020,7 +74282,7 @@ function boekwachterIssueFingerprint(path2, issue) {
     issue.category.trim().toLocaleLowerCase(),
     issue.message.trim().toLocaleLowerCase().replace(/\s+/g, " ")
   ].join("\0");
-  return createHash20("sha256").update(normalized2).digest("hex");
+  return createHash21("sha256").update(normalized2).digest("hex");
 }
 var ConfigCorruptionError = class extends Error {
   code = "CONFIG_CORRUPT";
@@ -75768,6 +76030,7 @@ ${p.content.trim()}`).join("\n\n---\n\n");
   async createProject(input, opts) {
     const release2 = await this.acquireProjectCreationLock();
     try {
+      if (input.workingDir) this.assertSafeWorkingDir(input.workingDir);
       const id = opts?.id ?? await this.uniqueProjectId(slugify(input.name) || randomUUID10().slice(0, 8));
       if (!/^[a-z0-9][a-z0-9-]*$/.test(id)) {
         throw new Error(`invalid project id "${id}"`);
@@ -75791,14 +76054,22 @@ ${p.content.trim()}`).join("\n\n---\n\n");
           projectName: input.name
         });
       }
+      let github = input.github?.url ? { url: input.github.url } : void 0;
+      if (input.workingDir) {
+        github = await autoDetectGitHubLink(input.workingDir, github) ?? github;
+      }
       const project = {
         id,
         name: input.name,
         description: input.description,
         ...input.workingDir ? { workingDir: input.workingDir } : {},
+        // Opening an existing folder is an intake action, not a declaration
+        // that its objectives are ready for active supervision. Keep the
+        // Meester quiet until the user explicitly opts this project back in.
+        ...input.workingDir ? { nudgeConfig: { enabled: false } } : {},
         ...input.mode && input.mode !== "crew" ? { mode: input.mode } : {},
         ...input.indexingEnabled !== void 0 ? { indexingEnabled: input.indexingEnabled } : {},
-        ...input.github?.url ? { github: { url: input.github.url } } : {},
+        ...github ? { github } : {},
         createdAt: nowIso5(),
         updatedAt: nowIso5()
       };
@@ -79473,7 +79744,7 @@ import { projectCodeReviewsFile } from "@bendyline/gezel/paths";
 import { createLogger as createLogger77, projectAllowsAmbientWork } from "@bendyline/gezel";
 
 // src/tasks/manager.ts
-import { createHash as createHash21, randomUUID as randomUUID12 } from "crypto";
+import { createHash as createHash22, randomUUID as randomUUID12 } from "crypto";
 import {
   DEFAULT_NIGHT_SHIFT_WINDOW,
   MANAGED_WORKSPACE_WRITE_SETTING_LABEL as MANAGED_WORKSPACE_WRITE_SETTING_LABEL4,
@@ -80250,6 +80521,7 @@ var TaskManager = class {
       ...cron ? { cron } : {},
       ...nightShift ? { nightShift } : {},
       ...fanout ? { fanout } : {},
+      ...input.roleBasedNameOnlyMode !== void 0 ? { roleBasedNameOnlyMode: input.roleBasedNameOnlyMode } : {},
       createdAt: now,
       updatedAt: now,
       createdBy: input.createdBy ?? { kind: "user" }
@@ -81324,7 +81596,7 @@ ${paramLines}` : ""}`,
     if (step.advanceWhen?.file) {
       const content = await (step.advanceWhen.artifact ? this.store.readProjectArtifact(projectId, step.advanceWhen.file) : this.store.readProjectWorkspaceFile(projectId, step.advanceWhen.file)).catch(() => null);
       if (content !== null) {
-        contentHash2 = createHash21("sha256").update(content).digest("hex");
+        contentHash2 = createHash22("sha256").update(content).digest("hex");
       }
     }
     if (contentHash2 !== void 0 && step.lastGateReject?.contentHash !== void 0 && step.lastGateReject.contentHash === contentHash2) {
@@ -82244,6 +82516,7 @@ Fix one of these, then set the task active again:
       ...parent.nightShift?.enabled ? { nightShift: { enabled: true } } : {},
       activeStepId,
       parentTaskRef: parent.ref,
+      ...parent.roleBasedNameOnlyMode !== void 0 ? { roleBasedNameOnlyMode: parent.roleBasedNameOnlyMode } : {},
       createdAt: now,
       updatedAt: now,
       createdBy: parent.createdBy
@@ -82990,7 +83263,7 @@ function sumStat(s, key) {
 }
 
 // src/grants/manager.ts
-import { createHash as createHash22, randomBytes as randomBytes5, randomUUID as randomUUID13, timingSafeEqual } from "crypto";
+import { createHash as createHash23, randomBytes as randomBytes5, randomUUID as randomUUID13, timingSafeEqual } from "crypto";
 import { chmod as chmod8 } from "fs/promises";
 import { pendingGrantsFile as defaultPendingGrantsFile } from "@bendyline/gezel/paths";
 var PENDING_GRANT_TTL_MS = 10 * 6e4;
@@ -83062,7 +83335,7 @@ function generateVerificationCode() {
   return `${raw.slice(0, 3)}-${raw.slice(3)}`;
 }
 function hashVerificationCode(salt, normalizedCode) {
-  return createHash22("sha256").update(salt, "base64url").update("\0").update(normalizedCode, "ascii").digest();
+  return createHash23("sha256").update(salt, "base64url").update("\0").update(normalizedCode, "ascii").digest();
 }
 function codeMatches(grant, suppliedCode) {
   const normalized2 = normalizeVerificationCode(suppliedCode);
@@ -84982,7 +85255,7 @@ function tokenize2(question) {
 }
 
 // src/http/cert.ts
-import { createHash as createHash23 } from "crypto";
+import { createHash as createHash24 } from "crypto";
 import { generate as selfsignedGenerate } from "selfsigned";
 var CERT_VALIDITY_DAYS = 90;
 async function generateLoopbackCert() {
@@ -85019,7 +85292,7 @@ async function generateLoopbackCert() {
     ]
   });
   const der = pemToDer(pems.cert);
-  const digest = createHash23("sha256").update(der).digest();
+  const digest = createHash24("sha256").update(der).digest();
   return {
     certPem: pems.cert,
     keyPem: pems.private,
@@ -85033,14 +85306,14 @@ function pemToDer(pem) {
 }
 
 // src/http/codex-bridge-port.ts
-import { createHash as createHash24 } from "crypto";
+import { createHash as createHash25 } from "crypto";
 import { realpathSync as realpathSync3 } from "fs";
 import { resolve as resolve10 } from "path";
 var CODEX_BRIDGE_PORT_RANGE_START = 2e4;
 var CODEX_BRIDGE_PORT_RANGE_END = 49151;
 var CODEX_BRIDGE_PORT_RANGE_SIZE = CODEX_BRIDGE_PORT_RANGE_END - CODEX_BRIDGE_PORT_RANGE_START + 1;
 function codexBridgePortForHome(home) {
-  const digest = createHash24("sha256").update(canonicalPath2(home)).digest();
+  const digest = createHash25("sha256").update(canonicalPath2(home)).digest();
   const bucket = digest.readUInt32BE(0) % CODEX_BRIDGE_PORT_RANGE_SIZE;
   return CODEX_BRIDGE_PORT_RANGE_START + bucket;
 }
@@ -85266,7 +85539,7 @@ async function loadGezelByRef(ref, ctx) {
 import { randomUUID as randomUUID15 } from "crypto";
 
 // src/http/openai-compat/responses-translate.ts
-import { createHash as createHash25 } from "crypto";
+import { createHash as createHash26 } from "crypto";
 import { z as z11 } from "zod";
 
 // src/http/openai-compat/translate.ts
@@ -85705,7 +85978,7 @@ var CUSTOM_TOOL_INPUT_KEY = "input";
 function flattenResponsesNamespaceToolName(namespace, name) {
   const joined = `${namespace}__${name}`;
   if (joined.length <= MAX_LOCAL_TOOL_NAME_LENGTH) return joined;
-  const digest = createHash25("sha256").update(namespace).update("\0").update(name).digest("hex").slice(0, 12);
+  const digest = createHash26("sha256").update(namespace).update("\0").update(name).digest("hex").slice(0, 12);
   const prefixLength = MAX_LOCAL_TOOL_NAME_LENGTH - digest.length - 2;
   return `${joined.slice(0, prefixLength)}__${digest}`;
 }
@@ -86935,7 +87208,7 @@ function mountMachineEngineHints(app) {
 }
 
 // src/http/preview-capability.ts
-import { createHash as createHash26, randomBytes as randomBytes6 } from "crypto";
+import { createHash as createHash27, randomBytes as randomBytes6 } from "crypto";
 import { posix as posix3 } from "path";
 var DEFAULT_PREVIEW_CAPABILITY_TTL_MS = 10 * 60 * 1e3;
 var DEFAULT_PREVIEW_CAPABILITY_ABSOLUTE_TTL_MS = 2 * 60 * 60 * 1e3;
@@ -87079,7 +87352,7 @@ function pathIsInScope(path2, scopePath) {
   return scopePath === "" || path2 === scopePath || path2.startsWith(`${scopePath}/`);
 }
 function tokenDigest(token) {
-  return createHash26("sha256").update(token).digest("base64url");
+  return createHash27("sha256").update(token).digest("base64url");
 }
 
 // src/http/routes/ai.ts
@@ -87448,6 +87721,15 @@ var KOKORO_HF_REPO = "onnx-community/Kokoro-82M-v1.0-ONNX";
 var KOKORO_APPROX_BYTES_BY_ID = {
   [KOKORO_DEFAULT_MODEL_ID]: 95e6
 };
+function isKokoroRuntimeAvailable(resolveModule = (specifier) => import.meta.resolve(specifier)) {
+  try {
+    resolveModule("kokoro-js");
+    resolveModule("@huggingface/transformers");
+    return true;
+  } catch {
+    return false;
+  }
+}
 var KOKORO_DEFAULT_VOICES = [
   {
     id: "af_heart",
@@ -87777,7 +88059,7 @@ function parseGender(s) {
 }
 
 // src/providers/audio/whisper-cpp.ts
-import { createHash as createHash27 } from "crypto";
+import { createHash as createHash28 } from "crypto";
 import { createReadStream as createReadStream5 } from "fs";
 import { mkdir as mkdir37, readFile as readFile39, rename as rename11, rm as rm25, writeFile as writeFile14 } from "fs/promises";
 import { basename as basename12, join as join52 } from "path";
@@ -88072,7 +88354,7 @@ async function* downloadWithSha256(fetchImpl, opts) {
       yield { type: "progress", bytesWritten: writtenAll, totalBytes: totalAllBytes };
     }
   }
-  const hasher = createHash27("sha256");
+  const hasher = createHash28("sha256");
   await new Promise((resolve18, reject) => {
     const stream = createReadStream5(tmpPath, { highWaterMark: MODEL_HASH_READ_BUFFER_BYTES });
     stream.on("data", (chunk2) => hasher.update(chunk2));
@@ -88123,6 +88405,41 @@ function machineEngineProxy(ctx, sourcePrefix, targetPrefix, localPaths = [], sh
 
 // src/http/routes/audio.ts
 var log85 = createLogger88("audio");
+function buildAudioCatalog(options = {}) {
+  const kokoroRuntimeAvailable = options.kokoroRuntimeAvailable ?? isKokoroRuntimeAvailable();
+  return {
+    // All Whisper weights ship under MIT (whisper.cpp / OpenAI Whisper);
+    // Kokoro under Apache 2.0. Both are permissive → "Free, open".
+    stt: WHISPER_MODEL_CATALOG.map((m) => ({
+      id: m.id,
+      name: m.name,
+      description: m.description,
+      approxSizeBytes: m.approxSizeBytes,
+      kind: "stt",
+      license: "MIT",
+      licenseClass: "open",
+      licenseShortName: "MIT",
+      licenseUrl: "https://huggingface.co/ggerganov/whisper.cpp",
+      // The Base (English) variant is the recommended STT default: ~140 MB,
+      // realtime on laptop CPUs. Curated recoScore → ★ badge + auto-pick.
+      ...m.id === "whisper-base.en" ? { recoScore: 20 } : {}
+    })),
+    tts: kokoroRuntimeAvailable ? [
+      {
+        id: KOKORO_DEFAULT_MODEL_ID,
+        name: "Kokoro 82M v1.0",
+        description: "Apache 2.0 TTS \u2014 54+ voices, ~80MB quantized, near-realtime on M1 / modern desktop CPUs.",
+        approxSizeBytes: 95e6,
+        kind: "tts",
+        license: "Apache 2.0",
+        licenseClass: "open",
+        licenseShortName: "Apache 2.0",
+        licenseUrl: "https://huggingface.co/onnx-community/Kokoro-82M-v1.0-ONNX",
+        recoScore: 20
+      }
+    ] : []
+  };
+}
 function audioRoutes(ctx) {
   const app = new Hono4();
   app.use(
@@ -88244,38 +88561,7 @@ function audioRoutes(ctx) {
     });
   });
   app.get("/catalog", (c) => {
-    return c.json({
-      // All Whisper weights ship under MIT (whisper.cpp / OpenAI Whisper);
-      // Kokoro under Apache 2.0. Both are permissive → "Free, open".
-      stt: WHISPER_MODEL_CATALOG.map((m) => ({
-        id: m.id,
-        name: m.name,
-        description: m.description,
-        approxSizeBytes: m.approxSizeBytes,
-        kind: "stt",
-        license: "MIT",
-        licenseClass: "open",
-        licenseShortName: "MIT",
-        licenseUrl: "https://huggingface.co/ggerganov/whisper.cpp",
-        // The Base (English) variant is the recommended STT default: ~140 MB,
-        // realtime on laptop CPUs. Curated recoScore → ★ badge + auto-pick.
-        ...m.id === "whisper-base.en" ? { recoScore: 20 } : {}
-      })),
-      tts: [
-        {
-          id: KOKORO_DEFAULT_MODEL_ID,
-          name: "Kokoro 82M v1.0",
-          description: "Apache 2.0 TTS \u2014 54+ voices, ~80MB quantized, near-realtime on M1 / modern desktop CPUs.",
-          approxSizeBytes: 95e6,
-          kind: "tts",
-          license: "Apache 2.0",
-          licenseClass: "open",
-          licenseShortName: "Apache 2.0",
-          licenseUrl: "https://huggingface.co/onnx-community/Kokoro-82M-v1.0-ONNX",
-          recoScore: 20
-        }
-      ]
-    });
+    return c.json(buildAudioCatalog());
   });
   app.get("/stt/models", async (c) => {
     const provider = await ctx.stt.current();
@@ -90247,6 +90533,8 @@ function configRoutes(ctx) {
       autoUpdateChecks: config.autoUpdateChecks !== false,
       quitOnClose: config.quitOnClose === true,
       themePref: config.themePref,
+      cliShowThinking: config.cliShowThinking !== false,
+      cliShowWrites: config.cliShowWrites === true,
       documentExportOptions: config.documentExportOptions,
       sidebarSide: config.sidebarSide,
       homeGreetingCollapsed: config.homeGreetingCollapsed === true,
@@ -90593,6 +90881,8 @@ function configRoutes(ctx) {
       autoUpdateChecks: updated.autoUpdateChecks !== false,
       quitOnClose: updated.quitOnClose === true,
       themePref: updated.themePref,
+      cliShowThinking: updated.cliShowThinking !== false,
+      cliShowWrites: updated.cliShowWrites === true,
       documentExportOptions: updated.documentExportOptions,
       sidebarSide: updated.sidebarSide,
       homeGreetingCollapsed: updated.homeGreetingCollapsed === true,
@@ -91982,7 +92272,11 @@ function ds4Routes(ctx) {
     const catalogId = c.req.param("catalogId");
     const skipShaRaw = c.req.query("skipSha");
     const skipSha = skipShaRaw != null && skipShaRaw !== "" && skipShaRaw !== "0" && skipShaRaw !== "false";
-    ctx.chatInstalls.ds4.start(catalogId, { skipSha, includeMmproj: false });
+    ctx.chatInstalls.ds4.start(catalogId, {
+      skipSha,
+      includeMmproj: false,
+      installCompanion: false
+    });
     return streamSSE5(c, (stream) => subscribeToInstallSse(ctx.chatInstalls.ds4, catalogId, stream));
   });
   app.delete("/models/:catalogId/install", (c) => {
@@ -93670,6 +93964,7 @@ function gezelRoutes(ctx) {
         toGezelIdOrName: toId,
         projectId: body.projectId,
         text: body.text,
+        ...body.suppressReply ? { suppressReply: true } : {},
         ...body.expectedDeliverable ? { expectedDeliverable: body.expectedDeliverable } : {}
       });
       return c.json({
@@ -94611,7 +94906,7 @@ import { HandboekRenderModeSchema } from "@bendyline/gezel";
 import { Hono as Hono29 } from "hono";
 
 // src/handboek/narration.ts
-import { createHash as createHash28 } from "crypto";
+import { createHash as createHash29 } from "crypto";
 import { existsSync as existsSync14 } from "fs";
 import { mkdir as mkdir42, readFile as readFile43, writeFile as writeFile16 } from "fs/promises";
 import { join as join65 } from "path";
@@ -94627,7 +94922,7 @@ function createHandboekNarrator(deps) {
   const pathFor = (hash) => join65(dir, `${hash}.wav`);
   const metaPathFor = (hash) => join65(dir, `${hash}.json`);
   async function ensureSegment(key, synthesize) {
-    const hash = createHash28("sha256").update(key).digest("hex");
+    const hash = createHash29("sha256").update(key).digest("hex");
     const metaPath = metaPathFor(hash);
     if (existsSync14(pathFor(hash)) && existsSync14(metaPath)) {
       try {
@@ -95627,9 +95922,15 @@ function llamaCppRoutes(ctx) {
     const catalogId = c.req.param("catalogId");
     const skipShaRaw = c.req.query("skipSha");
     const skipSha = skipShaRaw != null && skipShaRaw !== "" && skipShaRaw !== "0" && skipShaRaw !== "false";
+    const skipCompanionRaw = c.req.query("skipCompanion");
+    const skipCompanion = skipCompanionRaw != null && skipCompanionRaw !== "" && skipCompanionRaw !== "0" && skipCompanionRaw !== "false";
     const config = await ctx.store.readConfig().catch(() => null);
     const includeMmproj = config?.nativeVision?.[catalogId] === true;
-    ctx.chatInstalls.llamaCpp.start(catalogId, { skipSha, includeMmproj });
+    ctx.chatInstalls.llamaCpp.start(catalogId, {
+      skipSha,
+      includeMmproj,
+      installCompanion: !skipCompanion
+    });
     return streamSSE9(
       c,
       (stream) => subscribeToInstallSse(ctx.chatInstalls.llamaCpp, catalogId, stream)
@@ -95720,7 +96021,7 @@ function mcpToolRoutes(ctx) {
 import { Hono as Hono36 } from "hono";
 
 // src/meester/status-generator.ts
-import { createHash as createHash29 } from "crypto";
+import { createHash as createHash30 } from "crypto";
 import {
   MEESTER_STATUS_HEADLINE_MAX,
   MeesterStatusModelOutputSchema,
@@ -96032,7 +96333,7 @@ function localDay4(date) {
   return `${y}-${m}-${d}`;
 }
 function actionKey(projectId, title) {
-  return createHash29("sha256").update(`${projectId}
+  return createHash30("sha256").update(`${projectId}
 ${normalizeTitle(title)}`).digest("hex");
 }
 function normalizeTitle(title) {
@@ -96044,7 +96345,7 @@ function hashInput(candidates) {
     ...c.openTasks.map((t) => `${t.ref}:${t.status}`),
     ...c.events.map((e) => e.id)
   ]);
-  return createHash29("sha256").update(lines.join("\n")).digest("hex");
+  return createHash30("sha256").update(lines.join("\n")).digest("hex");
 }
 function parseModelOutput(raw) {
   const fence = raw.match(/```(?:json)?\s*\n([\s\S]*?)\n?```/);
@@ -96144,19 +96445,19 @@ function memoryRoutes(ctx) {
   const app = new Hono37();
   app.post("/search", async (c) => {
     const body = await c.req.json();
-    const results = await ctx.memory.searchAll(
+    const outcome = await ctx.memory.searchAllDetailed(
       body.gezelId,
       body.projectId,
       body.query,
       body.topK ?? 10
     );
-    return c.json({ results });
+    return c.json(outcome);
   });
   app.post("/save", async (c) => {
     const body = await c.req.json();
     const kind = isMemoryKind(body.kind) ? body.kind : "fact";
     const outcome = await ctx.memory.save(body.scope, body.id, body.text, kind);
-    return c.json({ ok: true, status: outcome?.status ?? "saved" });
+    return c.json({ ok: true, ...outcome });
   });
   app.get("/recent", async (c) => {
     const scope = c.req.query("scope") ?? "gezel";
@@ -96337,7 +96638,7 @@ import { Hono as Hono39 } from "hono";
 import { z as z20 } from "zod";
 
 // src/models/gezmodel.ts
-import { createHash as createHash30, randomUUID as randomUUID19 } from "crypto";
+import { createHash as createHash31, randomUUID as randomUUID19 } from "crypto";
 import { createReadStream as createReadStream6, createWriteStream as createWriteStream5 } from "fs";
 import { mkdir as mkdir43, open as open3, readFile as readFile45, readdir as readdir26, rm as rm29, stat as stat26, writeFile as writeFile17 } from "fs/promises";
 import { basename as basename14, dirname as dirname35, extname as extname5, join as join66 } from "path";
@@ -96439,7 +96740,7 @@ var GezmodelManager = class {
       files.push({
         path: path2,
         sizeBytes: content.byteLength,
-        sha256: createHash30("sha256").update(content).digest("hex"),
+        sha256: createHash31("sha256").update(content).digest("hex"),
         role: path2 === "manifests/installed.json" ? "installed-manifest" : path2 === "manifests/catalog.json" ? "catalog-manifest" : "catalog-file"
       });
     }
@@ -96645,7 +96946,7 @@ var GezmodelManager = class {
   }
 };
 async function hashFile(path2) {
-  const hash = createHash30("sha256");
+  const hash = createHash31("sha256");
   const stream = createReadStream6(path2, { highWaterMark: MODEL_HASH_READ_BUFFER_BYTES });
   for await (const chunk2 of stream) hash.update(chunk2);
   return hash.digest("hex");
@@ -96843,7 +97144,7 @@ function extractOne(archivePath, wanted, dest, expected) {
           zip.openReadStream(entry, (streamErr, stream) => {
             if (streamErr || !stream)
               return fail2(streamErr ?? new Error("could not read ZIP entry"));
-            const hash = createHash30("sha256");
+            const hash = createHash31("sha256");
             let bytes = 0;
             const verifier = new Transform({
               transform(chunk2, _encoding, callback) {
@@ -97077,7 +97378,7 @@ import {
 } from "@bendyline/gezel";
 
 // src/providers/mlx/models.ts
-import { createHash as createHash31 } from "crypto";
+import { createHash as createHash32 } from "crypto";
 import { createReadStream as createReadStream7 } from "fs";
 import { mkdir as mkdir44, readFile as readFile47, rename as rename12, rm as rm30, stat as stat27, writeFile as writeFile18 } from "fs/promises";
 import { join as join68, resolve as resolvePath2 } from "path";
@@ -97639,7 +97940,7 @@ var MlxModelManager = class {
       }
     }
     push({ type: "verifying", file: file.name });
-    const hasher = createHash31("sha256");
+    const hasher = createHash32("sha256");
     await new Promise((resolve18, reject) => {
       const stream = createReadStream7(tmpPath, { highWaterMark: MODEL_HASH_READ_BUFFER_BYTES });
       stream.on("data", (chunk2) => hasher.update(chunk2));
@@ -99479,7 +99780,7 @@ function describeHostCadence(args) {
 }
 
 // src/project-type/craftbooks.ts
-import { createHash as createHash32 } from "crypto";
+import { createHash as createHash33 } from "crypto";
 import {
   craftbookFromDoc as craftbookFromDoc3,
   createLogger as createLogger109,
@@ -99503,7 +99804,7 @@ function craftbookContentHash(book) {
     command: book.command ?? null,
     requirements: book.requirements ?? null
   };
-  return `sha256:${createHash32("sha256").update(JSON.stringify(canonical)).digest("hex")}`;
+  return `sha256:${createHash33("sha256").update(JSON.stringify(canonical)).digest("hex")}`;
 }
 async function resolveTypeCraftbook(catalog, input, id, now) {
   const embedded = await catalog.readItemFile(
@@ -100211,7 +100512,7 @@ function pageInvokeRoutes(ctx) {
 }
 
 // src/http/routes/page-read.ts
-import { createHash as createHash33 } from "crypto";
+import { createHash as createHash34 } from "crypto";
 import { readFile as readFile50, readdir as readdir29, stat as stat28 } from "fs/promises";
 import { PageReadRequestSchema, createLogger as createLogger113 } from "@bendyline/gezel";
 import { Hono as Hono48 } from "hono";
@@ -100220,7 +100521,7 @@ var PAGE_READ_MAX_BYTES = 2 * 1024 * 1024;
 var RATE_WINDOW_MS3 = 6e4;
 var RATE_MAX_READS = 600;
 function etagOf(size, mtimeMs) {
-  return createHash33("sha256").update(`${size}:${Math.trunc(mtimeMs)}`).digest("base64url").slice(0, 16);
+  return createHash34("sha256").update(`${size}:${Math.trunc(mtimeMs)}`).digest("base64url").slice(0, 16);
 }
 function pageReadRoutes(ctx) {
   const app = new Hono48();
@@ -100270,7 +100571,7 @@ function pageReadRoutes(ctx) {
             return `${entry.name}:${entry.isDirectory() ? "dir" : "file"}:${Math.trunc(child?.mtimeMs ?? 0)}`;
           })
         );
-        const digest = createHash33("sha256").update(listed.sort().join("\n")).digest("base64url").slice(0, 16);
+        const digest = createHash34("sha256").update(listed.sort().join("\n")).digest("base64url").slice(0, 16);
         return c.json({ op: "stat", etag: digest, mtime: stats.mtimeMs });
       }
       return c.json({
@@ -100295,7 +100596,7 @@ function pageReadRoutes(ctx) {
           };
         })
       )).filter((entry) => entry !== null);
-      const digest = createHash33("sha256").update(
+      const digest = createHash34("sha256").update(
         listed.map((e) => `${e.name}:${e.kind}:${Math.trunc(e.mtime)}`).sort().join("\n")
       ).digest("base64url").slice(0, 16);
       return c.json({ op: "list", entries: listed, etag: digest, mtime: stats.mtimeMs });
@@ -101005,10 +101306,11 @@ import {
   projectGezelId as projectGezelId2,
   skillToCraftbookDoc
 } from "@bendyline/gezel";
+init_ensure();
 init_install();
 
 // src/workspace/instruction-scanner.ts
-import { createHash as createHash34 } from "crypto";
+import { createHash as createHash35 } from "crypto";
 import { readFile as readFile52, stat as stat30 } from "fs/promises";
 import { join as join73 } from "path";
 var MAX_CONTENT_CHARS = 64e3;
@@ -101053,7 +101355,7 @@ ${i.content.trim()}`).join("\n\n---\n\n");
   return { content: chosen.content, sourceFile: chosen.source, hash: chosen.hash };
 }
 function sha2563(s) {
-  return createHash34("sha256").update(s).digest("hex");
+  return createHash35("sha256").update(s).digest("hex");
 }
 
 // src/workspace/skill-script-translator.ts
@@ -101187,6 +101489,30 @@ async function translateShellBlock(chat, skillName, scriptName, code) {
 // src/workspace/import-sync.ts
 var log110 = createLogger114("import-sync");
 var VOORMAN_TEMPLATE_ID = "voorman";
+var BUILDER_TEMPLATE_ID = "builder";
+async function ensureFolderProjectBuilder(deps, projectId) {
+  const { store, catalog } = deps;
+  if (!projectId || projectId === "default") return {};
+  const project = await store.getProject(projectId).catch(() => null);
+  if (!project || project.mode !== "solo" || !project.workingDir) return {};
+  if (project.voormanGezelId) return {};
+  const gezels = await store.listGezels().catch(() => []);
+  const existing = gezels.find(
+    (gezel) => gezel.templateId === BUILDER_TEMPLATE_ID || gezel.role?.trim().toLowerCase() === BUILDER_TEMPLATE_ID
+  );
+  const recruited = existing ? null : await recruitFromTemplate(store, catalog, BUILDER_TEMPLATE_ID).catch((err) => {
+    log110.warn(`[import-sync] ${projectId}: Builder recruit failed: ${describe6(err)}`);
+    return null;
+  });
+  const builder = existing ?? recruited;
+  if (!builder) return {};
+  await store.updateProject(projectId, {
+    voormanGezelId: builder.id,
+    voormanAutoAssignedAt: nowIso12()
+  });
+  log110.info(`[import-sync] ${projectId}: assigned ${builder.id} as Builder`);
+  return recruited ? { createdGezel: recruited } : {};
+}
 async function syncProjectImports(deps, projectId, instructions, skills) {
   const { store } = deps;
   const gate = await store.assertWorkspaceWritable(projectId).catch(() => null);
@@ -101315,16 +101641,20 @@ async function findExistingVoorman(store) {
   return match?.id ?? null;
 }
 async function recruitVoorman(store, catalog) {
-  const detail = await catalog.get("gezel-template", VOORMAN_TEMPLATE_ID).catch(() => null);
-  if (!detail || detail.manifest.kind !== "gezel-template") return null;
+  return recruitFromTemplate(store, catalog, VOORMAN_TEMPLATE_ID);
+}
+async function recruitFromTemplate(store, catalog, templateId) {
+  const template = await resolveGildeTemplateForRole(catalog, templateId).catch(() => null);
+  if (!template || template.templateId !== templateId) return null;
   const { name, gender } = pickRandomNameWithGender4();
   const created = await store.createGezel({
     name,
-    role: detail.manifest.role,
+    role: template.role,
     gender,
-    about: detail.about ?? "",
-    templateId: VOORMAN_TEMPLATE_ID,
-    templateVersion: detail.manifest.version
+    about: template.about,
+    templateId,
+    templateVersion: template.templateVersion,
+    ...template.frontmatter ? { frontmatter: template.frontmatter } : {}
   });
   return { id: created.id, name: created.name };
 }
@@ -101799,6 +102129,7 @@ async function resolveActor(ctx, gezelIdHeader) {
 }
 function projectTaskRoutes(ctx) {
   const app = new Hono55();
+  const inflightCraftbookInvocations = /* @__PURE__ */ new Map();
   app.get("/:projectId/tasks", async (c) => {
     const projectId = c.req.param("projectId");
     const filter = ListFilterSchema.parse({
@@ -101814,10 +102145,31 @@ function projectTaskRoutes(ctx) {
   });
   app.post("/:projectId/tasks", async (c) => {
     const projectId = c.req.param("projectId");
-    const { dispatchEntry, ...body } = CreateTaskRequestSchema.parse(await c.req.json());
+    const { dispatchEntry, craftbookInvocationKey, ...body } = CreateTaskRequestSchema.parse(
+      await c.req.json()
+    );
     let task;
     try {
-      task = await ctx.tasks.create(projectId, body);
+      if (craftbookInvocationKey) {
+        const existing = (await ctx.tasks.list({ projectId })).find(
+          (candidate) => candidate.origin?.kind === "craftbook-invocation" && candidate.origin.key === craftbookInvocationKey && (candidate.status === "draft" || candidate.status === "active" || candidate.status === "paused")
+        );
+        if (existing) return c.json(existing);
+        const inflightKey = `${projectId}:${craftbookInvocationKey}`;
+        const pending5 = inflightCraftbookInvocations.get(inflightKey);
+        if (pending5) return c.json(await pending5);
+        const create = ctx.tasks.create(projectId, body, {
+          origin: { kind: "craftbook-invocation", key: craftbookInvocationKey }
+        });
+        inflightCraftbookInvocations.set(inflightKey, create);
+        try {
+          task = await create;
+        } finally {
+          inflightCraftbookInvocations.delete(inflightKey);
+        }
+      } else {
+        task = await ctx.tasks.create(projectId, body);
+      }
     } catch (err) {
       if (err instanceof CraftbookSetupRequiredError) {
         return c.json(
@@ -102888,7 +103240,7 @@ async function recoverTypedProjectCreations(store) {
 }
 
 // src/project-type/gzl.ts
-import { createHash as createHash35 } from "crypto";
+import { createHash as createHash36 } from "crypto";
 import { mkdir as mkdir48, writeFile as writeFile21 } from "fs/promises";
 import { dirname as dirname40 } from "path";
 import {
@@ -102906,7 +103258,7 @@ function shard(id) {
   return id.slice(0, 2).toLowerCase();
 }
 function hashItemFiles(files) {
-  const hash = createHash35("sha256");
+  const hash = createHash36("sha256");
   for (const { rel, content } of [...files].sort((a, b) => a.rel < b.rel ? -1 : 1)) {
     hash.update(rel);
     hash.update("\0");
@@ -103054,7 +103406,7 @@ async function importGzlBundle(deps, buffer, opts = {}) {
 
 // src/workspace/command-approvals.ts
 init_atomic();
-import { createHash as createHash36 } from "crypto";
+import { createHash as createHash37 } from "crypto";
 import { existsSync as existsSync18 } from "fs";
 import { mkdir as mkdir49, readFile as readFile57 } from "fs/promises";
 import { dirname as dirname41, join as join79 } from "path";
@@ -103062,7 +103414,7 @@ import { projectPrivateDir as projectPrivateDir5 } from "@bendyline/gezel/paths"
 function hashCommandInvocation(body, args, inputFiles = []) {
   const files = [...inputFiles].map(({ path: path2, sha256: sha2565 }) => ({ path: path2, sha256: sha2565 })).sort((a, b) => a.path.localeCompare(b.path) || a.sha256.localeCompare(b.sha256));
   const payload = JSON.stringify({ version: 2, body: body ?? null, args, files });
-  return createHash36("sha256").update("gezel-command-invocation\0").update(payload).digest("hex");
+  return createHash37("sha256").update("gezel-command-invocation\0").update(payload).digest("hex");
 }
 function approvalsPath(home, projectId) {
   return join79(projectPrivateDir5(home, projectId), "command-approvals.json");
@@ -103288,20 +103640,20 @@ import {
 } from "@bendyline/gezel";
 import { projectPrivateDir as projectPrivateDir6 } from "@bendyline/gezel/paths";
 var SHIPPED_ALLOWLIST = [
-  { package: "zod", allowedVersions: ["^3", "^4"] },
-  { package: "chalk", allowedVersions: ["^5"] },
-  { package: "commander", allowedVersions: ["^12", "^13"] },
-  { package: "date-fns", allowedVersions: ["^3", "^4"] },
-  { package: "yaml", allowedVersions: ["^2"] },
-  { package: "cheerio", allowedVersions: ["^1"] },
-  { package: "mime-types", allowedVersions: ["^2", "^3"] },
-  { package: "marked", allowedVersions: ["^12", "^13", "^14", "^15"] },
-  { package: "nanoid", allowedVersions: ["^5"] },
-  { package: "pino", allowedVersions: ["^9"] },
-  { package: "playwright-core", allowedVersions: ["^1"] },
-  { package: "tsx", allowedVersions: ["^4"] },
-  { package: "typescript", allowedVersions: ["^5"] },
-  { package: "undici", allowedVersions: ["^6", "^7"] }
+  { package: "zod", allowedVersions: ["^3", "^4"], defaultVersion: "^4" },
+  { package: "chalk", allowedVersions: ["^5"], defaultVersion: "^5" },
+  { package: "commander", allowedVersions: ["^12", "^13"], defaultVersion: "^13" },
+  { package: "date-fns", allowedVersions: ["^3", "^4"], defaultVersion: "^4" },
+  { package: "yaml", allowedVersions: ["^2"], defaultVersion: "^2" },
+  { package: "cheerio", allowedVersions: ["^1"], defaultVersion: "^1" },
+  { package: "mime-types", allowedVersions: ["^2", "^3"], defaultVersion: "^3" },
+  { package: "marked", allowedVersions: ["^12", "^13", "^14", "^15"], defaultVersion: "^15" },
+  { package: "nanoid", allowedVersions: ["^5"], defaultVersion: "^5" },
+  { package: "pino", allowedVersions: ["^9"], defaultVersion: "^9" },
+  { package: "playwright-core", allowedVersions: ["^1"], defaultVersion: "^1" },
+  { package: "tsx", allowedVersions: ["^4"], defaultVersion: "^4" },
+  { package: "typescript", allowedVersions: ["^5"], defaultVersion: "^5" },
+  { package: "undici", allowedVersions: ["^6", "^7"], defaultVersion: "^7" }
 ];
 function projectAllowlistPath(home, projectId) {
   return join81(projectPrivateDir6(home, projectId), "npm-allowlist.json");
@@ -103332,6 +103684,9 @@ function matchesAllowlist(pkg, version) {
   }
   return false;
 }
+function shippedDefaultVersion(pkg) {
+  return SHIPPED_ALLOWLIST.find((entry) => entry.package === pkg)?.defaultVersion;
+}
 function matchesProjectApproval(allowlist, pkg, version) {
   return allowlist.approved.some((e) => e.package === pkg && e.version === version);
 }
@@ -103461,7 +103816,9 @@ function dedupRequests(raw) {
   const out = [];
   for (const r of raw) {
     const pkg = NpmPackageNameSchema.parse(r.package);
-    const version = NpmRegistryVersionSchema.parse(r.version ?? "latest");
+    const version = NpmRegistryVersionSchema.parse(
+      r.version ?? shippedDefaultVersion(pkg) ?? "latest"
+    );
     const key = keyOf(pkg, version);
     if (seen.has(key)) continue;
     seen.add(key);
@@ -103631,7 +103988,7 @@ import { join as join82 } from "path";
 import { nowIso as nowIso14 } from "@bendyline/gezel";
 
 // src/workspace/command-inputs.ts
-import { createHash as createHash37 } from "crypto";
+import { createHash as createHash38 } from "crypto";
 import { createReadStream as createReadStream8 } from "fs";
 import { readFile as readFile59, realpath as realpath7, stat as stat35 } from "fs/promises";
 import { dirname as dirname43, extname as extname6, isAbsolute as isAbsolute10, relative as relative10, resolve as resolve13, sep as sep9 } from "path";
@@ -103704,7 +104061,7 @@ function portableRelative(root, file) {
   return relative10(root, file).split(sep9).join("/");
 }
 async function sha256File4(file) {
-  const hash = createHash37("sha256");
+  const hash = createHash38("sha256");
   await new Promise((resolveStream, reject) => {
     const stream = createReadStream8(file);
     stream.on("data", (chunk2) => hash.update(chunk2));
@@ -104263,12 +104620,13 @@ function projectRoutes(ctx) {
   app.post("/", async (c) => {
     const body = CreateProjectRequestSchema.parse(await c.req.json());
     const created = await ctx.store.createProject(body);
-    const ensured2 = await ensureProjectVoorman(
+    const ensureLead = body.workingDir && body.mode === "solo" ? ensureFolderProjectBuilder : ensureProjectVoorman;
+    const ensured2 = await ensureLead(
       { store: ctx.store, chat: ctx.chat, home: ctx.home, catalog: ctx.catalog },
       created.id
     ).catch((err) => {
       const message = err instanceof Error ? err.message : String(err);
-      log114.warn(`[projects] ensure-voorman failed for ${created.id}: ${message}`);
+      log114.warn(`[projects] ensure-lead failed for ${created.id}: ${message}`);
       return {};
     });
     if (ensured2.createdGezel) {
@@ -104791,6 +105149,31 @@ function projectRoutes(ctx) {
       return c.json({ error: "not found" }, 404);
     }
   });
+  app.post("/:id/reveal-reference", async (c) => {
+    const id = c.req.param("id");
+    const request = ReferenceFileLocationRequestSchema.parse({
+      kind: c.req.query("kind"),
+      path: c.req.query("path")
+    });
+    const base = request.kind === "artifact" ? ctx.store.projectArtifactsDir(id) : request.kind === "workspace" ? await ctx.store.projectWorkspaceDir(id) : ctx.store.documentsDir();
+    const joined = safeJoin(base, request.path);
+    if (!joined || !await realpathContained(base, joined)) {
+      return c.json({ error: "path traversal" }, 400);
+    }
+    let path2;
+    try {
+      const file = await stat36(joined);
+      if (!file.isFile()) return c.json({ error: "not found" }, 404);
+      path2 = await realpath8(joined);
+    } catch {
+      return c.json({ error: "not found" }, 404);
+    }
+    const { execFile: execFile8 } = await import("child_process");
+    const launcher = process.platform === "darwin" ? { cmd: "open", args: ["-R", path2] } : process.platform === "win32" ? { cmd: "explorer", args: ["/select,", path2] } : { cmd: "xdg-open", args: [dirname44(path2)] };
+    execFile8(launcher.cmd, launcher.args, { windowsHide: true }, () => {
+    });
+    return c.json(ReferenceFileLocationResponseSchema.parse({ path: path2 }));
+  });
   app.get("/:id/artifacts", async (c) => {
     const id = c.req.param("id");
     const subpath = c.req.query("path") ?? "";
@@ -107583,7 +107966,7 @@ async function readProjectScriptRun(home, projectId, runId) {
 }
 
 // src/scripts/sdk.ts
-import { createHash as createHash39 } from "crypto";
+import { createHash as createHash40 } from "crypto";
 import { readFile as readFile67 } from "fs/promises";
 import { dirname as dirname45, join as join87, relative as relative11 } from "path";
 import { fileURLToPath as fileURLToPath7 } from "url";
@@ -107649,7 +108032,7 @@ async function readSdkTypes() {
     });
   } catch {
   }
-  const hash = createHash39("sha256");
+  const hash = createHash40("sha256");
   for (const f of files) hash.update(f.name).update("\0").update(f.content);
   cachedTypes = { version: hash.digest("hex"), files };
   return cachedTypes;
@@ -110463,9 +110846,13 @@ async function grepWorkspace(opts) {
   const plan = normalizePlan(opts);
   const target = await resolveSearchTarget(opts.workspaceDir, opts.path);
   const requestedEngine = opts.engine ?? "auto";
-  const ripgrepPath = requestedEngine === "javascript" ? null : await resolveExecutableOnPath("rg", target.workspaceDir, Math.min(plan.timeoutMs, 2e3));
+  const ripgrepPath = requestedEngine === "javascript" ? null : await resolveRipgrepExecutable(target.workspaceDir, Math.min(plan.timeoutMs, 2e3));
   if (requestedEngine === "ripgrep" && !ripgrepPath) {
-    throw new WorkspaceGrepError("ripgrep is not installed on this machine", 500, "rg-unavailable");
+    throw new WorkspaceGrepError(
+      "ripgrep is unavailable (the bundled platform package is missing and rg is not on PATH)",
+      500,
+      "rg-unavailable"
+    );
   }
   let raw;
   let engine;
@@ -110969,6 +111356,16 @@ async function resolveExecutableOnPath(command, forbiddenRoot, timeoutMs) {
     if (timer) clearTimeout(timer);
   }
 }
+async function resolveRipgrepExecutable(forbiddenRoot, timeoutMs) {
+  const onPath = await resolveExecutableOnPath("rg", forbiddenRoot, timeoutMs);
+  if (onPath) return onPath;
+  try {
+    const { rgPath } = await import("@vscode/ripgrep");
+    return await validateExecutable(rgPath, forbiddenRoot);
+  } catch {
+    return null;
+  }
+}
 async function findExecutableOnPath(command, forbiddenRoot) {
   const pathValue = process.env.PATH;
   if (!pathValue) return null;
@@ -110977,22 +111374,28 @@ async function findExecutableOnPath(command, forbiddenRoot) {
     const entry = rawEntry.replace(/^"|"$/g, "");
     if (!entry || !isAbsolute11(entry)) continue;
     for (const suffix of suffixes) {
-      try {
-        const executable = await realpath10(join89(entry, `${command}${suffix}`));
-        if (pathIsInside(forbiddenRoot, executable)) continue;
-        const executableStat = await stat39(executable);
-        if (!executableStat.isFile()) continue;
-        await access3(
-          executable,
-          process.platform === "win32" ? fsConstants.F_OK : fsConstants.X_OK
-        );
-        return executable;
-      } catch {
-      }
+      const executable = await validateExecutable(
+        join89(entry, `${command}${suffix}`),
+        forbiddenRoot
+      );
+      if (executable) return executable;
     }
   }
   return null;
 }
+async function validateExecutable(candidate, forbiddenRoot) {
+  if (!isAbsolute11(candidate)) return null;
+  try {
+    const executable = await realpath10(candidate);
+    if (pathIsInside(forbiddenRoot, executable)) return null;
+    const executableStat = await stat39(executable);
+    if (!executableStat.isFile()) return null;
+    await access3(executable, process.platform === "win32" ? fsConstants.F_OK : fsConstants.X_OK);
+    return executable;
+  } catch {
+    return null;
+  }
+}
 function pathIsInside(root, candidate) {
   const rel = relative12(root, candidate);
   return rel === "" || rel !== ".." && !rel.startsWith(`..${sep10}`) && !isAbsolute11(rel);
@@ -116245,7 +116648,10 @@ function opaqueServerErrors(log189, onUnexpectedHttpError) {
     const raw = await prior.clone().text().catch(() => "");
     try {
       const parsed = JSON.parse(raw);
-      if (parsed.error === "internal_error" && typeof parsed.requestId === "string") return;
+      if (parsed.error === "internal_error" && typeof parsed.requestId === "string") {
+        c.header("x-request-id", parsed.requestId);
+        return;
+      }
       if ((parsed.error === "machine_engine_unavailable" || parsed.error === "capacity_denied") && Object.keys(parsed).length === 1) {
         return;
       }
@@ -118594,7 +119000,7 @@ function indexShadowBody(store, file, body) {
 }
 
 // src/index-store/area-pass.ts
-import { createHash as createHash40 } from "crypto";
+import { createHash as createHash41 } from "crypto";
 var ARCHITECTURE_KEY = "::project";
 var MIN_AREA_FILES = 2;
 var AREA_INPUT_CAP = 6e3;
@@ -118656,7 +119062,7 @@ async function runAreaPass(index, deps) {
   return result;
 }
 function hashLines(lines) {
-  return createHash40("sha256").update([...lines].sort().join("\n")).digest("hex");
+  return createHash41("sha256").update([...lines].sort().join("\n")).digest("hex");
 }
 function buildAreaPrompt(area, entries) {
   let body = "";
@@ -118846,9 +119252,9 @@ function triv(kind) {
 }
 
 // src/index-store/hash.ts
-import { createHash as createHash41 } from "crypto";
+import { createHash as createHash42 } from "crypto";
 function sha2564(data) {
-  return createHash41("sha256").update(data).digest("hex");
+  return createHash42("sha256").update(data).digest("hex");
 }
 
 // src/index-store/artifacts-indexer.ts
@@ -123759,7 +124165,7 @@ ${body}\r
 }
 
 // src/mail/mime.ts
-import { createHash as createHash42 } from "crypto";
+import { createHash as createHash43 } from "crypto";
 import { simpleParser } from "mailparser";
 
 // src/mail/html.ts
@@ -123874,7 +124280,7 @@ function normalizeReferences(refs) {
 }
 function synthesizeMessageId(parsed, ctx) {
   const basis = `${addressText(parsed.from)}|${parsed.subject ?? ""}|${parsed.date?.toISOString() ?? ctx.fallbackDate ?? ""}|${ctx.id}`;
-  return `<${createHash42("sha256").update(basis).digest("hex").slice(0, 32)}@gezel.local>`;
+  return `<${createHash43("sha256").update(basis).digest("hex").slice(0, 32)}@gezel.local>`;
 }
 async function parseRawMessage(raw, ctx) {
   const parsed = await simpleParser(raw);
@@ -124497,7 +124903,7 @@ async function migrateOversightTask(store, num) {
 
 // src/memory/compaction.ts
 init_atomic();
-import { createHash as createHash43 } from "crypto";
+import { createHash as createHash44 } from "crypto";
 import { readFile as readFile77 } from "fs/promises";
 import { join as join101 } from "path";
 import { createLogger as createLogger160, isProactiveAllowed as isProactiveAllowed5 } from "@bendyline/gezel";
@@ -124709,7 +125115,7 @@ var MemoryCompactor = class {
       }
     }
     if (entries.length < minEntries) return false;
-    const inputHash = createHash43("sha256").update(eligibleDays.map((d) => `${d}
+    const inputHash = createHash44("sha256").update(eligibleDays.map((d) => `${d}
 ${dayContents.get(d)}`).join("\n")).digest("hex");
     const state = await this.readState(scope, id);
     if (state.inputHash === inputHash) return false;
@@ -124815,7 +125221,7 @@ ${dayContents.get(d)}`).join("\n")).digest("hex");
     const notes = await this.memory.getRecent("gezel", gezelId, lookbackDays);
     if (!notes.trim()) return;
     const current = await this.store.readMemoryLessons(gezelId);
-    const lessonsInputHash = createHash43("sha256").update(`${notes}
+    const lessonsInputHash = createHash44("sha256").update(`${notes}
 ---
 ${current}`).digest("hex");
     const state = await this.readState("gezel", gezelId);
@@ -125156,8 +125562,8 @@ var MemoryManager = class {
    * that text dedups, so we accept the race rather than lock.
    *
    * Degraded mode (embeddings disabled): markdown is still appended (it is
-   * the source of truth and the index self-heals on rebuild) and the
-   * EmbeddingsDisabledError propagates, preserving the pre-dedup contract.
+   * the source of truth) and the outcome reports deferred indexing. The health
+   * monitor self-heals the derived index once embeddings recover.
    */
   async save(scope, id, text, kind = DEFAULT_MEMORY_KIND) {
     const trimmed = text.trim();
@@ -125172,9 +125578,19 @@ var MemoryManager = class {
       vector = await embed(trimmed);
     } catch (err) {
       await this.store.appendMemory(scope, id, trimmed, kind);
-      throw err;
+      log155.warn(
+        `[memory] saved ${scope}/${id} to Markdown; semantic indexing deferred: ${describeError3(err)}`
+      );
+      return deferredIndexOutcome();
+    }
+    let top;
+    try {
+      top = (await searchByVector(indexDir, vector, 1))[0];
+    } catch (error) {
+      log155.warn(
+        `[memory] vector dedup unavailable for ${scope}/${id}; continuing save: ${describeError3(error)}`
+      );
     }
-    const top = (await searchByVector(indexDir, vector, 1))[0];
     if (top && top.score >= this.dedupThreshold) {
       log155.info(
         `[memory] dup-skip (${top.score.toFixed(2)} vs "${top.text.slice(0, 40)}") ${scope}/${id}: ${trimmed.slice(0, 60)}`
@@ -125182,20 +125598,27 @@ var MemoryManager = class {
       return { status: "duplicate", match: { text: top.text, score: top.score, via: "vector" } };
     }
     await this.store.appendMemory(scope, id, trimmed, kind);
-    await addToIndex(
-      indexDir,
-      {
-        text: trimmed,
-        scope,
-        id,
-        day: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
-        at: (/* @__PURE__ */ new Date()).toISOString(),
-        kind
-      },
-      vector
-    );
+    try {
+      await addToIndex(
+        indexDir,
+        {
+          text: trimmed,
+          scope,
+          id,
+          day: (/* @__PURE__ */ new Date()).toISOString().slice(0, 10),
+          at: (/* @__PURE__ */ new Date()).toISOString(),
+          kind
+        },
+        vector
+      );
+    } catch (error) {
+      log155.warn(
+        `[memory] saved ${scope}/${id} to Markdown; semantic index write deferred: ${describeError3(error)}`
+      );
+      return deferredIndexOutcome();
+    }
     log155.info(`[memory] saved ${scope}/${id} [${kind}]: ${trimmed.slice(0, 60)}`);
-    return { status: "saved" };
+    return { status: "saved", indexed: true };
   }
   /**
    * Exact-text match against today's and yesterday's daily files. Two days
@@ -125217,7 +125640,15 @@ var MemoryManager = class {
   }
   async search(scope, id, query, topK = 10) {
     const indexDir = this.store.memoryIndexDir(scope, id);
-    return searchIndex(indexDir, query, topK);
+    if (!this.hasIndex(scope, id)) return this.searchLexical(scope, id, query, topK);
+    try {
+      return await searchIndex(indexDir, query, topK);
+    } catch (error) {
+      log155.warn(
+        `[memory] semantic search failed for ${scope}/${id}; using lexical fallback: ${describeError3(error)}`
+      );
+      return this.searchLexical(scope, id, query, topK);
+    }
   }
   /**
    * Like {@link search} but with a precomputed query embedding — lets the
@@ -125246,11 +125677,64 @@ var MemoryManager = class {
     return existsSync28(join103(this.store.memoryIndexDir(scope, id), "mem.db"));
   }
   async searchAll(gezelId, projectId, query, topK = 10) {
-    const [agentResults, projectResults] = await Promise.all([
-      this.search("gezel", gezelId, query, topK),
-      this.search("project", projectId, query, topK)
+    return (await this.searchAllDetailed(gezelId, projectId, query, topK)).results;
+  }
+  /**
+   * Search both scopes with one query embedding. Missing indexes fall back to
+   * the daily Markdown source; an unavailable/corrupt semantic cache does the
+   * same and reports a degraded mode instead of turning an optional feature
+   * into an HTTP 500.
+   */
+  async searchAllDetailed(gezelId, projectId, query, topK = 10) {
+    const gezelIndexed = this.hasIndex("gezel", gezelId);
+    const projectIndexed = this.hasIndex("project", projectId);
+    if (!gezelIndexed && !projectIndexed) {
+      return {
+        results: await this.searchAllLexical(gezelId, projectId, query, topK),
+        mode: "lexical"
+      };
+    }
+    try {
+      const vector = await embedQuery(query);
+      const [gezelResults, projectResults] = await Promise.all([
+        gezelIndexed ? this.searchVector("gezel", gezelId, vector, topK) : this.searchLexical("gezel", gezelId, query, topK),
+        projectIndexed ? this.searchVector("project", projectId, vector, topK) : this.searchLexical("project", projectId, query, topK)
+      ]);
+      return {
+        results: rankSearchResults([...gezelResults, ...projectResults], topK),
+        mode: gezelIndexed && projectIndexed ? "semantic" : "hybrid"
+      };
+    } catch (error) {
+      log155.warn(
+        `[memory] semantic search unavailable; using daily-memory lexical fallback: ${describeError3(error)}`
+      );
+      return {
+        results: await this.searchAllLexical(gezelId, projectId, query, topK),
+        mode: "lexical",
+        degraded: {
+          code: "semantic_search_unavailable",
+          message: "Semantic memory search is temporarily unavailable; searched saved memory text directly instead."
+        }
+      };
+    }
+  }
+  async searchAllLexical(gezelId, projectId, query, topK) {
+    const [gezelResults, projectResults] = await Promise.all([
+      this.searchLexical("gezel", gezelId, query, topK),
+      this.searchLexical("project", projectId, query, topK)
     ]);
-    return [...agentResults, ...projectResults].sort((a, b) => b.score - a.score).slice(0, topK);
+    return rankSearchResults([...gezelResults, ...projectResults], topK);
+  }
+  async searchLexical(scope, id, query, topK) {
+    const entries = await this.allEntries(scope, id);
+    return entries.map((entry) => ({ entry, score: lexicalScore(query, entry.text) })).filter((candidate) => candidate.score > 0).sort((a, b) => b.score - a.score || b.entry.at.localeCompare(a.entry.at)).slice(0, topK).map(({ entry, score }) => ({
+      text: entry.text,
+      score,
+      day: entry.day,
+      scope: entry.scope,
+      id: entry.id,
+      kind: entry.kind ?? DEFAULT_MEMORY_KIND
+    }));
   }
   async listDays(scope, id) {
     return this.store.listMemoryDays(scope, id);
@@ -125315,6 +125799,36 @@ var MemoryManager = class {
     return entries.length;
   }
 };
+function rankSearchResults(results, topK) {
+  return results.sort((a, b) => b.score - a.score).slice(0, topK);
+}
+function deferredIndexOutcome() {
+  return {
+    status: "saved",
+    indexed: false,
+    degraded: {
+      code: "semantic_index_unavailable",
+      message: "Memory was saved, but semantic indexing is temporarily unavailable."
+    }
+  };
+}
+function lexicalScore(query, text) {
+  const normalizedQuery = query.trim().toLocaleLowerCase();
+  const normalizedText = text.toLocaleLowerCase();
+  if (!normalizedQuery || !normalizedText) return 0;
+  if (normalizedText.includes(normalizedQuery)) return 1;
+  const queryTokens = new Set(normalizedQuery.match(/[\p{L}\p{N}_-]+/gu) ?? []);
+  if (queryTokens.size === 0) return 0;
+  const textTokens = new Set(normalizedText.match(/[\p{L}\p{N}_-]+/gu) ?? []);
+  let matches = 0;
+  for (const token of queryTokens) {
+    if (textTokens.has(token)) matches++;
+  }
+  return matches / queryTokens.size;
+}
+function describeError3(error) {
+  return error instanceof Error ? error.message : String(error);
+}
 
 // src/models/install-jobs.ts
 import { createLogger as createLogger166 } from "@bendyline/gezel";
@@ -125477,6 +125991,7 @@ var LlamaVisionProvider = class {
     await mkdir57(itemDir, { recursive: true });
     const totalAllBytes = spec.files.reduce((n, f) => n + f.approxSizeBytes, 0);
     let writtenAll = 0;
+    const verifiedDigests = {};
     for (const file of spec.files) {
       const result = yield* downloadWithSha256(this.fetchImpl, {
         url: file.downloadUrl,
@@ -125492,8 +126007,9 @@ var LlamaVisionProvider = class {
         return;
       }
       writtenAll = result.writtenAll;
+      verifiedDigests[file.filename] = file.sha256.toLowerCase();
     }
-    const fileSha256 = await hashModelPayloadFiles(itemDir);
+    const fileSha256 = await hashModelPayloadFiles(itemDir, verifiedDigests);
     await writeFile26(
       join104(itemDir, "manifest.json"),
       `${JSON.stringify(
@@ -125913,7 +126429,7 @@ async function* runGgufInstallWithCompanion(catalogId, o, deps) {
     yield event;
   }
   if (!finished) return;
-  yield* companionRecognitionEvents(catalogId, deps);
+  if (o.installCompanion) yield* companionRecognitionEvents(catalogId, deps);
   yield finished;
 }
 async function* companionRecognitionEvents(catalogId, deps) {
@@ -127221,7 +127737,7 @@ function makeActionable(message) {
 }
 
 // src/providers/image/sd-cpp.ts
-import { createHash as createHash44 } from "crypto";
+import { createHash as createHash45 } from "crypto";
 import { createReadStream as createReadStream10 } from "fs";
 import { mkdir as mkdir60, readFile as readFile81, rename as rename15, rm as rm41, writeFile as writeFile29 } from "fs/promises";
 import { join as join110 } from "path";
@@ -127560,7 +128076,7 @@ var StableDiffusionCppProvider = class {
       }
     }
     const partialPath = `${destPath}.partial`;
-    const hasher = createHash44("sha256");
+    const hasher = createHash45("sha256");
     await new Promise((resolve18, reject) => {
       const stream = createReadStream10(partialPath, {
         highWaterMark: MODEL_HASH_READ_BUFFER_BYTES
@@ -128079,7 +128595,7 @@ function isMachineImageProvider(config, env) {
 }
 
 // src/providers/recognition/store.ts
-import { createHash as createHash45 } from "crypto";
+import { createHash as createHash46 } from "crypto";
 import { mkdir as mkdir61, readFile as readFile82, rename as rename16, rm as rm42, writeFile as writeFile30 } from "fs/promises";
 import { join as join112 } from "path";
 import { ImageRecognitionSchema, createLogger as createLogger172 } from "@bendyline/gezel";
@@ -128091,8 +128607,8 @@ var RecognitionCache = class {
     this.root = join112(opts.home, "recognition");
   }
   keyFor(input) {
-    const imageHash = createHash45("sha256").update(input.bytes).digest("hex");
-    return createHash45("sha256").update(`${imageHash}\0${input.mode}\0${input.modelId}\0v${PROMPT_VERSION}`).digest("hex");
+    const imageHash = createHash46("sha256").update(input.bytes).digest("hex");
+    return createHash46("sha256").update(`${imageHash}\0${input.mode}\0${input.modelId}\0v${PROMPT_VERSION}`).digest("hex");
   }
   pathFor(key) {
     return join112(this.root, key.slice(0, 2), `${key}.json`);
@@ -128537,7 +129053,7 @@ var MockVideoProvider = class {
 };
 
 // src/providers/video/models.ts
-import { createHash as createHash46 } from "crypto";
+import { createHash as createHash47 } from "crypto";
 import { createReadStream as createReadStream11 } from "fs";
 import { mkdir as mkdir62, readFile as readFile83, rename as rename17, rm as rm43, writeFile as writeFile31 } from "fs/promises";
 import { dirname as dirname50, join as join113 } from "path";
@@ -128723,7 +129239,7 @@ var VideoModelManager = class {
           await rm43(finalPath, { force: true });
           await rename17(partialPath, finalPath);
         } catch (err) {
-          yield { type: "error", error: `rename failed for ${file.name}: ${describeError3(err)}` };
+          yield { type: "error", error: `rename failed for ${file.name}: ${describeError4(err)}` };
           return;
         }
       }
@@ -128810,7 +129326,7 @@ var VideoModelManager = class {
       }
     }
     push({ type: "verifying", file: file.name });
-    const hasher = createHash46("sha256");
+    const hasher = createHash47("sha256");
     await new Promise((resolve18, reject) => {
       const stream = createReadStream11(tmpPath, { highWaterMark: MODEL_HASH_READ_BUFFER_BYTES });
       stream.on("data", (chunk2) => hasher.update(chunk2));
@@ -128882,7 +129398,7 @@ var VideoModelSelector = class {
     return (id ? await this.models.resolveModel(id) : null) ?? await this.models.resolveDefaultModel();
   }
 };
-function describeError3(err) {
+function describeError4(err) {
   return err instanceof Error ? err.message : String(err);
 }
 function isSafeId3(id) {
@@ -133083,11 +133599,18 @@ var TaskRunner = class {
   /** Run one serialized dispatch pass now, sharing the interval's overlap guard. */
   async wake() {
     if (this.tickInFlight) return this.tickInFlight;
-    this.tickInFlight = this.tick().finally(() => {
+    this.tickInFlight = this.tickOnce().finally(() => {
       this.tickInFlight = null;
     });
     return this.tickInFlight;
   }
+  /**
+   * Public test/operator entry point. Keep it serialized with the interval:
+   * callers may drive a real, already-started service whose ticker is active.
+   */
+  async tick() {
+    return this.wake();
+  }
   /**
    * Scan every `active` task and enqueue a handoff for any whose
    * current step has an effective gezel owner. Call on service boot and
@@ -133134,9 +133657,9 @@ var TaskRunner = class {
   /**
    * One dispatch pass. Walks pending in FIFO order; dispatches any
    * whose target provider has a free slot; skips items for tasks
-   * that are no longer active. Public for test-driven ticks.
+   * that are no longer active.
    */
-  async tick() {
+  async tickOnce() {
     await this.pruneActiveDispatches();
     if (this.pending.length === 0) {
       this.holdReason = void 0;
@@ -133148,6 +133671,7 @@ var TaskRunner = class {
       return;
     }
     const snapshot = this.pending.slice();
+    const snapshotIds = new Set(snapshot.map((handoff) => handoff.id));
     const keep = [];
     const inTickDispatches = /* @__PURE__ */ new Map();
     const nightShiftOn = this.isNightShiftActive();
@@ -133213,6 +133737,7 @@ var TaskRunner = class {
           ...handoff.fromGezelName ? { fromGezelName: handoff.fromGezelName } : {},
           ...handoff.fromGezelId ? { fromGezelId: handoff.fromGezelId } : {},
           ...handoff.kind ? { kind: handoff.kind } : {},
+          ...task.roleBasedNameOnlyMode !== void 0 ? { roleBasedNameOnlyMode: task.roleBasedNameOnlyMode } : {},
           lane,
           ...isNight ? { ambient: true } : {},
           ...isNight ? { nightShift: true } : {},
@@ -133235,8 +133760,9 @@ var TaskRunner = class {
         );
       }
     }
+    const enqueuedDuringTick = this.pending.filter((handoff) => !snapshotIds.has(handoff.id));
     this.pending.length = 0;
-    this.pending.push(...keep);
+    this.pending.push(...keep, ...enqueuedDuringTick);
     this.holdReason = keep.some((handoff) => handoff.heldFor === "provider-busy") ? "provider-busy" : void 0;
   }
   async pruneActiveDispatches() {
@@ -133726,6 +134252,10 @@ Step "${step.name}" (\`${step.id}\`) was re-driven ${maxRedrives}\xD7 without pr
     } catch {
     }
     const activeTasks = projectTasks.filter((t) => t.status === "active");
+    if (projectTasks.length === 0) {
+      trace("skip \u2014 project has no tasks to advance");
+      return;
+    }
     if (projectTasks.length > 0 && activeTasks.length === 0) {
       if (projectTasks.some((t) => t.status === "draft")) {
         trace("skip \u2014 only draft task(s) await activation; not nudging or stabilizing");
@@ -137467,7 +137997,7 @@ Address these, then the gate re-checks automatically.`,
       try {
         const existing = await tasks.listChildren(task.ref).catch(() => []);
         if (existing.length === 0) {
-          const raw = await store.readProjectWorkspaceFile(projectId, spawn14.overFile).catch(() => null);
+          const raw = await (spawn14.overArtifact ? store.readProjectArtifact(projectId, spawn14.overFile) : store.readProjectWorkspaceFile(projectId, spawn14.overFile)).catch(() => null);
           const items = raw ? extractSpawnItems(raw, spawn14.itemsPath) : [];
           if (items.length === 0) {
             log188.warn(
@@ -137496,7 +138026,7 @@ Address these, then the gate re-checks automatically.`,
 
 ${kids.map((k) => `- ${k.ref}: ${k.title}`).join("\n")}
 `;
-          await store.writeProjectWorkspaceFile(projectId, advanceFile, manifest).catch((err) => log188.warn(`[fanout] ${task.ref}: could not write ${advanceFile}:`, err));
+          await (newStep.advanceWhen?.artifact ? store.writeProjectArtifact(projectId, advanceFile, manifest) : store.writeProjectWorkspaceFile(projectId, advanceFile, manifest)).catch((err) => log188.warn(`[fanout] ${task.ref}: could not write ${advanceFile}:`, err));
         }
         const nextStep = newStep.advanceWhen?.goto ?? newStep.next;
         if (nextStep) {