aiden-runtime 4.0.2 → 4.1.1

package/dist/core/cronManager.js

@@ -1,300 +1,39 @@
 "use strict";
 // ============================================================
-// DevOS — Autonomous AI Execution System
-// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// Copyright (c) 2026 Shiva Deore (Taracod). Licensed under AGPL-3.0.
 // ============================================================
 //
-// core/cronManager.ts — scheduled task engine.
+// core/cronManager.ts — backward-compat shim.
 //
-// Public API (kept stable): createJob, listJobs, getJob,
-// pauseJob, resumeJob, deleteJob, triggerJob, parseSchedule,
-// loadJobs.
-//
-// Capabilities:
-//   - "every N minutes/hours/days", "hourly", "daily", "30m"
-//   - 5-field cron expressions ("0 9 * * *", "*/30 * * * *")
-//   - One-shot ISO timestamps ("2026-02-03T14:00")
-// Persistence:
-//   - ~/.aiden/cron_jobs.json — atomic temp-then-rename + fsync,
-//     guarded by a per-path mutex. cron_jobs.json never observed
-//     in a half-written state, even if the process is killed
-//     mid-write.
-// Scheduling:
-//   - lastRun-anchored chained setTimeout (no setInterval drift).
-//     Each fire schedules the next from `lastRun + intervalMs`,
-//     so a process restart resumes the cadence from where it
-//     left off. Stale anchors (lastRun + interval < now) fire
-//     immediately, then the regular cadence resumes.
-// Per-run logs:
-//   - ~/.aiden/cron-logs/<job-id>.log gets a full STARTED /
-//     output / DONE block per fire. cron_jobs.json carries a
-//     4 KB summary on the job record.
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
+// The legacy in-process scheduler this file used to host has been
+// replaced by the hardened scheduler at
+// `core/v4/cron/cronManager.ts` (Phase v4.1-cron).
+// Public function names + parseSchedule are preserved so existing
+// importers (notably cli/v4/commands/cron.ts) keep working
+// unchanged. The legacy synchronous `loadJobs()` / `createJob()`
+// signatures were always followed by a `save()` which itself was
+// async-fire-and-forget; the new module is async-end-to-end.
+// Callers that previously did `cron.createJob(...)` and assumed
+// instant disk persistence now MUST `await` the call.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSchedule = void 0;
-exports.awaitPendingSaves = awaitPendingSaves;
-exports.loadJobs = loadJobs;
-exports.createJob = createJob;
-exports.listJobs = listJobs;
-exports.getJob = getJob;
-exports.pauseJob = pauseJob;
-exports.resumeJob = resumeJob;
-exports.deleteJob = deleteJob;
-exports.triggerJob = triggerJob;
-exports.__resetForTests = __resetForTests;
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const atomicWrite_1 = require("./v4/cron/atomicWrite");
-const scheduleParser_1 = require("./v4/cron/scheduleParser");
-const outputCapture_1 = require("./v4/cron/outputCapture");
-// ── State ─────────────────────────────────────────────────────────────────────
-const jobs = new Map();
-const timers = new Map();
-let jobSeq = 1;
-let pendingSave = Promise.resolve();
-const DATA_DIR = path.join(os.homedir(), '.aiden');
-const DATA_FILE = path.join(DATA_DIR, 'cron_jobs.json');
-const LOGS_DIR = path.join(DATA_DIR, 'cron-logs');
-// Re-export so callers can keep `import { parseSchedule } from './cronManager'`.
-var scheduleParser_2 = require("./v4/cron/scheduleParser");
-Object.defineProperty(exports, "parseSchedule", { enumerable: true, get: function () { return scheduleParser_2.parseSchedule; } });
-// ── Persistence ───────────────────────────────────────────────────────────────
-function save() {
-    // Fire-and-forget, but chain off the previous save so writes serialise.
-    pendingSave = pendingSave.catch(() => undefined).then(() => (0, atomicWrite_1.writeJsonAtomic)(DATA_FILE, Array.from(jobs.values())));
-}
-// Test/shutdown hook — drain any queued writes.
-async function awaitPendingSaves() {
-    await pendingSave;
-}
-function loadJobs() {
-    try {
-        if (!fs.existsSync(DATA_FILE))
-            return;
-        const data = JSON.parse(fs.readFileSync(DATA_FILE, 'utf8'));
-        if (!Array.isArray(data))
-            return;
-        for (const raw of data) {
-            const job = migrateJob(raw);
-            if (!job)
-                continue;
-            jobs.set(job.id, job);
-            const num = parseInt(job.id, 10);
-            if (!isNaN(num) && num >= jobSeq)
-                jobSeq = num + 1;
-            if (job.enabled)
-                _scheduleJob(job);
-        }
-    }
-    catch { /* corrupt file → start with empty registry */ }
-}
-function migrateJob(raw) {
-    if (!raw || typeof raw !== 'object' || !raw.id)
-        return null;
-    // Old shape (pre-Phase-24.1) had no `kind`; everything was an interval.
-    if (!raw.kind) {
-        raw.kind = raw.cronExpr ? 'cron'
-            : raw.oneshotIso ? 'oneshot'
-                : 'interval';
-    }
-    return raw;
-}
-// ── Scheduling ────────────────────────────────────────────────────────────────
-function _scheduleJob(job) {
-    if (timers.has(job.id))
-        return; // already armed
-    if (!job.enabled)
-        return;
-    const target = (0, scheduleParser_1.computeNextFire)(job);
-    if (!target) {
-        // Nothing to fire (e.g. completed one-shot). Make sure no stale timer.
-        return;
-    }
-    const delay = Math.max(0, target.getTime() - Date.now());
-    job.nextRun = new Date(Date.now() + delay).toISOString();
-    jobs.set(job.id, { ...job });
-    save();
-    const handle = setTimeout(async () => {
-        timers.delete(job.id);
-        try {
-            await _fireJob(job.id);
-        }
-        catch { /* errors already captured into the run log */ }
-        const fresh = jobs.get(job.id);
-        if (!fresh)
-            return;
-        if (fresh.kind === 'oneshot') {
-            fresh.enabled = false;
-            jobs.set(fresh.id, { ...fresh });
-            save();
-            return;
-        }
-        if (fresh.enabled)
-            _scheduleJob(fresh);
-    }, delay);
-    if (typeof handle.unref === 'function')
-        handle.unref();
-    timers.set(job.id, handle);
-}
-async function _fireJob(id) {
-    const job = jobs.get(id);
-    if (!job)
-        return;
-    const startedMs = Date.now();
-    const cap = await (0, outputCapture_1.captureRun)(job.id, job.description || job.id, LOGS_DIR, async () => {
-        try {
-            const { executeTool } = await Promise.resolve().then(() => __importStar(require('./toolRegistry')));
-            const r = await executeTool('shell_exec', { command: job.action }, 0);
-            const text = typeof r === 'string' ? r : (r?.output ?? JSON.stringify(r));
-            const failed = r?.success === false;
-            return { output: String(text ?? ''), failed };
-        }
-        catch (e) {
-            return { output: e?.stack ?? e?.message ?? String(e), failed: true };
-        }
-    });
-    const fresh = jobs.get(id);
-    if (!fresh)
-        return;
-    fresh.lastRun = new Date(startedMs).toISOString();
-    fresh.lastResult = cap.result;
-    fresh.lastOutput = cap.output;
-    fresh.runCount = (fresh.runCount ?? 0) + 1;
-    jobs.set(fresh.id, { ...fresh });
-    save();
-}
-function clearTimer(id) {
-    const h = timers.get(id);
-    if (h) {
-        clearTimeout(h);
-        timers.delete(id);
-    }
-}
-// ── Public API ────────────────────────────────────────────────────────────────
-function createJob(description, schedule, action) {
-    const spec = (0, scheduleParser_1.parseSchedule)(schedule);
-    const id = String(jobSeq++);
-    const job = {
-        id,
-        description,
-        schedule: spec.display,
-        kind: spec.kind,
-        action,
-        enabled: true,
-        createdAt: new Date().toISOString(),
-        runCount: 0,
-        ...attachKindFields(spec),
-    };
-    const first = (0, scheduleParser_1.computeFirstFire)(job);
-    if (first)
-        job.nextRun = first.toISOString();
-    jobs.set(id, job);
-    _scheduleJob(job);
-    save();
-    return job;
-}
-function attachKindFields(spec) {
-    if (spec.kind === 'interval')
-        return { intervalMs: spec.intervalMs };
-    if (spec.kind === 'cron')
-        return { cronExpr: spec.cronExpr };
-    return { oneshotIso: spec.runAtIso };
-}
-function listJobs() {
-    return Array.from(jobs.values());
-}
-function getJob(id) {
-    return jobs.get(id);
-}
-function pauseJob(id) {
-    const job = jobs.get(id);
-    if (!job)
-        return false;
-    job.enabled = false;
-    clearTimer(id);
-    jobs.set(id, { ...job });
-    save();
-    return true;
-}
-function resumeJob(id) {
-    const job = jobs.get(id);
-    if (!job)
-        return false;
-    job.enabled = true;
-    jobs.set(id, { ...job });
-    _scheduleJob(job);
-    save();
-    return true;
-}
-function deleteJob(id) {
-    if (!jobs.has(id))
-        return false;
-    clearTimer(id);
-    jobs.delete(id);
-    save();
-    return true;
-}
-async function triggerJob(id) {
-    const job = jobs.get(id);
-    if (!job)
-        return false;
-    // A manual trigger should not double-fire alongside a pending timer; we
-    // cancel and re-arm after the run so the cadence anchors on the fresh
-    // lastRun set by _fireJob.
-    clearTimer(id);
-    await _fireJob(id);
-    const fresh = jobs.get(id);
-    if (fresh && fresh.enabled && fresh.kind !== 'oneshot')
-        _scheduleJob(fresh);
-    if (fresh && fresh.kind === 'oneshot') {
-        fresh.enabled = false;
-        jobs.set(fresh.id, { ...fresh });
-        save();
-    }
-    return true;
-}
-// ── Test hook ─────────────────────────────────────────────────────────────────
-//
-// Tests need to reset module state between cases. Production code never
-// reaches for this — it lives behind a name that signals "for tests" so
-// nobody depends on it accidentally.
-function __resetForTests() {
-    for (const id of timers.keys())
-        clearTimer(id);
-    jobs.clear();
-    jobSeq = 1;
-    pendingSave = Promise.resolve();
-}
+exports.isHeartbeatActive = exports.stopHeartbeat = exports.startHeartbeat = exports.getDiagnostics = exports.AIDEN_CRON_BUILD = exports.__resetForTests = exports.awaitPendingSaves = exports.parseSchedule = exports.triggerJob = exports.deleteJob = exports.resumeJob = exports.pauseJob = exports.createJobAsync = exports.createJob = exports.getJobAsync = exports.getJob = exports.listJobsAsync = exports.listJobs = exports.loadJobs = void 0;
+const cronManager_1 = require("./v4/cron/cronManager");
+Object.defineProperty(exports, "loadJobs", { enumerable: true, get: function () { return cronManager_1.loadJobs; } });
+Object.defineProperty(exports, "listJobs", { enumerable: true, get: function () { return cronManager_1.listJobs; } });
+Object.defineProperty(exports, "listJobsAsync", { enumerable: true, get: function () { return cronManager_1.listJobsAsync; } });
+Object.defineProperty(exports, "getJob", { enumerable: true, get: function () { return cronManager_1.getJob; } });
+Object.defineProperty(exports, "getJobAsync", { enumerable: true, get: function () { return cronManager_1.getJobAsync; } });
+Object.defineProperty(exports, "createJob", { enumerable: true, get: function () { return cronManager_1.createJob; } });
+Object.defineProperty(exports, "createJobAsync", { enumerable: true, get: function () { return cronManager_1.createJobAsync; } });
+Object.defineProperty(exports, "pauseJob", { enumerable: true, get: function () { return cronManager_1.pauseJob; } });
+Object.defineProperty(exports, "resumeJob", { enumerable: true, get: function () { return cronManager_1.resumeJob; } });
+Object.defineProperty(exports, "deleteJob", { enumerable: true, get: function () { return cronManager_1.deleteJob; } });
+Object.defineProperty(exports, "triggerJob", { enumerable: true, get: function () { return cronManager_1.triggerJob; } });
+Object.defineProperty(exports, "parseSchedule", { enumerable: true, get: function () { return cronManager_1.parseSchedule; } });
+Object.defineProperty(exports, "awaitPendingSaves", { enumerable: true, get: function () { return cronManager_1.awaitPendingSaves; } });
+Object.defineProperty(exports, "__resetForTests", { enumerable: true, get: function () { return cronManager_1.__resetForTests; } });
+Object.defineProperty(exports, "AIDEN_CRON_BUILD", { enumerable: true, get: function () { return cronManager_1.AIDEN_CRON_BUILD; } });
+Object.defineProperty(exports, "getDiagnostics", { enumerable: true, get: function () { return cronManager_1.getDiagnostics; } });
+Object.defineProperty(exports, "startHeartbeat", { enumerable: true, get: function () { return cronManager_1.startHeartbeat; } });
+Object.defineProperty(exports, "stopHeartbeat", { enumerable: true, get: function () { return cronManager_1.stopHeartbeat; } });
+Object.defineProperty(exports, "isHeartbeatActive", { enumerable: true, get: function () { return cronManager_1.isHeartbeatActive; } });

