@kernel.chat/kbot 4.1.0 → 4.3.0

package/dist/adapters/agent-sdk/from-agent-sdk.d.ts

@@ -0,0 +1,28 @@
+import type { ToolDefinition } from '../../tools/index.js';
+import type { AgentSdkExecutableTool, AgentSdkTool } from './types.js';
+export interface FromAgentSdkOptions {
+    /** kbot tier to assign to the imported tool. Default 'free'. */
+    tier?: ToolDefinition['tier'];
+    /** Custom timeout (ms). */
+    timeout?: number;
+    /** Max result size (bytes). */
+    maxResultSize?: number;
+    /**
+     * Fallback executor when the source tool ships no handler. Useful when the
+     * caller routes execution elsewhere (e.g., back through the Anthropic SDK).
+     */
+    fallbackExecutor?: (toolName: string, args: Record<string, unknown>) => Promise<string> | string;
+}
+/**
+ * Convert a non-executable Agent SDK tool definition into a kbot ToolDefinition.
+ * Because the source has no handler, an executor must be supplied via opts.fallbackExecutor
+ * — otherwise the resulting tool will return a structured "no handler" error string when invoked.
+ */
+export declare function fromAgentSdkTool(tool: AgentSdkTool, opts?: FromAgentSdkOptions): ToolDefinition;
+/**
+ * Convert an executable Agent SDK tool (schema + handler) into a kbot ToolDefinition.
+ * Preferred over fromAgentSdkTool() when the caller has the implementation in process.
+ */
+export declare function fromAgentSdkExecutableTool(tool: AgentSdkExecutableTool, opts?: Omit<FromAgentSdkOptions, 'fallbackExecutor'>): ToolDefinition;
+export declare function fromAgentSdkTools(tools: AgentSdkTool[], opts?: FromAgentSdkOptions): ToolDefinition[];
+//# sourceMappingURL=from-agent-sdk.d.ts.map

package/dist/adapters/agent-sdk/from-agent-sdk.js

@@ -0,0 +1,107 @@
+// Anthropic Agent SDK tool → kbot ToolDefinition
+//
+// Lets a kbot host import third-party Agent SDK tools (or hand-written
+// schema/handler pairs) and register them in the kbot tool registry. Schema
+// is downconverted from JSON Schema to kbot's flatter parameter shape.
+//
+// Inverse of to-agent-sdk.ts. Round-trip is lossy in general (JSON Schema is
+// strictly richer than kbot's shape), but is stable for the param shapes
+// that kbot itself uses.
+const JSON_TO_KBOT = {
+    string: 'string',
+    number: 'number',
+    integer: 'integer',
+    boolean: 'boolean',
+    object: 'object',
+    array: 'array',
+    null: 'null',
+};
+function pickType(t) {
+    if (typeof t === 'string')
+        return JSON_TO_KBOT[t] ?? 'string';
+    if (Array.isArray(t)) {
+        // Pick the first non-null type to keep parity with kbot's single-type shape.
+        const first = t.find((x) => x !== 'null');
+        return first ? JSON_TO_KBOT[first] ?? 'string' : 'string';
+    }
+    return 'string';
+}
+function mapProperty(p, required) {
+    const out = {
+        type: pickType(p.type),
+        description: typeof p.description === 'string' ? p.description : '',
+        required,
+    };
+    if (p.default !== undefined)
+        out.default = p.default;
+    if (p.items !== undefined)
+        out.items = p.items;
+    if (p.properties)
+        out.properties = p.properties;
+    return out;
+}
+function buildParameters(schema) {
+    if (!schema || typeof schema !== 'object')
+        return {};
+    const required = new Set(schema.required ?? []);
+    const out = {};
+    for (const [name, prop] of Object.entries(schema.properties ?? {})) {
+        out[name] = mapProperty(prop, required.has(name));
+    }
+    return out;
+}
+/**
+ * Convert a non-executable Agent SDK tool definition into a kbot ToolDefinition.
+ * Because the source has no handler, an executor must be supplied via opts.fallbackExecutor
+ * — otherwise the resulting tool will return a structured "no handler" error string when invoked.
+ */
+export function fromAgentSdkTool(tool, opts = {}) {
+    const fallback = opts.fallbackExecutor;
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: buildParameters(tool.input_schema),
+        tier: opts.tier ?? 'free',
+        timeout: opts.timeout,
+        maxResultSize: opts.maxResultSize,
+        async execute(args) {
+            if (fallback) {
+                try {
+                    const result = await fallback(tool.name, args);
+                    return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+                }
+                catch (e) {
+                    return `Error: ${e.message}`;
+                }
+            }
+            return `Error: tool "${tool.name}" was imported without a handler. Provide opts.fallbackExecutor when calling fromAgentSdkTool().`;
+        },
+    };
+}
+/**
+ * Convert an executable Agent SDK tool (schema + handler) into a kbot ToolDefinition.
+ * Preferred over fromAgentSdkTool() when the caller has the implementation in process.
+ */
+export function fromAgentSdkExecutableTool(tool, opts = {}) {
+    return {
+        name: tool.name,
+        description: tool.description,
+        parameters: buildParameters(tool.input_schema),
+        tier: opts.tier ?? 'free',
+        timeout: opts.timeout,
+        maxResultSize: opts.maxResultSize,
+        async execute(args) {
+            try {
+                const result = await tool.handler(args);
+                return typeof result === 'string' ? result : JSON.stringify(result, null, 2);
+            }
+            catch (e) {
+                return `Error: ${e.message}`;
+            }
+        },
+    };
+}
+export function fromAgentSdkTools(tools, opts = {}) {
+    return tools.map((t) => fromAgentSdkTool(t, opts));
+}
+//# sourceMappingURL=from-agent-sdk.js.map

