wotann 0.5.85 → 0.5.87

package/dist/cli/commands/skills-curator.d.ts

@@ -0,0 +1,50 @@
+/**
+ * `wotann skills curator <verb>` — thin CLI shell around skill-curator.
+ *
+ * Verbs:
+ *   status                   — render scheduler state + per-skill lifecycle
+ *   run [--dry-run]          — execute a pass (or preview without mutating)
+ *   pause / resume           — toggle the paused flag
+ *   pin <name> / unpin <name>— bypass auto-transitions for a specific skill
+ *
+ * No side effects at import time. The src/index.ts skillsCmd dispatcher
+ * lazy-imports this module so the CLI cold path stays slim.
+ */
+import { applyAutomaticTransitions, type CuratorState } from "../../learning/skill-curator.js";
+export interface StatusOptions {
+    /** Inject a writer for testability. Defaults to console.log. */
+    readonly write?: (line: string) => void;
+    /** Anchor "now" for the time-ago math. */
+    readonly now?: Date;
+}
+export declare function runStatus(opts?: StatusOptions): number;
+export interface RunOptions {
+    readonly dryRun?: boolean;
+    readonly write?: (line: string) => void;
+    readonly now?: Date;
+}
+export declare function runRun(opts?: RunOptions): number;
+export declare function runPause(opts?: {
+    write?: (line: string) => void;
+}): number;
+export declare function runResume(opts?: {
+    write?: (line: string) => void;
+}): number;
+export declare function runPin(skillName: string, opts?: {
+    write?: (line: string) => void;
+}): number;
+export declare function runUnpin(skillName: string, opts?: {
+    write?: (line: string) => void;
+}): number;
+/**
+ * Daemon-friendly entry point: applies auto-transitions WITHOUT
+ * rendering anything. Returns counts so the caller can log / emit
+ * telemetry on its own terms.
+ *
+ * Used by the (future) kairos idle-detector wire. Manual CLI runs
+ * go through {@link runRun} which writes the summary string.
+ */
+export declare function runSilentPass(now?: Date): {
+    readonly transitions: ReturnType<typeof applyAutomaticTransitions>;
+    readonly stateAfter: CuratorState;
+};

package/dist/cli/commands/skills-curator.js

