@adhdev/daemon-core 0.9.82-rc.482 → 0.9.82-rc.483

package/dist/mesh/contracts.d.ts

@@ -161,7 +161,12 @@ export declare function assertPendingMeshCoordinatorEventV2(raw: unknown, path?:
  * Decide whether a v2 pending event should be delivered to the given drainer.
  * Centralised so every drain implementation uses the same rule.
  *
- *   - 'broadcast': always delivered.
+ *   - 'broadcast': always delivered. NOTE: a terminal task event that reached the
+ *     queue as broadcast is an ownership leak (it belongs to its dispatching
+ *     coordinator). This pure helper does not have the drain-window
+ *     daemon-form/session matching semantics, so the terminal+broadcast
+ *     dispatchedBy filter is applied one layer up in the drainer (see
+ *     mesh-events-pending routeV2EventsForDrainer) where those semantics live.
  *   - 'system': never delivered to coordinators (system handler only).
  *   - 'unicast': delivered iff intendedFor matches drainer identity.
  *
@@ -170,6 +175,15 @@ export declare function assertPendingMeshCoordinatorEventV2(raw: unknown, path?:
  * are quarantined to a dedicated drain endpoint instead.
  */
 export declare function shouldDeliverPendingEventToCoordinator(event: PendingMeshCoordinatorEventV2, drainer: CoordinatorIdentity): boolean;
+/**
+ * True for a terminal task event (completion / stop / refine outcome). A terminal
+ * event belongs to exactly the coordinator that dispatched the task, so it must
+ * never fan out to sibling coordinators that did not dispatch it. Used by the
+ * emit-side stamp (to avoid downgrading an unaddressed terminal event to full
+ * broadcast) and by the drain-side filter (defense-in-depth for any terminal
+ * event that already reached the queue as broadcast).
+ */
+export declare function isTerminalTaskEvent(eventName: string): boolean;
 /**
  * Default the v2 scope for an event by its producer event name (design decision
  * §3). Terminal task events and coordinator-addressed alerts → unicast (routed
@@ -219,9 +233,18 @@ export declare function coordinatorIdentityFromEmitFields(fields: {
  * returns undefined: the event stays a v1 (unstamped) event and is broadcast-
  * treated during rollout, exactly as before — no regression, no fabricated
  * identity. When the resolved scope is 'unicast' but no `intendedFor` is
- * available, the scope is downgraded to 'broadcast' so the stamp never violates
- * the "unicast requires intendedFor" contract (a terminal event that cannot be
- * addressed to its originator is safest delivered broadly, not dropped).
+ * available, the fallback depends on the event class:
+ *
+ *   - Terminal task events (completion / stop / refine outcome) MUST NOT be
+ *     broadcast to every coordinator — a completion belongs to the coordinator
+ *     that dispatched the task, and broadcasting it makes non-owner coordinators
+ *     (e.g. sibling MAGI coordinators that never dispatched this replica's task)
+ *     act on a completion that is not theirs (MAGI-REPLICA-COMPLETION-EVENT-LEAK).
+ *     For these we address the event to `dispatchedBy` (the dispatching
+ *     coordinator) and KEEP it unicast, so the stamp stays contract-valid and the
+ *     event reaches only its originating coordinator.
+ *   - Any other unicast event with no addressable target falls back to broadcast
+ *     (contract-valid, still delivered, never dropped) — unchanged.
  */
 export declare function buildPendingEventEmitStamp(opts: {
     eventName: string;

package/dist/repo-mesh-types.d.ts

@@ -372,7 +372,7 @@ export declare function magiAutoLaunchedSessionCleanupDecision(args: {
 };
 /** Min/max bounds for the global write-task parallel cap. */
 export declare const MESH_MAX_PARALLEL_TASKS_MIN = 1;
-export declare const MESH_MAX_PARALLEL_TASKS_MAX = 8;
+export declare const MESH_MAX_PARALLEL_TASKS_MAX = 64;
 /**
  * Default multiplier applied to the write cap to derive the read-only diagnosis
  * cap. Read-only (live_debug_readonly) tasks carry no isolation/merge cost so they

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adhdev/daemon-core",
-  "version": "0.9.82-rc.482",
+  "version": "0.9.82-rc.483",
   "description": "ADHDev daemon core — CDP, IDE detection, providers, command execution",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -47,8 +47,8 @@
   "author": "vilmire",
   "license": "AGPL-3.0-or-later",
   "dependencies": {
-    "@adhdev/mesh-shared": "0.9.82-rc.482",
-    "@adhdev/session-host-core": "0.9.82-rc.482",
+    "@adhdev/mesh-shared": "0.9.82-rc.483",
+    "@adhdev/session-host-core": "0.9.82-rc.483",
     "@agentclientprotocol/sdk": "^0.16.1",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",

package/src/commands/low-family/coordinator-prompt.ts

@@ -8,6 +8,59 @@
 import type { LowFamilyContext, LowFamilyHandler } from './types.js';
 
 export const coordinatorPromptHandlers: Record<string, LowFamilyHandler> = {
+    /**
+     * Render the coordinator system prompt for a mesh + CLI type, so the
+     * dashboard can show the operator exactly what a coordinator session
+     * receives by default. This resolves the mesh, applies its repo-mesh
+     * config, and runs the SAME buildCoordinatorSystemPrompt the launch path
+     * uses — minus the runtime-only best-effort sections (mission / recent
+     * activity / operating notes), which are launch-scope and not part of the
+     * static "default base" an operator is trying to preview here.
+     *
+     * It respects mesh-level and user-file override/append layering, so the
+     * preview reflects the effective prompt: with no overrides configured it
+     * shows the pure daemon default; with an override set it shows that.
+     */
+    coordinator_prompt_preview: async (ctx: LowFamilyContext, args: any) => {
+        const meshId = typeof args?.meshId === 'string' ? args.meshId.trim() : '';
+        const cliType = typeof args?.cliType === 'string' && args.cliType.trim() ? args.cliType.trim() : 'claude-cli';
+        if (!meshId) return { success: false, error: 'meshId required' };
+        try {
+            // Prefer the router-bound resolver (inline cache aware); fall back to
+            // local config when a bare context is used (e.g. unit tests).
+            let mesh: any = null;
+            if (ctx.getMeshForCommand) {
+                const resolved = await ctx.getMeshForCommand(meshId);
+                mesh = resolved?.mesh ?? null;
+            }
+            if (!mesh) {
+                const { getMesh } = await import('../../config/mesh-config.js');
+                mesh = getMesh(meshId);
+            }
+            if (!mesh) return { success: false, error: `mesh not found: ${meshId}` };
+
+            // Apply the on-disk repo-mesh config overlay exactly as launch does,
+            // so policy/nodes reflect the effective mesh.
+            let effectiveMesh = mesh;
+            try {
+                const { loadRepoMeshJsonConfig, applyRepoMeshConfig } = await import('../../config/mesh-json-config.js');
+                const workspace = typeof mesh?.workspace === 'string' ? mesh.workspace : undefined;
+                if (workspace) {
+                    const loaded = loadRepoMeshJsonConfig(workspace);
+                    if (loaded?.sourceType !== 'invalid') {
+                        effectiveMesh = applyRepoMeshConfig(mesh, loaded?.config);
+                    }
+                }
+            } catch { /* overlay is best-effort — fall back to the raw mesh */ }
+
+            const { buildCoordinatorSystemPrompt } = await import('../../mesh/coordinator-prompt.js');
+            const prompt = buildCoordinatorSystemPrompt({ mesh: effectiveMesh, coordinatorCliType: cliType });
+            return { success: true, prompt, cliType, meshId, bytes: Buffer.byteLength(prompt, 'utf8') };
+        } catch (error: any) {
+            return { success: false, error: error?.message || String(error) };
+        }
+    },
+
     list_coordinator_prompts: async (_ctx: LowFamilyContext, _args: any) => {
         const fs = await import('node:fs');
         const path = await import('node:path');

package/src/commands/med-family/mesh-crud.ts

@@ -480,6 +480,9 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
             const daemonId = typeof args?.daemonId === 'string' && args.daemonId.trim() ? args.daemonId.trim() : undefined;
             const machineId = typeof args?.machineId === 'string' && args.machineId.trim() ? args.machineId.trim() : undefined;
             const repoRoot = typeof args?.repoRoot === 'string' && args.repoRoot.trim() ? args.repoRoot.trim() : undefined;
+            const capabilities = Array.isArray(args?.capabilities)
+                ? args.capabilities.map((t: any) => typeof t === 'string' ? t.trim() : '').filter(Boolean)
+                : undefined;
             const node = addNode(meshId, {
                 workspace,
                 ...(repoRoot ? { repoRoot } : {}),
@@ -487,6 +490,7 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
                 ...(machineId ? { machineId } : {}),
                 ...(policy ? { policy } : {}),
                 ...(role ? { role } : {}),
+                ...(capabilities && capabilities.length ? { capabilities } : {}),
             });
             if (!node) return { success: false, error: 'Mesh not found' };
             // mesh_status hands back a coordinator-memory aggregate
@@ -543,6 +547,13 @@ export const meshCrudHandlers: Record<string, MedFamilyHandler> = {
             } else if (args?.systemPrompt === null) {
                 patch.systemPrompt = undefined;
             }
+            // Operator custom capability tags. An explicit (possibly empty) array
+            // replaces them; omitting the arg leaves existing tags untouched.
+            if (Array.isArray(args?.capabilities)) {
+                patch.capabilities = args.capabilities
+                    .map((t: any) => typeof t === 'string' ? t.trim() : '')
+                    .filter(Boolean);
+            }
             const node = updateNode(meshId, nodeId, patch as any);
             if (!node) return { success: false, error: 'Mesh node not found' };
             // Provider priority / systemPrompt changes don't touch

package/src/config/mesh-config.ts

@@ -570,6 +570,11 @@ export function updateNode(
     opts: {
         userOverrides?: Partial<RepoMeshNodeCapabilities>;
         policy?: RepoMeshNodePolicy;
+        /** Operator-defined custom capability tags used by mesh queue matching.
+         *  Passing an array replaces the node's custom tags (empty/whitespace
+         *  entries dropped, deduped); an empty result clears them. Omit to leave
+         *  the existing tags untouched. */
+        capabilities?: string[];
         worktreeBootstrap?: LocalMeshNodeEntry['worktreeBootstrap'];
         /** Per-node instruction surfaced in the coordinator prompt. Pass an
          *  empty string or undefined to clear it. */
@@ -610,6 +615,13 @@ export function updateNode(
         node.reportedDaemonBuildVersion = opts.reportedDaemonBuildVersion.trim();
     }
     if (opts.policy) node.policy = { ...node.policy, ...opts.policy };
+    if (Object.prototype.hasOwnProperty.call(opts, 'capabilities')) {
+        // Explicit replace: normalize (trim/dedup/drop-empties); an empty result
+        // clears the tags entirely so the field never persists as [].
+        const tags = normalizeCapabilityTags(opts.capabilities);
+        if (tags && tags.length) node.capabilities = tags;
+        else delete node.capabilities;
+    }
     if (opts.worktreeBootstrap) node.worktreeBootstrap = opts.worktreeBootstrap;
     if (Object.prototype.hasOwnProperty.call(opts, 'systemPrompt')) {
         // Honor explicit clears: { systemPrompt: undefined } drops the field.

package/src/mesh/contracts.ts

@@ -332,7 +332,12 @@ export function assertPendingMeshCoordinatorEventV2(raw: unknown, path = '$'): P
  * Decide whether a v2 pending event should be delivered to the given drainer.
  * Centralised so every drain implementation uses the same rule.
  *
- *   - 'broadcast': always delivered.
+ *   - 'broadcast': always delivered. NOTE: a terminal task event that reached the
+ *     queue as broadcast is an ownership leak (it belongs to its dispatching
+ *     coordinator). This pure helper does not have the drain-window
+ *     daemon-form/session matching semantics, so the terminal+broadcast
+ *     dispatchedBy filter is applied one layer up in the drainer (see
+ *     mesh-events-pending routeV2EventsForDrainer) where those semantics live.
  *   - 'system': never delivered to coordinators (system handler only).
  *   - 'unicast': delivered iff intendedFor matches drainer identity.
  *
@@ -367,6 +372,18 @@ const TERMINAL_TASK_EVENTS: ReadonlySet<string> = new Set([
   'refine:accepted',
 ]);
 
+/**
+ * True for a terminal task event (completion / stop / refine outcome). A terminal
+ * event belongs to exactly the coordinator that dispatched the task, so it must
+ * never fan out to sibling coordinators that did not dispatch it. Used by the
+ * emit-side stamp (to avoid downgrading an unaddressed terminal event to full
+ * broadcast) and by the drain-side filter (defense-in-depth for any terminal
+ * event that already reached the queue as broadcast).
+ */
+export function isTerminalTaskEvent(eventName: string): boolean {
+  return TERMINAL_TASK_EVENTS.has(eventName);
+}
+
 /**
  * Coordinator-addressed dispatch-plane alerts. `mesh:dispatch_blocked` is the
  * Fix (1) actionable dispatch-skip notification: it exists precisely to page the
@@ -445,9 +462,18 @@ export function coordinatorIdentityFromEmitFields(fields: {
  * returns undefined: the event stays a v1 (unstamped) event and is broadcast-
  * treated during rollout, exactly as before — no regression, no fabricated
  * identity. When the resolved scope is 'unicast' but no `intendedFor` is
- * available, the scope is downgraded to 'broadcast' so the stamp never violates
- * the "unicast requires intendedFor" contract (a terminal event that cannot be
- * addressed to its originator is safest delivered broadly, not dropped).
+ * available, the fallback depends on the event class:
+ *
+ *   - Terminal task events (completion / stop / refine outcome) MUST NOT be
+ *     broadcast to every coordinator — a completion belongs to the coordinator
+ *     that dispatched the task, and broadcasting it makes non-owner coordinators
+ *     (e.g. sibling MAGI coordinators that never dispatched this replica's task)
+ *     act on a completion that is not theirs (MAGI-REPLICA-COMPLETION-EVENT-LEAK).
+ *     For these we address the event to `dispatchedBy` (the dispatching
+ *     coordinator) and KEEP it unicast, so the stamp stays contract-valid and the
+ *     event reaches only its originating coordinator.
+ *   - Any other unicast event with no addressable target falls back to broadcast
+ *     (contract-valid, still delivered, never dropped) — unchanged.
  */
 export function buildPendingEventEmitStamp(opts: {
   eventName: string;
@@ -460,9 +486,18 @@ export function buildPendingEventEmitStamp(opts: {
   let scope: MeshEventScope = opts.scope ?? defaultScopeForEvent(opts.eventName);
   let intendedFor = opts.intendedFor;
   if (scope === 'unicast' && !intendedFor) {
-    // No addressable target for a unicast event — fall back to broadcast so the
-    // stamp is contract-valid and the event is still delivered (never dropped).
-    scope = 'broadcast';
+    if (isTerminalTaskEvent(opts.eventName)) {
+      // Terminal event with no explicit target: address it to the dispatching
+      // coordinator rather than broadcasting to every coordinator. dispatchedBy
+      // is the coordinator that owns the task, so this is the correct — and
+      // contract-valid (unicast requires intendedFor) — narrowing.
+      intendedFor = opts.dispatchedBy;
+    } else {
+      // No addressable target for a non-terminal unicast event — fall back to
+      // broadcast so the stamp is contract-valid and the event is still
+      // delivered (never dropped).
+      scope = 'broadcast';
+    }
   }
   if (scope !== 'unicast') intendedFor = undefined;
   return {

package/src/mesh/coordinator-prompt.ts

@@ -454,6 +454,23 @@ function buildNodeConfigSection(mesh: LocalMeshEntry): string {
             : [];
         const providerRolesSuffix = providerRoles.length ? ` | caps: ${providerRoles.join(', ')}` : '';
         lines.push(`- ${explicitLabel} nodeId: \`${n.id}\` | workspace: \`${n.workspace}\`${n.daemonId ? ` | daemon: \`${n.daemonId}\`` : ''}${providerPriority}${providerRolesSuffix}${suffix}`);
+        // Routing tags: what this node advertises for mesh_enqueue_task required_tags.
+        // Surfaced so the coordinator can route by-capability (e.g. enqueue a Windows
+        // build with required_tags:["os=win32"], or a custom "test-runner" node).
+        // os=/arch= use the same userOverrides → reported precedence as the matcher;
+        // the internal converge= tag is omitted (it is not something to target by hand).
+        const routingTags: string[] = [];
+        const custom = Array.isArray((n as any).capabilities) ? (n as any).capabilities : [];
+        for (const t of custom) { const s = typeof t === 'string' ? t.trim() : ''; if (s) routingTags.push(s); }
+        const tagOs = ((n as any).userOverrides?.platform || (n as any).reportedPlatform || '').toString().trim();
+        const tagArch = ((n as any).userOverrides?.arch || (n as any).reportedArch || '').toString().trim();
+        if (tagOs) routingTags.push(`os=${tagOs}`);
+        if (tagArch) routingTags.push(`arch=${tagArch}`);
+        const wtBranch = typeof (n as any).worktreeBranch === 'string' ? (n as any).worktreeBranch.trim() : '';
+        if (n.isLocalWorktree && wtBranch) routingTags.push(`worktree=${wtBranch}`);
+        if (routingTags.length) {
+            lines.push(`  🏷️ routing tags: ${routingTags.map(t => `\`${t}\``).join(', ')}`);
+        }
         const nodePrompt = typeof (n as any).systemPrompt === 'string' ? (n as any).systemPrompt.trim() : '';
         if (nodePrompt) {
             lines.push(`  📌 Node instruction: ${indentFollowing(nodePrompt, '     ')}`);
@@ -663,6 +680,7 @@ const WORKFLOW_SECTION = `## Orchestration Workflow
 3. **Queue / Delegate** — The Mesh uses an autonomous pull-based Work Queue:
    a. **General Tasks**: Enqueue tasks using \`mesh_enqueue_task\`. Idle node agents will automatically pull tasks from the queue and begin working.
    b. **Node Preparation**: Reuse an existing idle session on the correct node/provider before launching a new chat/session. Call \`mesh_launch_session\` only when no suitable session exists, when the user explicitly asks for a fresh provider/session, or when branch/worktree isolation requires it. If you need branch isolation for parallel work, call \`mesh_clone_node\` to create a worktree node first.
+   b1. **Keep a branch's work on its worktree (worktree affinity).** A worktree node is a durable per-branch workspace, not a one-task throwaway — implement, review, and fix for the same branch all belong on the SAME worktree, and it lives until its work is converged (merged/pushed) and it is cleaned up. So once you clone a worktree for a branch, route every subsequent \`code_change\`/\`validation\`/fix task for that branch back to that same node: pass \`required_tags: ["worktree=<branch>"]\` or \`target_node_id: <that worktree node's id>\`. **Where to get the node id / tag:** the \`mesh_clone_node\` result returns the new node's \`id\` and \`worktreeBranch\` directly — use them immediately. The Configured Nodes list in this prompt is a launch-time snapshot and will NOT list a worktree you cloned after this session started, so do not rely on it for freshly-cloned worktrees; take the id/branch from the \`mesh_clone_node\` result, or call \`mesh_status\` to re-list the live nodes (each worktree there advertises its \`worktree=<branch>\` tag). Do NOT leave same-branch follow-ups untargeted — an untargeted task is claimed by whichever node polls first (usually the base machine node), which strands the work off the branch's worktree. The ONE exception is a \`convergence\` task (merge/push): that is base-only and must NOT be pinned to the worktree.
    c. **Targeted Tasks**: Use \`mesh_send_task\` only when you need to bypass the queue and force a specific node to execute a task immediately.
    d. For the first dispatch of a new task, provide a **complete, self-contained** instruction that includes all context the agent needs (file paths, line numbers, what to change, why). Do not send partial instructions expecting future follow-up.
    e. For a continuation of the same issue in an existing session, send a concise **delta instruction**: current verified state, the exact failed/blocked step, the newly approved action, and final reporting requirements. Do not resend the full original task or open a new chat solely to continue the same work; that wastes coordinator and worker context.
@@ -718,6 +736,7 @@ function buildRulesSection(coordinatorCliType?: string): string {
 - **Route, don't implement.** Delegate all code reading, analysis, and execution to node agents. Never read source files or run commands in the coordinator — keep context lean.
 - **Front-load task messages.** Include everything the agent needs (files, problem, expected fix) in \`mesh_enqueue_task\` / \`mesh_send_task\`. Append a structured result request at the end: ask the worker to conclude with a JSON block containing \`status\`, \`changedFiles\`, \`gitStatus\`, \`validationResults\`, \`errors\`, \`nextAction\`. The daemon parses this automatically; you can read it from \`mesh_task_history\`.
 - **Reuse idle sessions.** For follow-up, retry, commit/push, or cleanup on the same issue, send only the delta to the existing idle session. Start fresh only for independent work, provider mismatch, transcript contamination, or required worktree isolation.
+- **Worktree affinity.** A worktree is a durable per-branch workspace; keep all of a branch's code_change/fix/review work on its worktree node by targeting \`required_tags: ["worktree=<branch>"]\` or \`target_node_id\`. Get the id/branch from the \`mesh_clone_node\` result or a live \`mesh_status\` — the Configured Nodes snapshot won't list a worktree cloned after launch. Untargeted same-branch follow-ups drift to the base node. Only \`convergence\` (merge/push) runs on the base, never pinned to the worktree.
 - **Respect explicit provider requests.** Map: Hermes → \`hermes-cli\`, Claude/Claude Code → \`claude-cli\`, Codex → \`codex-cli\`, Gemini → \`gemini-cli\`, Antigravity → \`antigravity-cli\`. Never substitute the coordinator's own runtime.
 - **Verify via git, not source.** Use \`mesh_git_status\` to confirm side effects. Treat agent summaries as self-reports, not verification.
 - **Limit parallelism.** Start with 1–2 tasks; scale only on success. Never duplicate a session because \`mesh_read_chat\` shows no final message while tool/terminal activity is ongoing. This caps *concurrent* load — it does not mean serialize independent work: when a new, independent request arrives and there is headroom under \`maxParallelTasks\`, dispatch it right away rather than waiting for an in-flight task or a user nudge (read-only diagnosis especially, since it has no merge cost).

package/src/mesh/mesh-events-pending.ts

@@ -14,6 +14,7 @@ import {
     coordinatorIdentityFromEmitFields,
     coordinatorIdentityKey,
     isMeshEventScope,
+    isTerminalTaskEvent,
     MESH_PROTOCOL_VERSION_V2,
     shouldDeliverPendingEventToCoordinator,
     type CoordinatorIdentity,
@@ -408,6 +409,25 @@ function routeV2EventsForDrainer(
         // Broadcast → any coordinator; system → daemon handler only (never a
         // coordinator). Delegates to the contract helper for those two scopes.
         if (validated.scope !== 'unicast') {
+            // Defense-in-depth (MAGI-REPLICA-COMPLETION-EVENT-LEAK): a TERMINAL task
+            // event that reached the queue as broadcast is an ownership leak — a
+            // completion/stop belongs to the coordinator that dispatched the task, so
+            // a sibling coordinator that never dispatched it must NOT act on it. The
+            // emit-side stamp now narrows unaddressed terminal events to unicast, but a
+            // legacy/version-skewed/other-path broadcast can still arrive here; filter
+            // it by dispatchedBy vs the drainer using the SAME daemon-form/session
+            // matching semantics as unicast (identityDeliversTo), so the true owner —
+            // possibly addressed under a different daemon-id form — still receives it.
+            if (validated.scope === 'broadcast' && isTerminalTaskEvent(validated.event)) {
+                if (identityDeliversTo(validated.dispatchedBy, drainer)) {
+                    ctx.batchSeen.add(eventId);
+                    bump('v2Delivered');
+                    kept.push(event);
+                } else {
+                    bump('v2RoutedAway');
+                }
+                continue;
+            }
             if (shouldDeliverPendingEventToCoordinator(validated, drainer)) {
                 ctx.batchSeen.add(eventId);
                 bump('v2Delivered');

package/src/repo-mesh-types.ts

@@ -527,7 +527,7 @@ const DIRTY_WORKSPACE_BEHAVIORS = new Set<RepoMeshPolicy['dirtyWorkspaceBehavior
 
 /** Min/max bounds for the global write-task parallel cap. */
 export const MESH_MAX_PARALLEL_TASKS_MIN = 1;
-export const MESH_MAX_PARALLEL_TASKS_MAX = 8;
+export const MESH_MAX_PARALLEL_TASKS_MAX = 64;
 
 /**
  * Default multiplier applied to the write cap to derive the read-only diagnosis