@monoes/monomindcli 2.15.7 → 2.16.1

package/dist/src/orgrt/daemon.js

@@ -4,6 +4,8 @@ import { execFileSync } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { existsSync, mkdirSync, readFileSync, unlinkSync } from 'node:fs';
 import { isAbsolute, join } from 'node:path';
+import { resolveOrgDefBlueprints } from '../catalog/blueprints.js';
+import { pickRoleForTask } from '../decision/picks.js';
 import { writeJsonFileAtomic } from '../utils/json-file.js';
 import { configureResourceLimits, getResourceLimits, reapOrphanedSdkProcesses, } from '../utils/resource-governor.js';
 import { AntigravityAgentRunner } from './antigravity-runner.js';
@@ -11,7 +13,7 @@ import { AntigravityAgentRunner } from './antigravity-runner.js';
 import * as approvalOps from './approvals.js';
 import { BrokerLease, normalizeCredential } from './broker.js';
 import { OrgBus } from './bus.js';
-import { captureCheckpoint, generateChecksum, isCheckpointExpired, migrateCheckpoint, restoreMailboxQueue, validateCheckpoint, } from './checkpoint.js';
+import { captureCheckpoint, generateChecksum, isCheckpointExpired, migrateCheckpoint, restoredRoleStatus, restoreMailboxQueue, validateCheckpoint, } from './checkpoint.js';
 import * as checkpointOps from './checkpoint-ops.js';
 import { CodexAgentRunner } from './codex-runner.js';
 import { checkCompletion } from './completion-gate.js';
@@ -35,19 +37,21 @@ import * as orgMemory from './org-memory.js';
 import { PiRpcAgentRunner } from './pi-rpc-runner.js';
 import { PiAgentRunner } from './pi-runner.js';
 import { PolicyEngine } from './policy.js';
+import { expandOrgPolicyPathVars, promptVarsFor } from './prompt-vars.js';
 import { resolveRoleProvider } from './provider.js';
 import * as questionOps from './questions.js';
 import { QwenRpcAgentRunner } from './qwen-rpc-runner.js';
 import { QwenAgentRunner } from './qwen-runner.js';
 import { historyFile, readHistory, readRunEvents, summarizeRun, } from './reporting.js';
 import { buildRespawnReceipt, computeReplacementBudget, mergeEffectiveRoleConfig, redactRoleConfig, validateRespawnInput, } from './role-slot.js';
+import { currentRoleTrace, endTurn, withTrace } from './role-trace.js';
 import { buildRuntimeOptions } from './runtime-options.js';
 import * as scheduler from './scheduler-integration.js';
 import { runAgentSession } from './session.js';
 import { SessionLedger } from './session-ledger.js';
 import { effectiveToolProviders } from './skill-library.js';
 import { TaskDag } from './task-dag.js';
-import { freshChainId, roleProviderPrefixes, ToolProviderHub, } from './tool-providers.js';
+import { roleProviderPrefixes, ToolProviderHub } from './tool-providers.js';
 import { ORG_DIR, OrgDefSchema, } from './types.js';
 import { VercelAgentRunner } from './vercel-runner.js';
 /** OpenTelemetry tracing helper - creates spans for major operations */
@@ -145,6 +149,23 @@ export function resolveRoleRunner(roleRuntime, orgRuntime, roleProviderKind, org
         return resolveRunner(explicit, undefined, roleProvider);
     return resolveRunner(undefined, roleProviderKind ?? orgProviderKind, roleProvider);
 }
