@cleocode/core 2026.6.12 → 2026.6.14

package/dist/tools/skill-agent-tool.d.ts

@@ -0,0 +1,108 @@
+/**
+ * `run_skill` agent tool — bridge the EXISTING SKILL.md loader to the agent loop
+ * (T11949 · M7 · epic T11456 · SG-TOOLS; replaces the cancelled T11869).
+ *
+ * T11869 ("adopt Pi's SKILL.md loader") is CANCELLED: CLEO ALREADY owns a native
+ * skill loader + dispatch path ({@link import('../skills/discovery.js')}'s
+ * `parseFrontmatter` / `discoverSkill` / `findSkill`, plus
+ * {@link import('../skills/dispatch.js')}'s `dispatchExplicit`). This tool does
+ * NOT rebuild any of that. It surfaces the SUBSET of skills the model may invoke —
+ * those whose frontmatter marks `invocable: true` — to the loop as a single
+ * `run_skill` tool. `run_skill`:
+ *
+ *   - resolves a skill BY NAME via the EXISTING {@link findSkill} (the same
+ *     filesystem scan + name-mapping the CLI uses);
+ *   - REJECTS a skill whose frontmatter is not `invocable: true` (a typed, non-
+ *     throwing failure result) — only explicitly-invocable skills are runnable;
+ *   - dispatches the resolved skill through the EXISTING
+ *     {@link dispatchExplicit} path and returns the skill's instructions
+ *     (`SKILL.md` body) + dispatch metadata for the loop to act on.
+ *
+ * No new loader, no new parser, no new dispatch mechanism — pure consumption of
+ * the skills subsystem (Gate-11: DEFINED here under `packages/core/src/tools`,
+ * CONSUMES the skills path). The tier-0 skill-drift gate + skill-coverage map are
+ * untouched — this is a consumer of the loader, not a change to it.
+ *
+ * ## Availability (always-true, daemon-OFF)
+ *
+ * Skill discovery is a LOCAL filesystem scan — no credential, no network, no
+ * daemon. `run_skill` is therefore {@link ALWAYS_AVAILABLE}.
+ *
+ * ## Gate-13
+ *
+ * No model/transport/provider client is constructed here — resolving + reading a
+ * SKILL.md is local I/O. There is no chokepoint concern.
+ *
+ * @epic T11456
+ * @task T11949
+ * @see ../skills/discovery.js — `findSkill` (the existing loader this tool reuses)
+ * @see ../skills/dispatch.js — `dispatchExplicit` (the existing dispatch path)
+ */
+import type { Skill } from '../skills/types.js';
+import { type AgentToolRegistry } from './agent-registry.js';
+/**
+ * The skills-subsystem seam {@link registerSkillAgentTool} resolves + dispatches a
+ * skill through. Each member has the SAME signature as the corresponding existing
+ * function. Injectable so the unit test can supply a fake skill surface (no real
+ * SKILL.md on disk); defaults to the real `discovery` / `dispatch` functions.
+ */
+export interface SkillResolver {
+    /** Resolve a skill by name (→ `findSkill`). Returns `null` when unknown. */
+    readonly findSkill: (name: string, cwd?: string) => Skill | null;
+    /**
+     * Dispatch an explicit skill (→ `dispatchExplicit`). Returns the dispatch
+     * metadata, or `null` when the skill does not resolve.
+     */
+    readonly dispatchExplicit: (skillName: string, cwd?: string) => {
+        skill: string;
+        strategy: string;
+        confidence: number;
+        protocol?: string;
+    } | null;
+}
+/** The shape `run_skill` returns to the loop — resolution outcome + payload. */
+export interface RunSkillResult {
+    /** Whether an invocable skill resolved and dispatched. */
+    readonly ok: boolean;
+    /** The resolved skill's canonical directory name (present on success). */
+    readonly skill?: string;
+    /** The dispatched protocol, when the skill declares one. */
+    readonly protocol?: string;
+    /** The `SKILL.md` body the loop acts on (present on success). */
+    readonly instructions?: string;
+    /** A stable code + message for why resolution failed (present on failure). */
+    readonly error?: {
+        readonly code: string;
+        readonly message: string;
+    };
+}
+/** Options for {@link registerSkillAgentTool} — all injectable for testing. */
+export interface SkillAgentToolOptions {
+    /** The skills-subsystem seam. Defaults to the real discovery + dispatch functions. */
+    readonly resolver?: SkillResolver;
+    /**
+     * The cwd skill discovery scans from (defaults to the resolved project root via
+     * {@link resolveOrCwd} — never a bare `process.cwd()` in core, T9584).
+     */
+    readonly cwd?: string;
+}
+/**
+ * Register the `run_skill` tool into `registry`. Pure registration — no skill is
+ * resolved, no SKILL.md is read here; all of that happens later inside the tool's
+ * `execute` through the injected (or lazily-resolved real) seam. Import-time
+ * side-effect-free.
+ *
+ * @param registry - The registry to populate.
+ * @param options - Injectable resolver / cwd (for testing).
+ */
+export declare function registerSkillAgentTool(registry: AgentToolRegistry, options?: SkillAgentToolOptions): void;
+/**
+ * Self-registration marker (AC1) — the identifier the
+ * {@link AgentToolRegistry.discover} bounded source scan greps for. Aliases
+ * {@link registerSkillAgentTool} so a future scan-dir discovery (or the built-in
+ * aggregator) can call it uniformly with the other agent-tool modules.
+ *
+ * @param registry - The registry to populate.
+ */
+export declare function registerAgentTools(registry: AgentToolRegistry): void;
+//# sourceMappingURL=skill-agent-tool.d.ts.map

