qlogicagent 2.13.5 → 2.13.7

package/dist/skills/tools/checkpoint-tool.d.ts

@@ -1,66 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const CHECKPOINT_TOOL_NAME: "checkpoint";
-export type CheckpointAction = "create" | "list" | "restore" | "diff";
-export interface CheckpointToolParams {
-    action: CheckpointAction;
-    /** Checkpoint ID (for restore/diff) */
-    checkpointId?: string;
-    /** Optional message for create */
-    message?: string;
-    /** File paths to restore (partial restore). If empty, restores all. */
-    paths?: string[];
-}
-export declare const CHECKPOINT_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["create", "list", "restore", "diff"];
-            readonly description: string;
-        };
-        readonly checkpointId: {
-            readonly type: "string";
-            readonly description: "Checkpoint ID. Required for restore and diff.";
-        };
-        readonly message: {
-            readonly type: "string";
-            readonly description: "Optional descriptive message for the checkpoint.";
-        };
-        readonly paths: {
-            readonly type: "array";
-            readonly items: {
-                readonly type: "string";
-            };
-            readonly description: "File paths to restore (partial restore). Omit to restore everything.";
-        };
-    };
-    readonly required: readonly ["action"];
-};
-export interface Checkpoint {
-    id: string;
-    message: string;
-    timestamp: string;
-    fileCount: number;
-}
-export interface CheckpointResult {
-    success: boolean;
-    checkpoint?: Checkpoint;
-    checkpoints?: Checkpoint[];
-    diff?: string;
-    error?: string;
-}
-/**
- * Host-provided checkpoint backend.
- * Uses shadow git repos (isolated from user project) for snapshots.
- */
-export interface CheckpointToolDeps {
-    /** Create a snapshot of the current workspace state */
-    createCheckpoint(message?: string): Promise<CheckpointResult>;
-    /** List all available checkpoints */
-    listCheckpoints(): Promise<CheckpointResult>;
-    /** Restore workspace to a checkpoint state (optionally partial) */
-    restoreCheckpoint(checkpointId: string, paths?: string[]): Promise<CheckpointResult>;
-    /** Show diff between current state and a checkpoint */
-    diffCheckpoint(checkpointId: string): Promise<CheckpointResult>;
-}
-export declare function createCheckpointTool(deps: CheckpointToolDeps): PortableTool<CheckpointToolParams>;

package/dist/skills/tools/checkpoint-tool.js

