@kernel.chat/kbot 3.99.21 → 3.99.22

package/dist/critic-gate.d.ts

@@ -5,11 +5,14 @@
  * ~/.kbot/config.json: critic_enabled (bool), critic_strictness (0..1).
  * Hard disable: env KBOT_NO_CRITIC=1.
  */
+import { type RFClass } from './critic-taxonomy.js';
 export interface CriticVerdict {
     accept: boolean;
     reason?: string;
     retry_hint?: string;
     confidence: number;
+    /** RF taxonomy class when a rule-based classifier fired (arXiv:2601.22208). */
+    failure_class?: RFClass;
 }
 export interface GateOpts {
     strictness?: number;

package/dist/critic-gate.js

@@ -6,6 +6,7 @@
  * Hard disable: env KBOT_NO_CRITIC=1.
  */
 import { loadConfig } from './auth.js';
+import { classifyToolResult } from './critic-taxonomy.js';
 const TRUSTED_TOOLS = new Set([
     'read', 'read_file', 'kbot_read', 'kbot_read_file',
     'glob', 'kbot_glob', 'grep', 'kbot_grep', 'list_directory', 'ls',
@@ -166,13 +167,15 @@ export async function gateToolResult(tool, args, result, opts = {}) {
     if (isTriviallyValid(tool, resultText)) {
         return { accept: true, confidence: 0.9, reason: 'trivial-valid fast path' };
     }
-    // If result is empty, reject without calling LLM.
-    if (!resultText || resultText.trim().length === 0) {
+    // Rule-based RF classifier — cheap, no LLM. High-confidence hits short-circuit.
+    const rf = classifyToolResult(resultText);
+    if (rf && rf.confidence >= 0.8) {
         return {
             accept: false,
-            confidence: 0.9,
-            reason: 'empty tool result',
-            retry_hint: 'Tool produced no output. Try different arguments or a different tool.',
+            confidence: rf.confidence,
+            reason: `${rf.class}: ${rf.evidence}`,
+            retry_hint: 'Taxonomy match — try different arguments or a different tool.',
+            failure_class: rf.class,
         };
     }
     const userPrompt = buildUserPrompt(tool, args, resultText);

package/dist/critic-taxonomy.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Reasoning-failure taxonomy for the critic gate.
+ *
+ * Adopted verbatim from "Stalled, Biased, and Confused: Uncovering Reasoning
+ * Failures in LLMs for Cloud-Based Root Cause Analysis" (arXiv:2601.22208,
+ * 2026). 16 modes, evaluated across 48k simulated scenarios on ReAct and
+ * Plan-and-Execute workflows. The domain is cloud RCA but the modes generalize
+ * to tool-using agents.
+ *
+ * Purpose here: replace ad-hoc ERROR_KEYWORDS matching in critic-gate.ts with
+ * a typed classifier so that when the critic rejects a tool result we can
+ * attribute the rejection to a named class. Makes FP-rate measurement tractable
+ * per-class instead of in aggregate.
+ *
+ * This module is pure (no I/O, no LLM calls). Classification is rule-based and
+ * intentionally conservative — when nothing matches, returns null and the
+ * existing critic fallback handles it.
+ */
+export type RFClass = 'RF-01-fabricated-evidence' | 'RF-02-metric-interpretation' | 'RF-03-confused-provenance' | 'RF-04-temporal-misordering' | 'RF-05-spurious-causal-attribution' | 'RF-06-unjustified-instance-specificity' | 'RF-07-arbitrary-evidence-selection' | 'RF-08-evidential-insufficiency' | 'RF-09-failure-to-update-belief' | 'RF-10-simulation-role-confusion' | 'RF-11-excessive-speculation' | 'RF-12-repetition-failure-to-resume' | 'RF-13-anchoring-bias' | 'RF-14-invalid-inference-pattern' | 'RF-15-internal-contradiction' | 'RF-16-arithmetic-error';
+export interface RFClassification {
+    class: RFClass;
+    evidence: string;
+    confidence: number;
+}
+export interface TrajectoryStep {
+    tool: string;
+    args: Record<string, unknown>;
+    result: string;
+    timestampMs: number;
+}
+/** RF-12: trajectory-level — last N steps repeat the same tool+args. */
+export declare function detectRepetition(trajectory: TrajectoryStep[], windowSize?: number): RFClassification | null;
+/**
+ * Classify a single tool result against the RF taxonomy.
+ *
+ * Returns the highest-confidence match, or null if nothing fires. Callers
+ * should treat null as "no taxonomy signal" — not as "result is fine".
+ */
+export declare function classifyToolResult(result: string): RFClassification | null;
+//# sourceMappingURL=critic-taxonomy.d.ts.map

package/dist/critic-taxonomy.js

@@ -0,0 +1,146 @@
+/**
+ * Reasoning-failure taxonomy for the critic gate.
+ *
+ * Adopted verbatim from "Stalled, Biased, and Confused: Uncovering Reasoning
+ * Failures in LLMs for Cloud-Based Root Cause Analysis" (arXiv:2601.22208,
+ * 2026). 16 modes, evaluated across 48k simulated scenarios on ReAct and
+ * Plan-and-Execute workflows. The domain is cloud RCA but the modes generalize
+ * to tool-using agents.
+ *
+ * Purpose here: replace ad-hoc ERROR_KEYWORDS matching in critic-gate.ts with
+ * a typed classifier so that when the critic rejects a tool result we can
+ * attribute the rejection to a named class. Makes FP-rate measurement tractable
+ * per-class instead of in aggregate.
+ *
+ * This module is pure (no I/O, no LLM calls). Classification is rule-based and
+ * intentionally conservative — when nothing matches, returns null and the
+ * existing critic fallback handles it.
+ */
+const SPECULATION_MARKERS = [
+    'i think', 'probably', 'might be', 'could be', 'perhaps',
+    'it seems', 'i believe', 'likely', "i'm guessing", 'my guess',
+];
+const FABRICATION_MARKERS = [
+    'as an ai', 'i cannot actually', 'i don\'t have access', 'hypothetically',
+    'let\'s assume', 'for the sake of', 'imagine that',
+];
+const UNRESOLVED_ERROR_MARKERS = [
+    'enoent', 'permission denied', 'eacces', 'connection refused',
+    'timeout', 'econnrefused', 'not found',
+];
+function lower(s) {
+    return (s || '').toLowerCase();
+}
+/** RF-01: tool result contains hedging language presented as fact. */
+function detectFabrication(text) {
+    const lc = lower(text);
+    for (const m of FABRICATION_MARKERS) {
+        if (lc.includes(m)) {
+            return {
+                class: 'RF-01-fabricated-evidence',
+                evidence: `hedging marker "${m}" in tool result`,
+                confidence: 0.7,
+            };
+        }
+    }
+    return null;
+}
+/** RF-08: result is structurally empty or shorter than task demands. */
+function detectEvidentialInsufficiency(text) {
+    const trimmed = (text || '').trim();
+    if (trimmed.length === 0) {
+        return {
+            class: 'RF-08-evidential-insufficiency',
+            evidence: 'empty tool result',
+            confidence: 0.95,
+        };
+    }
+    if (trimmed.length < 16 && !/\d/.test(trimmed)) {
+        return {
+            class: 'RF-08-evidential-insufficiency',
+            evidence: `result is ${trimmed.length} chars with no numeric content`,
+            confidence: 0.55,
+        };
+    }
+    return null;
+}
+/** RF-11: speculation language in what should be a factual tool result. */
+function detectExcessiveSpeculation(text) {
+    const lc = lower(text);
+    const hits = SPECULATION_MARKERS.filter(m => lc.includes(m));
+    if (hits.length >= 2) {
+        return {
+            class: 'RF-11-excessive-speculation',
+            evidence: `speculation markers: ${hits.slice(0, 3).join(', ')}`,
+            confidence: 0.6,
+        };
+    }
+    return null;
+}
+/** RF-10: model output claims tool ran when the result text shows it did not. */
+function detectSimulationConfusion(text) {
+    const lc = lower(text);
+    const hasUnresolvedError = UNRESOLVED_ERROR_MARKERS.some(m => lc.includes(m));
+    const claimsSuccess = /\b(successfully|completed|done|finished)\b/.test(lc);
+    if (hasUnresolvedError && claimsSuccess) {
+        return {
+            class: 'RF-10-simulation-role-confusion',
+            evidence: 'result claims success and contains an error marker',
+            confidence: 0.85,
+        };
+    }
+    return null;
+}
+/** RF-15: internal contradiction — two opposing claims in one result. */
+function detectInternalContradiction(text) {
+    const lc = lower(text);
+    if (/\b(is|was|are)\s+\w+/.test(lc) && /\bis\s+not\b.*\bis\b/.test(lc)) {
+        return {
+            class: 'RF-15-internal-contradiction',
+            evidence: 'opposing "is"/"is not" claims within result',
+            confidence: 0.5,
+        };
+    }
+    return null;
+}
+/** RF-12: trajectory-level — last N steps repeat the same tool+args. */
+export function detectRepetition(trajectory, windowSize = 3) {
+    if (trajectory.length < windowSize)
+        return null;
+    const window = trajectory.slice(-windowSize);
+    const first = window[0];
+    const key = `${first.tool}:${JSON.stringify(first.args)}`;
+    const allSame = window.every(s => `${s.tool}:${JSON.stringify(s.args)}` === key);
+    if (allSame) {
+        return {
+            class: 'RF-12-repetition-failure-to-resume',
+            evidence: `${windowSize} consecutive identical calls to ${first.tool}`,
+            confidence: 0.9,
+        };
+    }
+    return null;
+}
+/**
+ * Classify a single tool result against the RF taxonomy.
+ *
+ * Returns the highest-confidence match, or null if nothing fires. Callers
+ * should treat null as "no taxonomy signal" — not as "result is fine".
+ */
+export function classifyToolResult(result) {
+    const detectors = [
+        detectSimulationConfusion,
+        detectFabrication,
+        detectEvidentialInsufficiency,
+        detectExcessiveSpeculation,
+        detectInternalContradiction,
+    ];
+    let best = null;
+    for (const d of detectors) {
+        const hit = d(result);
+        if (hit && (!best || hit.confidence > best.confidence)) {
+            best = hit;
+        }
+    }
+    return best;
+}
+//# sourceMappingURL=critic-taxonomy.js.map

package/dist/planner/hierarchical/dag.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Task-Decoupled Planning (TDP) — DAG node types.
+ *
+ * Adopted from "Beyond Entangled Planning: Task-Decoupled Planning for
+ * Long-Horizon Agents" (arXiv:2601.07577, 2026). The paper reports up to 82%
+ * token reduction by decomposing a task into a DAG of sub-goals, each executed
+ * under a context scoped to only that node's ancestors — not the full history.
+ *
+ * This module is types-only. Phase 2 of the hierarchical planner will wrap
+ * existing Phase nodes as DAG nodes; no runtime here.
+ *
+ * Scoping rule (paper §3.2): a DAG node's context window contains
+ *   - the node's own sub-goal + acceptance criteria
+ *   - outputs (summaries) of ancestor nodes only
+ *   - the typed tool schemas available for that node
+ * Non-ancestor siblings are excluded. Replanning fires only when the node's
+ * verifier rejects — never regenerates the whole trajectory.
+ */
+import type { Phase, Action, TierVerdict } from './types.js';
+/** Stable node identifier within a DAG. */
+export type NodeId = string;
+/**
+ * One node in the task DAG. In the kbot mapping, a `DAGNode` wraps a `Phase`
+ * and its child `Action`s, adding explicit parent edges and a scoped-context
+ * marker. Keeping `phase` as an embedded field means Phase 2 can migrate
+ * incrementally — tools that walk Phases still work.
+ */
+export interface DAGNode {
+    id: NodeId;
+    /** Parent node ids — the node's inputs. Empty for root. */
+    parents: NodeId[];
+    /** The wrapped Phase. Its `id` is duplicated here as the node id. */
+    phase: Phase;
+    /** Actions executed inside this node. */
+    actions: Action[];
+    /**
+     * Summary of the node's output, produced once status flips to done.
+     * This is what descendants see — not the full action trace.
+     */
+    outputSummary?: string;
+    /** Verdicts emitted against this node only. */
+    verdicts: TierVerdict[];
+    status: 'pending' | 'running' | 'done' | 'failed';
+}
+export interface TaskDAG {
+    /** Root node ids — usually one. */
+    roots: NodeId[];
+    nodes: Record<NodeId, DAGNode>;
+}
+/**
+ * Build the context a node sees during execution. Paper §3.2 calls this the
+ * "scoped context". Returns ancestor summaries plus the node's own sub-goal.
+ *
+ * Ordering: breadth-first from roots, so earlier context appears first in the
+ * prompt. The ancestor set is closed under the transitive parent relation.
+ */
+export declare function buildScopedContext(dag: TaskDAG, nodeId: NodeId): {
+    subGoal: string;
+    ancestorSummaries: Array<{
+        id: NodeId;
+        summary: string;
+    }>;
+};
+/**
+ * Topological order of `dag`. Throws on cycles — DAG invariant is caller's
+ * responsibility to maintain; this is the detector of last resort.
+ */
+export declare function topologicalOrder(dag: TaskDAG): NodeId[];
+/** Nodes whose parents are all done — eligible to run next. */
+export declare function readyNodes(dag: TaskDAG): DAGNode[];
+//# sourceMappingURL=dag.d.ts.map

package/dist/planner/hierarchical/dag.js

@@ -0,0 +1,97 @@
+/**
+ * Task-Decoupled Planning (TDP) — DAG node types.
+ *
+ * Adopted from "Beyond Entangled Planning: Task-Decoupled Planning for
+ * Long-Horizon Agents" (arXiv:2601.07577, 2026). The paper reports up to 82%
+ * token reduction by decomposing a task into a DAG of sub-goals, each executed
+ * under a context scoped to only that node's ancestors — not the full history.
+ *
+ * This module is types-only. Phase 2 of the hierarchical planner will wrap
+ * existing Phase nodes as DAG nodes; no runtime here.
+ *
+ * Scoping rule (paper §3.2): a DAG node's context window contains
+ *   - the node's own sub-goal + acceptance criteria
+ *   - outputs (summaries) of ancestor nodes only
+ *   - the typed tool schemas available for that node
+ * Non-ancestor siblings are excluded. Replanning fires only when the node's
+ * verifier rejects — never regenerates the whole trajectory.
+ */
+/**
+ * Build the context a node sees during execution. Paper §3.2 calls this the
+ * "scoped context". Returns ancestor summaries plus the node's own sub-goal.
+ *
+ * Ordering: breadth-first from roots, so earlier context appears first in the
+ * prompt. The ancestor set is closed under the transitive parent relation.
+ */
+export function buildScopedContext(dag, nodeId) {
+    const node = dag.nodes[nodeId];
+    if (!node) {
+        throw new Error(`buildScopedContext: node ${nodeId} not in DAG`);
+    }
+    const ancestors = collectAncestors(dag, nodeId);
+    const ancestorSummaries = [];
+    for (const aid of ancestors) {
+        const a = dag.nodes[aid];
+        if (a?.outputSummary) {
+            ancestorSummaries.push({ id: aid, summary: a.outputSummary });
+        }
+    }
+    return { subGoal: node.phase.objective, ancestorSummaries };
+}
+/** Transitive parents of `nodeId`, breadth-first, excluding the node itself. */
+function collectAncestors(dag, nodeId) {
+    const seen = new Set();
+    const order = [];
+    const queue = [...(dag.nodes[nodeId]?.parents ?? [])];
+    while (queue.length > 0) {
+        const next = queue.shift();
+        if (seen.has(next))
+            continue;
+        seen.add(next);
+        order.push(next);
+        const parent = dag.nodes[next];
+        if (parent)
+            queue.push(...parent.parents);
+    }
+    return order;
+}
+/**
+ * Topological order of `dag`. Throws on cycles — DAG invariant is caller's
+ * responsibility to maintain; this is the detector of last resort.
+ */
+export function topologicalOrder(dag) {
+    const inDegree = {};
+    for (const id of Object.keys(dag.nodes))
+        inDegree[id] = 0;
+    for (const node of Object.values(dag.nodes)) {
+        for (const _p of node.parents) {
+            inDegree[node.id] = (inDegree[node.id] ?? 0) + 1;
+        }
+    }
+    const ready = Object.keys(inDegree).filter(id => inDegree[id] === 0);
+    const out = [];
+    while (ready.length > 0) {
+        const id = ready.shift();
+        out.push(id);
+        for (const other of Object.values(dag.nodes)) {
+            if (other.parents.includes(id)) {
+                inDegree[other.id] -= 1;
+                if (inDegree[other.id] === 0)
+                    ready.push(other.id);
+            }
+        }
+    }
+    if (out.length !== Object.keys(dag.nodes).length) {
+        throw new Error('topologicalOrder: cycle detected in task DAG');
+    }
+    return out;
+}
+/** Nodes whose parents are all done — eligible to run next. */
+export function readyNodes(dag) {
+    return Object.values(dag.nodes).filter(n => {
+        if (n.status !== 'pending')
+            return false;
+        return n.parents.every(pid => dag.nodes[pid]?.status === 'done');
+    });
+}
+//# sourceMappingURL=dag.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kernel.chat/kbot",
-  "version": "3.99.21",
+  "version": "3.99.22",
   "description": "Open-source terminal AI agent. 787+ tools, 35 agents, 20 providers. Dreams, learns, watches your system. Controls your phone. Fully local, fully sovereign. MIT.",
   "type": "module",
   "repository": {