talos-code 0.0.1 → 0.1.0

package/README.md

@@ -1,3 +1,111 @@
-# talos-code
-Official npm package of the TALOS CLI (https://github.com/Ninozzz95/talos).
-This first version reserves the name; the CLI is published here.
+# TALOS CLI
+
+TALOS in your terminal: a coding agent that reads, edits and runs code in your project, on the model you choose. Every tool
+asks before it acts unless you have allowed it, every file it changes can be restored, and every session can be resumed.
+
+The npm package is **`talos-code`**; the command it installs is **`talos`**.
+
+## Install
+
+TALOS CLI needs **Node.js 24** (24.18 or later in the 24 line).
+
+<!-- test:smoke -->
+```bash
+npm i -g talos-code
+talos --version
+```
+
+Tested on Windows 11 x64. macOS and Linux are not tested yet in 0.1.0.
+
+## Start
+
+Open a terminal in a project and run:
+
+<!-- test:smoke -->
+```bash
+talos
+```
+
+The first time, TALOS asks whether to trust the folder, then which provider and model to use. A key already in your
+environment (for example `OPENAI_API_KEY`) is used only after you agree once; otherwise you type it in hidden input and it
+is kept in the operating system's credential store, never in a file.
+
+For a one-shot task, without the interactive screen:
+
+<!-- test:smoke -->
+```bash
+talos -p "inspect this repository and explain the failing tests"
+```
+
+For machine-readable output:
+
+<!-- test:smoke -->
+```bash
+talos -p "summarize the changes" --json
+```
+
+## Models
+
+Cloud providers: OpenAI, Anthropic, Google Gemini, DeepSeek, OpenRouter, Mistral, Groq, xAI, Kimi, Qwen, Z.AI, MiniMax,
+Cerebras, Together, Fireworks, DeepInfra, Novita, Nebius, Hugging Face, Azure AI Foundry, Amazon Bedrock and Google
+Vertex AI. Local engines: Ollama, LM Studio and llama.cpp, with no key. TALOS never falls back from a local model to a cloud
+one on its own.
+
+`/provider` sets up a provider, `/model` (or `Alt+P`) picks the model, and `talos doctor` says what is ready.
+
+## What you can rely on
+
+- **Permissions.** Each tool is allowed, asked or denied, per project. Modes: `default`, `acceptEdits`, `plan`, `auto`,
+  `dontAsk`, `bypassPermissions`.
+- **Undo.** `/undo` restores the files a turn changed, from checkpoints kept outside your repository and outside Git.
+- **Sessions.** `/resume` and `/fork` open a picker; `talos --resume last` continues from the shell. Sessions can be exported
+  and imported; an imported session never runs anything by itself.
+- **Context.** With a model whose context window is known and at least 64k tokens, long conversations are compacted at
+  half of the window, and the screen says when and how much.
+- **Extensions.** MCP servers, hooks, plugins and custom commands, each trusted explicitly before it runs.
+
+In the interactive screen, `?` on an empty prompt shows the keys, `/help` the commands, `Ctrl+L` or `/redraw` repaints.
+`Shift+Enter` adds a line where the terminal reports it; `Ctrl+J` always does. Set `TALOS_REDUCED_MOTION=1` to turn the
+animations off, or pass `--no-color`.
+
+## Your data
+
+Nothing is sent anywhere except:
+
+- your prompts and the files TALOS reads, to the provider you chose;
+- the public model catalogue at models.dev, for context windows and prices, cached for 4 hours. Turn it off with
+  `talos config set catalog.modelsDev false` or `TALOS_MODELS_DEV=off`;
+- the npm registry, only when you run `talos update`.
+
+There is no telemetry. Configuration, sessions, checkpoints and logs stay on your machine:
+
+| | Windows | macOS / Linux |
+|---|---|---|
+| Configuration | `%APPDATA%\TALOS-CLI` | `~/.config/talos-cli` |
+| Sessions, checkpoints, logs | `%LOCALAPPDATA%\TALOS-CLI` | `~/.local/state/talos-cli` |
+
+## Update
+
+<!-- test:smoke -->
+```bash
+talos update --check
+```
+
+With an npm install, `talos update` tells you if a newer version exists and the command to run
+(`npm i -g talos-code@latest`). It does not change anything by itself.
+
+## Known limits in 0.1.0
+
+- Only Windows 11 x64 is tested.
+- Context compaction with a local Ollama model is not yet verified end to end.
+- A local provider that answers 401/403 without needing a key can be set aside as if its key were wrong.
+
+## Help
+
+`talos --help` lists every command, `/help` does the same inside the interactive screen, and `talos doctor` says what is
+missing when something does not work. `talos diagnostic bundle --out talos-diagnostic.zip` makes a redacted report for a
+bug; it contains no prompt or file content.
+
+## License
+
+AGPL-3.0-only. See `LICENSE` and `THIRD_PARTY_NOTICES.md` in this package.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,40 @@
+# TALOS CLI Third-Party Notices
+
+The package lock is the authoritative inventory for the complete dependency
+graph. The Windows runtime retains dependency package metadata and license
+files under `app/node_modules`.
+
+## Microsoft eXecution Containers SDK 0.8.0
+
+- Package: `@microsoft/mxc-sdk` `0.8.0`
+- Upstream: https://github.com/microsoft/mxc
+- Reviewed tag object: `c0ea508293705ddcc60baaf286aafd3776b42eb8`
+- npm integrity: `sha512-pnf5QsASwp+qtRi5uth2GDjwuyG0rHWRpxCf3RbAjQ4wDTNfBX/9l0A+RVZspU2agpF3/11uWB1JisIS7WrNYg==`
+- License: MIT
+
+MXC is distributed as a public preview and includes platform-specific native
+executables. TALOS checks host capability evidence before use and does not
+represent preview isolation as a security boundary unless the requested
+AppContainer, Bound File System, network, and process-tree controls have been
+verified on that host.
+
+The full upstream MIT license text is retained in
+`app/node_modules/@microsoft/mxc-sdk/LICENSE.md` in packaged runtimes.
+
+## jsdiff 9.0.0
+
+- Package: `diff` `9.0.0` (pinned exact, R3 owner decision 2026-09-24)
+- Upstream: https://github.com/kpdecker/jsdiff
+- npm integrity: `sha512-svtcdpS8CgJyqAjEQIXdb3OjhFVVYjzGAPO8WGCmRbrml64SPw/jJD4GoE98aR7r25A0XcgrK3F02yw9R/vhQw==`
+- License: BSD-3-Clause
+
+Used only to compute line differences for the file-change summaries and diffs TALOS shows; it never touches files.
+The full upstream BSD-3-Clause license text is retained in `app/node_modules/diff/LICENSE` in packaged runtimes.
+
+## Other direct runtime dependencies
+
+| Component | Upstream | License |
+|---|---|---|
+| ink 7.1.1 | https://github.com/vadimdemedes/ink | MIT |
+| react 19.3.0 | https://github.com/facebook/react | MIT |
+| string-width 8.2.2 | https://github.com/sindresorhus/string-width | MIT |

package/dist/archive/zip.js

@@ -0,0 +1,73 @@
+import { inflateRawSync } from 'node:zlib';
+import { crc32 } from "../diagnostics/zip.js";
+const MAX_ENTRIES = 2048;
+const MAX_ENTRY_BYTES = 64 * 1024 * 1024;
+const MAX_TOTAL_BYTES = 256 * 1024 * 1024;
+function fail(code) { throw Object.assign(new Error(code), { code }); }
+function locateEocd(buf) { for (let i = buf.length - 22; i >= Math.max(0, buf.length - 65_557); i--)
+    if (buf.readUInt32LE(i) === 0x06054b50)
+        return i; return -1; }
+export function readZipEntries(buf) {
+    const eocd = locateEocd(buf);
+    if (eocd < 0)
+        fail('ZIP_EOCD_NOT_FOUND');
+    const disk = buf.readUInt16LE(eocd + 4), centralDisk = buf.readUInt16LE(eocd + 6);
+    if (disk !== 0 || centralDisk !== 0)
+        fail('ZIP_MULTIDISK_UNSUPPORTED');
+    const count = buf.readUInt16LE(eocd + 10);
+    if (count > MAX_ENTRIES)
+        fail('ZIP_TOO_MANY_ENTRIES');
+    let off = buf.readUInt32LE(eocd + 16);
+    const result = new Map();
+    let total = 0;
+    for (let i = 0; i < count; i++) {
+        if (off + 46 > buf.length || buf.readUInt32LE(off) !== 0x02014b50)
+            fail('ZIP_CENTRAL_INVALID');
+        const flags = buf.readUInt16LE(off + 8);
+        const method = buf.readUInt16LE(off + 10);
+        const expectedCrc = buf.readUInt32LE(off + 16);
+        const compressed = buf.readUInt32LE(off + 20), uncompressed = buf.readUInt32LE(off + 24);
+        const nameLen = buf.readUInt16LE(off + 28), extraLen = buf.readUInt16LE(off + 30), commentLen = buf.readUInt16LE(off + 32);
+        const local = buf.readUInt32LE(off + 42);
+        if (flags & 1)
+            fail('ZIP_ENCRYPTED_UNSUPPORTED');
+        if (uncompressed > MAX_ENTRY_BYTES)
+            fail('ZIP_ENTRY_TOO_LARGE');
+        total += uncompressed;
+        if (total > MAX_TOTAL_BYTES)
+            fail('ZIP_TOO_LARGE');
+        if (off + 46 + nameLen + extraLen + commentLen > buf.length)
+            fail('ZIP_CENTRAL_INVALID');
+        const name = buf.subarray(off + 46, off + 46 + nameLen).toString('utf8').replaceAll('\\', '/');
+        if (result.has(name))
+            fail('ZIP_DUPLICATE_ENTRY');
+        if (local + 30 > buf.length || buf.readUInt32LE(local) !== 0x04034b50)
+            fail('ZIP_LOCAL_INVALID');
+        const localName = buf.readUInt16LE(local + 26), localExtra = buf.readUInt16LE(local + 28);
+        const dataStart = local + 30 + localName + localExtra;
+        if (dataStart + compressed > buf.length)
+            fail('ZIP_DATA_INVALID');
+        const raw = buf.subarray(dataStart, dataStart + compressed);
+        let data;
+        try {
+            if (method === 0)
+                data = Buffer.from(raw);
+            else if (method === 8)
+                data = inflateRawSync(raw);
+            else
+                fail(`ZIP_METHOD_UNSUPPORTED:${method}`);
+        }
+        catch (error) {
+            if (error?.code)
+                throw error;
+            fail('ZIP_DEFLATE_INVALID');
+        }
+        if (data.length !== uncompressed)
+            fail('ZIP_SIZE_MISMATCH');
+        if (crc32(data) !== expectedCrc)
+            fail('ZIP_CRC_MISMATCH');
+        result.set(name, data);
+        off += 46 + nameLen + extraLen + commentLen;
+    }
+    return result;
+}

package/dist/args.js

@@ -0,0 +1,97 @@
+import { parseArgs } from 'node:util';
+const MODES = new Set(['default', 'acceptEdits', 'plan', 'auto', 'dontAsk', 'bypassPermissions']);
+const FORMATS = new Set(['text', 'json', 'stream-json']);
+const PROTOCOLS = new Set(['v1', 'v2']);
+const SUBCOMMANDS = new Set(['project', 'config', 'provider', 'model', 'session', 'mcp', 'hook', 'plugin', 'command', 'memory', 'notes', 'tasks', 'library', 'research', 'automation', 'forge', 'checkpoint', 'doctor', 'logs', 'diagnostic', 'update', 'init']);
+function positiveInt(raw, flag) {
+    if (raw === undefined)
+        return undefined;
+    if (!/^\d+$/u.test(raw) || Number(raw) <= 0)
+        throw new Error(flag + ' must be a positive integer');
+    return Number(raw);
+}
+function firstPositionalIndex(argv) {
+    const needsValue = new Set(['--print', '-p', '--output-format', '--protocol', '--project', '--model', '--permission-mode', '--resume', '--fork', '--timeout']);
+    for (let i = 0; i < argv.length; i++) {
+        const token = argv[i];
+        if (token === '--')
+            return i + 1 < argv.length ? i + 1 : -1;
+        if (token.startsWith('--') && token.includes('='))
+            continue;
+        if (token.startsWith('-')) {
+            if (needsValue.has(token))
+                i += 1;
+            continue;
+        }
+        return i;
+    }
+    return -1;
+}
+export function parseCliArgs(argv) {
+    const first = firstPositionalIndex(argv);
+    const subcommandIndex = first >= 0 && SUBCOMMANDS.has(argv[first]) ? first : -1;
+    const parseArgv = subcommandIndex >= 0 ? argv.slice(0, subcommandIndex) : argv;
+    const { values, positionals } = parseArgs({
+        args: parseArgv,
+        allowPositionals: true,
+        strict: true,
+        options: {
+            print: { type: 'string', short: 'p' },
+            json: { type: 'boolean' },
+            'output-format': { type: 'string' },
+            protocol: { type: 'string' },
+            project: { type: 'string' }, model: { type: 'string' },
+            'permission-mode': { type: 'string' }, resume: { type: 'string' }, fork: { type: 'string' },
+            verbose: { type: 'boolean', short: 'v' }, 'no-color': { type: 'boolean' }, timeout: { type: 'string' },
+            version: { type: 'boolean' }, help: { type: 'boolean', short: 'h' },
+        }
+    });
+    if (values.resume && values.fork)
+        throw new Error('--resume and --fork are mutually exclusive');
+    const rawProtocol = values.protocol;
+    if (rawProtocol !== undefined && !PROTOCOLS.has(rawProtocol))
+        throw new Error('Invalid protocol: ' + rawProtocol);
+    const protocolVersion = (rawProtocol ?? 'v1');
+    if (values.version)
+        return { command: 'version', interactive: false, outputFormat: 'text', protocolVersion, verbose: false, color: true, positionals: [] };
+    if (values.help)
+        return { command: 'help', interactive: false, outputFormat: 'text', protocolVersion, verbose: false, color: true, positionals };
+    const rawMode = values['permission-mode'];
+    if (rawMode !== undefined && !MODES.has(rawMode))
+        throw new Error('Invalid permission mode: ' + rawMode);
+    let outputFormat = 'text';
+    if (values.json)
+        outputFormat = 'json';
+    if (values['output-format'] !== undefined) {
+        if (!FORMATS.has(values['output-format']))
+            throw new Error('Invalid output format: ' + values['output-format']);
+        outputFormat = values['output-format'];
+    }
+    if (protocolVersion === 'v2' && subcommandIndex >= 0)
+        throw new Error('--protocol v2 is only available for headless runs');
+    if (protocolVersion === 'v2' && outputFormat === 'text')
+        throw new Error('--protocol v2 requires --json or --output-format stream-json');
+    if (subcommandIndex >= 0) {
+        const timeoutSeconds = positiveInt(values.timeout, '--timeout');
+        return {
+            command: 'subcommand', interactive: false, outputFormat, protocolVersion,
+            ...(rawMode !== undefined ? { permissionMode: rawMode } : {}),
+            ...(values.project !== undefined ? { project: values.project } : {}), ...(values.model !== undefined ? { model: values.model } : {}),
+            ...(values.resume !== undefined ? { resume: values.resume } : {}), ...(values.fork !== undefined ? { fork: values.fork } : {}),
+            verbose: values.verbose ?? false, color: !(values['no-color'] ?? false), ...(timeoutSeconds !== undefined ? { timeoutSeconds } : {}),
+            positionals: argv.slice(subcommandIndex),
+        };
+    }
+    const promptParts = values.print !== undefined ? [values.print] : positionals;
+    const prompt = promptParts.length ? promptParts.join(' ') : undefined;
+    const interactive = values.print === undefined && outputFormat === 'text';
+    const timeoutSeconds = positiveInt(values.timeout, '--timeout');
+    return {
+        command: 'run', interactive, outputFormat, protocolVersion,
+        ...(prompt !== undefined ? { prompt } : {}), ...(rawMode !== undefined ? { permissionMode: rawMode } : {}),
+        ...(values.project !== undefined ? { project: values.project } : {}), ...(values.model !== undefined ? { model: values.model } : {}),
+        ...(values.resume !== undefined ? { resume: values.resume } : {}), ...(values.fork !== undefined ? { fork: values.fork } : {}),
+        verbose: values.verbose ?? false, color: !(values['no-color'] ?? false), ...(timeoutSeconds !== undefined ? { timeoutSeconds } : {}),
+        positionals: [...positionals],
+    };
+}

package/dist/automations/history-store.js

@@ -0,0 +1,34 @@
+import { mkdir, readFile, rename, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+function fail(code) { throw Object.assign(new Error(code), { code }); }
+function safeId(id) { if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(id))
+    fail('AUTOMATION_ID_INVALID'); return id; }
+function entry(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        fail('AUTOMATION_HISTORY_INVALID');
+    const outcome = value.outcome;
+    if (!['dispatch-started', 'dispatch-failed', 'missed-skipped'].includes(outcome))
+        fail('AUTOMATION_HISTORY_INVALID');
+    const nullable = (v) => v === null ? null : typeof v === 'string' ? v : fail('AUTOMATION_HISTORY_INVALID');
+    if (typeof value.attemptedAt !== 'string' || Number.isNaN(Date.parse(value.attemptedAt)))
+        fail('AUTOMATION_HISTORY_INVALID');
+    return { attemptedAt: new Date(value.attemptedAt).toISOString(), scheduledAt: nullable(value.scheduledAt), slotKey: nullable(value.slotKey), outcome, sessionId: nullable(value.sessionId), errorCode: nullable(value.errorCode), errorMessage: nullable(value.errorMessage), nextRetryAt: nullable(value.nextRetryAt) };
+}
+export function createAutomationHistoryStore(directory, options = {}) {
+    const limit = Number.isSafeInteger(options.limit) && Number(options.limit) > 0 ? Number(options.limit) : 200;
+    const pathFor = (id) => join(directory, safeId(id) + '.json');
+    async function list(id) { const path = pathFor(id); try {
+        const parsed = JSON.parse(await readFile(path, 'utf8'));
+        if (!Array.isArray(parsed))
+            fail('AUTOMATION_HISTORY_INVALID');
+        return parsed.map(entry);
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return [];
+        throw error;
+    } }
+    async function append(id, value) { const rows = await list(id); rows.push(entry(value)); const kept = rows.slice(-limit); await mkdir(directory, { recursive: true }); const path = pathFor(id), tmp = path + '.tmp-' + process.pid; await writeFile(tmp, JSON.stringify(kept, null, 2) + '\n', 'utf8'); await rename(tmp, path); return kept.at(-1); }
+    async function remove(id) { await rm(pathFor(id), { force: true }); }
+    return { list, append, delete: remove };
+}

package/dist/automations/policy-store.js

@@ -0,0 +1,43 @@
+import { mkdir, readFile, rename, writeFile, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { validateTimeZone } from "./schedule.js";
+function fail(code) { throw Object.assign(new Error(code), { code }); }
+function safeId(id) { if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(id))
+    fail('AUTOMATION_ID_INVALID'); return id; }
+function positive(value, name, zero = false) { if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < (zero ? 0 : 1))
+    fail(name); return value; }
+function normalize(id, value) {
+    safeId(id);
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        fail('AUTOMATION_POLICY_INVALID');
+    let schedule;
+    if (value.schedule?.kind === 'legacy')
+        schedule = { kind: 'legacy' };
+    else if (value.schedule?.kind === 'daily' && typeof value.schedule.at === 'string' && /^([01]\d|2[0-3]):[0-5]\d$/u.test(value.schedule.at) && typeof value.schedule.timezone === 'string')
+        schedule = { kind: 'daily', at: value.schedule.at, timezone: validateTimeZone(value.schedule.timezone) };
+    else
+        fail('AUTOMATION_POLICY_INVALID');
+    const mode = value.missedRun?.mode;
+    if (mode !== 'skip' && mode !== 'latest')
+        fail('AUTOMATION_POLICY_INVALID');
+    const missedRun = { mode, graceMinutes: positive(value.missedRun?.graceMinutes, 'AUTOMATION_POLICY_INVALID', true), catchupWindowMinutes: positive(value.missedRun?.catchupWindowMinutes, 'AUTOMATION_POLICY_INVALID', true) };
+    const baseSeconds = positive(value.backoff?.baseSeconds, 'AUTOMATION_POLICY_INVALID'), maxSeconds = positive(value.backoff?.maxSeconds, 'AUTOMATION_POLICY_INVALID');
+    if (maxSeconds < baseSeconds)
+        fail('AUTOMATION_POLICY_INVALID');
+    const consecutiveFailures = positive(value.backoff?.consecutiveFailures, 'AUTOMATION_POLICY_INVALID', true), nextRetryAt = value.backoff?.nextRetryAt === null ? null : typeof value.backoff?.nextRetryAt === 'string' && !Number.isNaN(Date.parse(value.backoff.nextRetryAt)) ? new Date(value.backoff.nextRetryAt).toISOString() : fail('AUTOMATION_POLICY_INVALID');
+    return { version: 1, automationId: id, schedule, missedRun, backoff: { baseSeconds, maxSeconds, consecutiveFailures, nextRetryAt }, lastHandledSlot: value.lastHandledSlot === null ? null : typeof value.lastHandledSlot === 'string' ? value.lastHandledSlot : fail('AUTOMATION_POLICY_INVALID') };
+}
+export function createAutomationPolicyStore(directory) {
+    const pathFor = (id) => join(directory, safeId(id) + '.json');
+    async function get(id) { const path = pathFor(id); try {
+        return normalize(id, JSON.parse(await readFile(path, 'utf8')));
+    }
+    catch (error) {
+        if (error?.code === 'ENOENT')
+            return null;
+        throw error;
+    } }
+    async function put(id, value) { const row = normalize(id, { ...value, automationId: id }); await mkdir(directory, { recursive: true }); const path = pathFor(id), tmp = path + '.tmp-' + process.pid; await writeFile(tmp, JSON.stringify(row, null, 2) + '\n', 'utf8'); await rename(tmp, path); return row; }
+    async function remove(id) { await rm(pathFor(id), { force: true }); }
+    return { get, put, delete: remove };
+}