@@ -1,102 +0,0 @@
-// ============================================================
-// Checkpoint Manager — transparent file history snapshots.
-// Reference: hermes-agent-main/tools/checkpoint_manager.py
-// Category: infrastructure (LLM does NOT directly invoke)
-// ============================================================
-export const CHECKPOINT_TOOL_NAME = "checkpoint";
-export const CHECKPOINT_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["create", "list", "restore", "diff"],
-            description: "Action: create (snapshot current state), list (show checkpoints), " +
-                "restore (revert to checkpoint), diff (show changes since checkpoint).",
-        },
-        checkpointId: {
-            type: "string",
-            description: "Checkpoint ID. Required for restore and diff.",
-        },
-        message: {
-            type: "string",
-            description: "Optional descriptive message for the checkpoint.",
-        },
-        paths: {
-            type: "array",
-            items: { type: "string" },
-            description: "File paths to restore (partial restore). Omit to restore everything.",
-        },
-    },
-    required: ["action"],
-};
-const COMMIT_HASH_PATTERN = /^[0-9a-fA-F]{4,64}$/;
-export function createCheckpointTool(deps) {
-    return {
-        name: CHECKPOINT_TOOL_NAME,
-        label: "Checkpoint",
-        description: "Manage workspace checkpoints (shadow snapshots independent of user's git). " +
-            "Create snapshots before risky operations, list history, restore on errors, " +
-            "or diff to see what changed. Checkpoints do NOT affect user's .git.",
-        parameters: CHECKPOINT_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "create": {
-                    const r = await deps.createCheckpoint(params.message);
-                    if (!r.success) {
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "checkpoint", error: r.error } };
-                    }
-                    return {
-                        content: [{ type: "text", text: `Checkpoint created: ${r.checkpoint.id}\nMessage: ${r.checkpoint.message}\nFiles: ${r.checkpoint.fileCount}` }],
-                        details: { type: "checkpoint", action: "create", checkpointId: r.checkpoint.id },
-                    };
-                }
-                case "list": {
-                    const r = await deps.listCheckpoints();
-                    if (!r.checkpoints || r.checkpoints.length === 0) {
-                        return { content: [{ type: "text", text: "No checkpoints available." }], details: { type: "checkpoint", action: "list", count: 0 } };
-                    }
-                    const lines = [`Checkpoints (${r.checkpoints.length}):`, ""];
-                    for (const cp of r.checkpoints) {
-                        lines.push(`- ${cp.id.slice(0, 8)} [${cp.timestamp}] ${cp.message} (${cp.fileCount} files)`);
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "checkpoint", action: "list", count: r.checkpoints.length } };
-                }
-                case "restore": {
-                    if (!params.checkpointId) {
-                        return { content: [{ type: "text", text: "Error: checkpointId required for restore." }], details: { type: "checkpoint", error: "missing_id" } };
-                    }
-                    if (!COMMIT_HASH_PATTERN.test(params.checkpointId)) {
-                        return { content: [{ type: "text", text: "Error: invalid checkpoint ID format." }], details: { type: "checkpoint", error: "invalid_id" } };
-                    }
-                    const r = await deps.restoreCheckpoint(params.checkpointId, params.paths);
-                    if (!r.success) {
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "checkpoint", error: r.error } };
-                    }
-                    const scope = params.paths ? `(${params.paths.length} files)` : "(full workspace)";
-                    return {
-                        content: [{ type: "text", text: `Restored to checkpoint ${params.checkpointId.slice(0, 8)} ${scope}` }],
-                        details: { type: "checkpoint", action: "restore", checkpointId: params.checkpointId },
-                    };
-                }
-                case "diff": {
-                    if (!params.checkpointId) {
-                        return { content: [{ type: "text", text: "Error: checkpointId required for diff." }], details: { type: "checkpoint", error: "missing_id" } };
-                    }
-                    if (!COMMIT_HASH_PATTERN.test(params.checkpointId)) {
-                        return { content: [{ type: "text", text: "Error: invalid checkpoint ID format." }], details: { type: "checkpoint", error: "invalid_id" } };
-                    }
-                    const r = await deps.diffCheckpoint(params.checkpointId);
-                    if (!r.success) {
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "checkpoint", error: r.error } };
-                    }
-                    return {
-                        content: [{ type: "text", text: r.diff || "(no changes since checkpoint)" }],
-                        details: { type: "checkpoint", action: "diff", checkpointId: params.checkpointId },
-                    };
-                }
-                default:
-                    return { content: [{ type: "text", text: `Error: unknown action "${params.action}".` }], details: { type: "checkpoint", error: "unknown_action" } };
-            }
-        },
-    };
-}

package/dist/skills/tools/config-tool.d.ts

@@ -1,61 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const CONFIG_TOOL_NAME: "config";
-export type ConfigAction = "get" | "set" | "list" | "reset";
-export interface ConfigToolParams {
-    /** Config action */
-    action: ConfigAction;
-    /** Setting key path (e.g. "model", "language", "theme") */
-    key?: string;
-    /** Value to set (for 'set' action) */
-    value?: string | boolean | number;
-}
-export declare const CONFIG_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["get", "set", "list", "reset"];
-            readonly description: string;
-        };
-        readonly key: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly value: {
-            readonly description: "Value to set. Type must match the tunable (numeric strings are coerced). Required for 'set'.";
-        };
-    };
-    readonly required: readonly ["action"];
-};
-export interface ConfigSetting {
-    key: string;
-    value: unknown;
-    type: "string" | "boolean" | "number" | "enum";
-    description: string;
-    options?: string[];
-    readOnly?: boolean;
-}
-export interface ConfigResult {
-    success: boolean;
-    setting?: ConfigSetting;
-    settings?: ConfigSetting[];
-    previousValue?: unknown;
-    error?: string;
-}
-/**
- * Host-provided config backend.
- * Manages persistent agent settings with safety guardrails.
- */
-export interface ConfigToolDeps {
-    /** Get a single config value */
-    getConfig(key: string): Promise<ConfigResult>;
-    /** Set a config value (respects readonly/whitelist) */
-    setConfig(key: string, value: unknown): Promise<ConfigResult>;
-    /** List all available config settings */
-    listConfig(): Promise<ConfigResult>;
-    /** Reset a setting to default */
-    resetConfig(key: string): Promise<ConfigResult>;
-    /** Check if a key is supported/valid */
-    isValidKey?(key: string): boolean;
-}
-export declare function createConfigTool(deps: ConfigToolDeps): PortableTool<ConfigToolParams>;