package/dist/tools/skill-agent-tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-agent-tool.d.ts","sourceRoot":"","sources":["../../src/tools/skill-agent-tool.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AAIH,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAAE,KAAK,iBAAiB,EAAoB,MAAM,qBAAqB,CAAC;AAE/E;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC5B,4EAA4E;IAC5E,QAAQ,CAAC,SAAS,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,KAAK,KAAK,GAAG,IAAI,CAAC;IACjE;;;OAGG;IACH,QAAQ,CAAC,gBAAgB,EAAE,CACzB,SAAS,EAAE,MAAM,EACjB,GAAG,CAAC,EAAE,MAAM,KACT;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,IAAI,CAAC;CACxF;AAED,gFAAgF;AAChF,MAAM,WAAW,cAAc;IAC7B,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IACrB,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,iEAAiE;IACjE,QAAQ,CAAC,YAAY,CAAC,EAAE,MAAM,CAAC;IAC/B,8EAA8E;IAC9E,QAAQ,CAAC,KAAK,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAC;CACtE;AAED,+EAA+E;AAC/E,MAAM,WAAW,qBAAqB;IACpC,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,CAAC;CACvB;AA4BD;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,GAAE,qBAA0B,GAClC,IAAI,CAgDN;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,iBAAiB,GAAG,IAAI,CAEpE"}

package/dist/tools/skill-agent-tool.js