@@ -0,0 +1,162 @@
+/**
+ * `wotann skills curator <verb>` — thin CLI shell around skill-curator.
+ *
+ * Verbs:
+ *   status                   — render scheduler state + per-skill lifecycle
+ *   run [--dry-run]          — execute a pass (or preview without mutating)
+ *   pause / resume           — toggle the paused flag
+ *   pin <name> / unpin <name>— bypass auto-transitions for a specific skill
+ *
+ * No side effects at import time. The src/index.ts skillsCmd dispatcher
+ * lazy-imports this module so the CLI cold path stays slim.
+ */
+import chalk from "chalk";
+import { applyAutomaticTransitions, isPaused, listAgentSkills, loadState, runCurator, saveState, setPaused, setPinned, } from "../../learning/skill-curator.js";
+// ── Time-ago formatter (Hermes-style) ─────────────────────────────
+function formatTimeAgo(iso, now = new Date()) {
+    if (iso === null)
+        return "never";
+    const ms = now.getTime() - new Date(iso).getTime();
+    if (!Number.isFinite(ms))
+        return "unknown";
+    const seconds = Math.max(0, Math.floor(ms / 1000));
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    if (seconds < 3600)
+        return `${Math.floor(seconds / 60)}m ago`;
+    if (seconds < 86_400)
+        return `${Math.floor(seconds / 3600)}h ago`;
+    return `${Math.floor(seconds / 86_400)}d ago`;
+}
+export function runStatus(opts = {}) {
+    const write = opts.write ?? ((line) => console.log(line));
+    const now = opts.now ?? new Date();
+    const state = loadState();
+    const skills = listAgentSkills();
+    write(chalk.bold(formatHeader(state)));
+    write(`  runs:           ${state.runCount}`);
+    write(`  last run:       ${formatTimeAgo(state.lastRunAt, now)}`);
+    write(`  last summary:   ${state.lastRunSummary ?? "(none)"}`);
+    if (state.lastRunDurationSeconds !== null) {
+        write(`  last duration:  ${state.lastRunDurationSeconds}s`);
+    }
+    const buckets = {
+        active: [],
+        stale: [],
+        archived: [],
+    };
+    const pinned = [];
+    for (const skill of skills) {
+        buckets[skill.state].push(skill);
+        if (skill.pinned)
+            pinned.push(skill.name);
+    }
+    write("");
+    if (skills.length === 0) {
+        write(chalk.dim("  no agent-created skills"));
+        return 0;
+    }
+    write(`  agent-created skills: ${skills.length}`);
+    for (const state_ of ["active", "stale", "archived"]) {
+        write(`    ${state_.padEnd(10)} ${buckets[state_].length}`);
+    }
+    if (pinned.length > 0) {
+        write("");
+        write(`  pinned (${pinned.length}): ${pinned.join(", ")}`);
+    }
+    const leastActive = [...buckets.active]
+        .sort((a, b) => {
+        const aT = a.lastActivityAt ?? a.createdAt;
+        const bT = b.lastActivityAt ?? b.createdAt;
+        return aT.localeCompare(bT);
+    })
+        .slice(0, 5);
+    if (leastActive.length > 0) {
+        write("");
+        write("  least recently active (top 5):");
+        for (const skill of leastActive) {
+            write(`    ${skill.name.padEnd(40)}  ` +
+                `use=${String(skill.useCount).padStart(3)}  ` +
+                `view=${String(skill.viewCount).padStart(3)}  ` +
+                `last=${formatTimeAgo(skill.lastActivityAt, now)}`);
+        }
+    }
+    return 0;
+}
+function formatHeader(state) {
+    if (state.paused)
+        return "curator: PAUSED";
+    return "curator: ENABLED";
+}
+export function runRun(opts = {}) {
+    const write = opts.write ?? ((line) => console.log(line));
+    if (isPaused() && opts.dryRun !== true) {
+        write(chalk.yellow("curator is paused. Resume with `wotann skills curator resume`."));
+        return 1;
+    }
+    const result = runCurator(opts.now ?? new Date(), { dryRun: opts.dryRun === true });
+    write(chalk.bold(result.dryRun ? "DRY RUN — no mutations" : "Curator pass"));
+    write(`  ${result.summary}`);
+    write(`  duration: ${result.durationSeconds.toFixed(2)}s`);
+    return 0;
+}
+// ── pause / resume ────────────────────────────────────────────────
+export function runPause(opts = {}) {
+    const write = opts.write ?? ((line) => console.log(line));
+    setPaused(true);
+    write(chalk.yellow("curator paused"));
+    return 0;
+}
+export function runResume(opts = {}) {
+    const write = opts.write ?? ((line) => console.log(line));
+    setPaused(false);
+    write(chalk.green("curator resumed"));
+    return 0;
+}
+// ── pin / unpin ───────────────────────────────────────────────────
+export function runPin(skillName, opts = {}) {
+    const write = opts.write ?? ((line) => console.log(line));
+    if (skillName.length === 0) {
+        write(chalk.red("usage: wotann skills curator pin <name>"));
+        return 2;
+    }
+    if (setPinned(skillName, true)) {
+        write(chalk.green(`pinned: ${skillName}`));
+        return 0;
+    }
+    write(chalk.red(`no agent-created skill on disk: ${skillName}`));
+    return 1;
+}
+export function runUnpin(skillName, opts = {}) {
+    const write = opts.write ?? ((line) => console.log(line));
+    if (skillName.length === 0) {
+        write(chalk.red("usage: wotann skills curator unpin <name>"));
+        return 2;
+    }
+    if (setPinned(skillName, false)) {
+        write(chalk.green(`unpinned: ${skillName}`));
+        return 0;
+    }
+    write(chalk.red(`no agent-created skill on disk: ${skillName}`));
+    return 1;
+}
+// ── transition-only (kairos / daemon entry point) ─────────────────
+/**
+ * Daemon-friendly entry point: applies auto-transitions WITHOUT
+ * rendering anything. Returns counts so the caller can log / emit
+ * telemetry on its own terms.
+ *
+ * Used by the (future) kairos idle-detector wire. Manual CLI runs
+ * go through {@link runRun} which writes the summary string.
+ */
+export function runSilentPass(now = new Date()) {
+    const transitions = applyAutomaticTransitions(now);
+    const prev = loadState();
+    saveState({
+        ...prev,
+        lastRunAt: now.toISOString(),
+        lastRunSummary: `silent: checked ${transitions.checked}, archived ${transitions.archived}`,
+        runCount: prev.runCount + 1,
+    });
+    return { transitions, stateAfter: loadState() };
+}

package/dist/core/runtime-agent-loop.d.ts

@@ -36,8 +36,48 @@ export interface ToolResultEvent {
     readonly toolName: string;
     readonly result: string;
 }
-export type RunAgentControlEvent = IterationStartEvent | ToolResultEvent;
+/**
+ * Emitted at an iteration boundary after the loop drained one or more
+ * user-side redirects (Hermes Gap 2 — interrupt-and-redirect). UI
+ * consumers can render a system bubble showing the redirected text so
+ * the user has visual confirmation the directive landed. The redirect
+ * is ALREADY appended to context by the loop before this event fires;
+ * receivers MUST NOT re-append it themselves.
+ */
+export interface RedirectReceivedEvent {
+    readonly kind: "redirect_received";
+    readonly count: number;
+    readonly messages: readonly string[];
+}
+export type RunAgentControlEvent = IterationStartEvent | ToolResultEvent | RedirectReceivedEvent;
 export type AgentEvent = StreamChunk | RunAgentControlEvent;