package/dist/adapters/agent-sdk/index.d.ts

@@ -0,0 +1,4 @@
+export type { AgentSdkTool, AgentSdkExecutableTool, AgentSdkInputSchema, JsonSchemaProperty, JsonSchemaType, } from './types.js';
+export { toAgentSdkTool, toAgentSdkTools, type ToAgentSdkOptions, } from './to-agent-sdk.js';
+export { fromAgentSdkTool, fromAgentSdkExecutableTool, fromAgentSdkTools, type FromAgentSdkOptions, } from './from-agent-sdk.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/adapters/agent-sdk/index.js

@@ -0,0 +1,14 @@
+// Anthropic Agent SDK adapter — bidirectional schema translation between
+// kbot's ToolDefinition surface and the Agent SDK / Messages API tool surface.
+//
+// kbot stays provider-agnostic — this adapter takes no runtime dependency
+// on @anthropic-ai/sdk. It only translates schemas and (for the from-side)
+// wraps optional executors. Round-trip kbot → Agent SDK → kbot is stable
+// for the parameter shapes kbot itself uses.
+//
+// Background: with the Anthropic Agent SDK opening to external developers
+// in May 2026, kbot tools can now be advertised to that ecosystem and
+// vice-versa — without coupling the registry to one provider's runtime.
+export { toAgentSdkTool, toAgentSdkTools, } from './to-agent-sdk.js';
+export { fromAgentSdkTool, fromAgentSdkExecutableTool, fromAgentSdkTools, } from './from-agent-sdk.js';
+//# sourceMappingURL=index.js.map

package/dist/adapters/agent-sdk/to-agent-sdk.d.ts

@@ -0,0 +1,13 @@
+import type { ToolDefinition } from '../../tools/index.js';
+import type { AgentSdkTool } from './types.js';
+export interface ToAgentSdkOptions {
+    /** If true (default), kbot tool names are passed through unchanged. */
+    preserveName?: boolean;
+    /** Optional rename hook. Wins over preserveName. */
+    renameTool?: (name: string) => string;
+    /** If true, pass `additionalProperties: false` on the input schema. Default true. */
+    strict?: boolean;
+}
+export declare function toAgentSdkTool(tool: ToolDefinition, opts?: ToAgentSdkOptions): AgentSdkTool;
+export declare function toAgentSdkTools(tools: ToolDefinition[], opts?: ToAgentSdkOptions): AgentSdkTool[];
+//# sourceMappingURL=to-agent-sdk.d.ts.map

package/dist/adapters/agent-sdk/to-agent-sdk.js

