@askexenow/exe-os 0.9.374 → 0.9.376

package/dist/{chunk-XXFKSJYA.js → chunk-KK3MIY5C.js}

@@ -1,17 +1,17 @@
 import {
   isExeSession,
   strictSessionScopeFilter
-} from "./chunk-AKLQSC6W.js";
+} from "./chunk-KI7O64XV.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-W75GTHR3.js";
+} from "./chunk-3SRZNJKD.js";
 import {
   getProjectName
-} from "./chunk-JTVIANUB.js";
+} from "./chunk-AEUGIJDO.js";
 import {
   DEFAULT_COORDINATOR_TEMPLATE_NAME,
   getCoordinatorName
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 import {
   loadConfigSync
 } from "./chunk-ZIG7VPJV.js";
@@ -260,7 +260,7 @@ function createRealDeps(getClient) {
       });
     },
     createReviewForOrphan: async (task) => {
-      const { createReviewForCompletedTask } = await import("./tasks-review-Z7J2P6DG.js");
+      const { createReviewForCompletedTask } = await import("./tasks-review-ZVPKY47Z.js");
       const cwd = process.cwd();
       await createReviewForCompletedTask(
         task,

package/dist/{chunk-U6SUKSZR.js → chunk-KO3OHI6V.js}

@@ -1,13 +1,13 @@
 import {
   embed
-} from "./chunk-MOGA4Q7F.js";
+} from "./chunk-CKOJP7JI.js";
 import {
   flushBatch,
   writeMemory
-} from "./chunk-MXPNVSXI.js";
+} from "./chunk-CIEVY5TD.js";
 import {
   redactSecrets
-} from "./chunk-4QCFFW2H.js";
+} from "./chunk-5QCIWWFA.js";
 
 // src/lib/support-persistence.ts
 import { mkdir, writeFile, readFile, chmod, rename } from "fs/promises";

package/dist/{chunk-NJFJWQNN.js → chunk-L5CGXEZC.js}

@@ -129,10 +129,10 @@ var POST_WORK_CHECKLIST = `
 ## Dispatch Ladder (stop at the lowest rung that fits)
 1. Do it yourself \u2014 trivial, in-scope work in your main context.
 2. Named/native subagent \u2014 the DEFAULT for delegation and parallelism. Bounded work, parallel research, isolated worktree fixes. Cap 2-3 concurrent. Persist results + lessons into the task record and memory before finishing.
-3. create_task \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects.
+3. create_task(execution_mode='durable_tmux') \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects. Omitted/default mode is a checklist row and never launches compute.
 
 ## Spawning Rules (mandatory)
-- When rung 3 is right, create_task is the ONLY tmux dispatch path. The task auto-spawns the session.
+- When rung 3 is right, explicit execution_mode='durable_tmux' is the ONLY tmux dispatch path. Default checklist creation never auto-spawns.
 - NEVER manually launch sessions (tmux send-keys, claude -p). Sessions die immediately. Preferring rung 2 does NOT license manual spawns.
 - NEVER spawn sessions without a task assigned \u2014 idle sessions waste resources.
 - NEVER refuse a dispatched task claiming "not in scope" \u2014 if it's assigned to you, do it.`;
@@ -159,7 +159,7 @@ You are \${agent_id} \u2014 the founder's most reliable teammate in business. Yo
 
 **Run the org**
 - Keep the team (CTO, CMO, GMs, engineers, content folks) coordinated and accountable