package/dist/skills/tools/config-tool.js

@@ -1,123 +0,0 @@
-// ============================================================
-// Config Tool — agent configuration management (read/write preferences).
-// Reference: claude-code-haha/src/tools/ConfigTool/ConfigTool.ts
-// Category: system
-// ============================================================
-export const CONFIG_TOOL_NAME = "config";
-export const CONFIG_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["get", "set", "list", "reset"],
-            description: "Action:\n" +
-                "- get: Read one tunable (current value + whether it is overridden)\n" +
-                "- set: Override a tunable (persists and takes effect immediately)\n" +
-                "- list: List ALL tunables with current values\n" +
-                "- reset: Remove an override (falls back to the built-in default)",
-        },
-        key: {
-            type: "string",
-            description: "Tunable key (e.g. 'defaultMaxRounds', 'defaultTemperature', 'defaultToolBudget', " +
-                "'defaultContextWindowTokens', 'teamBudgetTokens'). Use action='list' for the full set. " +
-                "Required for get/set/reset.",
-        },
-        value: {
-            description: "Value to set. Type must match the tunable (numeric strings are coerced). Required for 'set'.",
-        },
-    },
-    required: ["action"],
-};
-export function createConfigTool(deps) {
-    return {
-        name: CONFIG_TOOL_NAME,
-        label: "Config",
-        description: "Read and tune the agent's runtime parameters (tunables): max tool rounds, temperature, " +
-            "tool budget, context window, retry/compression behavior, team budget, etc. " +
-            "Overrides persist to settings and take effect immediately (values are re-read per use — no restart). " +
-            "Secret-like values are masked when read. Use action='list' to see every key.",
-        parameters: CONFIG_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "get": {
-                    if (!params.key) {
-                        return { content: [{ type: "text", text: "Error: key is required for get." }], details: { type: "config", error: "missing_key" } };
-                    }
-                    if (deps.isValidKey && !deps.isValidKey(params.key)) {
-                        return { content: [{ type: "text", text: `Error: unknown config key "${params.key}". Use action='list' to see available settings.` }], details: { type: "config", error: "unknown_key" } };
-                    }
-                    const result = await deps.getConfig(params.key);
-                    if (!result.success) {
-                        return { content: [{ type: "text", text: `Error: ${result.error}` }], details: { type: "config", error: result.error } };
-                    }
-                    const s = result.setting;
-                    const lines = [
-                        `${s.key} = ${JSON.stringify(s.value)}`,
-                        `  Type: ${s.type}${s.options ? ` (${s.options.join(" | ")})` : ""}`,
-                        `  ${s.description}`,
-                    ];
-                    if (s.readOnly)
-                        lines.push("  ⚠️ Read-only (cannot be changed)");
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "config", action: "get", key: params.key, value: s.value },
-                    };
-                }
-                case "set": {
-                    if (!params.key) {
-                        return { content: [{ type: "text", text: "Error: key is required for set." }], details: { type: "config", error: "missing_key" } };
-                    }
-                    if (params.value === undefined) {
-                        return { content: [{ type: "text", text: "Error: value is required for set." }], details: { type: "config", error: "missing_value" } };
-                    }
-                    if (deps.isValidKey && !deps.isValidKey(params.key)) {
-                        return { content: [{ type: "text", text: `Error: unknown config key "${params.key}".` }], details: { type: "config", error: "unknown_key" } };
-                    }
-                    const result = await deps.setConfig(params.key, params.value);
-                    if (!result.success) {
-                        return { content: [{ type: "text", text: `Error: ${result.error}` }], details: { type: "config", error: result.error } };
-                    }
-                    return {
-                        content: [{ type: "text", text: `Updated "${params.key}": ${JSON.stringify(result.previousValue)} → ${JSON.stringify(params.value)}` }],
-                        details: { type: "config", action: "set", key: params.key, previousValue: result.previousValue, newValue: params.value },
-                    };
-                }
-                case "list": {
-                    const result = await deps.listConfig();
-                    if (!result.settings || result.settings.length === 0) {
-                        return { content: [{ type: "text", text: "No config settings available." }], details: { type: "config", action: "list", count: 0 } };
-                    }
-                    const lines = [`Available settings (${result.settings.length}):`, ""];
-                    for (const s of result.settings) {
-                        const ro = s.readOnly ? " [read-only]" : "";
-                        const val = JSON.stringify(s.value);
-                        lines.push(`  ${s.key} = ${val}${ro}`);
-                        lines.push(`    ${s.description}`);
-                    }
-                    return {
-                        content: [{ type: "text", text: lines.join("\n") }],
-                        details: { type: "config", action: "list", count: result.settings.length },
-                    };
-                }
-                case "reset": {
-                    if (!params.key) {
-                        return { content: [{ type: "text", text: "Error: key is required for reset." }], details: { type: "config", error: "missing_key" } };
-                    }
-                    const result = await deps.resetConfig(params.key);
-                    if (!result.success) {
-                        return { content: [{ type: "text", text: `Error: ${result.error}` }], details: { type: "config", error: result.error } };
-                    }
-                    return {
-                        content: [{ type: "text", text: `Reset "${params.key}" to default: ${JSON.stringify(result.setting?.value)}` }],
-                        details: { type: "config", action: "reset", key: params.key, value: result.setting?.value },
-                    };
-                }
-                default:
-                    return {
-                        content: [{ type: "text", text: `Error: unknown action "${params.action}".` }],
-                        details: { type: "config", error: "unknown_action" },
-                    };
-            }
-        },
-    };
-}