package/dist/core/gateway.js

@@ -9,13 +9,34 @@ exports.gateway = void 0;
 // All inbound messages (dashboard, Telegram, API, future channels)
 // are routed through a single processor so they share the same
 // memory, context, and tool pipeline.
+//
+// Phase v4.1-1.3a — replaced direct console.* writes with the
+// Logger contract from `core/v4/logger`. The CLI's REPL is sacred:
+// in cli-interactive mode the boot logger has no stdout sink, so
+// route/register lines go to ~/.aiden/logs/aiden.log instead of
+// corrupting the chat prompt. The legacy code path remains
+// available — until `attachLogger()` is called the noopLogger
+// silently drops every record (better than console.log for the
+// REPL invariant). api/server.ts in serve mode wires a logger
+// that writes NDJSON to stdout, preserving the daemon trace.
 const sessionRouter_1 = require("./sessionRouter");
+const logger_1 = require("./v4/logger");
 // ── Gateway class ──────────────────────────────────────────────
 class Gateway {
     constructor() {
         this.handlers = new Map();
         this.messageProcessor = null;
         this.activeChannels = new Set();
+        this.log = (0, logger_1.noopLogger)();
+    }
+    // ── Logger injection ─────────────────────────────────────────
+    //
+    // Phase v4.1-1.3a — boot wires this once before any registerChannel
+    // / routeMessage call. Until then, noopLogger drops everything so
+    // accidentally-imported gateway code in tests / scripts can't leak
+    // anything to stdout.
+    attachLogger(logger) {
+        this.log = logger;
     }
     // ── Register the central message processor (Aiden's brain) ───
     setProcessor(handler) {
@@ -25,13 +46,13 @@ class Gateway {
     registerChannel(channel, deliveryHandler) {
         this.handlers.set(channel, deliveryHandler);
         this.activeChannels.add(channel);
-        console.log(`[Gateway] Channel registered: ${channel}`);
+        this.log.info(`channel registered: ${channel}`);
     }
     // ── Unregister a channel ──────────────────────────────────────
     unregisterChannel(channel) {
         this.handlers.delete(channel);
         this.activeChannels.delete(channel);
-        console.log(`[Gateway] Channel unregistered: ${channel}`);
+        this.log.info(`channel unregistered: ${channel}`);
     }
     // ── Route an incoming message through Aiden ───────────────────
     async routeMessage(message) {
@@ -42,13 +63,12 @@ class Gateway {
         const session = sessionRouter_1.sessionRouter.getSession(message.userId, message.channel);
         session.messageCount++;
         message.sessionId = session.sessionId;
-        console.log(`[Gateway] ${message.channel}:${message.channelId} ` +
-            `[${session.sessionId}] → "${message.text.substring(0, 60)}"`);
+        this.log.debug(`${message.channel}:${message.channelId} → "${message.text.substring(0, 60)}"`, { sessionId: session.sessionId });
         const start = Date.now();
         try {
             let response = await this.messageProcessor(message);
             const duration = Date.now() - start;
-            console.log(`[Gateway] Response ready (${duration}ms) → ${message.channel}`);
+            this.log.debug(`response ready → ${message.channel}`, { durationMs: duration });
             // Hint on Telegram first message: conversation continues on desktop
             if (message.channel === 'telegram' && session.messageCount === 1) {
                 response += '\n\n_Tip: Continue this conversation on your desktop dashboard with full context._';
@@ -56,7 +76,7 @@ class Gateway {
             return response;
         }
         catch (error) {
-            console.error(`[Gateway] Processing failed:`, error);
+            this.log.error(`processing failed: ${error instanceof Error ? error.message : String(error)}`);
             return 'Something went wrong processing your message. Try again.';
         }
     }
@@ -64,14 +84,15 @@ class Gateway {
     async deliver(message) {
         const handler = this.handlers.get(message.channel);
         if (!handler) {
-            console.log(`[Gateway] No handler for channel: ${message.channel}`);
+            this.log.warn(`no handler for channel: ${message.channel}`);
             return false;
         }
         try {
             return await handler(message);
         }
         catch (error) {
-            console.error(`[Gateway] Delivery failed to ${message.channel}:`, error);
+            this.log.error(`delivery failed to ${message.channel}: ` +
+                (error instanceof Error ? error.message : String(error)));
             return false;
         }
     }

package/dist/core/playwrightBridge.js

@@ -47,6 +47,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.pwQueueDepth = pwQueueDepth;
+exports.setPwLogger = setPwLogger;
+exports.withPwLock = withPwLock;
+exports.pwAcquire = pwAcquire;
 exports.pwNavigate = pwNavigate;
 exports.pwScreenshot = pwScreenshot;
 exports.pwClick = pwClick;
@@ -77,6 +81,92 @@ let _idleTimer = null;
 const IDLE_MS = 5 * 60 * 1000; // 5 min
 const NAV_TIMEOUT = parseInt(process.env.AIDEN_BROWSER_TIMEOUT ?? '15000', 10);
 const HEADLESS = process.env.AIDEN_BROWSER_HEADLESS === 'true';
+// ── Phase v4.1-subagent — Browser mutex ──────────────────────
+// One global browser context lives in this module. Subagent fanout
+// can spin up N parallel agents — if two of them claim the browser
+// at the same instant they'd collide on `_activePage` (one navigates
+// while the other reads, racing on URL state).
+//
+// The mutex is a single-slot async lock: callers `await
+// pwAcquire()`, do their work, then call the returned `release()`.
+// First arrival runs immediately; subsequent arrivals queue. Because
+// every browser tool already calls `ensureContext` / `ensurePage`
+// first, the mutex wraps the whole tool body — release is idempotent
+// so callers can call it from a `finally`.
+//
+// Common path (no contention) costs one extra microtask. A queued
+// subagent waits exactly as long as the holder takes — no busy
+// loops, no timers.
+let _browserBusy = false;
+const _browserWaiters = [];
+/** Public observability — number of waiters currently queued plus
+ *  the holder (if any). Used by subagent diagnostics; not part of
+ *  the tool path. */
+function pwQueueDepth() {
+    return _browserWaiters.length + (_browserBusy ? 1 : 0);
+}
+let _pwLogger = null;
+function setPwLogger(logger) {
+    _pwLogger = logger;
+}
+/** Higher-order helper — wrap any browser-claiming code in this so
+ *  all callers queue on the same mutex. Tag identifies the caller
+ *  in the queued/granted log lines.
+ *
+ *  Integration plan: subagent fanout (Phase v4.1-subagent) wraps its
+ *  per-subagent browser tool dispatch with `withPwLock` so two
+ *  subagents claiming the browser concurrently queue. The existing
+ *  public pw* functions in this module are left as direct callers
+ *  for now — the v3 single-loop path has no contention and the
+ *  primitive can be added file-by-file as fanout flushes out the
+ *  hot paths. The smoke for v4.1-subagent tests `pwAcquire` /
+ *  `withPwLock` directly. */
+async function withPwLock(tag, fn) {
+    const queued = _browserWaiters.length + (_browserBusy ? 1 : 0);
+    if (queued > 0 && _pwLogger) {
+        _pwLogger.info('browser mutex: queued', { tag, depth: queued });
+    }
+    const release = await pwAcquire();
+    if (_pwLogger) {
+        _pwLogger.info('browser mutex: granted', { tag });
+    }
+    try {
+        return await fn();
+    }
+    finally {
+        release();
+    }
+}
+/** Acquire the browser mutex. The returned `release` is idempotent —
+ *  multiple calls are no-ops. Always call from a `finally` so a
+ *  thrown tool body never strands the lock. */
+async function pwAcquire() {
+    if (!_browserBusy) {
+        _browserBusy = true;
+        return makeRelease();
+    }
+    return new Promise((resolve) => {
+        _browserWaiters.push(() => {
+            _browserBusy = true;
+            resolve(makeRelease());
+        });
+    });
+}
+function makeRelease() {
+    let released = false;
+    return () => {
+        if (released)
+            return;
+        released = true;
+        _browserBusy = false;
+        const next = _browserWaiters.shift();
+        // Defer to a microtask so the releasing call chain finishes
+        // before the next claimant starts — keeps stack depth bounded
+        // under deeply queued fanouts.
+        if (next)
+            queueMicrotask(next);
+    };
+}
 function getBrowserProfileDir() {
     const base = (0, paths_1.getUserDataDir)();
     const dir = path_1.default.join(base, 'browser-profile');

package/dist/core/v4/aidenAgent.js

@@ -56,6 +56,7 @@ const EMPTY_RETRY_NOTE = '[System note: your previous turn returned empty conten
 // ── Class ────────────────────────────────────────────────────────────────
 class AidenAgent {
     constructor(opts) {
+        this.skillMinerTurnIdx = 0;
         // ── Cross-call state ─────────────────────────────────────────────────
         /** Cached system prompt — invalidated by setPersonalityOverlay/markMemoryDirty/explicit. */
         this.cachedSystemPrompt = null;
@@ -83,6 +84,8 @@ class AidenAgent {
         this.honestyEnforcement = opts.honestyEnforcement;
         this.skillTeacher = opts.skillTeacher;
         this.skillTeacherCallbacks = opts.skillTeacherCallbacks;
+        this.skillMiner = opts.skillMiner;
+        this.onSkillCandidate = opts.onSkillCandidate;
         this.resolveVerifiedFlag = opts.resolveVerifiedFlag;
         this.resolveToolset = opts.resolveToolset;
         this.promptBuilder = opts.promptBuilder;
@@ -264,6 +267,38 @@ class AidenAgent {
                 /* SkillTeacher failures must not break the turn */
             }
         }
+        // 11. SkillMiner post-loop observation. Stages a candidate into
+        //     `<aidenHome>/skills/learned/.candidates.json` for user
+        //     review via `/skills review`. Complementary to SkillTeacher
+        //     above (inline propose-and-write); the miner's queue is the
+        //     deferred, audit-first path.
+        if (this.skillMiner) {
+            try {
+                const turnIdx = this.skillMinerTurnIdx;
+                this.skillMinerTurnIdx += 1;
+                const traceForMiner = loopResult.toolCallTrace.map((entry, i) => ({
+                    name: entry.name,
+                    args: loopResult.fullTrace[i]?.args ?? {},
+                    result: entry.result,
+                    error: entry.error,
+                    toolset: this.resolveToolset?.(entry.name),
+                }));
+                const sessionId = this.sessionId ?? 'session';
+                const outcome = await this.skillMiner.observeTurn({
+                    trace: traceForMiner,
+                    sessionId,
+                    sourceTurnIdx: turnIdx,
+                    finishReason: loopResult.finishReason,
+                    history,
+                });
+                if (outcome.status === 'queued' && outcome.candidate && this.onSkillCandidate) {
+                    this.onSkillCandidate(outcome.candidate);
+                }
+            }
+            catch {
+                /* SkillMiner failures must not break the turn */
+            }
+        }
         return {
             finalContent,
             messages: loopResult.messages,

package/dist/core/v4/auxiliaryClient.js

@@ -16,8 +16,8 @@
  *   - SkillTeacher        (purpose: 'skill_describe')
  *   - smart approval      (purpose: 'risk_assess', wired in Phase 14)
  *
- * resolution chain (main provider → OpenRouter → Nous Portal → custom →
- * Anthropic). Aiden v4.0.0 keeps a single resolved adapter for simplicity;
+ * resolution chain (main provider → OpenRouter → portal subscription →
+ * custom → Anthropic). Aiden v4.0.0 keeps a single resolved adapter for simplicity;
  * the multi-provider fallback chain comes back in v4.1.
  *
  * Failure mode: when the cheap model is unavailable, returns empty content

package/dist/core/v4/cron/atomicWrite.js

@@ -67,8 +67,22 @@ async function writeJsonAtomic(filePath, data) {
     }
 }
 async function doWrite(filePath, data) {
-    const dir = path.dirname(filePath);
-    const baseTmp = `.${path.basename(filePath)}.${process.pid}.${Date.now()}.tmp`;
+    // Phase v4.1-cron — symlink-aware rename. If the destination
+    // path is a symlink (e.g. cron_jobs.json points at a file in a
+    // shared directory), naive `fs.rename` *replaces* the symlink with
+    // a regular file, detaching it from the link target. Resolve the
+    // symlink first so the rename lands on the actual target. When the
+    // path is NOT a symlink (or doesn't exist yet), `realpath` returns
+    // the path itself or throws ENOENT — both safe to fall through.
+    let resolvedPath = filePath;
+    try {
+        resolvedPath = await fsp.realpath(filePath);
+    }
+    catch {
+        // ENOENT (file doesn't exist yet) or non-symlink — use original.
+    }
+    const dir = path.dirname(resolvedPath);
+    const baseTmp = `.${path.basename(resolvedPath)}.${process.pid}.${Date.now()}.tmp`;
     const tmpPath = path.join(dir, baseTmp);
     await fsp.mkdir(dir, { recursive: true });
     const json = JSON.stringify(data, null, 2);
@@ -86,7 +100,7 @@ async function doWrite(filePath, data) {
         await fh.close();
     }
     try {
-        await fsp.rename(tmpPath, filePath);
+        await fsp.rename(tmpPath, resolvedPath);
     }
     catch (err) {
         // rename failed — clean up the orphan temp file before re-raising.
@@ -98,7 +112,7 @@ async function doWrite(filePath, data) {
     }
     // Owner-only access. Best-effort: NTFS may refuse but we try anyway.
     try {
-        await fsp.chmod(filePath, 0o600);
+        await fsp.chmod(resolvedPath, 0o600);
     }
     catch { /* windows / non-POSIX */ }
 }