@bendyline/gezel-service 1.0.3 → 1.0.4

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;
@@ -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];
   }
@@ -33321,7 +33422,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];
@@ -37273,6 +37374,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 +40295,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 +40731,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 +42651,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 +46494,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 {
@@ -47779,6 +47910,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 +48216,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 +48350,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 +48399,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 +48456,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) => {
@@ -49167,11 +49310,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 +49339,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 +49814,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 +49847,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 +49864,7 @@ ${userText}`;
     return this.runSendAndDrain(
       sessionId2,
       userText,
-      opts?.nudge ? { ...opts, nudge: false } : opts
+      opts?.nudge ? { ...opts, nudge: false, messageOrigin } : { ...opts, messageOrigin }
     );
   }
   /**
@@ -49818,7 +49963,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 +49986,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 {
@@ -50171,6 +50317,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 +50339,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 +50363,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 +50372,7 @@ ${promptForTurn}`;
       }
       let continuations = 0;
       const maxContinuations = resolveContinuationBudget(state);
+      let voormanIdleNudged = false;
       const toolsAcrossContinuations = [];
       let compactionsThisSend = 0;
       let keurmeesterConsultedThisSend = false;
@@ -50476,6 +50636,7 @@ ${state.aboutSnapshot}`);
         const detectorVerdict = runPostTurnDetectors(state, {
           sessionId: sessionId2,
           isMeester: cfgForDetector?.meesterGezelId === state.record.gezelId,
+          messageOrigin,
           userText,
           drained: toolsAcrossContinuations,
           assistantContent: assistantMessage.content,
@@ -50489,7 +50650,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 +50804,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 +50825,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 +50838,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 +50892,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 +50919,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 +50930,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 +50977,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 +50995,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 +51573,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 +54324,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 +54333,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 +55656,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 +56096,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,
@@ -56438,13 +56631,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",
@@ -75768,6 +75966,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 +75990,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()
       };
@@ -80250,6 +80457,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" }
@@ -82244,6 +82452,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
@@ -96144,19 +96353,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";
@@ -101005,6 +101214,7 @@ import {
   projectGezelId as projectGezelId2,
   skillToCraftbookDoc
 } from "@bendyline/gezel";
+init_ensure();
 init_install();
 
 // src/workspace/instruction-scanner.ts
@@ -101187,6 +101397,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 +101549,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 +102037,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 +102053,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(
@@ -104263,12 +104523,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 +105052,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") ?? "";
@@ -116245,7 +116531,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;
       }
@@ -125156,8 +125445,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 +125461,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 +125481,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 +125523,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 +125560,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 +125682,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";
@@ -128723,7 +129120,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;
         }
       }
@@ -128882,7 +129279,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) {
@@ -133213,6 +133610,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 } : {},
@@ -133726,6 +134124,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 +137869,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 +137898,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) {