package/dist/skills/tools/cron-tool.d.ts

@@ -1,96 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const CRON_TOOL_NAME: "cron";
-export type CronAction = "create" | "list" | "get" | "update" | "delete" | "pause" | "resume" | "trigger";
-export interface CronToolParams {
-    action: CronAction;
-    /** Job ID (required for get/update/delete/pause/resume/trigger) */
-    jobId?: string;
-    /** Task prompt to execute on schedule */
-    prompt?: string;
-    /** Cron expression or shorthand ('5m', '1h', '0 9 * * *') */
-    schedule?: string;
-    /** Human-readable job name */
-    name?: string;
-    /** Whether the job is enabled */
-    enabled?: boolean;
-}
-export declare const CRON_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly action: {
-            readonly type: "string";
-            readonly enum: readonly ["create", "list", "get", "update", "delete", "pause", "resume", "trigger"];
-            readonly description: "Workflow-backed action: create/list/get/update/delete/pause/resume/trigger.";
-        };
-        readonly jobId: {
-            readonly type: "string";
-            readonly description: "Job ID. Required for get/update/delete/pause/resume/trigger.";
-        };
-        readonly prompt: {
-            readonly type: "string";
-            readonly description: "Task prompt to execute on schedule. Required for create.";
-        };
-        readonly schedule: {
-            readonly type: "string";
-            readonly description: string;
-        };
-        readonly name: {
-            readonly type: "string";
-            readonly description: "Human-readable job name.";
-        };
-        readonly enabled: {
-            readonly type: "boolean";
-            readonly description: "Whether the job is enabled (for update).";
-        };
-    };
-    readonly required: readonly ["action"];
-};
-export interface CronJob {
-    id: string;
-    name: string;
-    prompt: string;
-    schedule: string;
-    scheduleDisplay: string;
-    state: "scheduled" | "paused";
-    enabled: boolean;
-    nextRunAt?: string;
-    lastRunAt?: string;
-    lastStatus?: "success" | "error" | null;
-}
-export interface CronResult {
-    success: boolean;
-    job?: CronJob;
-    jobs?: CronJob[];
-    error?: string;
-}
-/**
- * Host-provided cron scheduler backend.
- * Jobs are persisted locally and survive restarts.
- */
-export interface CronToolDeps {
-    createJob(params: {
-        prompt: string;
-        schedule: string;
-        name?: string;
-        repeat?: number | null;
-        allowedTools?: string[];
-    }): Promise<CronResult>;
-    listJobs(): Promise<CronResult>;
-    getJob(jobId: string): Promise<CronResult>;
-    updateJob(jobId: string, updates: Partial<{
-        prompt: string;
-        schedule: string;
-        name: string;
-        enabled: boolean;
-        repeat: number | null;
-        allowedTools: string[];
-    }>): Promise<CronResult>;
-    deleteJob(jobId: string): Promise<CronResult>;
-    pauseJob(jobId: string): Promise<CronResult>;
-    resumeJob(jobId: string): Promise<CronResult>;
-    triggerJob(jobId: string): Promise<CronResult>;
-    /** Validate cron schedule expression. Returns error or null. */
-    validateSchedule?(schedule: string): string | null;
-}
-export declare const MAX_CRON_JOBS = 50;
-export declare function createCronTool(deps: CronToolDeps): PortableTool<CronToolParams>;

