@poolzin/pool-bot 2026.2.0 → 2026.2.1

package/dist/cli/cron-cli/register.cron-add.js

@@ -1,9 +1,9 @@
 import { danger } from "../../globals.js";
-import { defaultRuntime } from "../../runtime.js";
 import { sanitizeAgentId } from "../../routing/session-key.js";
+import { defaultRuntime } from "../../runtime.js";
 import { addGatewayClientOptions, callGatewayFromCli } from "../gateway-rpc.js";
 import { parsePositiveIntOrUndefined } from "../program/helpers.js";
-import { getCronChannelOptions, parseAtMs, parseDurationMs, printCronList, warnIfCronSchedulerDisabled, } from "./shared.js";
+import { getCronChannelOptions, parseAt, parseDurationMs, printCronList, warnIfCronSchedulerDisabled, } from "./shared.js";
 export function registerCronStatusCommand(cron) {
     addGatewayClientOptions(cron
         .command("status")
@@ -53,9 +53,10 @@ export function registerCronAddCommand(cron) {
         .option("--description <text>", "Optional description")
         .option("--disabled", "Create job disabled", false)
         .option("--delete-after-run", "Delete one-shot job after it succeeds", false)
+        .option("--keep-after-run", "Keep one-shot job after it succeeds", false)
         .option("--agent <id>", "Agent id for this job")
-        .option("--session <target>", "Session target (main|isolated)", "main")
-        .option("--wake <mode>", "Wake mode (now|next-heartbeat)", "next-heartbeat")
+        .option("--session <target>", "Session target (main|isolated)")
+        .option("--wake <mode>", "Wake mode (now|next-heartbeat)", "now")
         .option("--at <when>", "Run once at time (ISO) or +duration (e.g. 20m)")
         .option("--every <duration>", "Run every duration (e.g. 10m, 1h)")
         .option("--cron <expr>", "Cron expression (5-field)")
@@ -65,15 +66,14 @@ export function registerCronAddCommand(cron) {
         .option("--thinking <level>", "Thinking level for agent jobs (off|minimal|low|medium|high)")
         .option("--model <model>", "Model override for agent jobs (provider/model or alias)")
         .option("--timeout-seconds <n>", "Timeout seconds for agent jobs")
-        .option("--deliver", "Deliver agent output (required when using last-route delivery without --to)", false)
+        .option("--announce", "Announce summary to a chat (subagent-style)", false)
+        .option("--deliver", "Deprecated (use --announce). Announces a summary to a chat.")
+        .option("--no-deliver", "Disable announce delivery and skip main-session summary")
         .option("--channel <channel>", `Delivery channel (${getCronChannelOptions()})`, "last")
         .option("--to <dest>", "Delivery destination (E.164, Telegram chatId, or Discord channel/user)")
         .option("--best-effort-deliver", "Do not fail the job if delivery fails", false)
-        .option("--post-prefix <prefix>", "Prefix for main-session post", "Cron")
-        .option("--post-mode <mode>", "What to post back to main for isolated jobs (summary|full)", "summary")
-        .option("--post-max-chars <n>", "Max chars when --post-mode=full (default 8000)", "8000")
         .option("--json", "Output JSON", false)
-        .action(async (opts) => {
+        .action(async (opts, cmd) => {
         try {
             const schedule = (() => {
                 const at = typeof opts.at === "string" ? opts.at : "";
@@ -84,15 +84,17 @@ export function registerCronAddCommand(cron) {
                     throw new Error("Choose exactly one schedule: --at, --every, or --cron");
                 }
                 if (at) {
-                    const atMs = parseAtMs(at);
-                    if (!atMs)
+                    const atIso = parseAt(at);
+                    if (!atIso) {
                         throw new Error("Invalid --at; use ISO time or duration like 20m");
-                    return { kind: "at", atMs };
+                    }
+                    return { kind: "at", at: atIso };
                 }
                 if (every) {
                     const everyMs = parseDurationMs(every);
-                    if (!everyMs)
+                    if (!everyMs) {
                         throw new Error("Invalid --every; use e.g. 10m, 1h, 1d");
+                    }
                     return { kind: "every", everyMs };
                 }
                 return {
@@ -101,19 +103,20 @@ export function registerCronAddCommand(cron) {
                     tz: typeof opts.tz === "string" && opts.tz.trim() ? opts.tz.trim() : undefined,
                 };
             })();
-            const sessionTargetRaw = typeof opts.session === "string" ? opts.session : "main";
-            const sessionTarget = sessionTargetRaw.trim() || "main";
-            if (sessionTarget !== "main" && sessionTarget !== "isolated") {
-                throw new Error("--session must be main or isolated");
-            }
-            const wakeModeRaw = typeof opts.wake === "string" ? opts.wake : "next-heartbeat";
-            const wakeMode = wakeModeRaw.trim() || "next-heartbeat";
+            const wakeModeRaw = typeof opts.wake === "string" ? opts.wake : "now";
+            const wakeMode = wakeModeRaw.trim() || "now";
             if (wakeMode !== "now" && wakeMode !== "next-heartbeat") {
                 throw new Error("--wake must be now or next-heartbeat");
             }
             const agentId = typeof opts.agent === "string" && opts.agent.trim()
                 ? sanitizeAgentId(opts.agent.trim())
                 : undefined;
+            const hasAnnounce = Boolean(opts.announce) || opts.deliver === true;
+            const hasNoDeliver = opts.deliver === false;
+            const deliveryFlagCount = [hasAnnounce, hasNoDeliver].filter(Boolean).length;
+            if (deliveryFlagCount > 1) {
+                throw new Error("Choose at most one of --announce or --no-deliver");
+            }
             const payload = (() => {
                 const systemEvent = typeof opts.systemEvent === "string" ? opts.systemEvent.trim() : "";
                 const message = typeof opts.message === "string" ? opts.message.trim() : "";
@@ -121,8 +124,9 @@ export function registerCronAddCommand(cron) {
                 if (chosen !== 1) {
                     throw new Error("Choose exactly one payload: --system-event or --message");
                 }
-                if (systemEvent)
+                if (systemEvent) {
                     return { kind: "systemEvent", text: systemEvent };
+                }
                 const timeoutSeconds = parsePositiveIntOrUndefined(opts.timeoutSeconds);
                 return {
                     kind: "agentTurn",
@@ -132,35 +136,43 @@ export function registerCronAddCommand(cron) {
                         ? opts.thinking.trim()
                         : undefined,
                     timeoutSeconds: timeoutSeconds && Number.isFinite(timeoutSeconds) ? timeoutSeconds : undefined,
-                    deliver: opts.deliver ? true : undefined,
-                    channel: typeof opts.channel === "string" ? opts.channel : "last",
-                    to: typeof opts.to === "string" && opts.to.trim() ? opts.to.trim() : undefined,
-                    bestEffortDeliver: opts.bestEffortDeliver ? true : undefined,
                 };
             })();
+            const optionSource = typeof cmd?.getOptionValueSource === "function"
+                ? (name) => cmd.getOptionValueSource(name)
+                : () => undefined;
+            const sessionSource = optionSource("session");
+            const sessionTargetRaw = typeof opts.session === "string" ? opts.session.trim() : "";
+            const inferredSessionTarget = payload.kind === "agentTurn" ? "isolated" : "main";
+            const sessionTarget = sessionSource === "cli" ? sessionTargetRaw || "" : inferredSessionTarget;
+            if (sessionTarget !== "main" && sessionTarget !== "isolated") {
+                throw new Error("--session must be main or isolated");
+            }
+            if (opts.deleteAfterRun && opts.keepAfterRun) {
+                throw new Error("Choose --delete-after-run or --keep-after-run, not both");
+            }
             if (sessionTarget === "main" && payload.kind !== "systemEvent") {
                 throw new Error("Main jobs require --system-event (systemEvent).");
             }
             if (sessionTarget === "isolated" && payload.kind !== "agentTurn") {
                 throw new Error("Isolated jobs require --message (agentTurn).");
             }
-            const isolation = sessionTarget === "isolated"
-                ? {
-                    postToMainPrefix: typeof opts.postPrefix === "string" && opts.postPrefix.trim()
-                        ? opts.postPrefix.trim()
-                        : "Cron",
-                    postToMainMode: opts.postMode === "full" || opts.postMode === "summary"
-                        ? opts.postMode
-                        : undefined,
-                    postToMainMaxChars: typeof opts.postMaxChars === "string" && /^\d+$/.test(opts.postMaxChars)
-                        ? Number.parseInt(opts.postMaxChars, 10)
-                        : undefined,
-                }
+            if ((opts.announce || typeof opts.deliver === "boolean") &&
+                (sessionTarget !== "isolated" || payload.kind !== "agentTurn")) {
+                throw new Error("--announce/--no-deliver require --session isolated.");
+            }
+            const deliveryMode = sessionTarget === "isolated" && payload.kind === "agentTurn"
+                ? hasAnnounce
+                    ? "announce"
+                    : hasNoDeliver
+                        ? "none"
+                        : "announce"
                 : undefined;
             const nameRaw = typeof opts.name === "string" ? opts.name : "";
             const name = nameRaw.trim();
-            if (!name)
+            if (!name) {
                 throw new Error("--name is required");
+            }
             const description = typeof opts.description === "string" && opts.description.trim()
                 ? opts.description.trim()
                 : undefined;
@@ -168,13 +180,22 @@ export function registerCronAddCommand(cron) {
                 name,
                 description,
                 enabled: !opts.disabled,
-                deleteAfterRun: Boolean(opts.deleteAfterRun),
+                deleteAfterRun: opts.deleteAfterRun ? true : opts.keepAfterRun ? false : undefined,
                 agentId,
                 schedule,
                 sessionTarget,
                 wakeMode,
                 payload,
-                isolation,
+                delivery: deliveryMode
+                    ? {
+                        mode: deliveryMode,
+                        channel: typeof opts.channel === "string" && opts.channel.trim()
+                            ? opts.channel.trim()
+                            : undefined,
+                        to: typeof opts.to === "string" && opts.to.trim() ? opts.to.trim() : undefined,
+                        bestEffort: opts.bestEffortDeliver ? true : undefined,
+                    }
+                    : undefined,
             };
             const res = await callGatewayFromCli("cron.add", opts, params);
             defaultRuntime.log(JSON.stringify(res, null, 2));

package/dist/cli/cron-cli/register.cron-edit.js

@@ -1,11 +1,12 @@
 import { danger } from "../../globals.js";
-import { defaultRuntime } from "../../runtime.js";
 import { sanitizeAgentId } from "../../routing/session-key.js";
+import { defaultRuntime } from "../../runtime.js";
 import { addGatewayClientOptions, callGatewayFromCli } from "../gateway-rpc.js";
-import { getCronChannelOptions, parseAtMs, parseDurationMs, warnIfCronSchedulerDisabled, } from "./shared.js";
+import { getCronChannelOptions, parseAt, parseDurationMs, warnIfCronSchedulerDisabled, } from "./shared.js";
 const assignIf = (target, key, value, shouldAssign) => {
-    if (shouldAssign)
+    if (shouldAssign) {
         target[key] = value;
+    }
 };
 export function registerCronEditCommand(cron) {
     addGatewayClientOptions(cron
@@ -31,13 +32,13 @@ export function registerCronEditCommand(cron) {
         .option("--thinking <level>", "Thinking level for agent jobs")
         .option("--model <model>", "Model override for agent jobs")
         .option("--timeout-seconds <n>", "Timeout seconds for agent jobs")
-        .option("--deliver", "Deliver agent output (required when using last-route delivery without --to)")
-        .option("--no-deliver", "Disable delivery")
+        .option("--announce", "Announce summary to a chat (subagent-style)")
+        .option("--deliver", "Deprecated (use --announce). Announces a summary to a chat.")
+        .option("--no-deliver", "Disable announce delivery")
         .option("--channel <channel>", `Delivery channel (${getCronChannelOptions()})`)
         .option("--to <dest>", "Delivery destination (E.164, Telegram chatId, or Discord channel/user)")
         .option("--best-effort-deliver", "Do not fail job if delivery fails")
         .option("--no-best-effort-deliver", "Fail job when delivery fails")
-        .option("--post-prefix <prefix>", "Prefix for summary system event")
         .action(async (id, opts) => {
         try {
             if (opts.session === "main" && opts.message) {
@@ -46,31 +47,40 @@ export function registerCronEditCommand(cron) {
             if (opts.session === "isolated" && opts.systemEvent) {
                 throw new Error("Isolated jobs cannot use --system-event; use --message or --session main.");
             }
-            if (opts.session === "main" && typeof opts.postPrefix === "string") {
-                throw new Error("--post-prefix only applies to isolated jobs.");
+            if (opts.announce && typeof opts.deliver === "boolean") {
+                throw new Error("Choose --announce or --no-deliver (not multiple).");
             }
             const patch = {};
-            if (typeof opts.name === "string")
+            if (typeof opts.name === "string") {
                 patch.name = opts.name;
-            if (typeof opts.description === "string")
+            }
+            if (typeof opts.description === "string") {
                 patch.description = opts.description;
-            if (opts.enable && opts.disable)
+            }
+            if (opts.enable && opts.disable) {
                 throw new Error("Choose --enable or --disable, not both");
-            if (opts.enable)
+            }
+            if (opts.enable) {
                 patch.enabled = true;
-            if (opts.disable)
+            }
+            if (opts.disable) {
                 patch.enabled = false;
+            }
             if (opts.deleteAfterRun && opts.keepAfterRun) {
                 throw new Error("Choose --delete-after-run or --keep-after-run, not both");
             }
-            if (opts.deleteAfterRun)
+            if (opts.deleteAfterRun) {
                 patch.deleteAfterRun = true;
-            if (opts.keepAfterRun)
+            }
+            if (opts.keepAfterRun) {
                 patch.deleteAfterRun = false;
-            if (typeof opts.session === "string")
+            }
+            if (typeof opts.session === "string") {
                 patch.sessionTarget = opts.session;
-            if (typeof opts.wake === "string")
+            }
+            if (typeof opts.wake === "string") {
                 patch.wakeMode = opts.wake;
+            }
             if (opts.agent && opts.clearAgent) {
                 throw new Error("Use --agent or --clear-agent, not both");
             }
@@ -81,18 +91,21 @@ export function registerCronEditCommand(cron) {
                 patch.agentId = null;
             }
             const scheduleChosen = [opts.at, opts.every, opts.cron].filter(Boolean).length;
-            if (scheduleChosen > 1)
+            if (scheduleChosen > 1) {
                 throw new Error("Choose at most one schedule change");
+            }
             if (opts.at) {
-                const atMs = parseAtMs(String(opts.at));
-                if (!atMs)
+                const atIso = parseAt(String(opts.at));
+                if (!atIso) {
                     throw new Error("Invalid --at");
-                patch.schedule = { kind: "at", atMs };
+                }
+                patch.schedule = { kind: "at", at: atIso };
             }
             else if (opts.every) {
                 const everyMs = parseDurationMs(String(opts.every));
-                if (!everyMs)
+                if (!everyMs) {
                     throw new Error("Invalid --every");
+                }
                 patch.schedule = { kind: "every", everyMs };
             }
             else if (opts.cron) {
@@ -111,14 +124,16 @@ export function registerCronEditCommand(cron) {
                 ? Number.parseInt(String(opts.timeoutSeconds), 10)
                 : undefined;
             const hasTimeoutSeconds = Boolean(timeoutSeconds && Number.isFinite(timeoutSeconds));
+            const hasDeliveryModeFlag = opts.announce || typeof opts.deliver === "boolean";
+            const hasDeliveryTarget = typeof opts.channel === "string" || typeof opts.to === "string";
+            const hasBestEffort = typeof opts.bestEffortDeliver === "boolean";
             const hasAgentTurnPatch = typeof opts.message === "string" ||
                 Boolean(model) ||
                 Boolean(thinking) ||
                 hasTimeoutSeconds ||
-                typeof opts.deliver === "boolean" ||
-                typeof opts.channel === "string" ||
-                typeof opts.to === "string" ||
-                typeof opts.bestEffortDeliver === "boolean";
+                hasDeliveryModeFlag ||
+                hasDeliveryTarget ||
+                hasBestEffort;
             if (hasSystemEventPatch && hasAgentTurnPatch) {
                 throw new Error("Choose at most one payload change");
             }
@@ -134,16 +149,27 @@ export function registerCronEditCommand(cron) {
                 assignIf(payload, "model", model, Boolean(model));
                 assignIf(payload, "thinking", thinking, Boolean(thinking));
                 assignIf(payload, "timeoutSeconds", timeoutSeconds, hasTimeoutSeconds);
-                assignIf(payload, "deliver", opts.deliver, typeof opts.deliver === "boolean");
-                assignIf(payload, "channel", opts.channel, typeof opts.channel === "string");
-                assignIf(payload, "to", opts.to, typeof opts.to === "string");
-                assignIf(payload, "bestEffortDeliver", opts.bestEffortDeliver, typeof opts.bestEffortDeliver === "boolean");
                 patch.payload = payload;
             }
-            if (typeof opts.postPrefix === "string") {
-                patch.isolation = {
-                    postToMainPrefix: opts.postPrefix.trim() ? opts.postPrefix : "Cron",
-                };
+            if (hasDeliveryModeFlag || hasDeliveryTarget || hasBestEffort) {
+                const deliveryMode = opts.announce || opts.deliver === true
+                    ? "announce"
+                    : opts.deliver === false
+                        ? "none"
+                        : "announce";
+                const delivery = { mode: deliveryMode };
+                if (typeof opts.channel === "string") {
+                    const channel = opts.channel.trim();
+                    delivery.channel = channel ? channel : undefined;
+                }
+                if (typeof opts.to === "string") {
+                    const to = opts.to.trim();
+                    delivery.to = to ? to : undefined;
+                }
+                if (typeof opts.bestEffortDeliver === "boolean") {
+                    delivery.bestEffort = opts.bestEffortDeliver;
+                }
+                patch.delivery = delivery;
             }
             const res = await callGatewayFromCli("cron.update", opts, {
                 id,

package/dist/cli/cron-cli/shared.js

@@ -1,5 +1,6 @@
 import { listChannelPlugins } from "../../channels/plugins/index.js";
 import { parseAbsoluteTimeMs } from "../../cron/parse.js";
+import { formatDurationHuman } from "../../infra/format-time/format-duration.js";
 import { defaultRuntime } from "../../runtime.js";
 import { colorize, isRich, theme } from "../../terminal/theme.js";
 import { callGatewayFromCli } from "../gateway-rpc.js";
@@ -7,8 +8,9 @@ export const getCronChannelOptions = () => ["last", ...listChannelPlugins().map(
 export async function warnIfCronSchedulerDisabled(opts) {
     try {
         const res = (await callGatewayFromCli("cron.status", opts, {}));
-        if (res?.enabled === true)
+        if (res?.enabled === true) {
             return;
+        }
         const store = typeof res?.storePath === "string" ? res.storePath : "";
         defaultRuntime.error([
             "warning: cron scheduler is disabled in the Gateway; jobs are saved but will not run automatically.",
@@ -24,14 +26,17 @@ export async function warnIfCronSchedulerDisabled(opts) {
 }
 export function parseDurationMs(input) {
     const raw = input.trim();
-    if (!raw)
+    if (!raw) {
         return null;
+    }
     const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m|h|d)$/i);
-    if (!match)
+    if (!match) {
         return null;
+    }
     const n = Number.parseFloat(match[1] ?? "");
-    if (!Number.isFinite(n) || n <= 0)
+    if (!Number.isFinite(n) || n <= 0) {
         return null;
+    }
     const unit = (match[2] ?? "").toLowerCase();
     const factor = unit === "ms"
         ? 1
@@ -44,16 +49,19 @@ export function parseDurationMs(input) {
                     : 86_400_000;
     return Math.floor(n * factor);
 }
-export function parseAtMs(input) {
+export function parseAt(input) {
     const raw = input.trim();
-    if (!raw)
+    if (!raw) {
         return null;
+    }
     const absolute = parseAbsoluteTimeMs(raw);
-    if (absolute)
-        return absolute;
+    if (absolute !== null) {
+        return new Date(absolute).toISOString();
+    }
     const dur = parseDurationMs(raw);
-    if (dur)
-        return Date.now() + dur;
+    if (dur !== null) {
+        return new Date(Date.now() + dur).toISOString();
+    }
     return null;
 }
 const CRON_ID_PAD = 36;
@@ -66,56 +74,59 @@ const CRON_TARGET_PAD = 9;
 const CRON_AGENT_PAD = 10;
 const pad = (value, width) => value.padEnd(width);
 const truncate = (value, width) => {
-    if (value.length <= width)
+    if (value.length <= width) {
         return value;
-    if (width <= 3)
+    }
+    if (width <= 3) {
         return value.slice(0, width);
+    }
     return `${value.slice(0, width - 3)}...`;
 };
-const formatIsoMinute = (ms) => {
-    const d = new Date(ms);
-    if (Number.isNaN(d.getTime()))
+const formatIsoMinute = (iso) => {
+    const parsed = parseAbsoluteTimeMs(iso);
+    const d = new Date(parsed ?? NaN);
+    if (Number.isNaN(d.getTime())) {
         return "-";
-    const iso = d.toISOString();
-    return `${iso.slice(0, 10)} ${iso.slice(11, 16)}Z`;
-};
-const formatDuration = (ms) => {
-    if (ms < 60_000)
-        return `${Math.max(1, Math.round(ms / 1000))}s`;
-    if (ms < 3_600_000)
-        return `${Math.round(ms / 60_000)}m`;
-    if (ms < 86_400_000)
-        return `${Math.round(ms / 3_600_000)}h`;
-    return `${Math.round(ms / 86_400_000)}d`;
+    }
+    const isoStr = d.toISOString();
+    return `${isoStr.slice(0, 10)} ${isoStr.slice(11, 16)}Z`;
 };
 const formatSpan = (ms) => {
-    if (ms < 60_000)
+    if (ms < 60_000) {
         return "<1m";
-    if (ms < 3_600_000)
+    }
+    if (ms < 3_600_000) {
         return `${Math.round(ms / 60_000)}m`;
-    if (ms < 86_400_000)
+    }
+    if (ms < 86_400_000) {
         return `${Math.round(ms / 3_600_000)}h`;
+    }
     return `${Math.round(ms / 86_400_000)}d`;
 };
 const formatRelative = (ms, nowMs) => {
-    if (!ms)
+    if (!ms) {
         return "-";
+    }
     const delta = ms - nowMs;
     const label = formatSpan(Math.abs(delta));
     return delta >= 0 ? `in ${label}` : `${label} ago`;
 };
 const formatSchedule = (schedule) => {
-    if (schedule.kind === "at")
-        return `at ${formatIsoMinute(schedule.atMs)}`;
-    if (schedule.kind === "every")
-        return `every ${formatDuration(schedule.everyMs)}`;
+    if (schedule.kind === "at") {
+        return `at ${formatIsoMinute(schedule.at)}`;
+    }
+    if (schedule.kind === "every") {
+        return `every ${formatDurationHuman(schedule.everyMs)}`;
+    }
     return schedule.tz ? `cron ${schedule.expr} @ ${schedule.tz}` : `cron ${schedule.expr}`;
 };
 const formatStatus = (job) => {
-    if (!job.enabled)
+    if (!job.enabled) {
         return "disabled";
-    if (job.state.runningAtMs)
+    }
+    if (job.state.runningAtMs) {
         return "running";
+    }
     return job.state.lastStatus ?? "idle";
 };
 export function printCronList(jobs, runtime = defaultRuntime) {
@@ -144,17 +155,21 @@ export function printCronList(jobs, runtime = defaultRuntime) {
         const lastLabel = pad(formatRelative(job.state.lastRunAtMs, now), CRON_LAST_PAD);
         const statusRaw = formatStatus(job);
         const statusLabel = pad(statusRaw, CRON_STATUS_PAD);
-        const targetLabel = pad(job.sessionTarget, CRON_TARGET_PAD);
+        const targetLabel = pad(job.sessionTarget ?? "-", CRON_TARGET_PAD);
         const agentLabel = pad(truncate(job.agentId ?? "default", CRON_AGENT_PAD), CRON_AGENT_PAD);
         const coloredStatus = (() => {
-            if (statusRaw === "ok")
+            if (statusRaw === "ok") {
                 return colorize(rich, theme.success, statusLabel);
-            if (statusRaw === "error")
+            }
+            if (statusRaw === "error") {
                 return colorize(rich, theme.error, statusLabel);
-            if (statusRaw === "running")
+            }
+            if (statusRaw === "running") {
                 return colorize(rich, theme.warn, statusLabel);
-            if (statusRaw === "skipped")
+            }
+            if (statusRaw === "skipped") {
                 return colorize(rich, theme.muted, statusLabel);
+            }
             return colorize(rich, theme.muted, statusLabel);
         })();
         const coloredTarget = job.sessionTarget === "isolated"