@askexenow/exe-os 0.9.384 → 0.9.389

package/dist/{chunk-BQEZPRUC.js → chunk-IZWMWJZT.js}

@@ -1,4 +1,7 @@
 // src/lib/platform-procedures.ts
+import { mkdirSync, writeFileSync } from "fs";
+import path from "path";
+import os from "os";
 var PLATFORM_PROCEDURES = [
   // --- Foundation: what is exe-os ---
   {
@@ -11,13 +14,13 @@ var PLATFORM_PROCEDURES = [
     title: "Mode 1 \u2014 how exe-os runs inside Claude Code",
     domain: "architecture",
     priority: "p0",
-    content: "Mode 1: exe-os runs AS hooks + MCP + skills inside Claude Code, Codex, or OpenCode. The founder picks their default tool at setup. The COO orchestrates employees: normally as named subagents dispatched in-session (the default \u2014 see the Dispatch Ladder), and as tmux-session employees when the work must outlive the session or cross coordinator sessions. Each coordinator session is a separate window/project. The founder talks to the COO; the COO orchestrates the team. The tool is the shell, exe-os is the brain."
+    content: "Mode 1: exe-os runs AS hooks + MCP + skills inside Claude Code, Codex, or OpenCode. The founder picks their default tool at setup. The COO orchestrates employees as named subagents dispatched in-session \u2014 the ONLY dispatch path (see the Dispatch Ladder). Each coordinator session is a separate window/project. The founder talks to the COO; the COO orchestrates the team. The tool is the shell, exe-os is the brain."
   },
   {
     title: "Sessions explained \u2014 coordinator session names and projects",
     domain: "architecture",
     priority: "p0",
-    content: "Each coordinator session is an isolated project session. One might be exe-os development, another might be exe-wiki. Work inside a session normally runs on named subagents; when a session needs durable tmux employees they are named {employee}-{coordinatorSession}. Sessions share the same memory DB but tasks are scoped to the session that created them. A founder can run multiple projects simultaneously. Sessions never interfere with each other."
+    content: "Each coordinator session is an isolated project session. One might be exe-os development, another might be exe-wiki. ALL work inside a session runs on named subagents dispatched by that session's coordinator \u2014 there are no separate employee sessions. Sessions share the same memory DB but tasks are scoped to the session that created them. A founder can run multiple projects simultaneously. Sessions never interfere with each other."
   },
   {
     title: "Runtime settings \u2014 COO can view and change tools per agent",
@@ -42,7 +45,7 @@ var PLATFORM_PROCEDURES = [
     title: "Stay in your repo \u2014 never cd into other projects",
     domain: "workflow",
     priority: "p0",
-    content: "NEVER cd into another repo or project directory. Your working directory (cwd) is your project boundary. When a user says 'commit all' or 'push all', that means all changes IN THIS REPO, not across the machine. If you see uncommitted changes in another repo via memory or task recall, ignore them \u2014 that's another agent's responsibility. Running `cd /path/to/other-repo && git commit` from your session is a project boundary violation. If cross-repo work is needed, create_task to dispatch it to the right project's agent."
+    content: "NEVER cd into another repo or project directory. Your working directory (cwd) is your project boundary. When a user says 'commit all' or 'push all', that means all changes IN THIS REPO, not across the machine. If you see uncommitted changes in another repo via memory or task recall, ignore them \u2014 that's another agent's responsibility. Running `cd /path/to/other-repo && git commit` from your session is a project boundary violation. If cross-repo work is needed, dispatch a named subagent whose brief fences it to that repo, or hand the work to the coordinator session that owns the project."
   },
   // --- Hierarchy and dispatch ---
   {
@@ -51,12 +54,6 @@ var PLATFORM_PROCEDURES = [
     priority: "p0",
     content: "Founder -> coordinator (the executive agent, internally routed as 'COO') -> CTO/CMO/GMs. CTO -> engineers. CMO -> content production. GM -> specialists within their project scope. Never skip levels: the coordinator does not bypass managers for specialist work. Specialists report to their manager. If you need cross-team info, use ask_team_memory \u2014 don't read other agents' task folders. Each level owns dispatch downward and review upward."
   },
-  {
-    title: "When to hire new employees \u2014 scaling signals for the COO",
-    domain: "workflow",
-    priority: "p1",
-    content: "COO recommends hiring (/exe-new-employee) when: GM needed: separate project needs dedicated coordination, COO spending >30% context on it. Engineer: CTO has 5+ queued tasks, parallelization maxed. Content specialist: CMO backlog exceeds 1 week. Auditor: quality gates being skipped under pressure. General rule: if a role spends >50% time on delegatable work, hire. Templates: coo, cto, cmo, gm, principal-engineer, content-specialist, ai-specialist, staff-code-reviewer. Usage: /exe-new-employee <name> --role <template>."
-  },
   {
     title: "Orchestration phase guidance \u2014 recommend, never trap",
     domain: "workflow",
@@ -76,22 +73,22 @@ var PLATFORM_PROCEDURES = [
     content: "When the founder assigns work to a roster employee by name ('give this to X'), the coordinator dispatches a NATIVE SUBAGENT wearing that employee's identity: Agent(subagent_type='<name>') loads the generated identity definition (~/.claude/agents/<name>.md \u2014 identity + preset model/effort), worktree isolation for code work, and the employee's expertise applies. Hooks capture everything; attribution is granted ONLY through the spawn ledger (the session's own recorded dispatch \u2014 never the payload's claim), so the employee's three-layer cognition accrues from work actually delegated to them. Multiple subagents may wear the same identity concurrently; their experiences merge into one agent brain. The orchestrator remains the single deciding context: it briefs, reviews, verifies, and lands. This semantic applies to every coordinator on every runtime (Claude Code, Codex, OpenCode)."
   },
   {
-    title: "Dispatch Ladder \u2014 named subagents first; tmux employees are legacy",
+    title: "Dispatch Ladder \u2014 two rungs, and subagents are the only dispatch",
     domain: "workflow",
     priority: "p0",
-    content: "Three rungs \u2014 stop at the first that fits. (1) Do it yourself: trivial, in-scope work in main context. (2) Named/native subagents (Claude Code Agent tool + worktree isolation; Codex spawned agents; OpenCode sessions) \u2014 the DEFAULT for delegation AND parallelism: roster-employee work via named identity dispatch, bounded well-specified work, parallel research, isolated worktree fixes, verbose throwaway exploration. Cap 2-3 concurrent under load; merge or clean up subagent worktrees before finishing. MANDATORY: persist subagent results/lessons into the task record + memory BEFORE completing \u2014 subagent output must never die in a context window. Tasks created with task(action='create') are durable checklist items by default and never launch compute. (3) task(action='create', execution_mode='durable_tmux') -> tmux employee \u2014 LEGACY, reserved for work that must outlive the orchestrator's session or cross coordinator sessions/projects; gets no new investment. When used, the explicit durable_tmux mode remains the only tmux dispatch path \u2014 no manual spawns, no send_message for actionable work."
+    content: "TWO rungs \u2014 stop at the first that fits. (1) Do it yourself: trivial, in-scope work in main context. (2) Named subagent \u2014 Agent(subagent_type='<employee>') on Claude Code (Codex spawned agents / OpenCode sessions are the equivalent on those runtimes), with git worktree isolation for any code work. This is the ONLY delegation path: roster-employee work, bounded well-specified work, parallel research, isolated fixes, verbose throwaway exploration. Cap 2-3 concurrent under load; merge or clean up subagent worktrees before finishing. MANDATORY: persist subagent results/lessons into the task checklist row + memory BEFORE completing \u2014 subagent output must never die in a context window. There is no third rung: task(action='create') is a DURABLE CHECKLIST ROW for tracking and never launches compute, and background employee sessions are retired."
   },
   {
     title: "Subagent guardrails \u2014 fence scope, isolate Codex, never stash",
     domain: "workflow",
     priority: "p0",
-    content: "When delegating to subagents: (1) FENCE SCOPE \u2014 a subagent with MCP access must be explicitly forbidden from touching other agents' tasks, reviews, or folders; give it only its own brief. (2) Codex-runtime subagents ALWAYS run in an isolated git worktree \u2014 they auto-commit and cross file fences despite instructions. (3) NEVER run git stash \u2014 the stash stack is shared repo-wide across ALL worktrees; concurrent agents silently pop each other's uncommitted work. Use git diff > patch, a scratch commit, or a separate worktree instead. Brief every subagent you dispatch with these rules."
+    content: "When delegating to subagents: (1) FENCE SCOPE \u2014 a subagent with MCP access must be explicitly forbidden from touching other agents' tasks, reviews, or folders; give it only its own brief. (2) Codex-runtime subagents ALWAYS run in an isolated git worktree \u2014 they auto-commit and cross file fences despite instructions. (3) NEVER run git stash \u2014 the stash stack is shared repo-wide across ALL worktrees; concurrent agents silently pop each other's uncommitted work. Use git diff > patch, a scratch commit, or a separate worktree instead. (4) A subagent NEVER delegates further by starting background sessions: it does the work, or reports back. (5) Its result is not delivered until YOU have persisted it into the task checklist row + memory. Brief every subagent you dispatch with these rules \u2014 the brief is the only scope it has."
   },
   {
     title: "Right-size the model \u2014 match model cost to task difficulty",
     domain: "workflow",
     priority: "p1",
-    content: "Tokens are money \u2014 pick the model per task. Mechanical/bounded work (renames, config edits, boilerplate, well-specified fixes) -> cheaper model and/or lower reasoning effort. Adversarial verification, hard design, security review, debugging unknowns -> strong model; never verify a strong model's work with a weaker one. Set per agent via set_agent_config; legacy durable tmux dispatch may override spawn_model/spawn_runtime only with execution_mode='durable_tmux'. Audit spend with config(action='agent_spend')."
+    content: "Tokens are money \u2014 pick the model per task. Mechanical/bounded work (renames, config edits, boilerplate, well-specified fixes) -> cheaper model and/or lower reasoning effort. Adversarial verification, hard design, security review, debugging unknowns -> strong model; never verify a strong model's work with a weaker one. Set the per-employee default via set_agent_config (it is baked into the generated agent definition, so Agent(subagent_type='<name>') inherits it); override per dispatch with the Agent tool's own model argument. Audit spend with config(action='agent_spend')."
   },
   {
     title: "Fetch and scope-check before dispatching fix work",
@@ -104,14 +101,14 @@ var PLATFORM_PROCEDURES = [
     title: "Session isolation \u2014 scoping, boundaries, and enforcement",
     domain: "security",
     priority: "p0",
-    content: "SCOPING: Managers dispatch only within their own coordinator session. Employee sessions use {employee}-{coordinatorSession}. Cross-session dispatch is system-blocked. Tasks are scoped to the creating session. BOUNDARIES: (1) Never close/update/cancel tasks from another session. (2) Never review work from a different session \u2014 report it belongs elsewhere and skip. (3) Ignore other sessions' items in list_tasks. (4) Employees work ONLY on their parent session's tasks. Cross-session work is a system violation. ENFORCEMENT: Every DB query, notification, and task operation MUST filter on 3 dimensions: (1) session_scope matching current coordinator session, (2) project_name, (3) role hierarchy level. Any function touching tasks/reviews/messages/notifications must accept sessionScope and pass it to SQL WHERE. Unscoped queries are bugs. Test with 2+ coordinator sessions simultaneously."
+    content: "SCOPING: Managers dispatch only within their own coordinator session. A subagent has no session of its own \u2014 it inherits the dispatching coordinator's session_scope, so its work is scoped exactly where the dispatcher's is. Cross-session dispatch is system-blocked. Tasks are scoped to the creating session. BOUNDARIES: (1) Never close/update/cancel tasks from another session. (2) Never review work from a different session \u2014 report it belongs elsewhere and skip. (3) Ignore other sessions' items in list_tasks. (4) A subagent works ONLY on the task it was briefed with, inside its dispatcher's scope. Cross-session work is a system violation. ENFORCEMENT: Every DB query, notification, and task operation MUST filter on 3 dimensions: (1) session_scope matching current coordinator session, (2) project_name, (3) role hierarchy level. Any function touching tasks/reviews/messages/notifications must accept sessionScope and pass it to SQL WHERE. Unscoped queries are bugs. Test with 2+ coordinator sessions simultaneously."
   },
   // --- Hard constraints ---
   {
     title: "What you CANNOT do in exe-os \u2014 hard constraints",
     domain: "security",
     priority: "p0",
-    content: "NEVER: (1) Access the database directly \u2014 it's SQLCipher encrypted, always fails. Use MCP tools only. (2) Manually spawn tmux sessions \u2014 when tmux is the right rung, create_task handles it. (3) Run git checkout main \u2014 agents work in worktrees. (4) Modify another agent's in-progress task. (5) Push to remote \u2014 the COO reviews and pushes. (6) Skip update_task(done) \u2014 it's the ONLY way your work gets reviewed. (7) Run git init."
+    content: "NEVER: (1) Access the database directly \u2014 it's SQLCipher encrypted, always fails. Use MCP tools only. (2) Start background agent sessions by hand (terminal multiplexers, headless CLI launches, nohup) \u2014 delegation is Agent(subagent_type='<name>') and nothing else. (3) Run git checkout main \u2014 agents work in worktrees. (4) Modify another agent's in-progress task. (5) Push to remote \u2014 the COO reviews and pushes. (6) Skip update_task(done) \u2014 it's the ONLY way your work gets reviewed. (7) Run git init."
   },
   {
     title: "Destructive operations \u2014 mandatory reviewer gate",
@@ -121,10 +118,10 @@ var PLATFORM_PROCEDURES = [
   },
   // --- Support ---
   {
-    title: "Triage \u2014 upstream bugs vs features vs local customization",
+    title: "Bug lifecycle \u2014 file with evidence, triage once as STATE",
     domain: "support",
     priority: "p0",
-    content: "Classify every issue: upstream_bug (reproducible platform defect), upstream_feature (requires exe-os code changes), customer_customization (identity/behavior/config/workflow \u2014 belongs in customer layers), emergency_hotfix (temporary local patch). BUGS: MUST use create_bug_report before or alongside any workaround. Include version, repro steps, expected/actual, files changed, diff summary. If tool unavailable, save in exe/output and call support_test. Avoid permanent platform patches unless founder approves; document hotfixes in the report. FEATURES: use create_feature_request with use case, business impact, workaround. File proactively \u2014 no permission needed. LOCAL: implement immediately via store_behavior, update_identity, company_procedure, or config changes."
+    content: "FILING (create_bug) is GATED: reproduction_steps (a concrete step), expected, actual, and observed_kind+evidence_pointer are ALL required \u2014 refused otherwise. No real repro/evidence? Use memory(domain='lesson') or file a feature instead. Summary caps at 1500 chars; use add_comment for analysis. DEDUPE before filing: matches on the same product refuse once; retry with not_duplicate_of:[ids]. Classify: upstream_bug, customer_customization, emergency_hotfix, unclear. LIFECYCLE = open -> triaged -> fixed -> closed. triaged = classification via triage_bug OR a merged fix PR (auto-reconciled). fixed = a verification artifact via update_bug \u2014 never just a status flip. closed = delivery proof. Triage is RECORD STATE (classification, triaged_at, triage_notes) \u2014 a comment alone is not a triage. NEVER re-triage a triaged_at record without new evidence. Every triaged bug carries a `cluster` slug (root-cause class); fixes dispatch per repeat-class cluster \u2014 use list_bugs(cluster=...). Full detail: on-demand reference."
   },
   {
     title: "Bug and feature status checks \u2014 use support on request, not at boot",
@@ -136,7 +133,7 @@ var PLATFORM_PROCEDURES = [
     title: "Link fix PRs to bugs at PR-open time",
     domain: "support",
     priority: "p1",
-    content: "When you open a PR that addresses a filed bug, immediately comment the linkage onto that bug: support(action='add_comment', id=<bug-id>, comment='Fix PR opened: <repo>#<PR number> (<branch>)'). Do this the moment the PR exists \u2014 before merge, not after. The bug stays open until the fix lands, but the bug\u2194PR linkage must be recorded at PR-open time so triage and other agents can see which PR owns which bug without guessing. Also reference the bug ID in the PR body for the reverse link."
+    content: "When you open a PR that addresses a filed bug, immediately comment the linkage onto that bug: support(action='add_comment', id=<bug-id>, comment='Fix PR opened: <repo>#<PR number> (<branch>)'). Do this the moment the PR exists \u2014 before merge, not after. The bug stays open until the fix lands, but the bug\u2194PR linkage must be recorded at PR-open time so triage and other agents can see which PR owns which bug without guessing. Also reference the bug ID in the PR body for the reverse link. Merged PRs naming a bug id are auto-reconciled into status=triaged by the daemon's bug-landed reconciler within 30 minutes \u2014 agents still comment the linkage at PR-open time as above."
   },
   // --- Tool guidance ---
   {
@@ -180,24 +177,18 @@ var PLATFORM_PROCEDURES = [
     content: "NEVER defer work \u2014 no 'later', 'next sprint', or 'not urgent'. Every defer is a broken promise: deferred items pile up, get forgotten, block other work, and erode trust. Find a bug mid-task: fix it now, then resume. Outside your scope: create_task so someone fixes it NOW. If it truly cannot be done (missing credentials, external human action, third-party block), name the blocker and who must act. The only acceptable reason not to fix something is 'physically impossible right now' \u2014 never 'not urgent'."
   },
   // --- Observability ---
-  {
-    title: "Daemon logs and session lifecycle \u2014 full transparency for debugging",
-    domain: "operations",
-    priority: "p1",
-    content: "Daemon logs to ~/.exe-os/logs/exed-launchd.log. Primary debugging tool. Shows: session spawns, idle kills (90s graceful warning), event loop health (>3s warn, >10s CRITICAL), task enforcement (60s cycle), intercom delivery, MCP sessions, cloud sync. Read: `tail -100 ~/.exe-os/logs/exed-launchd.log` or /exe-doctor. Enforcement audit: ~/.exe-os/enforcement-audit.jsonl (structured JSONL). If agent seems stuck or killed unexpectedly, READ LOGS FIRST before reporting a bug."
-  },
   // --- Operations ---
   {
-    title: "Managers must supervise deployed workers",
+    title: "Managers own the subagents they dispatch \u2014 brief, receive, verify",
     domain: "workflow",
     priority: "p0",
-    content: `Every manager (COO/CTO/CMO) who dispatches work to a worker MUST actively monitor them. Check tmux capture-pane every 10 minutes. Verify they're working, not stuck. If idle at prompt with in_progress task -> send intercom. If stuck -> unblock or escalate. "Standing by" without checking is negligence.`
+    content: `Every manager (COO/CTO/CMO) who dispatches a subagent OWNS it end to end. A subagent runs inside your context: you get its result back, so supervision is not polling \u2014 it is (1) briefing it well enough to succeed (scope fence, file list, acceptance criteria, guardrails), (2) reading the result when it returns rather than trusting its summary, (3) persisting the result into the task checklist row + memory, and (4) re-dispatching with a corrected brief when it came back wrong. While it runs you may work on something else, but you may NOT finish your own turn with a dispatched subagent's result unread. "Standing by" while results sit unread is negligence.`
   },
   {
     title: "Coordinator verification \u2014 verify signals, triangulate absence",
     domain: "workflow",
     priority: "p0",
-    content: "Never act on a self-reported lifecycle signal without independent verification. Employee claims 'context-full' -> check tmux capture-pane first; the context bar reads left-to-right (% shown = USED, not remaining) \u2014 never kill a session under 80% used. 'Task done' -> read the deliverable and run the verification yourself. Before reporting absence ('no tasks', 'no work was done', 'agent is idle'), triangulate at least three sources: task DB across ALL statuses with project_name='all', output artifacts in exe/output/, and team memory. A null result from one query is the limit of your filter, not a fact about reality. If verification contradicts a detailed claim, double-check your verification before accusing the agent."
+    content: "Never act on a self-reported claim without independent verification. 'Task done' -> read the deliverable (git diff, exe/output/, the task row) and run the verification yourself. A subagent's closing summary is a claim, not evidence: check the diff it says it made and the test it says it ran. Before reporting absence ('no tasks', 'no work was done', 'agent is idle'), triangulate at least three sources: task DB across ALL statuses with project_name='all', output artifacts in exe/output/, and team memory. A null result from one query is the limit of your filter, not a fact about reality. If verification contradicts a detailed claim, double-check your verification before accusing the agent."
   },
   {
     title: "COO boot health check \u2014 trust the boot script, verify on request",
@@ -206,16 +197,16 @@ var PLATFORM_PROCEDURES = [
     content: "At startup, run only the /exe boot script; it prints daemon/MCP health, memory counts, cloud sync status, tasks, and blockers. Do NOT run pgrep, grep logs, or independent DB health queries at boot. If the founder asks for current health after boot, use diagnostics(action='daemon_health') or `exe-os healthcheck` and report verified results."
   },
   {
-    title: "Employee session lifecycle \u2014 boot, preservation, and closeout",
+    title: "Session lifecycle \u2014 boot, preservation, and closeout",
     domain: "workflow",
     priority: "p0",
-    content: "EMPLOYEE BOOT: Run `exe-os boot --project <project>` at employee project-session start. Coordinator startup uses the /exe boot script instead. Shows: working memory count, active behaviors, identity loaded, last session summary (where you left off), daemon health. Read summary first. Auto-detects project from git repo. PRESERVATION (three automatic layers): (1) EVERY RESPONSE: Stop hook writes periodic checkpoint (lightweight, every N responses). (2) /EXIT OR CLOSE: SessionEnd hook runs dreaming cycle + continuity checkpoint + summary commit (15s timeout, separate process). (3) MID-SESSION SAVE: `config(action='closeout')` \u2014 same dreaming+summary with full agent context (no timeout, richer). CLI equivalent: `exe-os snapshot`. Use when approaching context limits. CRASH/SIGKILL: no hooks fire \u2014 periodic checkpoints are your safety net. Normal /exit: SessionEnd handles everything automatically."
+    content: "BOOT: Coordinator startup uses the /exe boot script. Any other session in a project runs `exe-os boot --project <project>`. Shows: working memory count, active behaviors, identity loaded, last session summary (where you left off), daemon health. Read summary first. Auto-detects project from git repo. PRESERVATION (three automatic layers): (1) EVERY RESPONSE: Stop hook writes periodic checkpoint (lightweight, every N responses). (2) /EXIT OR CLOSE: SessionEnd hook runs dreaming cycle + continuity checkpoint + summary commit (15s timeout, separate process). (3) MID-SESSION SAVE: `config(action='closeout')` \u2014 same dreaming+summary with full agent context (no timeout, richer). CLI equivalent: `exe-os snapshot`. Use when approaching context limits. CRASH/SIGKILL: no hooks fire \u2014 periodic checkpoints are your safety net. Normal /exit: SessionEnd handles everything automatically."
   },
   {
-    title: "Structured handoffs \u2014 use typed messages instead of free text",
+    title: "Structured handoffs \u2014 record work on the task row, not in a message",
     domain: "communication",
     priority: "p1",
-    content: "Use typed message envelopes via send_message `type` param: task_result, status_update, question, blocker, handoff, review_request. Each has structured payload (files_changed, decisions, blockers, progress_pct). `update_task(done)` auto-generates a TaskResultPayload. Receiving agents see formatted summaries. Free text still works but typed messages are preferred for task-related communication."
+    content: "Task work is handed off through the DB, never through a message: update_task(done) carries the structured result (files_changed, commits, decisions, blockers, assertions_resolved) and is what the reviewer reads. A subagent's result is handed off by the dispatcher persisting it into that task row + memory before finishing. send_message is for human-directed notes between coordinator sessions (FYI, a question, a heads-up) and is fire-and-forget \u2014 NEVER use it to assign, deliver, or accept actionable work."
   },
   {
     title: "Assertions and estimation \u2014 mandatory confidence tracking on every task",
@@ -236,10 +227,10 @@ var PLATFORM_PROCEDURES = [
     content: "Wrong assertion -> next assertion on SAME problem must have lower confidence. First attempt: honest confidence. Second after failure: cap 0.5. Third: cap 0.3. After 3 failures: STOP. Reassess entire approach \u2014 your mental model is fundamentally wrong. Read code from scratch, check assumptions, trace execution. The pattern 'confident fix -> wrong -> repeat' destroys trust faster than admitting 'I don't know.'"
   },
   {
-    title: "Use /exe-afk for monitoring \u2014 /loop is deprecated for orchestration",
+    title: "No monitoring loops \u2014 pull the queue on every prompt instead",
     domain: "workflow",
     priority: "p1",
-    content: "For monitoring/orchestration (review checking, liveness, pipeline health), use /exe-afk not /loop. /loop lacks MCP health check, cycle mutex, and timeout \u2014 MCP disconnect freezes session permanently. /exe-afk checks daemon liveness each cycle, skips if unhealthy, uses lockfile mutex, times out hung commands. Default: 5 min, configurable via /exe-afk <minutes>."
+    content: "There is nothing to poll: subagents return their results to the dispatching context, so a timer that watches other sessions has no job. Do NOT run /loop (or any self-scheduled monitoring loop) for orchestration \u2014 it has no MCP health check, no cycle mutex and no timeout, so an MCP disconnect freezes the session permanently. Instead: check task(action='list', status='needs_review') and blocked tasks on every prompt, and dispatch the next subagent yourself. A genuine recurring job (a nightly report, a CI sweep) belongs in config(action='create_trigger'), not in a chat loop."
   },
   {
     title: "exe-build-adv mandatory for 3+ files",
@@ -276,19 +267,19 @@ var PLATFORM_PROCEDURES = [
     title: "Task lifecycle \u2014 the golden path every agent follows",
     domain: "workflow",
     priority: "p0",
-    content: "Tasks are durable, session-scoped checklist/notepad records by default; native subagent execution is orchestrated separately in the current context. For rung-3 legacy work (tmux employees \u2014 see the Dispatch Ladder), execution_mode='durable_tmux' is explicit dispatch + delivery. Task lifecycle: open -> in_progress (you start) -> done (update_task when finished) -> needs_review (reviewer nudged) -> closed (COO only via close_task). DB is the reliable delivery \u2014 intercom is just a speedup nudge. If you finish a task, self-chain: check for next task immediately (step 7). Never wait for a nudge. Never say 'standing by.'"
+    content: "Tasks are durable, session-scoped CHECKLIST records \u2014 they track work, they never dispatch it. Execution is always the current context or a named subagent it launches (see the Dispatch Ladder). Task lifecycle: open -> in_progress (you start) -> done (update_task when finished) -> needs_review -> closed (COO only via close_task). The DB row is the delivery: a subagent's result is not delivered until it is written there. If you finish a task, self-chain: check for the next task immediately (step 7). Never wait to be nudged. Never say 'standing by.'"
   },
   {
     title: "Review chain \u2014 managers must actively pull completed work, never wait for nudges",
     domain: "workflow",
     priority: "p0",
-    content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait for intercom. When needs_review: (1) read deliverable (git diff, exe/output/, task summary), (2) verify it works (tsc, build, run), (3) close_task if good or create fix task if not. Reviews sitting >30 min is a pipeline stall. Chain: worker update_task(done) -> needs_review -> manager pulls and verifies -> close_task -> COO reviews -> merge."
+    content: "When you dispatch work, you OWN the review. Check list_tasks(status='needs_review') on EVERY prompt \u2014 don't wait to be told. When needs_review: (1) read deliverable (git diff, exe/output/, task summary), (2) verify it works (tsc, build, run), (3) close_task if good or create fix task if not. Reviews sitting >30 min is a pipeline stall. Chain: worker update_task(done) -> needs_review -> manager pulls and verifies -> close_task -> COO reviews -> merge."
   },
   {
-    title: "Intercom is a speedup, not delivery \u2014 DB is the source of truth",
+    title: "The DB is the source of truth \u2014 a nudge is never delivery",
     domain: "architecture",
     priority: "p0",
-    content: "Tasks live in the DB. Intercom (tmux send-keys) is fire-and-forget \u2014 it may fail, get garbled, or arrive mid-work. Never rely on intercom for task delivery. The UserPromptSubmit hook checks the DB for new tasks on every prompt. Your operating procedures step 7 says check for next work. The daemon nudges idle agents as a speedup. If you have no tasks, you found them all."
+    content: "Tasks live in the DB. Any nudge that reaches you out of band (a message, a hook notice, a daemon ping) is fire-and-forget \u2014 it may fail, get garbled, or arrive mid-work \u2014 so it is a speedup, never delivery, and acting on one without re-reading the task row is how agents work from stale instructions. The UserPromptSubmit hook checks the DB for new tasks on every prompt; your operating procedures step 7 says check for next work. If you have no tasks, you found them all."
   },
   // --- Encryption key + cloud sync ---
   {
@@ -297,18 +288,12 @@ var PLATFORM_PROCEDURES = [
     priority: "p0",
     content: "Master key is in macOS Keychain (Secure Enclave) or Linux secret-tool \u2014 NOT a file. No ~/.exe-os/master.key on modern installs (auto-migrated to Keychain). Device linking: Device 1 runs `exe-os cloud link --show-full` to reveal 24-word BIP39 phrase, Device 2 runs `exe-os cloud` and pastes it. NEVER display/log/return the phrase in agent output. Tell user: 'Run exe-os cloud link --show-full in your Terminal.'"
   },
-  {
-    title: "Cloud endpoint is api.askexe.com \u2014 not askexe.com/cloud or cloud.askexe.com",
-    domain: "architecture",
-    priority: "p1",
-    content: "All cloud API calls go to https://api.askexe.com (Cloudflare Workers Custom Domain). NOT askexe.com/cloud or cloud.askexe.com (legacy, auto-migrated). Bypasses zone-level Bot Fight Mode that 403s datacenter IPs on askexe.com. If customer reports 403/challenge on cloud sync: verify latest exe-os version. Fix: `npm install -g @askexenow/exe-os@latest`. Override: EXE_CLOUD_ENDPOINT env var."
-  },
   // --- MCP is the ONLY data interface ---
   {
     title: "MCP disconnect \u2014 ask the user, never work around it",
     domain: "workflow",
     priority: "p0",
-    content: "If MCP tools are unavailable, disconnected, or returning connection errors: STOP. Tell the user: 'MCP server is disconnected. Please run /mcp to reconnect.' No workarounds \u2014 no raw Node imports, no direct DB, no CLI hacks, no daemon socket calls, no tmux send-keys. MCP is the ONLY data interface AND dispatch path. When down, you cannot create tasks, send messages, or coordinate agents. Ask once, wait, proceed when reconnected."
+    content: "If MCP tools are unavailable, disconnected, or returning connection errors: STOP. Tell the user: 'MCP server is disconnected. Please run /mcp to reconnect.' No workarounds \u2014 no raw Node imports, no direct DB, no CLI hacks, no daemon socket calls, no hand-started background sessions. MCP is the ONLY data interface. When down, you cannot create tasks, send messages, or record results. Ask once, wait, proceed when reconnected."
   },
   // --- Engineering discipline (coding agents) ---
   {
@@ -360,7 +345,7 @@ var PLATFORM_REFERENCE_PROCEDURES = [
     title: "MCP tool reference \u2014 all domains and key actions",
     domain: "tool-use",
     priority: "p1",
-    content: "exe-os MCP uses action-based dispatch (19 consolidated tools). Legacy 108-tool surface via EXE_MCP_TOOL_SURFACE=legacy. MEMORY: recall (search, as_of for bi-temporal, kind filter, retrieval_mode: all|decisions_only|procedures_only|operational|recent_high_value|document_aware) | ask_team | store (kind, procedure_for) | commit (high-importance) | search_everything | session_context | get_by_id | consolidate | cardinality | supersede. DECISION: store (domain, decision, rationale) | get (domain or query). TASK: create (title, assigned_to, context; defaults to checklist with zero execution side effects; blocked_by, parent_task_id, reviewer, complexity, budget_tokens, group_id, work_ref; execution_mode='durable_tmux' is the explicit legacy dispatch opt-in and enables spawn_runtime/spawn_model) | list | get | update (in_progress/done/blocked/cancelled + assertions) | close (COO only) | checkpoint | resume. GRAPH: query_relationships | entity_neighbors | hot_entities | stats | export | merge_entities | similar_trajectories. IDENTITY: get | update. BEHAVIOR: store | list | deactivate. SUPPORT: create_bug (title, description, severity p0-p3, product param for any AskExe product) | create_feature (title, description, use_case, proposed_solution) | list_my_bugs | list_my_features | triage_bug (AskExe-internal, uses triage_notes NOT notes) | health. MESSAGE: send | acknowledge. REMINDER: create | list | complete. SESSION: events | last_response. WIKI: list | get. DOCUMENT: ingest | list | purge | set_importance | rerank. CRM: list_people | get_person | list_tables | describe_table. RAW_DATA: list_sources | query | get. GATEWAY: send_whatsapp | query_conversations | query_company_brain. CONFIG: list_employees | set_agent_config | agent_spend | daemon_health | license_status | cloud_sync (cloud_action: status|sync|reupload) | memory_audit | run_consolidation | restart_telemetry | worker_gate | auto_wake_status | orchestration_phase | company_procedure (store|list|deactivate) | global_procedure | create_trigger | list_triggers | export_orchestration | import_orchestration | closeout | capability_cards (query param for best-agent match). DIAGNOSTICS: healthcheck | doctor | status_brief | check_update | stack_update_check | cloud_status | pending_work_summary | rename_employee | tool_search | drift. DREAMING: run | status | history. MCP_PING: daemon health + license + tool usage + retrieval health. Unsure an MCP path exists? diagnostics(action='tool_search', query='...') finds it before punting to the terminal. cloud_sync(cloud_action='reupload') is destructive \u2014 requires confirm_local_db_source_of_truth='LOCAL DB IS SOURCE OF TRUTH'."
+    content: "exe-os MCP uses action-based dispatch (19 consolidated tools). Legacy 108-tool surface via EXE_MCP_TOOL_SURFACE=legacy. MEMORY: recall (search, as_of for bi-temporal, kind filter, retrieval_mode: all|decisions_only|procedures_only|operational|recent_high_value|document_aware) | ask_team | store (kind, procedure_for) | commit (high-importance) | search_everything | session_context | get_by_id | consolidate | cardinality | supersede. DECISION: store (domain, decision, rationale) | get (domain or query). TASK: create (title, assigned_to, context; a durable checklist row with zero execution side effects \u2014 it never dispatches; blocked_by, parent_task_id, reviewer, complexity, budget_tokens, group_id, work_ref) | list | get | update (in_progress/done/blocked/cancelled + assertions) | close (COO only) | checkpoint | resume. spawn_model / spawn_runtime: accepted for compatibility and ignored \u2014 the response says so; model/runtime per employee come from set_agent_config and the Agent tool's own model arg. GRAPH: query_relationships | entity_neighbors | hot_entities | stats | export | merge_entities | similar_trajectories. IDENTITY: get | update. BEHAVIOR: store | list | deactivate. SUPPORT: create_bug (title, description, severity p0-p3, product param for any AskExe product) | create_feature (title, description, use_case, proposed_solution) | list_my_bugs | list_my_features | triage_bug (AskExe-internal, uses triage_notes NOT notes) | health. MESSAGE: send | acknowledge. REMINDER: create | list | complete. SESSION: events | last_response. WIKI: list | get. DOCUMENT: ingest | list | purge | set_importance | rerank. CRM: list_people | get_person | list_tables | describe_table. RAW_DATA: list_sources | query | get. GATEWAY: send_whatsapp | query_conversations | query_company_brain. CONFIG: list_employees | set_agent_config | agent_spend | daemon_health | license_status | cloud_sync (cloud_action: status|sync|reupload) | memory_audit | run_consolidation | restart_telemetry | worker_gate | auto_wake_status | orchestration_phase | company_procedure (store|list|deactivate) | global_procedure | create_trigger | list_triggers | export_orchestration | import_orchestration | closeout | capability_cards (query param for best-agent match). DIAGNOSTICS: healthcheck | doctor | status_brief | check_update | stack_update_check | cloud_status | pending_work_summary | rename_employee | tool_search | drift. DREAMING: run | status | history. MCP_PING: daemon health + license + tool usage + retrieval health. Unsure an MCP path exists? diagnostics(action='tool_search', query='...') finds it before punting to the terminal. cloud_sync(cloud_action='reupload') is destructive \u2014 requires confirm_local_db_source_of_truth='LOCAL DB IS SOURCE OF TRUTH'."
   },
   {
     title: "Cognition features \u2014 dreaming, reflexes, baselines, hot-path summary",
@@ -390,7 +375,31 @@ var PLATFORM_REFERENCE_PROCEDURES = [
     title: "MCP capability quick-reference \u2014 operations & orchestration surface",
     domain: "tool-use",
     priority: "p1",
-    content: "Beyond data reads/writes, use MCP over ad-hoc workarounds. Automation: config(create_trigger|list_triggers). Parallel dispatch barrier: task(create_group|group_status|group_results); verify_dispatch confirms ack. Push reminders: task(reminder_create) with daily_push. Decisions: memory(decision_store|decision_get|supersede). Prior solutions: graph(similar_trajectories). Org backup/restore: config(export_orchestration|import_orchestration). Self-improvement: config(dreaming_run|dreaming_status)."
+    content: "Beyond data reads/writes, use MCP over ad-hoc workarounds. Automation: config(create_trigger|list_triggers). Parallel-work barrier: task(create_group|group_status|group_results) tracks a fan-out of subagents as one unit. Push reminders: task(reminder_create) with daily_push. Decisions: memory(decision_store|decision_get|supersede). Prior solutions: graph(similar_trajectories). Org backup/restore: config(export_orchestration|import_orchestration). Self-improvement: config(dreaming_run|dreaming_status)."
+  },
+  {
+    title: "When to hire new employees \u2014 scaling signals for the COO",
+    domain: "workflow",
+    priority: "p1",
+    content: "COO recommends hiring (/exe-new-employee) when: GM needed: separate project needs dedicated coordination, COO spending >30% context on it. Engineer: CTO has 5+ queued tasks, parallelization maxed. Content specialist: CMO backlog exceeds 1 week. Auditor: quality gates being skipped under pressure. General rule: if a role spends >50% time on delegatable work, hire. Templates: coo, cto, cmo, gm, principal-engineer, content-specialist, ai-specialist, staff-code-reviewer. Usage: /exe-new-employee <name> --role <template>."
+  },
+  {
+    title: "Cloud endpoint is api.askexe.com \u2014 not askexe.com/cloud or cloud.askexe.com",
+    domain: "architecture",
+    priority: "p1",
+    content: "All cloud API calls go to https://api.askexe.com (Cloudflare Workers Custom Domain). NOT askexe.com/cloud or cloud.askexe.com (legacy, auto-migrated). Bypasses zone-level Bot Fight Mode that 403s datacenter IPs on askexe.com. If customer reports 403/challenge on cloud sync: verify latest exe-os version. Fix: `npm install -g @askexenow/exe-os@latest`. Override: EXE_CLOUD_ENDPOINT env var."
+  },
+  {
+    title: "Daemon logs and session lifecycle \u2014 full transparency for debugging",
+    domain: "operations",
+    priority: "p1",
+    content: "Daemon logs to ~/.exe-os/logs/exed-launchd.log. Primary debugging tool. Shows: session spawns, idle kills (90s graceful warning), event loop health (>3s warn, >10s CRITICAL), task enforcement (60s cycle), intercom delivery, MCP sessions, cloud sync. Read: `tail -100 ~/.exe-os/logs/exed-launchd.log` or /exe-doctor. Enforcement audit: ~/.exe-os/enforcement-audit.jsonl (structured JSONL). If agent seems stuck or killed unexpectedly, READ LOGS FIRST before reporting a bug."
+  },
+  {
+    title: "Bug lifecycle \u2014 full detail (filing gate, triage-as-state, dedupe, reconciliation)",
+    domain: "support",
+    priority: "p1",
+    content: "Full detail behind the always-injected 'Bug lifecycle' procedure (feature c06e754f). Root cause it fixes: an audit of 187 open bugs found 161 essay-length summaries (>800 chars), ZERO with reproduction_steps, ZERO with expected/actual, and package_version='unknown' on every agent filing \u2014 170 of 187 filed by our own agents in three nights. The schema always had these fields; they were optional, so nobody filled them in. \n\nFILING GATE (create_bug, enforced in create-bug-report.ts's handler \u2014 covers both the raw tool and support(action='create_bug')): reproduction_steps requires at least one CONCRETE step (a backticked command, a test id containing '::' or matching describe()/it(), or a UI-action verb aimed at something \u2014 not narrative). expected and actual are required non-empty strings. observed_kind (failing_test/command_output/log_excerpt/screenshot/live_probe) plus evidence_pointer (the test id, command+output excerpt, log path+line, or artifact path) are both required. screenshot and log_excerpt exist specifically so admin (on_behalf_of_email) and TUI/desktop customer-facing filings \u2014 where a human, not a command line, is doing the observing \u2014 can still satisfy the gate. summary/description caps at 1500 chars; anything longer belongs in add_comment AFTER filing, not in the filing itself. package_version is auto-resolved from the installed package.json (readPackageVersion() in mcp-transport-health.ts, the same helper the diagnostics/health tools use) whenever the caller omits it or it's unreadable \u2014 it should never read 'unknown' when the version is actually on disk. No repro you actually observed, or nothing to point at? File it as memory(action='store', domain='lesson') instead, or as a feature if what's missing is a control, not a defect.\n\nDEDUPE PRE-CHECK: before creating, one list call fetches the caller's own OPEN bugs for the same product (cached in-process for ~5 minutes so repeated filings in a session don't re-fetch). Candidates are found by title-token overlap (>=50% of the new title's significant tokens present in an existing title) or a shared file path/symbol between reproduction context and an existing bug's files_changed. A match refuses ONCE, listing candidate ids/titles; the caller acknowledges with not_duplicate_of:[ids] on retry if it is genuinely distinct. Dedupe fails OPEN on a network error \u2014 it is a courtesy check, not a gate that can block filing when the list call itself fails.\n\nLIFECYCLE = open -> triaged -> fixed -> closed, and each transition is RECORD STATE, never just a comment: triaged means classification is set via triage_bug(status='triaged', classification=...) \u2014 note the historical bug where triage_bug's inputSchema omitted the classification field entirely, so a caller's classification silently fell into an unused rest-spread and never reached the PATCH body, leaving every triaged record stuck at classification='unclear' regardless of what was passed (fixed alongside this procedure, with a regression test) \u2014 OR a fix PR merging, which the merged-PR reconciler auto-transitions to triaged (see the separate 'Link fix PRs to bugs at PR-open time' procedure for that linkage). fixed requires a verification artifact via update_bug/triage_bug (verification_kind \u2208 regression_test/manual/ops_transcript, per support-verification-input.ts) \u2014 a status flip alone is refused server-side. closed requires delivery proof. NEVER re-triage a record whose triaged_at is already set unless there is genuinely new evidence \u2014 re-triaging on a whim erodes the signal that triaged_at is supposed to carry. Comments (add_comment) are for narrative and context; they are never a substitute for writing the state fields. Tag repeat-class issues (the same root cause recurring across multiple filings) in triage_notes so the pattern becomes visible in listings \u2014 there is no separate repeat-of column, so this is a documented convention, not a new schema field."
   }
 ];
 function getPlatformReferenceMarkdown() {
@@ -399,6 +408,14 @@ function getPlatformReferenceMarkdown() {
 ${p.content}`).join("\n\n");
   return "# exe-os Platform Reference (read on demand)\n\nAuto-generated at COO boot from the installed exe-os version. These sections are intentionally NOT injected into every session's system prompt \u2014 read them here when a task needs them.\n\n" + body + "\n";
 }
+function writePlatformReferenceFile(targetDir) {
+  try {
+    const dir = targetDir ?? path.join(process.env.EXE_OS_DIR ?? path.join(os.homedir(), ".exe-os"), "reference");
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(path.join(dir, "platform-reference.md"), getPlatformReferenceMarkdown(), "utf8");
+  } catch {
+  }
+}
 var PLATFORM_PROCEDURE_TITLES = new Set(
   [...PLATFORM_PROCEDURES, ...PLATFORM_REFERENCE_PROCEDURES].map((p) => p.title)
 );
@@ -407,5 +424,6 @@ export {
   PLATFORM_PROCEDURES,
   PLATFORM_REFERENCE_PROCEDURES,
   getPlatformReferenceMarkdown,
+  writePlatformReferenceFile,
   PLATFORM_PROCEDURE_TITLES
 };

package/dist/{chunk-AHESD3KW.js → chunk-J4UVI652.js}

@@ -212,7 +212,7 @@ async function main(args) {
   console.log("[health-gate] Starting rollback...");
   restorePreDeployBackup();
   try {
-    const { rollbackStackUpdate, defaultStackPaths } = await import("./stack-update-ZQQ5YYPJ.js");
+    const { rollbackStackUpdate, defaultStackPaths } = await import("./stack-update-U53FBVCQ.js");
     const paths = defaultStackPaths();
     await rollbackStackUpdate({
       manifestRef: paths.manifestRef,

package/dist/{chunk-PLII76NJ.js → chunk-JBUCA4OX.js}

@@ -77,14 +77,24 @@ function hostMatchesDomain(host, domain) {
   if (!h || !d) return false;
   return h === d || h.endsWith(`.${d}`);
 }
+function compareVersions(a, b) {
+  const pa = a.split(".").map((x) => Number.parseInt(x, 10));
+  const pb = b.split(".").map((x) => Number.parseInt(x, 10));
+  for (let i = 0; i < Math.max(pa.length, pb.length); i += 1) {
+    const na = Number.isFinite(pa[i]) ? pa[i] : 0;
+    const nb = Number.isFinite(pb[i]) ? pb[i] : 0;
+    if (na !== nb) return na - nb;
+  }
+  return 0;
+}
 function resolveStack(manifest, requested) {
   if (manifest.services && !manifest.stacks) {
-    return { version: manifest.version ?? "(single)", services: manifest.services };
+    return { version: manifest.version ?? "(single)", services: manifest.services, found: true };
   }
-  if (!manifest.stacks) return { version: "(none)", services: {} };
-  const version = requested ?? manifest.latest ?? Object.keys(manifest.stacks).sort().pop() ?? "";
+  if (!manifest.stacks) return { version: "(none)", services: {}, found: false };
+  const version = requested ?? manifest.latest ?? [...Object.keys(manifest.stacks)].sort(compareVersions).pop() ?? "";
   const entry = manifest.stacks[version];
-  return { version, services: entry?.services ?? {} };
+  return { version, services: entry?.services ?? {}, found: entry !== void 0 };
 }
 function isAskExeImage(image) {
   return image.startsWith("ghcr.io/askexe/") || image.startsWith("update.askexe.com/askexe/");
@@ -480,7 +490,10 @@ function runPreflight(options) {
       failed: 1
     };
   }
-  const { version, services } = resolveStack(manifest, options?.stackVersion);
+  const { version, services, found } = resolveStack(manifest, options?.stackVersion);
+  if (!found) {
+    return absentStackReport(manifest, version, manifestPath, options?.stackVersion !== void 0 ? "requested" : "selected");
+  }
   const repoRoot = path.resolve(path.dirname(manifestPath), "..", "..");
   const envExamplePath = options?.envExamplePath ?? path.join(repoRoot, "deploy", "compose", ".env.example");
   const composePath = options?.composePath ?? path.join(repoRoot, "deploy", "compose", "docker-compose.yml");
@@ -494,9 +507,23 @@ function runPreflight(options) {
   const { verdict, passed, warned, failed } = tally(findings);
   return { verdict, manifestPath, stackVersion: version, findings, passed, warned, failed };
 }
+function absentStackReport(manifest, version, label, how) {
+  const known = Object.keys(manifest.stacks ?? {}).join(", ") || "(none)";
+  const finding = {
+    check: "stack-present",
+    status: "fail",
+    bug: "absent-stack-is-not-an-empty-stack",
+    offenders: [version],
+    message: `stack ${version} (${how}) is NOT present in this manifest, so nothing could be checked. This is an unreadable subject, not a failing one \u2014 every check below would have reported its requirement missing purely because the service map was empty. Known stacks: ${known}.` + (how === "selected" ? " Nothing asked for this version: it came from `latest` or from picking the newest key, so the MANIFEST is inconsistent \u2014 `latest` names a stack that does not exist." : " If this came from a dry run, the caller preflighted a version it had not written.")
+  };
+  return { verdict: "RED", manifestPath: label, stackVersion: version, findings: [finding], passed: 0, warned: 0, failed: 1 };
+}
 function runPreflightOnManifest(input) {
   const label = input.label ?? "(in-memory manifest)";
-  const { version, services } = resolveStack(input.manifest, input.stackVersion);
+  const { version, services, found } = resolveStack(input.manifest, input.stackVersion);
+  if (!found) {
+    return absentStackReport(input.manifest, version, label, input.stackVersion !== void 0 ? "requested" : "selected");
+  }
   const env = loadEnvLikeFile(input.envExamplePath);
   const envValues = loadEnvValues(input.envExamplePath);
   const compose = readComposeText(input.composePath);

package/dist/{chunk-2PZTMSMG.js → chunk-JOF4HQDF.js}

@@ -1,17 +1,17 @@
 import {
   isExeSession,
   strictSessionScopeFilter
-} from "./chunk-7UHZBVP3.js";
+} from "./chunk-QDVLVLXP.js";
 import {
   recordOrchestrationEventBestEffort
-} from "./chunk-LSNBTGW4.js";
+} from "./chunk-DPYZW42H.js";
 import {
   getProjectName
-} from "./chunk-UX2EO653.js";
+} from "./chunk-ZZWFZ46U.js";
 import {
   DEFAULT_COORDINATOR_TEMPLATE_NAME,
   getCoordinatorName
-} from "./chunk-GL47M7NY.js";
+} from "./chunk-3UD3OF3X.js";
 import {
   loadConfigSync
 } from "./chunk-MMS2HBRT.js";
@@ -260,7 +260,7 @@ function createRealDeps(getClient) {
       });
     },
     createReviewForOrphan: async (task) => {
-      const { createReviewForCompletedTask } = await import("./tasks-review-PPPVEE62.js");
+      const { createReviewForCompletedTask } = await import("./tasks-review-CG2A5GM3.js");
       const cwd = process.cwd();
       await createReviewForCompletedTask(
         task,

package/dist/{chunk-OBBO6EJR.js → chunk-JQN3QGSF.js}

@@ -1,6 +1,6 @@
 import {
   createReminder
-} from "./chunk-UXN4BICC.js";
+} from "./chunk-XMX5J52Z.js";
 
 // src/mcp/tools/create-reminder.ts
 import { z } from "zod";

package/dist/{chunk-P4PIZOL2.js → chunk-JWYIH5DR.js}

@@ -4,10 +4,10 @@ import {
   extractIdentifiers,
   isGarbageEntity,
   normalizeEntityName
-} from "./chunk-46VSBDUW.js";
+} from "./chunk-3DCBDG4T.js";
 import {
   getClient
-} from "./chunk-GL47M7NY.js";
+} from "./chunk-3UD3OF3X.js";
 
 // src/lib/memory-graph-extractor.ts
 function relationshipId(sourceId, targetId, relType) {
@@ -432,7 +432,7 @@ async function upsertMemoryGraph(result, memoryId, opts) {
     });
   }
   try {
-    const { createCoOccurrenceEdges } = await import("./co-occurrence-R5AG4OAU.js");
+    const { createCoOccurrenceEdges } = await import("./co-occurrence-5LBYCW3U.js");
     await createCoOccurrenceEdges(result.entities, memoryId, { linkOnly });
   } catch {
   }