package/dist/skills/tools/cron-tool.js

@@ -1,165 +0,0 @@
-// ============================================================
-// Cron Tool — scheduled task management (CRUD).
-// Reference: hermes-agent-main/tools/cronjob_tools.py
-// Category: system
-// ============================================================
-export const CRON_TOOL_NAME = "cron";
-export const CRON_TOOL_SCHEMA = {
-    type: "object",
-    properties: {
-        action: {
-            type: "string",
-            enum: ["create", "list", "get", "update", "delete", "pause", "resume", "trigger"],
-            description: "Workflow-backed action: create/list/get/update/delete/pause/resume/trigger.",
-        },
-        jobId: {
-            type: "string",
-            description: "Job ID. Required for get/update/delete/pause/resume/trigger.",
-        },
-        prompt: {
-            type: "string",
-            description: "Task prompt to execute on schedule. Required for create.",
-        },
-        schedule: {
-            type: "string",
-            description: "Schedule expression for the unified workflow scheduler. Supports cron " +
-                "('0 9 * * *') and shorthand ('5m', '1h', '1d'). Required for create.",
-        },
-        name: {
-            type: "string",
-            description: "Human-readable job name.",
-        },
-        enabled: {
-            type: "boolean",
-            description: "Whether the job is enabled (for update).",
-        },
-    },
-    required: ["action"],
-};
-export const MAX_CRON_JOBS = 50;
-export function createCronTool(deps) {
-    return {
-        name: CRON_TOOL_NAME,
-        label: "Cron",
-        description: "Thin entry point for scheduled workflows. Create recurring agent workflows with cron " +
-            "expressions or shorthand ('5m', '1h', '0 9 * * *'). Jobs persist in .qlogicagent/workflows. " +
-            "Actions: create, list, get, update, delete, pause, resume, trigger (run now).",
-        parameters: CRON_TOOL_SCHEMA,
-        execute: async (_toolCallId, params) => {
-            switch (params.action) {
-                case "create": {
-                    const legacy = params;
-                    if (!params.prompt) {
-                        return { content: [{ type: "text", text: "Error: prompt is required for create." }], details: { type: "cron", error: "missing_prompt" } };
-                    }
-                    if (!params.schedule) {
-                        return { content: [{ type: "text", text: "Error: schedule is required for create." }], details: { type: "cron", error: "missing_schedule" } };
-                    }
-                    if (deps.validateSchedule) {
-                        const err = deps.validateSchedule(params.schedule);
-                        if (err)
-                            return { content: [{ type: "text", text: `Error: invalid schedule — ${err}` }], details: { type: "cron", error: "invalid_schedule" } };
-                    }
-                    // Check max jobs limit
-                    const existing = await deps.listJobs();
-                    if (existing.jobs && existing.jobs.length >= MAX_CRON_JOBS) {
-                        return { content: [{ type: "text", text: `Error: maximum ${MAX_CRON_JOBS} jobs reached. Delete unused jobs first.` }], details: { type: "cron", error: "max_jobs_reached" } };
-                    }
-                    const r = await deps.createJob({ prompt: params.prompt, schedule: params.schedule, name: params.name, repeat: legacy.repeat, allowedTools: legacy.allowedTools });
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: formatJob(r.job) }], details: { type: "cron", action: "create", jobId: r.job.id } };
-                }
-                case "list": {
-                    const r = await deps.listJobs();
-                    if (!r.jobs || r.jobs.length === 0) {
-                        return { content: [{ type: "text", text: "No scheduled jobs." }], details: { type: "cron", action: "list", count: 0 } };
-                    }
-                    const lines = [`Scheduled jobs (${r.jobs.length}):`, ""];
-                    for (const j of r.jobs) {
-                        lines.push(`- **${j.name || j.id}** [${j.state}] ${j.scheduleDisplay} — next: ${j.nextRunAt || "N/A"}`);
-                    }
-                    return { content: [{ type: "text", text: lines.join("\n") }], details: { type: "cron", action: "list", count: r.jobs.length } };
-                }
-                case "get": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.getJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: formatJob(r.job) }], details: { type: "cron", action: "get", jobId: params.jobId } };
-                }
-                case "update": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const legacy = params;
-                    const updates = {};
-                    if (params.prompt !== undefined)
-                        updates.prompt = params.prompt;
-                    if (params.schedule !== undefined)
-                        updates.schedule = params.schedule;
-                    if (params.name !== undefined)
-                        updates.name = params.name;
-                    if (params.enabled !== undefined)
-                        updates.enabled = params.enabled;
-                    if (legacy.repeat !== undefined)
-                        updates.repeat = legacy.repeat;
-                    if (legacy.allowedTools !== undefined)
-                        updates.allowedTools = legacy.allowedTools;
-                    const r = await deps.updateJob(params.jobId, updates);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job updated.\n${formatJob(r.job)}` }], details: { type: "cron", action: "update", jobId: params.jobId } };
-                }
-                case "delete": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.deleteJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job ${params.jobId} deleted.` }], details: { type: "cron", action: "delete", jobId: params.jobId } };
-                }
-                case "pause": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.pauseJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job ${params.jobId} paused.` }], details: { type: "cron", action: "pause", jobId: params.jobId } };
-                }
-                case "resume": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.resumeJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job ${params.jobId} resumed.` }], details: { type: "cron", action: "resume", jobId: params.jobId } };
-                }
-                case "trigger": {
-                    if (!params.jobId)
-                        return { content: [{ type: "text", text: "Error: jobId required." }], details: { type: "cron", error: "missing_jobId" } };
-                    const r = await deps.triggerJob(params.jobId);
-                    if (!r.success)
-                        return { content: [{ type: "text", text: `Error: ${r.error}` }], details: { type: "cron", error: r.error } };
-                    return { content: [{ type: "text", text: `Job ${params.jobId} triggered (running now).` }], details: { type: "cron", action: "trigger", jobId: params.jobId } };
-                }
-                default:
-                    return { content: [{ type: "text", text: `Error: unknown action "${params.action}".` }], details: { type: "cron", error: "unknown_action" } };
-            }
-        },
-    };
-}
-function formatJob(job) {
-    const lines = [
-        `Job: ${job.name || job.id}`,
-        `ID: ${job.id}`,
-        `Schedule: ${job.scheduleDisplay} (${job.schedule})`,
-        `State: ${job.state}`,
-    ];
-    if (job.nextRunAt)
-        lines.push(`Next run: ${job.nextRunAt}`);
-    if (job.lastRunAt)
-        lines.push(`Last run: ${job.lastRunAt} (${job.lastStatus || "unknown"})`);
-    lines.push(`Prompt: ${job.prompt.slice(0, 100)}${job.prompt.length > 100 ? "..." : ""}`);
-    return lines.join("\n");
-}