@@ -0,0 +1,135 @@
+/**
+ * `run_skill` agent tool — bridge the EXISTING SKILL.md loader to the agent loop
+ * (T11949 · M7 · epic T11456 · SG-TOOLS; replaces the cancelled T11869).
+ *
+ * T11869 ("adopt Pi's SKILL.md loader") is CANCELLED: CLEO ALREADY owns a native
+ * skill loader + dispatch path ({@link import('../skills/discovery.js')}'s
+ * `parseFrontmatter` / `discoverSkill` / `findSkill`, plus
+ * {@link import('../skills/dispatch.js')}'s `dispatchExplicit`). This tool does
+ * NOT rebuild any of that. It surfaces the SUBSET of skills the model may invoke —
+ * those whose frontmatter marks `invocable: true` — to the loop as a single
+ * `run_skill` tool. `run_skill`:
+ *
+ *   - resolves a skill BY NAME via the EXISTING {@link findSkill} (the same
+ *     filesystem scan + name-mapping the CLI uses);
+ *   - REJECTS a skill whose frontmatter is not `invocable: true` (a typed, non-
+ *     throwing failure result) — only explicitly-invocable skills are runnable;
+ *   - dispatches the resolved skill through the EXISTING
+ *     {@link dispatchExplicit} path and returns the skill's instructions
+ *     (`SKILL.md` body) + dispatch metadata for the loop to act on.
+ *
+ * No new loader, no new parser, no new dispatch mechanism — pure consumption of
+ * the skills subsystem (Gate-11: DEFINED here under `packages/core/src/tools`,
+ * CONSUMES the skills path). The tier-0 skill-drift gate + skill-coverage map are
+ * untouched — this is a consumer of the loader, not a change to it.
+ *
+ * ## Availability (always-true, daemon-OFF)
+ *
+ * Skill discovery is a LOCAL filesystem scan — no credential, no network, no
+ * daemon. `run_skill` is therefore {@link ALWAYS_AVAILABLE}.
+ *
+ * ## Gate-13
+ *
+ * No model/transport/provider client is constructed here — resolving + reading a
+ * SKILL.md is local I/O. There is no chokepoint concern.
+ *
+ * @epic T11456
+ * @task T11949
+ * @see ../skills/discovery.js — `findSkill` (the existing loader this tool reuses)
+ * @see ../skills/dispatch.js — `dispatchExplicit` (the existing dispatch path)
+ */
+import { z } from 'zod';
+import { resolveOrCwd } from '../paths.js';
+import { ALWAYS_AVAILABLE } from './agent-registry.js';
+/**
+ * Build the real skills-subsystem seam by lazily importing the existing
+ * `discovery` + `dispatch` modules. Lazy so this tool module is import-time
+ * side-effect-free (the skills modules run filesystem-touching telemetry on
+ * load); the import happens only when the real resolver is first needed.
+ *
+ * @returns The production {@link SkillResolver}.
+ */
+async function realResolver() {
+    const { findSkill } = await import('../skills/discovery.js');
+    const { dispatchExplicit } = await import('../skills/dispatch.js');
+    return {
+        findSkill,
+        dispatchExplicit: (skillName, cwd) => {
+            const result = dispatchExplicit(skillName, cwd);
+            if (result === null)
+                return null;
+            return {
+                skill: result.skill,
+                strategy: result.strategy,
+                confidence: result.confidence,
+                ...(result.protocol !== undefined ? { protocol: result.protocol } : {}),
+            };
+        },
+    };
+}
+/**
+ * Register the `run_skill` tool into `registry`. Pure registration — no skill is
+ * resolved, no SKILL.md is read here; all of that happens later inside the tool's
+ * `execute` through the injected (or lazily-resolved real) seam. Import-time
+ * side-effect-free.
+ *
+ * @param registry - The registry to populate.
+ * @param options - Injectable resolver / cwd (for testing).
+ */
+export function registerSkillAgentTool(registry, options = {}) {
+    const cwd = resolveOrCwd(options.cwd);
+    registry.register({
+        name: 'run_skill',
+        // 'shell' — invoking a skill is a procedure run (its strongest side-effect surface).
+        class: 'shell',
+        description: 'Resolve and run an invocable CLEO skill by name. Returns the skill instructions ' +
+            '(SKILL.md body) and dispatch metadata for the loop to act on. Only skills whose ' +
+            'frontmatter marks them invocable can be run.',
+        toolset: 'agent',
+        stateless: false,
+        available: ALWAYS_AVAILABLE,
+        parameters: z.object({
+            name: z.string().describe('The skill name to resolve and run (e.g. "ct-research-agent").'),
+        }),
+        execute: async (rawArgs) => {
+            const name = String(rawArgs.name);
+            const resolver = options.resolver ?? (await realResolver());
+            const skill = resolver.findSkill(name, cwd);
+            if (skill === null) {
+                return {
+                    ok: false,
+                    error: { code: 'E_SKILL_NOT_FOUND', message: `no skill named "${name}"` },
+                };
+            }
+            if (skill.frontmatter.invocable !== true) {
+                return {
+                    ok: false,
+                    error: {
+                        code: 'E_SKILL_NOT_INVOCABLE',
+                        message: `skill "${skill.dirName}" is not invocable (frontmatter.invocable !== true)`,
+                    },
+                };
+            }
+            // Dispatch through the EXISTING explicit-dispatch path (no new mechanism).
+            const dispatch = resolver.dispatchExplicit(name, cwd);
+            return {
+                ok: true,
+                skill: skill.dirName,
+                ...(dispatch?.protocol !== undefined ? { protocol: dispatch.protocol } : {}),
+                ...(skill.content !== undefined ? { instructions: skill.content } : {}),
+            };
+        },
+    });
+}
+/**
+ * Self-registration marker (AC1) — the identifier the
+ * {@link AgentToolRegistry.discover} bounded source scan greps for. Aliases
+ * {@link registerSkillAgentTool} so a future scan-dir discovery (or the built-in
+ * aggregator) can call it uniformly with the other agent-tool modules.
+ *
+ * @param registry - The registry to populate.
+ */
+export function registerAgentTools(registry) {
+    registerSkillAgentTool(registry);
+}
+//# sourceMappingURL=skill-agent-tool.js.map

package/dist/tools/skill-agent-tool.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-agent-tool.js","sourceRoot":"","sources":["../../src/tools/skill-agent-tool.ts"],"names":[],"mappings":"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"}