+/**
+ * Channel for user-side redirects (Hermes Gap 2). The TUI / RPC client
+ * pushes messages when the user sends a new directive WHILE the agent
+ * is streaming. The runAgent loop drains at each iteration boundary
+ * and appends them to context as new user turns, so the model absorbs
+ * the directive on the next turn — no context loss, no abort needed.
+ *
+ * Implementations MUST be safe to call concurrently (push from the
+ * UI thread, drain from the loop's async generator).
+ */
+export interface RedirectChannel {
+    /** Drain all pending redirects. Returns empty array when none queued. */
+    drain(): readonly string[];
+}
+/**
+ * Default in-memory channel. Pushes are appended to a queue; drain
+ * empties the queue atomically. The queue ignores empty-string pushes
+ * so an accidental Ctrl+R on an empty composer doesn't inject a blank
+ * user turn into the model context.
+ */
+export declare class InMemoryRedirectChannel implements RedirectChannel {
+    private queue;
+    push(message: string): void;
+    drain(): readonly string[];
+    /** Snapshot of pending count — for status-bar indicators. Read-only. */
+    get pending(): number;
+}
 export interface RunAgentOptions {
     readonly prompt: string;
     readonly images?: readonly string[];
@@ -49,6 +89,14 @@ export interface RunAgentOptions {
     readonly signal?: AbortSignal;
     readonly guardrails?: readonly GuardrailCheck[];
     readonly guardrailContext?: GuardrailContext;
+    /**
+     * Optional user-redirect channel. When provided, the loop drains
+     * pending messages BEFORE each iteration's query and appends them
+     * to context as new user turns. Lets the user redirect a streaming
+     * agent without losing context (Hermes Gap 2). See
+     * {@link InMemoryRedirectChannel} for the default implementation.
+     */
+    readonly redirectChannel?: RedirectChannel;
     readonly query: (o: WotannQueryOptions) => AsyncGenerator<StreamChunk>;
     readonly executeTool: (name: string, input: Record<string, unknown>) => Promise<string>;
 }

package/dist/core/runtime-agent-loop.js

@@ -1,5 +1,31 @@
 import { evaluateGuardrails, } from "../guardrails/tripwire.js";
-import { IntelligenceAmplifier, updateDoomLoopState } from "../intelligence/amplifier.js";
+import { IntelligenceAmplifier, updateDoomLoopState, } from "../intelligence/amplifier.js";
+/**
+ * Default in-memory channel. Pushes are appended to a queue; drain
+ * empties the queue atomically. The queue ignores empty-string pushes
+ * so an accidental Ctrl+R on an empty composer doesn't inject a blank
+ * user turn into the model context.
+ */
+export class InMemoryRedirectChannel {
+    queue = [];
+    push(message) {
+        const trimmed = message.trim();
+        if (trimmed.length === 0)
+            return;
+        this.queue.push(trimmed);
+    }
+    drain() {
+        if (this.queue.length === 0)
+            return [];
+        const out = this.queue;
+        this.queue = [];
+        return out;
+    }
+    /** Snapshot of pending count — for status-bar indicators. Read-only. */
+    get pending() {
+        return this.queue.length;
+    }
+}
 export async function* runAgent(opts) {
     const maxIterations = opts.maxIterations ?? 8;
     const guardrails = opts.guardrails ?? [];
@@ -20,6 +46,22 @@ export async function* runAgent(opts) {
     while (iteration < maxIterations) {
         iteration++;
         yield { kind: "iteration_start", iteration };
+        // Hermes Gap 2 — drain user-side redirects BEFORE this iteration's
+        // query. Each pending message becomes a new user turn appended to
+        // context, so the model sees the directive on its next turn. No
+        // abort, no context loss. We emit a `redirect_received` control
+        // event so UI consumers can render a system breadcrumb.
+        if (opts.redirectChannel !== undefined) {
+            const pending = opts.redirectChannel.drain();
+            if (pending.length > 0) {
+                const next = [...context];
+                for (const msg of pending) {
+                    next.push({ role: "user", content: msg });
+                }
+                context = next;
+                yield { kind: "redirect_received", count: pending.length, messages: pending };
+            }
+        }
         let fullContent = "";
         let model;
         let provider;

package/dist/index.js

@@ -3578,6 +3578,58 @@ skillsCmd
     if (out.exitCode !== 0)
         process.exit(out.exitCode);
 });
+// ── wotann skills curator ────────────────────────────────────
+//
+// Hermes Gap 1 port — inactivity-triggered lifecycle manager for
+// agent-created skills. State machine lives in src/learning/
+// skill-curator.ts; this is the thin CLI wrapper. See the module
+// docblock there for the full lifecycle / invariants discussion.
+const curatorCmd = skillsCmd
+    .command("curator")
+    .description("Manage the inactivity-triggered skill lifecycle (active/stale/archived)");
+curatorCmd
+    .command("status")
+    .description("Show curator scheduler state + per-skill lifecycle counts")
+    .action(async () => {
+    const mod = await import("./cli/commands/skills-curator.js");
+    process.exit(mod.runStatus());
+});
+curatorCmd
+    .command("run")
+    .description("Execute one curator pass (apply auto-transitions)")
+    .option("--dry-run", "Compute would-be transitions without mutating the library")
+    .action(async (opts) => {
+    const mod = await import("./cli/commands/skills-curator.js");
+    process.exit(mod.runRun({ dryRun: opts.dryRun === true }));
+});
+curatorCmd
+    .command("pause")
+    .description("Pause the curator (scheduler will not run automatic passes)")
+    .action(async () => {
+    const mod = await import("./cli/commands/skills-curator.js");
+    process.exit(mod.runPause());
+});
+curatorCmd
+    .command("resume")
+    .description("Resume the curator after a pause")
+    .action(async () => {
+    const mod = await import("./cli/commands/skills-curator.js");
+    process.exit(mod.runResume());
+});
+curatorCmd
+    .command("pin <name>")
+    .description("Pin a skill so it bypasses auto-transitions (stale + archive)")
+    .action(async (name) => {
+    const mod = await import("./cli/commands/skills-curator.js");
+    process.exit(mod.runPin(name));
+});
+curatorCmd
+    .command("unpin <name>")
+    .description("Unpin a skill so it resumes auto-transitions")
+    .action(async (name) => {
+    const mod = await import("./cli/commands/skills-curator.js");
+    process.exit(mod.runUnpin(name));
+});
 // ── wotann cost ──────────────────────────────────────────────
 //
 // Wave 4G: the cost command now accepts an optional `period` argument

package/dist/learning/skill-curator.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Skill Curator — inactivity-triggered skill lifecycle manager.
+ *
+ * Port of Hermes' `agent/curator.py` (NousResearch/hermes-agent, MIT).
+ * The Hermes curator runs background reviews of agent-created skills,
+ * auto-transitioning them between lifecycle states (active → stale →
+ * archived) based on real activity timestamps, and pinning bypasses
+ * the auto-transitions entirely. Hermes' full curator also spawns a
+ * forked AIAgent to do LLM-graded review; we ship the pure-function
+ * scheduler + state machine first and wire the LLM review later when
+ * the auxiliary-credential pattern lands.
+ *
+ * Lifecycle:
+ *   active  → stale       (no activity for STALE_AFTER_DAYS, default 30)
+ *   stale   → archived    (no activity for ARCHIVE_AFTER_DAYS, default 90)
+ *   stale   → active      (activity recorded after marked stale = reactivation)
+ *   pinned  → bypasses all auto-transitions
+ *
+ * Strict invariants:
+ *   - Only touches AGENT-CREATED skills (those living under
+ *     ~/.wotann/skills/agent/ — the directory `skill-forge.ts`
+ *     promotes into). The curated/scientific registries are static
+ *     data and out of scope.
+ *   - Never auto-deletes. Archive moves the directory to
+ *     ~/.wotann/skills/.archive/<name>/ which is recoverable by hand.
+ *   - State writes are atomic (writeFileAtomic) so a crashed run
+ *     never leaves a half-written .curator_state.
+ *
+ * Persistence layout (under WOTANN_HOME):
+ *   skills/.curator_state               — global curator scheduler state
+ *   skills/agent/<name>/                — promoted agent-created skill
+ *   skills/agent/<name>/.activity.json  — per-skill activity record
+ *   skills/.archive/<name>/             — archived (recoverable) skills
+ *
+ * Quality bars:
+ *   QB#6 honest failures: corrupt state files return defaults rather
+ *        than crashing the curator; ENOENT on a missing skill dir is
+ *        the expected steady-state, not an error.
+ *   QB#7 per-call state: every function reads from disk on each call
+ *        and writes back atomically. No module-global caches.
+ *   QB#11 sibling-site scan: `applyAutomaticTransitions` is the ONE
+ *        place state mutations live — CLI status/run/pin paths all
+ *        funnel through it so the bug class "two writers race on the
+ *        same skill" cannot regress.
+ */
+/** 7 days — Hermes default. Override via {@link CuratorConfig.intervalHours}. */
+export declare const DEFAULT_INTERVAL_HOURS: number;
+/** 2 hours of agent inactivity before the curator considers running. */
+export declare const DEFAULT_MIN_IDLE_HOURS = 2;
+/** Skill marked `stale` after this many days without activity. */
+export declare const DEFAULT_STALE_AFTER_DAYS = 30;
+/** Skill `archived` after this many days without activity. */
+export declare const DEFAULT_ARCHIVE_AFTER_DAYS = 90;
+export type SkillState = "active" | "stale" | "archived";
+/** Global curator scheduler state — persisted at `.curator_state`. */
+export interface CuratorState {
+    readonly lastRunAt: string | null;
+    readonly lastRunDurationSeconds: number | null;
+    readonly lastRunSummary: string | null;
+    readonly paused: boolean;
+    readonly runCount: number;
+}
+/** Per-skill activity record — persisted at `agent/<name>/.activity.json`. */
+export interface SkillActivity {
+    readonly name: string;
+    readonly state: SkillState;
+    readonly pinned: boolean;
+    readonly lastActivityAt: string | null;
+    readonly createdAt: string;
+    readonly useCount: number;
+    readonly viewCount: number;
+}
+/** Aggregate counts emitted by {@link applyAutomaticTransitions}. */
+export interface TransitionCounts {
+    readonly checked: number;
+    readonly markedStale: number;
+    readonly archived: number;
+    readonly reactivated: number;
+}
+export interface CuratorConfig {
+    readonly intervalHours?: number;
+    readonly staleAfterDays?: number;
+    readonly archiveAfterDays?: number;
+}
+export interface RunResult {
+    readonly counts: TransitionCounts;
+    readonly durationSeconds: number;
+    readonly summary: string;
+    readonly dryRun: boolean;
+}
+/**
+ * Load the global curator scheduler state. Returns sensible defaults
+ * on missing or corrupt files — never throws.
+ */
+export declare function loadState(): CuratorState;
+/** Write the global curator state atomically. Creates the parent dir if needed. */
+export declare function saveState(state: CuratorState): void;
+export declare function setPaused(paused: boolean): void;
+export declare function isPaused(): boolean;
+/**
+ * Record a use (the user actually invoked the skill in an agent turn).
+ * Bumps {@link SkillActivity.useCount}, updates `lastActivityAt`, and
+ * reactivates archived skills (the skill clearly isn't dead).
+ */
+export declare function recordSkillUse(skillName: string, now?: Date): void;
+/**
+ * Record a view (the user inspected the skill via `/skills view` or
+ * the palette). Views ALSO count as activity per the Hermes design —
+ * a recently-inspected skill shouldn't immediately archive.
+ */
+export declare function recordSkillView(skillName: string, now?: Date): void;
+/**
+ * Pin or unpin a skill. Pinned skills bypass all auto-transitions.
+ * Returns false when the skill has no on-disk presence (we don't
+ * silently create a phantom activity record).
+ */
+export declare function setPinned(skillName: string, pinned: boolean, now?: Date): boolean;
+/**
+ * Walk `~/.wotann/skills/agent/` and return one activity record per
+ * agent-created skill. Skills with no activity file yet are seeded
+ * with defaults derived from their directory mtime so the first
+ * curator pass has somewhere to anchor lifecycle math.
+ */
+export declare function listAgentSkills(): SkillActivity[];
+/**
+ * Walk every agent-created skill and move active/stale/archived based
+ * on the latest activity timestamp. Pinned skills are never touched.
+ * Archived skills move on disk to `.archive/<name>/`. Returns aggregate
+ * counts so the CLI can render a summary.
+ */
+export declare function applyAutomaticTransitions(now?: Date, config?: CuratorConfig): TransitionCounts;
+/**
+ * Returns true when the curator should run NOW. Gates:
+ *   - not paused
+ *   - last_run_at present AND older than intervalHours
+ *
+ * First-run behavior: a missing `last_run_at` SEEDS the timestamp and
+ * returns false (defer the first real pass by one full interval —
+ * matches Hermes' "deferred first run" pattern so the very first
+ * background tick after `wotann update` doesn't immediately mutate
+ * the library).
+ *
+ * The min-idle-hours gate is intentionally NOT applied here — callers
+ * (kairos idle detector, CLI manual `run`) know their own idle state
+ * and apply it at the call site.
+ */
+export declare function shouldRunNow(now?: Date, intervalHours?: number): boolean;
+/**
+ * Execute one curator pass. When `dryRun` is true, computes what would
+ * change but does NOT mutate the skill library or the curator state.
+ * Otherwise applies transitions and persists `lastRunAt`/`runCount`/
+ * `lastRunSummary` for the next status render.
+ */
+export declare function runCurator(now?: Date, config?: CuratorConfig & {
+    dryRun?: boolean;
+}): RunResult;

package/dist/learning/skill-curator.js

@@ -0,0 +1,402 @@
+/**
+ * Skill Curator — inactivity-triggered skill lifecycle manager.
+ *
+ * Port of Hermes' `agent/curator.py` (NousResearch/hermes-agent, MIT).
+ * The Hermes curator runs background reviews of agent-created skills,
+ * auto-transitioning them between lifecycle states (active → stale →
+ * archived) based on real activity timestamps, and pinning bypasses
+ * the auto-transitions entirely. Hermes' full curator also spawns a
+ * forked AIAgent to do LLM-graded review; we ship the pure-function
+ * scheduler + state machine first and wire the LLM review later when
+ * the auxiliary-credential pattern lands.
+ *
+ * Lifecycle:
+ *   active  → stale       (no activity for STALE_AFTER_DAYS, default 30)
+ *   stale   → archived    (no activity for ARCHIVE_AFTER_DAYS, default 90)
+ *   stale   → active      (activity recorded after marked stale = reactivation)
+ *   pinned  → bypasses all auto-transitions
+ *
+ * Strict invariants:
+ *   - Only touches AGENT-CREATED skills (those living under
+ *     ~/.wotann/skills/agent/ — the directory `skill-forge.ts`
+ *     promotes into). The curated/scientific registries are static
+ *     data and out of scope.
+ *   - Never auto-deletes. Archive moves the directory to
+ *     ~/.wotann/skills/.archive/<name>/ which is recoverable by hand.
+ *   - State writes are atomic (writeFileAtomic) so a crashed run
+ *     never leaves a half-written .curator_state.
+ *
+ * Persistence layout (under WOTANN_HOME):
+ *   skills/.curator_state               — global curator scheduler state
+ *   skills/agent/<name>/                — promoted agent-created skill
+ *   skills/agent/<name>/.activity.json  — per-skill activity record
+ *   skills/.archive/<name>/             — archived (recoverable) skills
+ *
+ * Quality bars:
+ *   QB#6 honest failures: corrupt state files return defaults rather
+ *        than crashing the curator; ENOENT on a missing skill dir is
+ *        the expected steady-state, not an error.
+ *   QB#7 per-call state: every function reads from disk on each call
+ *        and writes back atomically. No module-global caches.
+ *   QB#11 sibling-site scan: `applyAutomaticTransitions` is the ONE
+ *        place state mutations live — CLI status/run/pin paths all
+ *        funnel through it so the bug class "two writers race on the
+ *        same skill" cannot regress.
+ */
+import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { writeFileAtomic } from "../utils/atomic-io.js";
+import { resolveWotannHomeSubdir } from "../utils/wotann-home.js";
+// ── Constants (Hermes defaults) ──────────────────────────────────
+/** 7 days — Hermes default. Override via {@link CuratorConfig.intervalHours}. */
+export const DEFAULT_INTERVAL_HOURS = 24 * 7;
+/** 2 hours of agent inactivity before the curator considers running. */
+export const DEFAULT_MIN_IDLE_HOURS = 2;
+/** Skill marked `stale` after this many days without activity. */
+export const DEFAULT_STALE_AFTER_DAYS = 30;
+/** Skill `archived` after this many days without activity. */
+export const DEFAULT_ARCHIVE_AFTER_DAYS = 90;
+// ── Path helpers ──────────────────────────────────────────────────
+function stateFilePath() {
+    return resolveWotannHomeSubdir("skills", ".curator_state");
+}
+function agentSkillsDir() {
+    return resolveWotannHomeSubdir("skills", "agent");
+}
+function archiveDir() {
+    return resolveWotannHomeSubdir("skills", ".archive");
+}
+function activityFilePath(skillName) {
+    return resolveWotannHomeSubdir("skills", "agent", skillName, ".activity.json");
+}
+// ── Global state I/O ──────────────────────────────────────────────
+function defaultState() {
+    return {
+        lastRunAt: null,
+        lastRunDurationSeconds: null,
+        lastRunSummary: null,
+        paused: false,
+        runCount: 0,
+    };
+}
+/**
+ * Load the global curator scheduler state. Returns sensible defaults
+ * on missing or corrupt files — never throws.
+ */
+export function loadState() {
+    const path = stateFilePath();
+    if (!existsSync(path))
+        return defaultState();
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed !== null && typeof parsed === "object") {
+            return { ...defaultState(), ...parsed };
+        }
+    }
+    catch {
+        // Corrupt JSON — return defaults rather than crash the run.
+    }
+    return defaultState();
+}
+/** Write the global curator state atomically. Creates the parent dir if needed. */
+export function saveState(state) {
+    writeFileAtomic(stateFilePath(), JSON.stringify(state, null, 2) + "\n");
+}
+export function setPaused(paused) {
+    saveState({ ...loadState(), paused });
+}
+export function isPaused() {
+    return loadState().paused;
+}
+// ── Per-skill activity ────────────────────────────────────────────
+function loadActivity(skillName) {
+    const path = activityFilePath(skillName);
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (parsed !== null && typeof parsed === "object" && typeof parsed.name === "string") {
+            return {
+                name: parsed.name,
+                state: parsed.state ?? "active",
+                pinned: parsed.pinned === true,
+                lastActivityAt: typeof parsed.lastActivityAt === "string" ? parsed.lastActivityAt : null,
+                createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : new Date().toISOString(),
+                useCount: typeof parsed.useCount === "number" ? parsed.useCount : 0,
+                viewCount: typeof parsed.viewCount === "number" ? parsed.viewCount : 0,
+            };
+        }
+    }
+    catch {
+        // Corrupt activity file — treat as missing.
+    }
+    return null;
+}
+function saveActivity(activity) {
+    writeFileAtomic(activityFilePath(activity.name), JSON.stringify(activity, null, 2) + "\n");
+}
+/**
+ * Record a use (the user actually invoked the skill in an agent turn).
+ * Bumps {@link SkillActivity.useCount}, updates `lastActivityAt`, and
+ * reactivates archived skills (the skill clearly isn't dead).
+ */
+export function recordSkillUse(skillName, now = new Date()) {
+    const existing = loadActivity(skillName);
+    saveActivity({
+        name: skillName,
+        state: existing?.state === "archived" ? "active" : (existing?.state ?? "active"),
+        pinned: existing?.pinned ?? false,
+        lastActivityAt: now.toISOString(),
+        createdAt: existing?.createdAt ?? now.toISOString(),
+        useCount: (existing?.useCount ?? 0) + 1,
+        viewCount: existing?.viewCount ?? 0,
+    });
+}
+/**
+ * Record a view (the user inspected the skill via `/skills view` or
+ * the palette). Views ALSO count as activity per the Hermes design —
+ * a recently-inspected skill shouldn't immediately archive.
+ */
+export function recordSkillView(skillName, now = new Date()) {
+    const existing = loadActivity(skillName);
+    saveActivity({
+        name: skillName,
+        state: existing?.state ?? "active",
+        pinned: existing?.pinned ?? false,
+        lastActivityAt: now.toISOString(),
+        createdAt: existing?.createdAt ?? now.toISOString(),
+        useCount: existing?.useCount ?? 0,
+        viewCount: (existing?.viewCount ?? 0) + 1,
+    });
+}
+/**
+ * Pin or unpin a skill. Pinned skills bypass all auto-transitions.
+ * Returns false when the skill has no on-disk presence (we don't
+ * silently create a phantom activity record).
+ */
+export function setPinned(skillName, pinned, now = new Date()) {
+    const existing = loadActivity(skillName);
+    if (existing !== null) {
+        saveActivity({ ...existing, pinned });
+        return true;
+    }
+    const skillDir = join(agentSkillsDir(), skillName);
+    if (!existsSync(skillDir))
+        return false;
+    saveActivity({
+        name: skillName,
+        state: "active",
+        pinned,
+        lastActivityAt: null,
+        createdAt: now.toISOString(),
+        useCount: 0,
+        viewCount: 0,
+    });
+    return true;
+}
+// ── Discovery ─────────────────────────────────────────────────────
+/**
+ * Walk `~/.wotann/skills/agent/` and return one activity record per
+ * agent-created skill. Skills with no activity file yet are seeded
+ * with defaults derived from their directory mtime so the first
+ * curator pass has somewhere to anchor lifecycle math.
+ */
+export function listAgentSkills() {
+    const dir = agentSkillsDir();
+    if (!existsSync(dir))
+        return [];
+    const out = [];
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        // Skip dotfile dirs (.archive, .scratch, etc.).
+        if (entry.name.startsWith("."))
+            continue;
+        const activity = loadActivity(entry.name);
+        if (activity !== null) {
+            out.push(activity);
+            continue;
+        }
+        // Skill exists on disk but no activity record yet — seed one.
+        let createdAt;
+        try {
+            createdAt = statSync(join(dir, entry.name)).birthtime.toISOString();
+        }
+        catch {
+            createdAt = new Date().toISOString();
+        }
+        const seeded = {
+            name: entry.name,
+            state: "active",
+            pinned: false,
+            lastActivityAt: null,
+            createdAt,
+            useCount: 0,
+            viewCount: 0,
+        };
+        try {
+            saveActivity(seeded);
+        }
+        catch {
+            // Best-effort seed — if write fails (read-only fs in CI), still
+            // surface the skill in the report.
+        }
+        out.push(seeded);
+    }
+    return out;
+}
+// ── Auto-transitions (pure function over time) ────────────────────
+/**
+ * Walk every agent-created skill and move active/stale/archived based
+ * on the latest activity timestamp. Pinned skills are never touched.
+ * Archived skills move on disk to `.archive/<name>/`. Returns aggregate
+ * counts so the CLI can render a summary.
+ */
+export function applyAutomaticTransitions(now = new Date(), config = {}) {
+    const staleAfter = config.staleAfterDays ?? DEFAULT_STALE_AFTER_DAYS;
+    const archiveAfter = config.archiveAfterDays ?? DEFAULT_ARCHIVE_AFTER_DAYS;
+    const nowMs = now.getTime();
+    const staleCutoff = nowMs - staleAfter * 86_400_000;
+    const archiveCutoff = nowMs - archiveAfter * 86_400_000;
+    let checked = 0;
+    let markedStale = 0;
+    let archived = 0;
+    let reactivated = 0;
+    for (const skill of listAgentSkills()) {
+        checked++;
+        if (skill.pinned)
+            continue;
+        const anchorIso = skill.lastActivityAt ?? skill.createdAt;
+        const anchor = new Date(anchorIso).getTime();
+        if (!Number.isFinite(anchor))
+            continue;
+        if (anchor <= archiveCutoff && skill.state !== "archived") {
+            if (archiveSkillOnDisk(skill.name)) {
+                archived++;
+            }
+        }
+        else if (anchor <= staleCutoff && skill.state === "active") {
+            saveActivity({ ...skill, state: "stale" });
+            markedStale++;
+        }
+        else if (anchor > staleCutoff && skill.state === "stale") {
+            saveActivity({ ...skill, state: "active" });
+            reactivated++;
+        }
+    }
+    return { checked, markedStale, archived, reactivated };
+}
+/**
+ * Move `skills/agent/<name>/` to `skills/.archive/<name>/`. If the
+ * archive slot is already occupied (re-archive after manual restore),
+ * suffix with the current timestamp so nothing is overwritten.
+ * Returns false when the source doesn't exist (skill already gone).
+ */
+function archiveSkillOnDisk(skillName) {
+    const src = join(agentSkillsDir(), skillName);
+    if (!existsSync(src))
+        return false;
+    mkdirSync(archiveDir(), { recursive: true });
+    let dst = join(archiveDir(), skillName);
+    if (existsSync(dst)) {
+        dst = `${dst}.${Date.now()}`;
+    }
+    renameSync(src, dst);
+    return true;
+}
+// ── Scheduler ─────────────────────────────────────────────────────
+/**
+ * Returns true when the curator should run NOW. Gates:
+ *   - not paused
+ *   - last_run_at present AND older than intervalHours
+ *
+ * First-run behavior: a missing `last_run_at` SEEDS the timestamp and
+ * returns false (defer the first real pass by one full interval —
+ * matches Hermes' "deferred first run" pattern so the very first
+ * background tick after `wotann update` doesn't immediately mutate
+ * the library).
+ *
+ * The min-idle-hours gate is intentionally NOT applied here — callers
+ * (kairos idle detector, CLI manual `run`) know their own idle state
+ * and apply it at the call site.
+ */
+export function shouldRunNow(now = new Date(), intervalHours = DEFAULT_INTERVAL_HOURS) {
+    const state = loadState();
+    if (state.paused)
+        return false;
+    if (state.lastRunAt === null) {
+        // Seed without running. Defer first pass by one interval.
+        saveState({ ...state, lastRunAt: now.toISOString() });
+        return false;
+    }
+    const last = new Date(state.lastRunAt).getTime();
+    if (!Number.isFinite(last))
+        return true; // corrupt timestamp → run
+    const intervalMs = intervalHours * 3_600_000;
+    return now.getTime() - last >= intervalMs;
+}
+// ── Run ───────────────────────────────────────────────────────────
+/**
+ * Execute one curator pass. When `dryRun` is true, computes what would
+ * change but does NOT mutate the skill library or the curator state.
+ * Otherwise applies transitions and persists `lastRunAt`/`runCount`/
+ * `lastRunSummary` for the next status render.
+ */
+export function runCurator(now = new Date(), config = {}) {
+    const start = Date.now();
+    const dryRun = config.dryRun === true;
+    const counts = dryRun
+        ? computeWouldTransition(now, config)
+        : applyAutomaticTransitions(now, config);
+    const end = Date.now();
+    const summary = formatSummary(counts, dryRun);
+    if (!dryRun) {
+        const prev = loadState();
+        saveState({
+            ...prev,
+            lastRunAt: now.toISOString(),
+            lastRunDurationSeconds: Math.max(0, Math.round((end - start) / 1000)),
+            lastRunSummary: summary,
+            runCount: prev.runCount + 1,
+        });
+    }
+    return {
+        counts,
+        durationSeconds: (end - start) / 1000,
+        summary,
+        dryRun,
+    };
+}
+function computeWouldTransition(now, config) {
+    const staleAfter = config.staleAfterDays ?? DEFAULT_STALE_AFTER_DAYS;
+    const archiveAfter = config.archiveAfterDays ?? DEFAULT_ARCHIVE_AFTER_DAYS;
+    const nowMs = now.getTime();
+    const staleCutoff = nowMs - staleAfter * 86_400_000;
+    const archiveCutoff = nowMs - archiveAfter * 86_400_000;
+    let checked = 0;
+    let markedStale = 0;
+    let archived = 0;
+    let reactivated = 0;
+    for (const skill of listAgentSkills()) {
+        checked++;
+        if (skill.pinned)
+            continue;
+        const anchor = new Date(skill.lastActivityAt ?? skill.createdAt).getTime();
+        if (!Number.isFinite(anchor))
+            continue;
+        if (anchor <= archiveCutoff && skill.state !== "archived")
+            archived++;
+        else if (anchor <= staleCutoff && skill.state === "active")
+            markedStale++;
+        else if (anchor > staleCutoff && skill.state === "stale")
+            reactivated++;
+    }
+    return { checked, markedStale, archived, reactivated };
+}
+function formatSummary(counts, dryRun) {
+    const prefix = dryRun ? "[dry-run] " : "";
+    return (`${prefix}checked ${counts.checked}, ` +
+        `marked stale ${counts.markedStale}, ` +
+        `archived ${counts.archived}, ` +
+        `reactivated ${counts.reactivated}`);
+}

