qlogicagent 2.13.3 → 2.13.5

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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,102 @@
+// ============================================================
+// 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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,123 @@
+// ============================================================
+// 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

@@ -0,0 +1,96 @@
+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

@@ -0,0 +1,165 @@
+// ============================================================
+// 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

@@ -0,0 +1,43 @@
+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>;