+/** Resolves `assignee: "auto"` on org_task (SessionOpts.pickAssignee).
+ *  pickRoleForTask itself falls back to deterministic keyword ranking over
+ *  role titles/responsibilities whenever no decision model is configured
+ *  (decision/picks.ts), so this must be wired unconditionally. It used to be
+ *  gated behind `decisionModelConfigured()` — meant only to keep org_task's
+ *  description byte-identical for caching when no decision model was set —
+ *  but that also left `pickAssignee` completely undefined whenever Jev was
+ *  off (the default). A literal "auto" assignee then never resolved to a
+ *  role: dispatchReadyTasks (decisions.ts) never matches "auto" against a
+ *  live agent or pending role, so the task stayed 'ready' forever with only
+ *  a repeating 'dispatch-assignee-unresolved' audit line to show for it
+ *  (round1-issue1). */
+export function resolveAutoAssignee(def) {
+    return (title) => pickRoleForTask(title, def.roles, {
+        onError: (err) => process.stderr.write(`[org] decision model "${err.provider}" unavailable (${err.message})\n`),
+    });
+}
 /** Per-role token budget: a role's own `budget_tokens` wins; otherwise the
  *  even split of run_config.budget_tokens across all roles. */
 export function roleTokenBudget(role, def) {
@@ -318,7 +339,11 @@ export class OrgDaemon {
         if (!running)
             throw new Error(`org ${name} is not running`);
         const defPath = join(this.root, ORG_DIR, `${name}.json`);
-        const newDef = OrgDefSchema.parse(JSON.parse(readFileSync(defPath, 'utf8')));
+        const parsedDef = OrgDefSchema.parse(JSON.parse(readFileSync(defPath, 'utf8')));
+        const bp = resolveOrgDefBlueprints(parsedDef, this.root);
+        if (bp.errors.length)
+            throw new Error(`org ${name}: ${bp.errors.join('; ')}`);
+        const newDef = expandOrgPolicyPathVars(bp.def, promptVarsFor(this.root));
         const changed = [];
         const newRoles = [];
         const removedRoles = [];
@@ -399,19 +424,10 @@ export class OrgDaemon {
     }
     /** M1: the chain trace a role's tool calls carry — from the most recent
      *  message delivered to it with a `[trace chn_… hop=N]` line, otherwise a
-     *  fresh chain (hop 0) minted once and kept for the role. */
+     *  fresh chain (hop 0) minted once and kept for the role — plus the role's
+     *  turn (#327, role-trace.ts). */
     roleTrace(org, role) {
-        const running = this.orgs.get(org);
-        if (!running)
-            return { chain_id: freshChainId(), hop: 0 };
-        if (!running.traces)
-            running.traces = new Map();
-        let t = running.traces.get(role);
-        if (!t) {
-            t = { chain_id: freshChainId(), hop: 0 };
-            running.traces.set(role, t);
-        }
-        return t;
+        return currentRoleTrace(this.orgs.get(org), role);
     }
     /** Hook for the SSE server — registers a listener for all bus events across all orgs. */
     onBusEvent = (fn) => {
@@ -528,7 +544,10 @@ export class OrgDaemon {
             /* best-effort: not a git repo, git missing, or a wedged hook */
         }
         const defPath = join(this.root, ORG_DIR, `${name}.json`);
-        const def = OrgDefSchema.parse(JSON.parse(readFileSync(defPath, 'utf8')));
+        const parsedDef = OrgDefSchema.parse(JSON.parse(readFileSync(defPath, 'utf8')));
+        const bp = resolveOrgDefBlueprints(parsedDef, this.root);
+        // {{home}} / {{org_root}} in policy paths, before any root or sandbox sees them.
+        const def = expandOrgPolicyPathVars(bp.def, promptVarsFor(this.root));
         let run;
         let checkpoint;
         if (options?.resume) {
@@ -644,7 +663,10 @@ export class OrgDaemon {
             throw new Error(`org ${name}: ${loadoutErrors.join('; ')}`);
         }
         const { validateRoleSkills } = await import('./skill-library.js');
-        const skillErrors = def.roles.flatMap((r) => validateRoleSkills(r, this.root));
+        const skillErrors = [
+            ...bp.errors,
+            ...def.roles.flatMap((r) => validateRoleSkills(r, this.root)),
+        ];
         if (skillErrors.length) {
             throw new Error(`org ${name}: ${skillErrors.join('; ')}`);
         }
@@ -1514,7 +1536,7 @@ export class OrgDaemon {
         const runtime = {
             mailbox,
             policy,
-            status: roleCheckpoint?.status ?? 'running',
+            status: restoredRoleStatus(roleCheckpoint),
             done: Promise.resolve(),
             metrics: { tokens: roleCheckpoint?.tokensUsed ?? 0, costUsd: roleCheckpoint?.costUsd ?? 0 },
             lastMessageId: roleCheckpoint?.lastMessageId,
@@ -1528,6 +1550,9 @@ export class OrgDaemon {
             for (const line of roleCheckpoint.scrollback)
                 runtime.scrollback.push(line);
         }
+        if (roleCheckpoint?.turns && !running.turns?.has(role.id)) {
+            (running.turns ??= new Map()).set(role.id, roleCheckpoint.turns);
+        }
         const sessionOpts = {
             org: name,
             role,
@@ -1586,8 +1611,12 @@ export class OrgDaemon {
             onSessionId: (id) => {
                 runtime.sessionId = id;
             },
-            onTurnEnd: () => decisionOps.nudgeOpenTasksAtTurnEnd(running, role.id),
-            deliver: (from, to, subject, body) => this.deliver(name, from, to, subject, body),
+            onTurnEnd: () => {
+                endTurn(running, role.id);
+                decisionOps.nudgeOpenTasksAtTurnEnd(running, role.id);
+            },
+            // #327: the role's org_send mail carries its chain at the next hop.
+            deliver: (from, to, subject, body) => this.deliver(name, from, to, subject, withTrace(body, this.roleTrace(name, role.id))),
             askHuman: (r, question, blocking) => this.askHuman(name, r, question, blocking),
             onGate: (r, gateName, gateDesc) => this.createGate(name, r, gateName, gateDesc),
             circuitBreaker: (() => {
@@ -1703,9 +1732,10 @@ export class OrgDaemon {
                 });
                 return text;
             },
-            createTask: (r, title, assignee, deps, loadout) => {
-                return this.dagCreateTask(name, r, title, assignee, deps, loadout);
+            createTask: (r, title, assignee, deps, loadout, brief) => {
+                return this.dagCreateTask(name, r, title, assignee, deps, loadout, brief);
             },
+            pickAssignee: resolveAutoAssignee(def),
             // ADR-O001 D7: only an org with a catalog gets the `loadout` argument;
             // the session itself is built with the loadout frozen above.
             loadoutCatalog: loadoutCatalog(def),
@@ -1721,10 +1751,7 @@ export class OrgDaemon {
             requestReview: def.roles.some((r) => r.review_input === 'artifact-only')
                 ? (r, taskId, reviewer, base) => this.dagRequestReview(name, r, taskId, reviewer, base)
                 : undefined,
-            listTasks: () => {
-                const running = this.orgs.get(name);
-                return JSON.stringify(running?.taskDag?.all() ?? [], null, 2);
-            },
+            listTasks: (taskId) => decisionOps.dagListTasks(this, name, taskId),
             splitTask: (r, parentId, children) => {
                 return this.dagSplitTask(name, r, parentId, children);
             },
@@ -2764,8 +2791,8 @@ export class OrgDaemon {
     listGates(org, status) {
         return decisionOps.listGates(this, org, status);
     }
-    dagCreateTask(org, role, title, assignee, deps, loadout) {
-        return decisionOps.dagCreateTask(this, org, role, title, assignee, deps, loadout);
+    dagCreateTask(org, role, title, assignee, deps, loadout, brief) {
+        return decisionOps.dagCreateTask(this, org, role, title, assignee, deps, loadout, brief);
     }
     dagCompleteTask(org, role, taskId, result, evidence) {
         return decisionOps.dagCompleteTask(this, org, role, taskId, result, evidence);