@drakon-systems/multi-clawd 1.0.0

package/dist/chain-audit.js

@@ -0,0 +1,202 @@
+import { isModernClaudeModelId } from "./models.js";
+export function maskSessionKey(key) {
+    const segs = key.split(":");
+    const last = segs[segs.length - 1];
+    const looksLikeId = /^\d{5,}$/.test(last) || /^[0-9a-f]{6,}(-[0-9a-f]+)*$/i.test(last);
+    if (!looksLikeId)
+        return key;
+    const tail = last.length >= 4 ? last.slice(-4) : last;
+    segs[segs.length - 1] = `…${tail}`;
+    return segs.join(":");
+}
+const CLAUDE_SHORT_ALIASES = new Set(["opus", "sonnet", "haiku"]);
+const ACCOUNT_PIN_RE = /^claw\d+$/;
+export function isClaudeModelId(modelId) {
+    const id = modelId.trim();
+    if (!id)
+        return false;
+    if (CLAUDE_SHORT_ALIASES.has(id))
+        return true;
+    if (/^(opus|sonnet|haiku)-/.test(id))
+        return true;
+    return isModernClaudeModelId(id);
+}
+function parseRef(ref) {
+    const idx = ref.indexOf("/");
+    if (idx < 0)
+        return { modelId: ref };
+    return { provider: ref.slice(0, idx), modelId: ref.slice(idx + 1) };
+}
+export function offPoolClaudeRef(ref, poolId) {
+    if (typeof ref !== "string" || ref.length === 0)
+        return null;
+    const { provider, modelId } = parseRef(ref);
+    if (!isClaudeModelId(modelId))
+        return null;
+    if (provider === undefined)
+        return null;
+    if (provider === poolId)
+        return null;
+    if (provider === "anthropic" || provider === "claude-cli")
+        return "strong";
+    if (ACCOUNT_PIN_RE.test(provider))
+        return "warn";
+    return null;
+}
+function classifyBypass(ref, poolId) {
+    const severity = offPoolClaudeRef(ref, poolId);
+    if (!severity)
+        return null;
+    const { provider } = parseRef(ref);
+    if (provider === "anthropic") {
+        return `routes direct to the Anthropic API/native, bypassing the ${poolId} pool — no cross-account failover`;
+    }
+    if (provider === "claude-cli") {
+        return `routes direct to the claude CLI, bypassing the ${poolId} pool — no cross-account failover`;
+    }
+    return `pins a single pool account; cross-account failover won't fire — use ${poolId}/ for the pool`;
+}
+function extractModelRefs(surface, value) {
+    if (typeof value === "string")
+        return [{ surface, ref: value }];
+    if (value && typeof value === "object") {
+        const out = [];
+        const v = value;
+        if (typeof v.primary === "string")
+            out.push({ surface: `${surface}.primary`, ref: v.primary });
+        if (Array.isArray(v.fallbacks)) {
+            v.fallbacks.forEach((f, i) => {
+                if (typeof f === "string")
+                    out.push({ surface: `${surface}.fallbacks[${i}]`, ref: f });
+            });
+        }
+        return out;
+    }
+    return [];
+}
+function collectCronRefs(surface, node, depth, out) {
+    if (!node || depth > 4)
+        return;
+    if (Array.isArray(node)) {
+        node.forEach((item, i) => collectCronRefs(`${surface}[${i}]`, item, depth + 1, out));
+        return;
+    }
+    if (typeof node !== "object")
+        return;
+    const obj = node;
+    if ("model" in obj) {
+        for (const r of extractModelRefs(`${surface}.model`, obj.model)) {
+            out.push({ ...r, allowlist: false });
+        }
+    }
+    for (const [k, v] of Object.entries(obj)) {
+        if (k === "model")
+            continue;
+        if (v && typeof v === "object")
+            collectCronRefs(`${surface}.${k}`, v, depth + 1, out);
+    }
+}
+const RESERVED_AGENT_KEYS = new Set(["defaults", "list", "models"]);
+function collectChainRefs(config) {
+    const out = [];
+    const push = (surface, value) => {
+        for (const r of extractModelRefs(surface, value))
+            out.push({ ...r, allowlist: false });
+    };
+    const cfg = (config ?? {});
+    const agents = (cfg.agents ?? {});
+    const defaults = (agents.defaults ?? {});
+    push("agents.defaults.model", defaults.model);
+    const subagents = (defaults.subagents ?? {});
+    if (subagents.model !== undefined)
+        push("agents.defaults.subagents.model", subagents.model);
+    for (const [k, v] of Object.entries(subagents)) {
+        if (k === "model")
+            continue;
+        if (v && typeof v === "object" && "model" in v) {
+            push(`agents.defaults.subagents.${k}.model`, v.model);
+        }
+    }
+    for (const [name, v] of Object.entries(agents)) {
+        if (RESERVED_AGENT_KEYS.has(name))
+            continue;
+        if (!v || typeof v !== "object")
+            continue;
+        const agent = v;
+        if ("model" in agent)
+            push(`agents.${name}.model`, agent.model);
+        if ("cron" in agent)
+            collectCronRefs(`agents.${name}.cron`, agent.cron, 0, out);
+    }
+    if (Array.isArray(agents.list)) {
+        agents.list.forEach((a, i) => {
+            if (!a || typeof a !== "object")
+                return;
+            const agent = a;
+            const label = typeof agent.id === "string" ? agent.id : String(i);
+            if ("model" in agent)
+                push(`agents.list[${label}].model`, agent.model);
+            if ("cron" in agent)
+                collectCronRefs(`agents.list[${label}].cron`, agent.cron, 0, out);
+        });
+    }
+    for (const section of ["crons", "schedules", "jobs", "scheduled"]) {
+        if (cfg[section] !== undefined)
+            collectCronRefs(section, cfg[section], 0, out);
+    }
+    const allowlist = defaults.models;
+    if (allowlist && typeof allowlist === "object") {
+        for (const key of Object.keys(allowlist)) {
+            out.push({ surface: `agents.defaults.models["${key}"]`, ref: key, allowlist: true });
+        }
+    }
+    return out;
+}
+export function auditEffectiveChain(config, poolId) {
+    if (!poolId)
+        return [];
+    const findings = [];
+    for (const { surface, ref, allowlist } of collectChainRefs(config)) {
+        const reason = classifyBypass(ref, poolId);
+        if (!reason)
+            continue;
+        findings.push({ surface, ref, severity: allowlist ? "note" : "warn", reason });
+    }
+    return findings;
+}
+const POOL_PROVIDER = "clawd";
+export function auditSessionOverrides(sessions, poolConfigured) {
+    if (!poolConfigured)
+        return [];
+    const findings = [];
+    for (const [sessionKey, entry] of Object.entries(sessions ?? {})) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        if (/:subagent:/.test(sessionKey))
+            continue;
+        const source = entry.modelOverrideSource;
+        if (typeof source !== "string" || source === "auto")
+            continue;
+        const provider = entry.providerOverride ?? entry.modelProvider;
+        const model = entry.modelOverride;
+        if (!provider || !model) {
+            const missing = !provider && !model ? "provider and model" : !provider ? "provider" : "model";
+            findings.push({
+                surface: `session ${sessionKey}`,
+                ref: `${provider ?? "?"}/${model ?? "?"}`,
+                severity: "warn",
+                reason: `session override present (source=${source}) but ${missing} field missing — schema drift, cannot verify pool routing`,
+            });
+            continue;
+        }
+        const ref = `${provider}/${model}`;
+        const severity = offPoolClaudeRef(ref, POOL_PROVIDER);
+        if (!severity)
+            continue;
+        const reason = severity === "strong"
+            ? `off-pool /model pin — routes direct to ${provider}, bypassing the ${POOL_PROVIDER} pool; no cross-account failover`
+            : `/model pin to a single pool account (${provider}); cross-account failover won't fire — use ${POOL_PROVIDER}/ for the pool`;
+        findings.push({ surface: `session ${sessionKey}`, ref, severity: "warn", reason });
+    }
+    return findings;
+}