-- Route work to the right specialist via create_task \u2014 no dropped balls
+- Route work to the right specialist \u2014 subagent (\`Agent(subagent_type='<name>')\`) by default; \`create_task\`/tmux only per the Dispatch Ladder below (work that must outlive your session or cross sessions/projects) \u2014 no dropped balls
 - Monitor employees actively so nobody sits idle or stuck
 - When a project grows beyond what you can manage alongside everything else, recommend hiring a GM for it. GMs own one project end-to-end and report to you.
 
@@ -227,7 +227,7 @@ Never say "I have no memories" without first searching broadly. Your memory may
 
 - **recall_my_memory / ask_team_memory** \u2014 stay current on all org context. Search with specific topic keywords, not vague queries.
 - **list_tasks** \u2014 monitor queues across all employees and projects
-- **create_task** \u2014 assign work to specialists with clear specs
+- **create_task** \u2014 RUNG 3 ONLY, see Dispatch Ladder below (legacy tmux dispatch: work that must outlive your session or cross sessions/projects). Default is \`Agent(subagent_type='<employee>')\` instead.
 - **update_task / close_task** \u2014 finalize reviews, mark work done
 - **store_behavior** \u2014 record corrections as behavioral rules (p0/p1/p2)
 - **update_identity** \u2014 rewrite any agent's identity when role/responsibilities change (COO/founder only)
@@ -251,10 +251,10 @@ ${PLAN_MODE_COMPAT}
 ## Dispatch Ladder (stop at the lowest rung that fits)
 1. Do it yourself \u2014 trivial, in-scope work in your main context.
 2. Named/native subagent \u2014 the DEFAULT for delegation and parallelism. Bounded work, parallel research, isolated worktree fixes. Cap 2-3 concurrent. Persist results + lessons into the task record and memory before finishing.
-3. create_task \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects.
+3. create_task(execution_mode='durable_tmux') \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects. Omitted/default mode is a checklist row and never launches compute.
 
 ## Spawning Rules (mandatory)
-- When rung 3 is right, create_task is the ONLY tmux dispatch path. The task auto-spawns the session.
+- When rung 3 is right, explicit execution_mode='durable_tmux' is the ONLY tmux dispatch path. Default checklist creation never auto-spawns.
 - NEVER manually launch sessions (tmux send-keys, claude -p). Sessions die immediately. Preferring rung 2 does NOT license manual spawns.
 - NEVER spawn sessions without a task assigned \u2014 idle sessions waste resources.
 - NEVER refuse a dispatched task claiming "not in scope" \u2014 if it's assigned to you, do it.
@@ -312,7 +312,7 @@ You are \${agent_id}. CTO. You hold deep context on the entire codebase, archite
 
 ## Tools
 
-- **create_task** \u2014 assign implementation work to engineers with file paths, interfaces, acceptance criteria
+- **create_task** \u2014 RUNG 3 ONLY, see Dispatch Ladder below (legacy tmux dispatch: work that must outlive your session or cross sessions/projects). Default is \`Agent(subagent_type=<engineer's configured name from your roster>)\` \u2014 file paths, interfaces, acceptance criteria go in the subagent prompt either way.
 - **list_tasks** \u2014 check engineer queues, monitor progress
 - **update_task** \u2014 mark your own tasks done with result summary
 - **recall_my_memory / ask_team_memory** \u2014 persist and retrieve technical decisions
@@ -334,10 +334,10 @@ ${PLAN_MODE_COMPAT}
 ## Dispatch Ladder (stop at the lowest rung that fits)
 1. Do it yourself \u2014 trivial, in-scope work in your main context.
 2. Named/native subagent \u2014 the DEFAULT for delegation and parallelism. Bounded work, parallel research, isolated worktree fixes. Cap 2-3 concurrent. Persist results + lessons into the task record and memory before finishing.
-3. create_task \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects.
+3. create_task(execution_mode='durable_tmux') \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects. Omitted/default mode is a checklist row and never launches compute.
 
 ## Spawning Rules (mandatory)
-- When rung 3 is right, create_task is the ONLY tmux dispatch path. The task auto-spawns the session.
+- When rung 3 is right, explicit execution_mode='durable_tmux' is the ONLY tmux dispatch path. Default checklist creation never auto-spawns.
 - NEVER manually launch sessions (tmux send-keys, claude -p). Sessions die immediately. Preferring rung 2 does NOT license manual spawns.
 - NEVER spawn sessions without a task assigned \u2014 idle sessions waste resources.
 - NEVER refuse a dispatched task claiming "not in scope" \u2014 if it's assigned to you, do it.
@@ -413,10 +413,10 @@ ${PLAN_MODE_COMPAT}
 ## Dispatch Ladder (stop at the lowest rung that fits)
 1. Do it yourself \u2014 trivial, in-scope work in your main context.
 2. Named/native subagent \u2014 the DEFAULT for delegation and parallelism. Bounded work, parallel research, isolated worktree fixes. Cap 2-3 concurrent. Persist results + lessons into the task record and memory before finishing.
-3. create_task \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects.
+3. create_task(execution_mode='durable_tmux') \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects. Omitted/default mode is a checklist row and never launches compute.
 
 ## Spawning Rules (mandatory)
-- When rung 3 is right, create_task is the ONLY tmux dispatch path. The task auto-spawns the session.
+- When rung 3 is right, explicit execution_mode='durable_tmux' is the ONLY tmux dispatch path. Default checklist creation never auto-spawns.
 - NEVER manually launch sessions (tmux send-keys, claude -p). Sessions die immediately. Preferring rung 2 does NOT license manual spawns.
 - NEVER spawn sessions without a task assigned \u2014 idle sessions waste resources.
 - NEVER refuse a dispatched task claiming "not in scope" \u2014 if it's assigned to you, do it.
@@ -491,10 +491,10 @@ ${PLAN_MODE_COMPAT}
 ## Dispatch Ladder (stop at the lowest rung that fits)
 1. Do it yourself \u2014 trivial, in-scope work in your main context.
 2. Named/native subagent \u2014 the DEFAULT for delegation and parallelism. Bounded work, parallel research, isolated worktree fixes. Cap 2-3 concurrent. Persist results + lessons into the task record and memory before finishing.
-3. create_task \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects.
+3. create_task(execution_mode='durable_tmux') \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects. Omitted/default mode is a checklist row and never launches compute.
 
 ## Spawning Rules (mandatory)
-- When rung 3 is right, create_task is the ONLY tmux dispatch path. The task auto-spawns the session.
+- When rung 3 is right, explicit execution_mode='durable_tmux' is the ONLY tmux dispatch path. Default checklist creation never auto-spawns.
 - NEVER manually launch sessions (tmux send-keys, claude -p). Sessions die immediately. Preferring rung 2 does NOT license manual spawns.
 - NEVER spawn sessions without a task assigned \u2014 idle sessions waste resources.
 - NEVER refuse a dispatched task claiming "not in scope" \u2014 if it's assigned to you, do it.
@@ -563,10 +563,10 @@ ${PLAN_MODE_COMPAT}
 ## Dispatch Ladder (stop at the lowest rung that fits)
 1. Do it yourself \u2014 trivial, in-scope work in your main context.
 2. Named/native subagent \u2014 the DEFAULT for delegation and parallelism. Bounded work, parallel research, isolated worktree fixes. Cap 2-3 concurrent. Persist results + lessons into the task record and memory before finishing.
-3. create_task \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects.
+3. create_task(execution_mode='durable_tmux') \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects. Omitted/default mode is a checklist row and never launches compute.
 
 ## Spawning Rules (mandatory)
-- When rung 3 is right, create_task is the ONLY tmux dispatch path. The task auto-spawns the session.
+- When rung 3 is right, explicit execution_mode='durable_tmux' is the ONLY tmux dispatch path. Default checklist creation never auto-spawns.
 - NEVER manually launch sessions (tmux send-keys, claude -p). Sessions die immediately. Preferring rung 2 does NOT license manual spawns.
 - NEVER spawn sessions without a task assigned \u2014 idle sessions waste resources.
 - NEVER refuse a dispatched task claiming "not in scope" \u2014 if it's assigned to you, do it.
@@ -610,7 +610,7 @@ You are the AI Product Lead \u2014 the competitive intelligence engine. You stud
 - Clone the repo, read the architecture, compare against ours. No shortcuts.
 - Report: what to steal (with file paths), what they do worse (our moat), patterns worth adopting.
 - Write analysis to exe/output/competitive/{repo-name}.md.
-- If a feature is worth building, create a task for the CTO with the spec.
+- If a feature is worth building, spec it for the CTO \u2014 default via \`Agent(subagent_type=<CTO's configured name from your roster>)\` in-session; \`create_task\`/tmux only if it must outlive your session (see Dispatch Ladder below).
 - When evaluating tools: build a minimal PoC, measure, report tradeoffs.
 
 ## Domain
@@ -628,7 +628,7 @@ You are the AI Product Lead \u2014 the competitive intelligence engine. You stud
 - **ask_team_memory** \u2014 pull context from the CTO on architecture constraints
 - **update_task** \u2014 mark tasks done with analysis results
 - **store_memory** \u2014 persist competitive analyses, evaluations, recommendations
-- **create_task** \u2014 when a feature is worth building, spec it for the CTO
+- **create_task** \u2014 RUNG 3 ONLY, see Dispatch Ladder below. Default when a feature is worth building: \`Agent(subagent_type=<CTO's configured name from your roster>)\` with the spec.
 ${PLAN_MODE_COMPAT}
 ## Completion Workflow
 
@@ -645,10 +645,10 @@ ${PLAN_MODE_COMPAT}
 ## Dispatch Ladder (stop at the lowest rung that fits)
 1. Do it yourself \u2014 trivial, in-scope work in your main context.
 2. Named/native subagent \u2014 the DEFAULT for delegation and parallelism. Bounded work, parallel research, isolated worktree fixes. Cap 2-3 concurrent. Persist results + lessons into the task record and memory before finishing.
-3. create_task \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects.
+3. create_task(execution_mode='durable_tmux') \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects. Omitted/default mode is a checklist row and never launches compute.
 
 ## Spawning Rules (mandatory)
-- When rung 3 is right, create_task is the ONLY tmux dispatch path. The task auto-spawns the session.
+- When rung 3 is right, explicit execution_mode='durable_tmux' is the ONLY tmux dispatch path. Default checklist creation never auto-spawns.
 - NEVER manually launch sessions (tmux send-keys, claude -p). Sessions die immediately. Preferring rung 2 does NOT license manual spawns.
 - NEVER spawn sessions without a task assigned \u2014 idle sessions waste resources.
 - NEVER refuse a dispatched task claiming "not in scope" \u2014 if it's assigned to you, do it.
@@ -702,7 +702,7 @@ You are \${agent_id}. Staff Code Reviewer and System Auditor. Last line of defen
 - **recall_my_memory / ask_team_memory** \u2014 past audit findings
 - **store_behavior** \u2014 record new patterns
 - **update_task** \u2014 mark reviews done with structured findings
-- **create_task** \u2014 assign fixes to the CTO
+- **create_task** \u2014 RUNG 3 ONLY, see Dispatch Ladder below. Default when assigning a fix: \`Agent(subagent_type=<CTO's configured name from your roster>)\` with the finding.
 ${PLAN_MODE_COMPAT}
 ## Completion Workflow
 
@@ -713,6 +713,11 @@ ${PLAN_MODE_COMPAT}
 5. Call **update_task** with status "done" and finding count
 6. Call **store_memory** with audit summary
 7. Check for next task \u2014 auto-chain
+
+## Dispatch Ladder (stop at the lowest rung that fits)
+1. Do it yourself \u2014 trivial, in-scope work in your main context.
+2. Named/native subagent \u2014 the DEFAULT for delegation and parallelism. Bounded work, parallel research, isolated worktree fixes. Cap 2-3 concurrent. Persist results + lessons into the task record and memory before finishing.
+3. create_task(execution_mode='durable_tmux') \u2192 tmux employee \u2014 LEGACY. Only for work that must outlive your session or cross sessions/projects. Omitted/default mode is a checklist row and never launches compute.
 `,
   // --- General Manager (project-scoped coordinator) ---
   gm: `---
@@ -742,7 +747,7 @@ You are \${agent_id}. General Manager \u2014 you own one project or business uni
 - Report up to the COO on progress, blockers, and key decisions
 
 **Coordinate your team**
-- Route work to specialists via create_task \u2014 clear specs, acceptance criteria, deadlines
+- Route work to specialists \u2014 subagent (\`Agent(subagent_type='<name>')\`) by default; \`create_task\`/tmux is legacy rung-3, only for work that must outlive your session or cross sessions/projects \u2014 clear specs, acceptance criteria, deadlines
 - Review deliverables against the project brief \u2014 don't rubber-stamp
 - Unblock your team proactively \u2014 don't let tasks sit blocked
 
@@ -781,7 +786,7 @@ You are \${agent_id}. General Manager \u2014 you own one project or business uni
 ## Tools
 
 - **recall_my_memory / ask_team_memory** \u2014 stay current on project context
-- **list_tasks / create_task** \u2014 manage your team's work queue
+- **list_tasks** \u2014 manage your team's work queue. \`create_task\` is legacy rung-3 only \u2014 work that must outlive your session or cross sessions/projects. Default is \`Agent(subagent_type='<name>')\`.
 - **update_task / close_task** \u2014 finalize reviews within your project scope
 - **store_behavior** \u2014 record corrections for your team (p0/p1/p2)
 - **store_memory** \u2014 persist project decisions and outcomes

package/dist/{chunk-NBXDXKLC.js → chunk-LK3XQDBP.js}

@@ -1,6 +1,6 @@
 import {
   listReminders
-} from "./chunk-636LKCKE.js";
+} from "./chunk-Q6ZLQMP2.js";
 
 // src/mcp/tools/list-reminders.ts
 import { z } from "zod";

package/dist/{chunk-T3QUKNLI.js → chunk-LM443ORV.js}

@@ -1,7 +1,7 @@
 import {
   getIdentity,
   loadEmployeesSync
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 
 // src/lib/drift-probes.ts
 var DRIFT_THRESHOLD = 80;

package/dist/{chunk-BBSIEYF5.js → chunk-LNAFLXL7.js}

@@ -1,15 +1,16 @@
 import {
   PLATFORM_PROCEDURE_TITLES
-} from "./chunk-PY3FOMRN.js";
+} from "./chunk-BQEZPRUC.js";
 import {
   isGhostBehaviorRow
-} from "./chunk-WMEYJT4R.js";
+} from "./chunk-6FG34V6D.js";
 import {
+  IdentityConflictError,
   getClient,
   getIdentity,
   listIdentities,
   updateIdentity
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 import {
   atomicWriteJsonSync
 } from "./chunk-HSGBZSCA.js";
@@ -258,7 +259,14 @@ async function importIdentities(identities, updatedBy) {
     if (existing?.raw) {
       continue;
     }
-    await updateIdentity(agentId, content, updatedBy);
+    try {
+      await updateIdentity(agentId, content, updatedBy, { expectedContentHash: "" });
+    } catch (err) {
+      if (err instanceof IdentityConflictError) {
+        continue;
+      }
+      throw err;
+    }
     imported += 1;
   }
   return imported;

package/dist/{chunk-32YV32VA.js → chunk-LTUA5EYI.js}

@@ -1,15 +1,32 @@
 import {
   listBehaviors
-} from "./chunk-WMEYJT4R.js";
+} from "./chunk-6FG34V6D.js";
 import {
   incrementSkillUsage
-} from "./chunk-7GE2EQ23.js";
+} from "./chunk-YGVAKKGJ.js";
 
 // src/lib/behavior-injection.ts
 import { appendFile } from "fs/promises";
 var MAX_BEHAVIORS = 10;
 var MIN_BEHAVIORS_FOR_INJECTION = 3;
 var BEHAVIOR_INJECTION_CAP = 15;
+var BEHAVIOR_INJECTION_FETCH_LIMIT = 200;
+var BEHAVIOR_INJECTION_FETCH_MAX = 5e3;
+async function fetchInjectableBehaviors(agentId, projectName, list = listBehaviors) {
+  let limit = BEHAVIOR_INJECTION_FETCH_LIMIT;
+  let rows = await list(agentId, projectName, limit);
+  while (rows.length >= limit && limit < BEHAVIOR_INJECTION_FETCH_MAX && rows[rows.length - 1]?.priority === "p0") {
+    limit = Math.min(limit * 4, BEHAVIOR_INJECTION_FETCH_MAX);
+    rows = await list(agentId, projectName, limit);
+  }
+  return rows;
+}
+function selectInjectedBehaviors(sorted, cap = BEHAVIOR_INJECTION_CAP) {
+  const p0 = sorted.filter((b) => b.priority === "p0");
+  const rest = sorted.filter((b) => b.priority !== "p0");
+  const remaining = Math.max(0, cap - p0.length);
+  return [...p0, ...rest.slice(0, remaining)];
+}
 function p0OverflowNotice(activeBehaviors, cap = BEHAVIOR_INJECTION_CAP) {
   const storedP0 = activeBehaviors.filter((b) => b.priority === "p0").length;
   const injectedP0 = Math.min(storedP0, cap);
@@ -28,8 +45,11 @@ function behaviorTruncationNotice(injected, counts) {
   return `\u26A0\uFE0F TRUNCATED: showing ${shown} of ${counts.total} active behaviors \u2014 ${dropped} not injected.${p0Clause} Selection order: ${BEHAVIOR_SELECTION_ORDER_DOC}. Your ruleset here is PARTIAL \u2014 do not assume a rule does not exist because it is absent. Run behavior(action='list', priority='p0') for the rest.`;
 }
 function formatOverCapWarning(agentId, counts, cap = BEHAVIOR_INJECTION_CAP) {
-  if (counts.total <= cap) return null;
-  return `\u26A0\uFE0F Over injection cap: ${agentId} now has ${counts.total} active behaviors (${counts.p0} p0) but only ~${cap} are injected into context (${BEHAVIOR_SELECTION_ORDER_DOC}). The rest are stored but NOT enforced at runtime. Prune stale ones with behavior(action='deactivate') or raise the priority of what must always apply.`;
+  const nonP0 = Math.max(0, counts.total - counts.p0);
+  const nonP0Budget = Math.max(0, cap - counts.p0);
+  const droppedNonP0 = Math.max(0, nonP0 - nonP0Budget);
+  if (droppedNonP0 === 0) return null;
+  return `\u26A0\uFE0F ${agentId} has ${counts.total} active behaviors (${counts.p0} p0). All p0 rules are always injected and enforced, but only ${nonP0Budget} of your ${nonP0} lower-priority behaviors fit the ${cap} cap \u2014 ${droppedNonP0} are stored but NOT injected at runtime. Deactivate stale lower-priority behaviors with behavior(action='deactivate'), or raise priority to p0 for any that must always apply.`;
 }
 function cosineSimilarity(a, b) {
   if (a.length !== b.length || a.length === 0) return 0;
@@ -177,6 +197,55 @@ function extractKeywords(title, context) {
   const unique = [...new Set(tokens)];
   return unique.filter((t) => !STOP_WORDS.has(t) && t.length >= 3);
 }
+var TASK_BRIEF_BEHAVIOR_CAP = 6;
+var SEMANTIC_RELEVANCE_THRESHOLD = 0.3;
+var KEYWORD_MIN_DISTINCT_HITS = 2;
+async function selectRelevantBehaviorsWithReasons(behaviors, title, context, maxCount = TASK_BRIEF_BEHAVIOR_CAP, projectName) {
+  const PROJECT_BOOST = 1.5;
+  const keywords = extractKeywords(title, context);
+  const keywordScored = (rows) => {
+    if (keywords.length === 0) return [];
+    return rows.map((b) => {
+      const contentLower = b.content.toLowerCase();
+      const hit = keywords.filter((kw) => contentLower.includes(kw));
+      const raw = hit.length / keywords.length;
+      const boosted = projectName && b.project_name === projectName ? raw * PROJECT_BOOST : raw;
+      return { b, hit, boosted };
+    }).filter((s) => s.hit.length >= KEYWORD_MIN_DISTINCT_HITS).map((s) => ({
+      behavior: s.b,
+      score: s.boosted,
+      method: "keyword",
+      reason: `brief mentions ${s.hit.slice(0, 4).map((k) => `"${k}"`).join(", ")}`
+    }));
+  };
+  const withVectors = behaviors.filter((b) => b.vector && b.vector.length > 0);
+  const withoutVectors = behaviors.filter((b) => !b.vector || b.vector.length === 0);
+  if (withVectors.length > 0) {
+    try {
+      const { embed } = await import("./lib/embedder.js");
+      const taskText = `${title}
+${context}`.slice(0, 2e3);
+      const taskVector = await embed(taskText);
+      const semantic = withVectors.map((b) => {
+        const raw = cosineSimilarity(taskVector, b.vector);
+        const boosted = projectName && b.project_name === projectName ? raw * PROJECT_BOOST : raw;
+        return { b, raw, boosted };
+      }).filter((s) => s.boosted > SEMANTIC_RELEVANCE_THRESHOLD).map((s) => ({
+        behavior: s.b,
+        score: s.boosted,
+        method: "semantic",
+        reason: `semantic match ${s.raw.toFixed(2)}` + (s.boosted !== s.raw ? ` (x1.5 same-project boost -> ${s.boosted.toFixed(2)})` : "")
+      }));
+      const merged = [...semantic, ...keywordScored(withoutVectors)];
+      merged.sort((a, b) => b.score - a.score);
+      return merged.slice(0, maxCount);
+    } catch {
+    }
+  }
+  const all = keywordScored(behaviors);
+  all.sort((a, b) => b.score - a.score);
+  return all.slice(0, maxCount);
+}
 async function selectRelevantBehaviors(behaviors, title, context, maxCount = MAX_BEHAVIORS, projectName) {
   const PROJECT_BOOST = 1.5;
   const behaviorsWithVectors = behaviors.filter((b) => b.vector && b.vector.length > 0);
@@ -238,27 +307,64 @@ function formatBehaviorsMarkdown(behaviors) {
   lines.push("");
   return lines.join("\n");
 }
+function formatSelectedBehaviorsMarkdown(selected, totalConsidered, cap = TASK_BRIEF_BEHAVIOR_CAP) {
+  if (selected.length === 0) return "";
+  const method = selected[0].method;
+  const lines = [
+    "",
+    "## Behaviours you are BOUND BY on this task (auto-retrieved)",
+    "",
+    `These are not suggestions. They were matched against this brief by ${method} retrieval over ${totalConsidered} stored behaviour(s); the top ${selected.length} of at most ${cap} are shown, with the reason each was selected.`,
+    "",
+    `This list is SCOPED TO THIS BRIEF, not complete. If you are about to do something consequential that no rule here covers, that means retrieval did not match it \u2014 not that no rule exists. Run \`behavior(action='list')\`.`,
+    ""
+  ];
+  for (const s of selected) {
+    const domain = s.behavior.domain ? `[${s.behavior.domain}]` : "[general]";
+    const firstLine = s.behavior.content.split("\n")[0].trim().slice(0, 400);
+    lines.push(`- ${domain} ${firstLine}`);
+    lines.push(`  - _why injected: ${s.reason}_`);
+  }
+  lines.push("");
+  return lines.join("\n");
+}
 async function injectBehaviors(opts) {
   try {
-    if (opts.assignedBy === "system" || opts.title.startsWith("Review:")) return;
-    if (!opts.context.trim()) return;
+    if (opts.assignedBy === "system" || opts.title.startsWith("Review:")) return [];
+    if (!opts.context.trim()) return [];
     const behaviors = await listBehaviors(opts.assignedTo, opts.projectName, 30);
-    if (behaviors.length < MIN_BEHAVIORS_FOR_INJECTION) return;
-    const relevant = await selectRelevantBehaviors(behaviors, opts.title, opts.context, MAX_BEHAVIORS, opts.projectName);
-    if (relevant.length === 0) return;
-    const markdown = formatBehaviorsMarkdown(relevant);
+    if (behaviors.length < MIN_BEHAVIORS_FOR_INJECTION) return [];
+    const cap = opts.cap ?? TASK_BRIEF_BEHAVIOR_CAP;
+    const selected = await selectRelevantBehaviorsWithReasons(
+      behaviors,
+      opts.title,
+      opts.context,
+      cap,
+      opts.projectName
+    );
+    if (selected.length === 0) return [];
+    const markdown = formatSelectedBehaviorsMarkdown(selected, behaviors.length, cap);
     await appendFile(opts.taskFile, markdown, "utf-8");
-    await incrementSkillUsage(relevant);
+    process.stderr.write(
+      `[behavior-injection] ${opts.assignedTo} <- ${selected.length}/${behaviors.length} behaviour(s) for "${opts.title.slice(0, 60)}": ` + selected.map((s) => `${s.behavior.id.slice(0, 8)}(${s.score.toFixed(2)})`).join(" ") + "\n"
+    );
+    await incrementSkillUsage(selected.map((s) => s.behavior));
+    return selected;
   } catch (err) {
     process.stderr.write(
       `[behavior-injection] Failed for "${opts.title}": ${err instanceof Error ? err.message : String(err)}
 `
     );
+    return [];
   }
 }
 
 export {
   BEHAVIOR_INJECTION_CAP,
+  BEHAVIOR_INJECTION_FETCH_LIMIT,
+  BEHAVIOR_INJECTION_FETCH_MAX,
+  fetchInjectableBehaviors,
+  selectInjectedBehaviors,
   p0OverflowNotice,
   BEHAVIOR_SELECTION_ORDER_DOC,
   behaviorTruncationNotice,
@@ -266,7 +372,12 @@ export {
   cosineSimilarity,
   scoreRelevance,
   extractKeywords,
+  TASK_BRIEF_BEHAVIOR_CAP,
+  SEMANTIC_RELEVANCE_THRESHOLD,
+  KEYWORD_MIN_DISTINCT_HITS,
+  selectRelevantBehaviorsWithReasons,
   selectRelevantBehaviors,
   formatBehaviorsMarkdown,
+  formatSelectedBehaviorsMarkdown,
   injectBehaviors
 };

package/dist/{chunk-23MVDXLY.js → chunk-MAXD5JQL.js}

@@ -2,15 +2,15 @@ import {
   BUSY_PATTERN,
   sendIntercom,
   updateTaskStatus
-} from "./chunk-AKLQSC6W.js";
+} from "./chunk-KI7O64XV.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-W75GTHR3.js";
+} from "./chunk-3SRZNJKD.js";
 import {
   baseAgentName,
   getCoordinatorName,
   isCoordinatorName
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 
 // src/lib/play-mode.ts
 import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
@@ -281,7 +281,7 @@ function strictTaskSessionScope(scope) {
 }
 async function countOrphanedTasksForAgent(client, agentName, statuses) {
   const result = await client.execute({
-    sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status IN (${statuses}) AND session_scope IS NULL`,
+    sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status IN (${statuses}) AND execution_mode = 'durable_tmux' AND session_scope IS NULL`,
     args: [agentName]
   });
   return Number(result.rows[0]?.cnt ?? 0);
@@ -332,7 +332,7 @@ async function surfaceStaleDispatchPendingSignals(scopeList, now, thresholdMs =
     const sessionScope = signalScope ?? (scopeList.length === 1 ? scopeList[0] : null);
     if (allowedScopes.size > 0 && sessionScope && !allowedScopes.has(sessionScope)) continue;
     try {
-      const { writeNotification } = await import("./notifications-MACUZPYP.js");
+      const { writeNotification } = await import("./notifications-LGYY22W5.js");
       await writeNotification({
         agentId: getCoordinatorName(),
         agentRole: "COO",
@@ -513,7 +513,7 @@ async function runTaskEnforcementTick(deps) {
       let paneIdle;
       if (isManager) {
         const openResult = await client.execute({
-          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status = 'open'${effectiveScope.sql}`,
+          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status = 'open' AND execution_mode = 'durable_tmux'${effectiveScope.sql}`,
           args: [agentName, ...effectiveScope.args]
         });
         openTasks = Number(openResult.rows[0]?.cnt ?? 0);
@@ -528,7 +528,7 @@ async function runTaskEnforcementTick(deps) {
         }
         if (openTasks > 0) {
           const subtaskResult = await client.execute({
-            sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_by = ? AND status = 'in_progress'${effectiveScope.sql}`,
+            sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_by = ? AND status = 'in_progress' AND execution_mode = 'durable_tmux'${effectiveScope.sql}`,
             args: [agentName, ...effectiveScope.args]
           });
           activeSubtasks = Number(subtaskResult.rows[0]?.cnt ?? 0);
@@ -537,7 +537,7 @@ async function runTaskEnforcementTick(deps) {
         let graceRemaining = 0;
         if (openTasks > 0) {
           const newestResult = await client.execute({
-            sql: `SELECT created_at FROM tasks WHERE assigned_to = ? AND status = 'open'${effectiveScope.sql} ORDER BY created_at DESC LIMIT 1`,
+            sql: `SELECT created_at FROM tasks WHERE assigned_to = ? AND status = 'open' AND execution_mode = 'durable_tmux'${effectiveScope.sql} ORDER BY created_at DESC LIMIT 1`,
             args: [agentName, ...effectiveScope.args]
           });
           const newestCreatedAt = newestResult.rows[0]?.created_at;
@@ -552,7 +552,7 @@ async function runTaskEnforcementTick(deps) {
         let inProgressTasks = 0;
         if (openTasks > 0) {
           const ipResult = await client.execute({
-            sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status = 'in_progress'${effectiveScope.sql}`,
+            sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status = 'in_progress' AND execution_mode = 'durable_tmux'${effectiveScope.sql}`,
             args: [agentName, ...effectiveScope.args]
           });
           inProgressTasks = Number(ipResult.rows[0]?.cnt ?? 0);
@@ -584,7 +584,7 @@ async function runTaskEnforcementTick(deps) {
         );
       } else {
         const taskResult = await client.execute({
-          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status IN ('open', 'in_progress')${effectiveScope.sql}`,
+          sql: `SELECT COUNT(*) as cnt FROM tasks WHERE assigned_to = ? AND status IN ('open', 'in_progress') AND execution_mode = 'durable_tmux'${effectiveScope.sql}`,
           args: [agentName, ...effectiveScope.args]
         });
         const taskCount = Number(taskResult.rows[0]?.cnt ?? 0);
@@ -695,6 +695,7 @@ async function runTaskEnforcementTick(deps) {
       const reviewerRows = scopeList.length === 0 ? { rows: [] } : await client.execute({
         sql: `SELECT reviewer, session_scope, id FROM tasks
                   WHERE status = 'needs_review'
+                    AND execution_mode = 'durable_tmux'
                     AND reviewer IS NOT NULL
                     AND reviewer != ''
                     AND session_scope IN (${scopeList.map(() => "?").join(",")})`,

package/dist/{chunk-GNUAL43X.js → chunk-MFASHRJ6.js}

@@ -1,16 +1,16 @@
 import {
   getAgentLivenessReport
 } from "./chunk-PHUHIVD5.js";
-import {
-  isValidSessionScope
-} from "./chunk-BTSWFMEH.js";
 import {
   leaseExpiryIso,
   leaseNowIso
 } from "./chunk-E23LNUWJ.js";
+import {
+  isValidSessionScope
+} from "./chunk-BTSWFMEH.js";
 import {
   getClient
-} from "./chunk-TAMDAOCU.js";
+} from "./chunk-66CGXQUA.js";
 
 // src/lib/work-claims.ts
 var CLAIM_TTL_MINUTES = 90;
@@ -306,7 +306,7 @@ async function heartbeatClaims(holderSession, ttlMinutes = CLAIM_TTL_MINUTES) {
 }
 async function recordClaimEvent(eventType, sessionScope, agentId, payload, severity) {
   try {
-    const { recordOrchestrationEventBestEffort } = await import("./orchestration-events-N7LYMUGA.js");
+    const { recordOrchestrationEventBestEffort } = await import("./orchestration-events-JPHB6NPY.js");
     recordOrchestrationEventBestEffort({
       eventType,
       source: "work-claims",

package/dist/chunk-MFYMDGE7.js

@@ -0,0 +1,37 @@
+// src/lib/atomic-write.ts
+import {
+  writeFileSync,
+  renameSync,
+  fsyncSync,
+  openSync,
+  closeSync,
+  unlinkSync
+} from "fs";
+import path from "path";
+function writeFileAtomicSync(destPath, data) {
+  const dir = path.dirname(destPath);
+  const tmpPath = path.join(
+    dir,
+    `.${path.basename(destPath)}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`
+  );
+  const fd = openSync(tmpPath, "w");
+  try {
+    writeFileSync(fd, data);
+    fsyncSync(fd);
+  } finally {
+    closeSync(fd);
+  }
+  try {
+    renameSync(tmpPath, destPath);
+  } catch (err) {
+    try {
+      unlinkSync(tmpPath);
+    } catch {
+    }
+    throw err;
+  }
+}
+
+export {
+  writeFileAtomicSync
+};