package/dist/automations/runner.js

@@ -0,0 +1,107 @@
+import { decideAutomationSchedule } from "./schedule.js";
+export async function runDueAutomations(rows, { now = Date.now(), runtime }) { const ran = []; const failed = []; for (const r of rows) {
+    if (!r.enabled || Date.parse(r.nextRunAt) > now)
+        continue;
+    try {
+        await runtime.start({ projectRoot: r.projectRoot, prompt: r.prompt, model: r.model, permissionMode: r.permissionMode });
+        ran.push(r.id);
+    }
+    catch (e) {
+        failed.push({ id: r.id, error: e instanceof Error ? e.message : String(e) });
+    }
+} return { ran, failed }; }
+const DEFAULT_BACKOFF = { baseSeconds: 30, maxSeconds: 900, consecutiveFailures: 0, nextRetryAt: null };
+const DEFAULT_MISSED = { mode: 'skip', graceMinutes: 5, catchupWindowMinutes: 0 };
+function legacyDecision(row, now) {
+    if (!row.attiva)
+        return { action: 'wait', reason: 'inactive', slot: null, nextAt: row.prossimaEsecuzione ?? null };
+    if (!row.prossimaEsecuzione)
+        return { action: 'wait', reason: 'no-next-run', slot: null, nextAt: null };
+    const due = Date.parse(row.prossimaEsecuzione);
+    if (Number.isNaN(due))
+        return { action: 'wait', reason: 'invalid-next-run', slot: null, nextAt: null };
+    if (due > now)
+        return { action: 'wait', reason: 'future', slot: null, nextAt: new Date(due).toISOString() };
+    return { action: 'run', reason: 'legacy-due', slot: { slotKey: 'legacy:' + new Date(due).toISOString(), scheduledAt: new Date(due).toISOString(), adjustedForDst: false }, nextAt: null };
+}
+export async function dryRunAutomation(input) {
+    const now = input.now ?? Date.now(), row = input.row, policy = input.policy;
+    if (!row.attiva)
+        return { action: 'wait', reason: 'inactive', slot: null, nextAt: row.prossimaEsecuzione ?? null };
+    if (policy?.backoff.nextRetryAt && Date.parse(policy.backoff.nextRetryAt) > now)
+        return { action: 'wait', reason: 'backoff', slot: null, nextAt: policy.backoff.nextRetryAt };
+    if (policy?.schedule.kind === 'daily')
+        return decideAutomationSchedule({ schedule: policy.schedule, now, lastHandledSlot: policy.lastHandledSlot, policy: policy.missedRun });
+    return legacyDecision(row, now);
+}
+function errorInfo(error) { const e = error; return { code: typeof e?.code === 'string' ? e.code : 'AUTOMATION_DISPATCH_FAILED', message: error instanceof Error ? error.message : String(error) }; }
+function policyForFailure(row, policy) {
+    return policy ?? { version: 1, automationId: row.id, schedule: { kind: 'legacy' }, missedRun: DEFAULT_MISSED, backoff: { ...DEFAULT_BACKOFF }, lastHandledSlot: null };
+}
+function nextBackoff(policy, now) {
+    const failures = policy.backoff.consecutiveFailures + 1;
+    const seconds = Math.min(policy.backoff.maxSeconds, policy.backoff.baseSeconds * (2 ** Math.min(failures - 1, 20)));
+    return { ...policy, backoff: { ...policy.backoff, consecutiveFailures: failures, nextRetryAt: new Date(now + seconds * 1000).toISOString() } };
+}
+function utcDay(ms) { return new Date(ms).toISOString().slice(0, 10); }
+export async function runAutomationTick(input) {
+    const now = input.now ?? Date.now(), started = [], failed = [], skipped = [];
+    for (const row of input.rows) {
+        let policy = await input.policyFor(row.id);
+        const decision = await dryRunAutomation({ now, row, policy });
+        const count = row.giornoContatore === utcDay(now) ? Number(row.eseguiteOggi ?? 0) : 0;
+        if (decision.action === 'run' && typeof row.limiteAlGiorno === 'number' && Number.isFinite(row.limiteAlGiorno) && count >= row.limiteAlGiorno) {
+            skipped.push({ id: row.id, reason: 'daily-limit' });
+            continue;
+        }
+        if (decision.action === 'skip-missed' && decision.slot) {
+            if (policy) {
+                policy = { ...policy, lastHandledSlot: decision.slot.slotKey };
+                await input.savePolicy(row.id, policy);
+            }
+            await input.appendHistory(row.id, { attemptedAt: new Date(now).toISOString(), scheduledAt: decision.slot.scheduledAt, slotKey: decision.slot.slotKey, outcome: 'missed-skipped', sessionId: null, errorCode: null, errorMessage: null, nextRetryAt: null });
+            skipped.push({ id: row.id, reason: decision.reason });
+            continue;
+        }
+        if (decision.action !== 'run' || !decision.slot) {
+            skipped.push({ id: row.id, reason: decision.reason });
+            continue;
+        }
+        let sessionId = null;
+        try {
+            const result = await input.registry.avvia(row.taskId, {}, { kind: 'talos-cli-automation' });
+            if (result?.erroreAvvio)
+                throw Object.assign(new Error(String(result.erroreAvvio)), { code: result.code });
+            sessionId = typeof result === 'string' ? result : typeof result?.sessionId === 'string' ? result.sessionId : null;
+            if (!sessionId)
+                throw Object.assign(new Error('AUTOMATION_SESSION_ID_MISSING'), { code: 'AUTOMATION_SESSION_ID_MISSING' });
+        }
+        catch (error) {
+            policy = nextBackoff(policyForFailure(row, policy), now);
+            await input.savePolicy(row.id, policy);
+            const info = errorInfo(error);
+            const history = { attemptedAt: new Date(now).toISOString(), scheduledAt: decision.slot.scheduledAt, slotKey: decision.slot.slotKey, outcome: 'dispatch-failed', sessionId: null, errorCode: info.code, errorMessage: info.message, nextRetryAt: policy.backoff.nextRetryAt };
+            await input.appendHistory(row.id, history);
+            failed.push({ id: row.id, taskId: row.taskId, ...info, nextRetryAt: policy.backoff.nextRetryAt });
+            continue;
+        }
+        const bookkeepingErrors = [];
+        const bookkeeping = async (stage, operation) => { try {
+            await operation();
+        }
+        catch (error) {
+            const info = errorInfo(error);
+            bookkeepingErrors.push({ stage, ...info });
+        } };
+        const history = { attemptedAt: new Date(now).toISOString(), scheduledAt: decision.slot.scheduledAt, slotKey: decision.slot.slotKey, outcome: 'dispatch-started', sessionId, errorCode: null, errorMessage: null, nextRetryAt: null };
+        await bookkeeping('history', () => input.appendHistory(row.id, history));
+        if (policy) {
+            policy = { ...policy, lastHandledSlot: policy.schedule.kind === 'daily' ? decision.slot.slotKey : policy.lastHandledSlot, backoff: { ...policy.backoff, consecutiveFailures: 0, nextRetryAt: null } };
+            const saved = policy;
+            await bookkeeping('policy', () => input.savePolicy(row.id, saved));
+        }
+        await bookkeeping('execution-store', () => input.recordExecution(row.id));
+        started.push({ id: row.id, taskId: row.taskId, sessionId, slotKey: decision.slot.slotKey, bookkeepingErrors });
+    }
+    return { started, failed, skipped };
+}