package/dist/degrade.js

@@ -0,0 +1,32 @@
+export function decideDegradation(params) {
+    const { verdicts, requestedModel, ladder } = params;
+    if (ladder.length === 0)
+        return undefined;
+    if (ladder.includes(requestedModel))
+        return undefined;
+    const allExhausted = verdicts.length > 0 && verdicts.every((v) => v.verdict === "exhausted");
+    if (!allExhausted)
+        return undefined;
+    return {
+        model: ladder[0],
+        reason: `pool exhausted for ${requestedModel}`,
+    };
+}
+export function matchesPin(pins, launch) {
+    return pins.some((pin) => {
+        const checks = [];
+        if (pin.agentDirIncludes)
+            checks.push(launch.agentDir.includes(pin.agentDirIncludes));
+        if (pin.workspaceDirIncludes)
+            checks.push(launch.workspaceDir.includes(pin.workspaceDirIncludes));
+        return checks.length > 0 && checks.every(Boolean);
+    });
+}
+export function rewriteModelArg(argv, model) {
+    const out = [...argv];
+    for (let i = 0; i < out.length - 1; i += 1) {
+        if (out[i] === "--model")
+            out[i + 1] = model;
+    }
+    return out;
+}

package/dist/exec-policy.js

@@ -0,0 +1,15 @@
+export function resolveExecMode(config) {
+    if (typeof config !== "object" || config === null)
+        return undefined;
+    const tools = config.tools;
+    if (typeof tools !== "object" || tools === null)
+        return undefined;
+    const exec = tools.exec;
+    if (typeof exec !== "object" || exec === null)
+        return undefined;
+    const mode = exec.mode;
+    return typeof mode === "string" ? mode : undefined;
+}
+export function permissionModeArgs(execMode) {
+    return execMode === "full" ? ["--permission-mode", "bypassPermissions"] : [];
+}