@@ -0,0 +1,73 @@
+// kbot ToolDefinition → Anthropic Agent SDK tool
+//
+// One-way schema translation. The Agent SDK delivers tool_use blocks and
+// expects the host to route them to a handler — that routing belongs in the
+// caller's agent loop, not in the adapter. This file only produces the
+// schema half so kbot tools can be advertised to the Agent SDK / Messages
+// API without taking a runtime dependency on @anthropic-ai/sdk.
+const KBOT_TYPE_TO_JSON = {
+    string: 'string',
+    number: 'number',
+    integer: 'integer',
+    boolean: 'boolean',
+    object: 'object',
+    array: 'array',
+    null: 'null',
+};
+function mapType(t) {
+    const lc = t.toLowerCase();
+    return KBOT_TYPE_TO_JSON[lc] ?? 'string';
+}
+function mapParameter(p) {
+    const out = {
+        type: mapType(p.type),
+        description: p.description,
+    };
+    if (p.default !== undefined)
+        out.default = p.default;
+    if (p.items)
+        out.items = p.items;
+    if (p.properties) {
+        const nested = {};
+        for (const [k, v] of Object.entries(p.properties)) {
+            // Best-effort: nested properties in kbot params are loosely typed.
+            const vv = v;
+            nested[k] = {
+                type: vv.type ? mapType(vv.type) : 'string',
+                description: vv.description ?? '',
+            };
+        }
+        out.properties = nested;
+    }
+    return out;
+}
+export function toAgentSdkTool(tool, opts = {}) {
+    const properties = {};
+    const required = [];
+    for (const [name, param] of Object.entries(tool.parameters)) {
+        properties[name] = mapParameter(param);
+        if (param.required)
+            required.push(name);
+    }
+    const input_schema = {
+        type: 'object',
+        properties,
+        additionalProperties: opts.strict === false ? true : false,
+    };
+    if (required.length > 0)
+        input_schema.required = required;
+    const name = opts.renameTool
+        ? opts.renameTool(tool.name)
+        : opts.preserveName === false
+            ? tool.name.replace(/[^A-Za-z0-9_-]/g, '_')
+            : tool.name;
+    return {
+        name,
+        description: tool.description,
+        input_schema,
+    };
+}
+export function toAgentSdkTools(tools, opts = {}) {
+    return tools.map((t) => toAgentSdkTool(t, opts));
+}
+//# sourceMappingURL=to-agent-sdk.js.map

package/dist/adapters/agent-sdk/types.d.ts