package/dist/ui/components/v3/AppV3.js

@@ -41,7 +41,7 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "#wotann-jsx/j
  */
 import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 import { Box, Text, useInput } from "ink";
-import { runAgent } from "../../../core/runtime-agent-loop.js";
+import { InMemoryRedirectChannel, runAgent } from "../../../core/runtime-agent-loop.js";
 import { buildAgentToolContext } from "../../../core/agent-tool-context.js";
 import { AGENT_TOOL_DEFINITIONS, executeAgentTool } from "../../../tools/agent-tools.js";
 import { ThemeProvider, useThemeTone } from "../../theme/context.js";
@@ -217,6 +217,13 @@ function AppV3Inner({ providers, initialModel, initialProvider, messages, isStre
     const [transcriptScrollOffset, setTranscriptScrollOffset] = useState(0);
     const activeRunRef = useRef(null);
     const sideActiveRunRef = useRef(null);
+    // Hermes Gap 2 — interrupt-and-redirect: persistent channel for the
+    // host composer's mid-stream redirects. Ctrl+R captures the current
+    // draft and pushes it here; runAgent's iteration loop drains pending
+    // redirects at the next iteration boundary and appends them to
+    // context as new user turns. One channel per AppV3Inner instance so
+    // pending redirects survive within a session.
+    const redirectChannelRef = useRef(new InMemoryRedirectChannel());
     const [sidePaneDraft, setSidePaneDraft] = useState("");
     const [nowMs, setNowMs] = useState(() => Date.now());
     useEffect(() => {
@@ -241,6 +248,16 @@ function AppV3Inner({ providers, initialModel, initialProvider, messages, isStre
     // composer is empty so we don't intercept the dot from a typed
     // slash-command argument or filename.
     useInput((input, key) => {
+        // Hermes Gap 2 — Ctrl+R: queue the composer draft as a mid-stream
+        // redirect. ONLY fires when the agent is currently streaming AND
+        // the draft has non-whitespace content. The channel's drain runs
+        // at the next iteration boundary, so the user sees a system
+        // "redirect queued" bubble within ~1 turn.
+        if (key.ctrl && input === "r" && isStreaming && draftValue.trim().length > 0) {
+            redirectChannelRef.current.push(draftValue);
+            setDraftValue("");
+            return;
+        }
         if (key.ctrl && (input === "k" || input === "p")) {
             overlay.open("palette");
             return;
@@ -342,6 +359,7 @@ function AppV3Inner({ providers, initialModel, initialProvider, messages, isStre
                     provider: initialProvider || undefined,
                     tools: AGENT_TOOL_DEFINITIONS,
                     signal: abortController.signal,
+                    redirectChannel: redirectChannelRef.current,
                     query: (o) => runtime.query(o),
                     executeTool: (name, input) => executeAgentTool(name, input, buildAgentToolContext(runtime, {
                         workingDir: runtime.getWorkingDir(),
@@ -362,6 +380,20 @@ function AppV3Inner({ providers, initialModel, initialProvider, messages, isStre
                                 },
                             ]);
                         }
+                        else if (ev.kind === "redirect_received") {
+                            // Hermes Gap 2 — UI breadcrumb so user sees the directive
+                            // landed. The loop already appended it to context; we
+                            // ONLY render here (do NOT push to context again).
+                            for (const message of ev.messages) {
+                                setMessages((prev) => [
+                                    ...prev,
+                                    {
+                                        role: "system",
+                                        content: `↳ redirect queued: ${message}`,
+                                    },
+                                ]);
+                            }
+                        }
                         continue;
                     }
                     if (ev.type === "text" && ev.content.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wotann",
-  "version": "0.5.85",
+  "version": "0.5.87",
   "description": "WOTANN — The All-Father of AI Agent Harnesses",
   "type": "module",
   "main": "dist/index.js",