package/dist/health.js

@@ -0,0 +1,83 @@
+import { modelWindowKey } from "./shim-core.js";
+const DEFAULT_UTILIZATION_THRESHOLD = 0.85;
+const DEFAULT_STALE_AFTER_MS = 6 * 60 * 60 * 1000;
+export const MODEL_REJECTED_TTL_MS = 60 * 60 * 1000;
+const MODEL_WINDOW_PREFIX = "model:";
+export const MAX_RESET_HORIZON_MS = 8 * 24 * 60 * 60 * 1000;
+export function classifyAccountHealth(state, options, nowMs, requestedModel) {
+    const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_AFTER_MS;
+    const threshold = options.utilizationThreshold ?? DEFAULT_UTILIZATION_THRESHOLD;
+    if (!state)
+        return { verdict: "no_data" };
+    const requestedWindowKey = requestedModel !== undefined ? modelWindowKey(requestedModel) : undefined;
+    let worst = { verdict: "ok" };
+    let hasLiveEvidence = false;
+    for (const [window, w] of Object.entries(state.windows)) {
+        const resetMs = typeof w.resetsAt === "number" ? w.resetsAt * 1000 : undefined;
+        const resetBearing = resetMs !== undefined && resetMs > nowMs;
+        if (resetBearing && nowMs - w.seenAt > MAX_RESET_HORIZON_MS) {
+            console.warn(`[multi-clawd] health: window ${window} on ${state.accountId} exceeded 8d ` +
+                `reset-horizon cap (resetsAt=${new Date(resetMs).toISOString()}) — ` +
+                `possible clock skew / resetsAt parse bug`);
+            continue;
+        }
+        if (window.startsWith(MODEL_WINDOW_PREFIX)) {
+            const modelFresh = resetBearing || nowMs - w.seenAt <= MODEL_REJECTED_TTL_MS;
+            if (!modelFresh)
+                continue;
+            hasLiveEvidence = true;
+            const canonicalWindow = modelWindowKey(window.slice(MODEL_WINDOW_PREFIX.length));
+            if (!requestedWindowKey || canonicalWindow !== requestedWindowKey)
+                continue;
+            if (w.status !== "rejected")
+                continue;
+            if (resetMs !== undefined) {
+                if (resetMs > nowMs) {
+                    return {
+                        verdict: "exhausted",
+                        resumeAt: resetMs,
+                        reason: `${requestedModel} limit rejected until ${new Date(resetMs).toISOString()}`,
+                    };
+                }
+                continue;
+            }
+            return {
+                verdict: "exhausted",
+                resumeAt: w.seenAt + MODEL_REJECTED_TTL_MS,
+                reason: `${requestedModel} limit hit ${Math.round((nowMs - w.seenAt) / 60000)}m ago (no reset time; TTL block)`,
+            };
+        }
+        const fresh = resetBearing || nowMs - w.seenAt <= staleAfterMs;
+        if (!fresh)
+            continue;
+        hasLiveEvidence = true;
+        if (w.status === "rejected" && resetBearing) {
+            return {
+                verdict: "exhausted",
+                resumeAt: resetMs,
+                reason: `${window} rejected until ${new Date(resetMs).toISOString()}`,
+            };
+        }
+        if (worst.verdict === "ok" &&
+            typeof w.utilization === "number" &&
+            w.utilization >= threshold &&
+            (resetBearing || resetMs === undefined)) {
+            worst = {
+                verdict: "near_limit",
+                reason: `${window} utilization ${w.utilization} >= ${threshold}`,
+            };
+        }
+    }
+    if (worst.verdict === "ok" && !hasLiveEvidence)
+        return { verdict: "no_data" };
+    return worst;
+}
+export function choosePoolAccount(pool) {
+    const usable = pool.find((a) => a.verdict === "ok" || a.verdict === "no_data");
+    if (usable)
+        return usable.id;
+    return pool.find((a) => a.verdict === "near_limit")?.id;
+}
+export function pickPoolAccountForLaunch(pool) {
+    return choosePoolAccount(pool) ?? pool[0].id;
+}