@@ -0,0 +1,41 @@
+export type JsonSchemaType = 'string' | 'number' | 'integer' | 'boolean' | 'object' | 'array' | 'null';
+export interface JsonSchemaProperty {
+    type?: JsonSchemaType | JsonSchemaType[];
+    description?: string;
+    enum?: unknown[];
+    items?: JsonSchemaProperty | Record<string, unknown>;
+    properties?: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    default?: unknown;
+    [k: string]: unknown;
+}
+export interface AgentSdkInputSchema {
+    type: 'object';
+    properties: Record<string, JsonSchemaProperty>;
+    required?: string[];
+    additionalProperties?: boolean;
+}
+/**
+ * The on-the-wire tool definition the Agent SDK and the Messages API both
+ * accept. Names are snake_case by convention; the SDK does not enforce.
+ */
+export interface AgentSdkTool {
+    name: string;
+    description: string;
+    input_schema: AgentSdkInputSchema;
+}
+/**
+ * Optional executable companion. The SDK delivers `tool_use` blocks; the
+ * caller is responsible for routing them to a handler. `AgentSdkExecutableTool`
+ * couples the schema with a handler so the from-adapter can hand back something
+ * the kbot registry can run.
+ */
+export interface AgentSdkExecutableTool extends AgentSdkTool {
+    /**
+     * Handler may return a string (passed through) or arbitrary JSON-serializable
+     * value (stringified by the adapter). Mirrors what real Agent SDK handlers
+     * return in practice.
+     */
+    handler: (input: Record<string, unknown>) => Promise<unknown> | unknown;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/adapters/agent-sdk/types.js

@@ -0,0 +1,9 @@
+// Anthropic Agent SDK tool surface — minimal type model.
+//
+// Mirrors the Tool shape used by @anthropic-ai/sdk and the Agent SDK
+// without taking a runtime dependency. kbot stays provider-agnostic;
+// this adapter only ever speaks JSON Schema and JSON.
+//
+// Reference: https://docs.anthropic.com/en/api/messages#tools
+export {};
+//# sourceMappingURL=types.js.map

package/dist/cli.js

@@ -56,6 +56,7 @@ async function main() {
         .option('--lite', 'Lightweight mode — skip heavy tools (auto-enabled on Replit)')
         .option('--safe', 'Confirm destructive operations')
         .option('--strict', 'Confirm ALL operations')
+        .option('--persona <id>', 'Scope tool access to a persona (researcher, coder, computer-use)')
         .option('--ollama-launch', 'Auto-configure for ollama launch (sets Ollama as provider)')
         .argument('[prompt...]', 'One-shot prompt')
         .helpOption('-h, --help', 'display help for command')
@@ -4369,7 +4370,7 @@ async function main() {
     }
     // Permission mode: autonomous by default, users opt-in to confirmations
     {
-        const { setPermissionMode } = await import('./permissions.js');
+        const { setPermissionMode, setActivePersona } = await import('./permissions.js');
         if (opts.yes) {
             // --yes / -y: skip all confirmations (for scripts & CI)
             setPermissionMode('permissive');
@@ -4384,6 +4385,19 @@ async function main() {
             // DEFAULT: permissive — kbot acts autonomously, no confirmation prompts
             setPermissionMode('permissive');
         }
+        // Persona scoping (v4.2.0). Optional. Falls back to env var.
+        const personaId = opts.persona || process.env.KBOT_PERSONA || null;
+        if (personaId) {
+            try {
+                setActivePersona(personaId);
+                if (!opts.quiet && !opts.pipe)
+                    printInfo(`Persona: ${personaId}`);
+            }
+            catch (err) {
+                printError(err.message);
+                process.exit(1);
+            }
+        }
     }
     // Register built-in agents (hacker, operator, dreamer) so --agent flag works
     registerBuiltinAgents();

package/dist/permissions.d.ts

@@ -1,4 +1,21 @@
+import { type Persona } from './futures/persona/index.js';
 export type PermissionMode = 'permissive' | 'normal' | 'strict';
+/**
+ * Set (or clear) the active persona by id. Pass null to disable persona checking.
+ * Throws if id is not found in PERSONA_REGISTRY.
+ *
+ * v4.2.0 wires the futures/persona substrate into the live permissions chain.
+ * When a persona is set, every checkPermission() call runs canInvoke() FIRST;
+ * if the persona denies, the tool is blocked before the destructive-op prompt.
+ */
+export declare function setActivePersona(id: string | null): void;
+/** Get the currently active persona, or null if none. */
+export declare function getActivePersona(): Persona | null;
+/**
+ * Check the active persona (if any) against a tool invocation.
+ * Returns the denial reason string if denied, or null if allowed (or no persona set).
+ */
+export declare function checkPersonaScope(toolName: string, args: Record<string, unknown>): string | null;
 /** Set the permission mode */
 export declare function setPermissionMode(mode: PermissionMode): void;
 /** Get the current permission mode */

package/dist/permissions.js

@@ -13,7 +13,46 @@
 //   'strict'      — confirm all file writes and tool calls
 import { createInterface } from 'node:readline';
 import chalk from 'chalk';
+import { canInvoke, PERSONA_REGISTRY, } from './futures/persona/index.js';
 let currentMode = 'normal';
+/** Active persona for this CLI run. null = no persona-scoping (default). */
+let activePersona = null;
+/**
+ * Set (or clear) the active persona by id. Pass null to disable persona checking.
+ * Throws if id is not found in PERSONA_REGISTRY.
+ *
+ * v4.2.0 wires the futures/persona substrate into the live permissions chain.
+ * When a persona is set, every checkPermission() call runs canInvoke() FIRST;
+ * if the persona denies, the tool is blocked before the destructive-op prompt.
+ */
+export function setActivePersona(id) {
+    if (id === null) {
+        activePersona = null;
+        return;
+    }
+    const persona = PERSONA_REGISTRY[id];
+    if (!persona) {
+        const known = Object.keys(PERSONA_REGISTRY).join(', ');
+        throw new Error(`unknown persona "${id}". Known personas: ${known}`);
+    }
+    activePersona = persona;
+}
+/** Get the currently active persona, or null if none. */
+export function getActivePersona() {
+    return activePersona;
+}
+/**
+ * Check the active persona (if any) against a tool invocation.
+ * Returns the denial reason string if denied, or null if allowed (or no persona set).
+ */
+export function checkPersonaScope(toolName, args) {
+    if (!activePersona)
+        return null;
+    const verdict = canInvoke(activePersona, toolName, args);
+    if (verdict.allowed)
+        return null;
+    return `Persona '${activePersona.id}' denies '${toolName}': ${verdict.reason ?? 'permission denied'}`;
+}
 /** Patterns that always require confirmation in normal mode */
 const DESTRUCTIVE_PATTERNS = [
     { pattern: /^git\s+push/i, reason: 'Pushes code to remote — visible to others' },
@@ -119,6 +158,15 @@ export async function confirmToolCall(toolName, args, reason) {
  * Used as middleware in the tool execution pipeline.
  */
 export async function checkPermission(toolName, args) {
+    // Persona check fires BEFORE the destructive-op prompt. If a persona is
+    // set and denies the tool, fail fast — no confirmation prompt, no retry.
+    const personaDenial = checkPersonaScope(toolName, args);
+    if (personaDenial) {
+        console.log();
+        console.log(`  ${chalk.red('✗')} ${personaDenial}`);
+        console.log();
+        return false;
+    }
     const reason = needsConfirmation(toolName, args);
     if (!reason)
         return true;

package/dist/tool-pipeline.js

@@ -11,6 +11,7 @@
 //   pipeline.use(metricsMiddleware(recordMetrics))
 //   pipeline.use(executionMiddleware(executeTool))
 //   await pipeline.execute(ctx)
+import { checkPersonaScope } from './permissions.js';
 export class ToolPipeline {
     middleware = [];
     /** Append middleware to the end of the pipeline */
@@ -56,6 +57,16 @@ export class ToolPipeline {
  */
 export function permissionMiddleware(checkPermission) {
     return async (ctx, next) => {
+        // v4.2.0: persona scope check fires BEFORE the destructive-op
+        // confirmation. A persona denial blocks the tool with a clear reason
+        // and is non-interactive — no prompt, no retry.
+        const personaDenial = checkPersonaScope(ctx.toolName, ctx.toolArgs);
+        if (personaDenial) {
+            ctx.aborted = true;
+            ctx.abortReason = personaDenial;
+            ctx.error = personaDenial;
+            return;
+        }
         const allowed = await checkPermission(ctx.toolName, ctx.toolArgs);
         if (!allowed) {
             ctx.aborted = true;

package/dist/tools/forecast-summary.d.ts

@@ -0,0 +1,25 @@
+import type { ToolDefinition } from './index.js';
+import { type GrowthMetrics } from './foundation-engines.js';
+import type { Horizon, Signal } from '../futures/forecast/types.js';
+interface HistoryRecord {
+    ts: number;
+    signals: Partial<Record<keyof GrowthMetrics, number>>;
+}
+/** Read history file. Skips malformed lines. Returns chronological order. */
+export declare function readHistory(path?: string): HistoryRecord[];
+/** Append a record, cap to MAX_HISTORY entries. Atomic via tmp + rename. */
+export declare function appendHistory(rec: HistoryRecord, path?: string): void;
+/**
+ * Convert a list of HistoryRecord into Signal[] keyed by metric name.
+ * Only emits metrics that appear in at least one record.
+ */
+export declare function buildSignals(history: HistoryRecord[]): Signal[];
+/** Run the full forecast pipeline, given a horizon and an optional clock. */
+export declare function runForecastSummary(opts?: {
+    horizon?: Horizon;
+    now?: number;
+    metricsOverride?: GrowthMetrics | null;
+}): string;
+export declare const forecastSummaryTool: ToolDefinition;
+export {};
+//# sourceMappingURL=forecast-summary.d.ts.map

package/dist/tools/forecast-summary.js

@@ -0,0 +1,204 @@
+// forecast-summary — wires the v5 futures/forecast substrate into a kbot tool.
+//
+// Reads kbot's current growth metrics (the same surface growth_summary
+// produces), persists a rolling-window JSONL history at
+// ~/.kbot/growth/history.jsonl, and projects each metric forward via
+// synthesizeForecasts(). Returns markdown narrative + structured JSON.
+//
+// First substrate-to-product hop for the v4.2 forecast module. Opt-in only;
+// does NOT modify growth_summary.
+import { readFileSync, writeFileSync, mkdirSync, existsSync, renameSync } from 'node:fs';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { loadGrowth } from './foundation-engines.js';
+import { synthesizeForecasts, narrative } from '../futures/forecast/index.js';
+import { clampHorizon, signalHistory, } from '../futures/forecast/projection.js';
+const HORIZONS = new Set(['1d', '7d', '30d', '90d']);
+const MAX_HISTORY = 90;
+const MIN_SAMPLES = 5;
+/** Override for tests; falls back to ~/.kbot/growth. */
+function historyDir() {
+    return process.env.KBOT_GROWTH_HISTORY_DIR ?? join(homedir(), '.kbot', 'growth');
+}
+function historyPath() {
+    return join(historyDir(), 'history.jsonl');
+}
+/** Read history file. Skips malformed lines. Returns chronological order. */
+export function readHistory(path = historyPath()) {
+    if (!existsSync(path))
+        return [];
+    const out = [];
+    for (const line of readFileSync(path, 'utf8').split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            const rec = JSON.parse(trimmed);
+            if (typeof rec.ts === 'number' && rec.signals && typeof rec.signals === 'object') {
+                out.push(rec);
+            }
+        }
+        catch {
+            // skip malformed
+        }
+    }
+    out.sort((a, b) => a.ts - b.ts);
+    return out;
+}
+/** Append a record, cap to MAX_HISTORY entries. Atomic via tmp + rename. */
+export function appendHistory(rec, path = historyPath()) {
+    const dir = path.substring(0, path.lastIndexOf('/'));
+    mkdirSync(dir, { recursive: true });
+    const existing = readHistory(path);
+    existing.push(rec);
+    // Keep only the last MAX_HISTORY records
+    const kept = existing.slice(-MAX_HISTORY);
+    const body = kept.map((r) => JSON.stringify(r)).join('\n') + '\n';
+    const tmp = `${path}.tmp-${process.pid}-${Date.now()}`;
+    writeFileSync(tmp, body, 'utf8');
+    renameSync(tmp, path);
+}
+/**
+ * Convert a list of HistoryRecord into Signal[] keyed by metric name.
+ * Only emits metrics that appear in at least one record.
+ */
+export function buildSignals(history) {
+    const byMetric = new Map();
+    for (const rec of history) {
+        for (const [name, v] of Object.entries(rec.signals)) {
+            if (typeof v !== 'number' || !Number.isFinite(v))
+                continue;
+            const arr = byMetric.get(name) ?? [];
+            arr.push({ ts: rec.ts, value: v });
+            byMetric.set(name, arr);
+        }
+    }
+    return [...byMetric.entries()].map(([name, values]) => ({ name, values }));
+}
+/** Read current growth metrics. Used to capture a fresh sample. */
+function currentMetrics() {
+    const g = loadGrowth();
+    if (!g)
+        return null;
+    return { ...g.metrics };
+}
+function pickMetricsForHistory(m) {
+    // Persist every metric — the tool decides what to project at read time.
+    return {
+        npmDownloads: m.npmDownloads,
+        githubStars: m.githubStars,
+        totalUsers: m.totalUsers,
+        totalMessages: m.totalMessages,
+        totalStreams: m.totalStreams,
+        totalStreamMinutes: m.totalStreamMinutes,
+        toolsBuilt: m.toolsBuilt,
+        factsLearned: m.factsLearned,
+        dreamsDreamed: m.dreamsDreamed,
+        techniquesDiscovered: m.techniquesDiscovered,
+        worldBlocksPlaced: m.worldBlocksPlaced,
+        versionsShipped: m.versionsShipped,
+    };
+}
+function bootstrapMessage(sample) {
+    return [
+        `# forecast_summary — bootstrapping`,
+        ``,
+        `forecast_summary needs at least ${MIN_SAMPLES} historical samples to project.`,
+        `This is sample ${sample} of ${MIN_SAMPLES}. Re-run periodically to seed the history.`,
+        ``,
+        `History path: \`${historyPath()}\``,
+    ].join('\n');
+}
+function markdownTable(forecasts) {
+    if (forecasts.length === 0)
+        return '';
+    const lines = [];
+    lines.push('| signal | direction | point | range | confidence | method |');
+    lines.push('|---|---|---|---|---|---|');
+    for (const f of forecasts) {
+        const dir = f.trend.kind === 'flat' ? 'flat' : f.trend.slope > 0 ? 'up' : 'down';
+        const point = formatNum(f.pointEstimate);
+        const range = `${formatNum(f.lowerBound)} – ${formatNum(f.upperBound)}`;
+        const conf = `${(f.confidence * 100).toFixed(0)}%`;
+        lines.push(`| ${f.signal} | ${dir} | ${point} | ${range} | ${conf} | ${f.method} |`);
+    }
+    return lines.join('\n');
+}
+function formatNum(n) {
+    if (!Number.isFinite(n))
+        return '—';
+    const abs = Math.abs(n);
+    if (abs >= 1_000_000)
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    if (abs >= 1_000)
+        return `${(n / 1_000).toFixed(1)}k`;
+    if (abs >= 10)
+        return n.toFixed(0);
+    if (abs >= 1)
+        return n.toFixed(1);
+    return n.toFixed(2);
+}
+/** Run the full forecast pipeline, given a horizon and an optional clock. */
+export function runForecastSummary(opts = {}) {
+    const horizon = opts.horizon && HORIZONS.has(opts.horizon) ? opts.horizon : '30d';
+    const now = opts.now ?? Date.now();
+    const metrics = opts.metricsOverride === undefined ? currentMetrics() : opts.metricsOverride;
+    const path = historyPath();
+    // Capture a new sample if we have growth metrics to sample from.
+    if (metrics) {
+        appendHistory({ ts: now, signals: pickMetricsForHistory(metrics) }, path);
+    }
+    const history = readHistory(path);
+    if (history.length < MIN_SAMPLES) {
+        return bootstrapMessage(history.length);
+    }
+    const allSignals = buildSignals(history);
+    // Identify signals too short for the requested horizon → skip + note.
+    const skipped = [];
+    const usable = [];
+    for (const sig of allSignals) {
+        if (clampHorizon(horizon, signalHistory(sig))) {
+            usable.push(sig);
+        }
+        else {
+            skipped.push(sig.name);
+        }
+    }
+    const forecasts = synthesizeForecasts(usable, horizon);
+    const summary = narrative(forecasts);
+    const md = [];
+    md.push(`# forecast_summary — horizon ${horizon}`);
+    md.push('');
+    md.push(summary);
+    md.push('');
+    if (forecasts.length > 0) {
+        md.push(markdownTable(forecasts));
+        md.push('');
+    }
+    if (skipped.length > 0) {
+        md.push(`> Skipped (history shorter than ${horizon}): ${skipped.join(', ')}`);
+        md.push('');
+    }
+    md.push('```json');
+    md.push(JSON.stringify({ horizon, forecasts, skipped, samples: history.length }, null, 2));
+    md.push('```');
+    return md.join('\n');
+}
+export const forecastSummaryTool = {
+    name: 'forecast_summary',
+    description: 'Project kbot growth signals (npm downloads, GitHub stars, users, etc.) forward at the given horizon. Wraps the futures/forecast substrate. Returns a markdown narrative + structured JSON. Opt-in; does not run automatically.',
+    parameters: {
+        horizon: {
+            type: 'string',
+            description: 'Projection horizon: 1d, 7d, 30d, or 90d (default 30d).',
+            required: false,
+        },
+    },
+    tier: 'free',
+    async execute(args) {
+        const raw = typeof args.horizon === 'string' ? args.horizon : '30d';
+        const horizon = HORIZONS.has(raw) ? raw : '30d';
+        return runForecastSummary({ horizon });
+    },
+};
+//# sourceMappingURL=forecast-summary.js.map