package/dist/skills/tools/edit-tool.d.ts

@@ -1,43 +0,0 @@
-import type { PortableTool } from "../portable-tool.js";
-export declare const EDIT_TOOL_NAME: "edit";
-export interface EditToolParams {
-    path: string;
-    oldText: string;
-    newText: string;
-}
-export declare const EDIT_TOOL_SCHEMA: {
-    readonly type: "object";
-    readonly properties: {
-        readonly path: {
-            readonly type: "string";
-            readonly description: "Path to the file to edit (relative or absolute).";
-        };
-        readonly oldText: {
-            readonly type: "string";
-            readonly description: "Exact text to find and replace (must match exactly, including whitespace).";
-        };
-        readonly newText: {
-            readonly type: "string";
-            readonly description: "New text to replace the old text with.";
-        };
-    };
-    readonly required: readonly ["path", "oldText", "newText"];
-};
-/** Deps injected by the host runtime for file editing. */
-export interface EditToolDeps {
-    /** Read file content as text. */
-    readFile(path: string): Promise<string>;
-    /** Write content back. */
-    writeFile(path: string, content: string): Promise<void>;
-    /** Resolve a relative path to absolute. */
-    resolvePath(input: string): string;
-    /**
-     * Check for concurrent modification before writing.
-     * The host tracks when each file was last read vs last modified on disk.
-     * Returns null if safe to write, or a descriptive warning if the file
-     * has been modified since last read (by user, another tool, or external process).
-     * If not provided, no concurrent modification check is performed.
-     */
-    checkConcurrentModification?(path: string): string | null;
-}
-export declare function createEditTool(deps: EditToolDeps): PortableTool<EditToolParams>;