package/dist/automations/schedule.js

@@ -0,0 +1,85 @@
+function fail(code) { throw Object.assign(new Error(code), { code }); }
+function two(n) { return String(n).padStart(2, '0'); }
+function dateKey(y, m, d) { return String(y).padStart(4, '0') + '-' + two(m) + '-' + two(d); }
+function dateParts(key) { return [Number(key.slice(0, 4)), Number(key.slice(5, 7)), Number(key.slice(8, 10))]; }
+function addDate(key, days) { const [y, m, d] = dateParts(key); return new Date(Date.UTC(y, m - 1, d + days)).toISOString().slice(0, 10); }
+function wallMinutes(at) { if (!/^([01]\d|2[0-3]):[0-5]\d$/u.test(at))
+    fail('AUTOMATION_TIME_INVALID'); return Number(at.slice(0, 2)) * 60 + Number(at.slice(3, 5)); }
+export function validateTimeZone(value) {
+    if (value !== 'UTC' && !/^[A-Za-z_]+(?:\/[A-Za-z0-9._+-]+)+$/u.test(value))
+        fail('AUTOMATION_TIMEZONE_INVALID');
+    try {
+        new Intl.DateTimeFormat('en-US', { timeZone: value }).format(new Date(0));
+    }
+    catch {
+        fail('AUTOMATION_TIMEZONE_INVALID');
+    }
+    return value;
+}
+function localParts(ms, timeZone) {
+    const parts = new Intl.DateTimeFormat('en-CA', { timeZone, year: 'numeric', month: '2-digit', day: '2-digit', hour: '2-digit', minute: '2-digit', second: '2-digit', hourCycle: 'h23' }).formatToParts(new Date(ms));
+    const value = (type) => Number(parts.find(p => p.type === type)?.value);
+    return { year: value('year'), month: value('month'), day: value('day'), hour: value('hour'), minute: value('minute') };
+}
+function localDate(ms, tz) { const p = localParts(ms, tz); return dateKey(p.year, p.month, p.day); }
+function resolveLocal(date, at, timeZone) {
+    validateTimeZone(timeZone);
+    const target = wallMinutes(at);
+    const [y, m, d] = dateParts(date), hh = Number(at.slice(0, 2)), mm = Number(at.slice(3, 5));
+    const rough = Date.UTC(y, m - 1, d, hh, mm), exact = [], later = [];
+    for (let ms = rough - 18 * 60 * 60_000; ms <= rough + 18 * 60 * 60_000; ms += 60_000) {
+        const p = localParts(ms, timeZone);
+        if (dateKey(p.year, p.month, p.day) !== date)
+            continue;
+        const wall = p.hour * 60 + p.minute;
+        if (wall === target)
+            exact.push(ms);
+        else if (wall > target)
+            later.push({ ms, wall });
+    }
+    let chosen, adjusted = false;
+    if (exact.length)
+        chosen = Math.min(...exact);
+    else {
+        later.sort((a, b) => a.wall - b.wall || a.ms - b.ms);
+        if (!later.length)
+            fail('AUTOMATION_SCHEDULE_UNRESOLVABLE');
+        chosen = later[0].ms;
+        adjusted = true;
+    }
+    return { slotKey: date + '@' + at + '[' + timeZone + ']', scheduledAt: new Date(chosen).toISOString(), adjustedForDst: adjusted };
+}
+export function nextDailySlot(schedule, afterMs) {
+    const timezone = validateTimeZone(schedule.timezone);
+    wallMinutes(schedule.at);
+    const start = localDate(afterMs, timezone);
+    for (let i = 0; i < 4; i++) {
+        const slot = resolveLocal(addDate(start, i), schedule.at, timezone);
+        if (Date.parse(slot.scheduledAt) > afterMs)
+            return slot;
+    }
+    fail('AUTOMATION_SCHEDULE_UNRESOLVABLE');
+}
+function latestDailySlot(schedule, now) {
+    const timezone = validateTimeZone(schedule.timezone);
+    wallMinutes(schedule.at);
+    const today = localDate(now, timezone);
+    const slot = resolveLocal(today, schedule.at, timezone);
+    if (Date.parse(slot.scheduledAt) <= now)
+        return slot;
+    return resolveLocal(addDate(today, -1), schedule.at, timezone);
+}
+export function decideAutomationSchedule(input) {
+    const slot = latestDailySlot(input.schedule, input.now);
+    if (input.lastHandledSlot === slot.slotKey) {
+        const next = nextDailySlot(input.schedule, input.now);
+        return { action: 'wait', reason: 'slot-handled', slot: null, nextAt: next.scheduledAt };
+    }
+    const lateness = Math.max(0, (input.now - Date.parse(slot.scheduledAt)) / 60_000), grace = Math.max(0, input.policy.graceMinutes), catchup = Math.max(0, input.policy.catchupWindowMinutes);
+    if (lateness <= grace)
+        return { action: 'run', reason: 'due', slot, nextAt: null };
+    const next = nextDailySlot(input.schedule, input.now);
+    if (input.policy.mode === 'latest' && lateness <= catchup)
+        return { action: 'run', reason: 'latest-missed', slot, nextAt: null };
+    return { action: 'skip-missed', reason: input.policy.mode === 'skip' ? 'missed-policy-skip' : 'missed-window-expired', slot, nextAt: next.scheduledAt };
+}