package/dist/tools/web-agent-tools.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Web + browser agent-tool FAMILY — registration (T1742 · epic T11456 · SG-TOOLS).
+ *
+ * Registers the `web` toolset into the {@link ./agent-registry.js |
+ * AgentToolRegistry}, on top of the terminal/file/search/git families
+ * ({@link ./agent-tool-families.js}):
+ *
+ *   - **AC1** `web_search` — pluggable, backend-agnostic search
+ *     ({@link ./web-search-backends.js}); graceful `unavailable` result when no
+ *     backend can answer. NO hard paid-API dependency.
+ *   - **AC2** `web_extract` — fetch a URL + convert HTML to markdown.
+ *   - **AC3** `browser_navigate` — Playwright (lazily, optionally loaded).
+ *   - **AC4** `browser_click` / `browser_type` / `browser_press`.
+ *   - **AC5** `browser_snapshot` — accessibility tree.
+ *   - **AC6** `browser_vision` — screenshot + AI analysis routed THROUGH the E9
+ *     `resolveLLMForSystem` chokepoint + sealed-credential handle (never a raw
+ *     provider call).
+ *   - **AC7** `browser_scroll` up / down.
+ *   - **AC8** all registered; the browser tools' `available()` returns `false`
+ *     (with an install hint) when Playwright is absent.
+ *
+ * Browser tools share ONE lazily-launched {@link BrowserSession} per registration
+ * (a closure cell), so the optional Playwright load happens at most once per run.
+ * The web tools' network egress flows through an injectable {@link HttpFetch}; the
+ * vision AI call flows through the single E9 chokepoint — neither bypasses the
+ * resolver / credential layer. Import-time side-effect-free (NO top-level
+ * playwright import).
+ *
+ * @epic T11456
+ * @task T1742
+ * @see ./browser-driver.js — the optional-Playwright lazy-load backend
+ * @see ./web-search-backends.js — the pluggable search backends + HTML→markdown
+ */
+import type { AgentToolRegistry } from './agent-registry.js';
+import { BrowserSession } from './browser-driver.js';
+import { type HttpFetch } from './web-search-backends.js';
+/**
+ * Options for {@link registerWebAgentTools} — all injectable so tests run with
+ * NO real network and NO real browser launch (AC9).
+ */
+export interface WebAgentToolOptions {
+    /** Injected HTTP fetch (defaults to the platform `fetch`). */
+    readonly http?: HttpFetch;
+    /** Injected browser session (defaults to a real lazy-Playwright session). */
+    readonly browser?: BrowserSession;
+    /**
+     * SearXNG instance URL for the `searxng` backend. When omitted, the SearXNG
+     * backend reports unconfigured and only DuckDuckGo answers — preserving the
+     * "graceful when unconfigured" contract (AC1). Read from `SEARXNG_URL` env when
+     * not supplied.
+     */
+    readonly searxngUrl?: string;
+    /**
+     * Project root threaded into the E9 `resolveLLMForSystem` chokepoint for
+     * `browser_vision` (defaults to the resolver's own `process.cwd()` fallback).
+     */
+    readonly projectRoot?: string;
+}
+/**
+ * Register the web + browser agent-tool family into `registry`. Pure
+ * registration — no network, no browser launch, no scan; side effects happen
+ * later through the injected {@link HttpFetch} / {@link BrowserSession}.
+ *
+ * The browser tools are registered with a `playwright`-gated availability
+ * predicate (AC8): present in the registry but hidden by `available()` until a
+ * context advertises the optional Playwright capability.
+ *
+ * @param registry - The registry to populate.
+ * @param options - Injectable backends (HTTP fetch, browser session, searxng URL).
+ */
+export declare function registerWebAgentTools(registry: AgentToolRegistry, options?: WebAgentToolOptions): void;
+//# sourceMappingURL=web-agent-tools.d.ts.map

package/dist/tools/web-agent-tools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web-agent-tools.d.ts","sourceRoot":"","sources":["../../src/tools/web-agent-tools.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AAWH,OAAO,KAAK,EAAE,iBAAiB,EAAqB,MAAM,qBAAqB,CAAC;AAChF,OAAO,EAAE,cAAc,EAA2B,MAAM,qBAAqB,CAAC;AAC9E,OAAO,EAGL,KAAK,SAAS,EAGf,MAAM,0BAA0B,CAAC;AAuBlC;;;GAGG;AACH,MAAM,WAAW,mBAAmB;IAClC,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAC1B,6EAA6E;IAC7E,QAAQ,CAAC,OAAO,CAAC,EAAE,cAAc,CAAC;IAClC;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,MAAM,CAAC;CAC/B;AA0FD;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,iBAAiB,EAC3B,OAAO,GAAE,mBAAwB,GAChC,IAAI,CAkRN"}