dsh-scheduled-actions 0.1.1 → 0.2.0

package/README.md

@@ -19,6 +19,7 @@
 - **SchedulerEngine** на `setTimeout` — не привязан к сессии, работает на уровне хоста.
 - **Валидация времени** через встроенный `Intl.DateTimeFormat` (IANA-зоны, DST) — без внешних зависимостей.
 - **UI в Настройках**: секция «Запланированные действия» — таблица, фильтр «показать прошедшие», массовое удаление, форма создания/редактирования с проверкой, запуск «выполнить сейчас».
+- **Куда отправлять запрос** (для `agent-prompt`): по умолчанию — первому активному агенту, либо конкретный чат из списка живых, либо «создать чат для события» (имя = названию события), либо «каждый раз в новом чате» (имя = событие + дата запуска). Для создания чата выбирается workspace в форме.
 - **AI-инструменты** для агентов: `scheduled_action_list`, `scheduled_action_create`, `scheduled_action_update`, `scheduled_action_delete`, `scheduled_action_run_now`.
 - **RPC-мост** между браузером и хостом через `ctx.connection` (`/scheduled-actions/<method>`).
 - **Полная обратимость**: при остановке/удалении плагина все таймеры и обработчики корректно отключаются.

package/lib/client.js

@@ -59,6 +59,17 @@ window.__ModuleLoader__.load({
 		};
 
 		const WEEKDAY_NAMES = ["Вс", "Пн", "Вт", "Ср", "Чт", "Пт", "Сб"];
+		const OVERDUE_DISMISS_KEY = "dsh-scheduled-actions:overdue-dismissed";
+		const loadDismissed = () => {
+			try {
+				const raw = localStorage.getItem(OVERDUE_DISMISS_KEY);
+				const v = raw ? JSON.parse(raw) : {};
+				return v && typeof v === "object" && !Array.isArray(v) ? v : {};
+			} catch { return {}; }
+		};
+		const saveDismissed = (m) => {
+			try { localStorage.setItem(OVERDUE_DISMISS_KEY, JSON.stringify(m)); } catch { /* ignore */ }
+		};
 
 		const fmtSchedule = (schedule) => {
 			if (!schedule) return "—";
@@ -114,6 +125,16 @@ window.__ModuleLoader__.load({
 				return () => document.removeEventListener("mousedown", onDown);
 			}, [openMenu]);
 			const [selected, setSelected] = react.useState(new Set());
+			const [dismissed, setDismissed] = react.useState(() => loadDismissed());
+			const dismissOccurrence = (id, action) => {
+				const m = { ...dismissed, [id]: action.nextRunAt ?? null };
+				setDismissed(m); saveDismissed(m);
+			};
+			// Show in the banner only real wall-clock misses the user did not already
+			// dismiss for this exact occurrence. on-startup actions auto-run at host start
+			// and are never "missed".
+			const showInBanner = (a) => a.schedule?.type !== "on-startup"
+				&& dismissed[a.id] !== (a.nextRunAt ?? null);
 
 			const toggleOne = (id) => setSelected((prev) => {
 				const n = new Set(prev);
@@ -142,10 +163,16 @@ window.__ModuleLoader__.load({
 				} finally { setBusy(false); }
 			};
 
-			// A past/finished action is one already completed/failed (no next run)
-			// or whose nextRunAt has passed. Active = enabled with a future run.
+			// A finished action is completed/failed (no run ahead) or disabled. An
+			// ENABLED action whose scheduled time already passed is missed/pending: it
+			// stays in the active list so the user can open it and run it manually
+			// later instead of burying it among the finished ones.
 			const isPast = (a) => {
 				if (a.state === "completed" || a.state === "failed") return true;
+				if (a.state === "idle" && a.enabled && a.nextRunAt) {
+					const t = Date.parse(a.nextRunAt);
+					if (Number.isFinite(t) && t <= Date.now()) return false; // missed -> pending
+				}
 				if (a.state === "idle" && a.nextRunAt) {
 					const t = Date.parse(a.nextRunAt);
 					if (Number.isFinite(t) && t <= Date.now()) return true;
@@ -172,7 +199,7 @@ window.__ModuleLoader__.load({
 						const [list, od] = await Promise.all([rpc("list", {}), rpc("checkOverdue", {})]);
 						if (!alive) return;
 						setActions(Array.isArray(list) ? list : []);
-						setOverdue(Array.isArray(od) ? od : []);
+						setOverdue(Array.isArray(od) ? od.filter(showInBanner) : []);
 					} catch (e) {
 						if (alive) setError(e.message);
 					}
@@ -265,7 +292,19 @@ window.__ModuleLoader__.load({
 				} finally { setBusy(false); }
 			};
 
-			const closeOverdue = () => setOverdue([]);
+			const dismissOverdue = async (id, action) => {
+				// Remember locally first so the message never re-appears on the next
+				// visit even before the host endpoint is reachable.
+				dismissOccurrence(id, action);
+				setOverdue((cur) => cur.filter((a) => a.id !== id));
+				setBusy(true); setError(null);
+				try {
+					await rpc("dismissOverdue", { id });
+				} catch (e) {
+					// Host lands the persistent dismissal after a DSH restart; the local
+					// record above already hides this occurrence in this browser.
+				} finally { setBusy(false); }
+			};
 			const runOverdue = async (id) => {
 				setBusy(true); setError(null);
 				try {
@@ -288,7 +327,7 @@ window.__ModuleLoader__.load({
 					overdue.map((a) => jsxs("div", { style: { display: "flex", gap: 8, alignItems: "center" }, children: [
 						jsx("span", { style: { flex: 1, fontSize: 13, color: "var(--dsw-alias-label-primary)" }, children: a.label }),
 						jsx(button, { disabled: busy, onClick: () => runOverdue(a.id), children: "Выполнить" }),
-						jsx(button, { disabled: busy, onClick: closeOverdue, children: "Позже" }),
+						jsx(button, { disabled: busy, onClick: () => dismissOverdue(a.id, a), children: "Позже" }),
 					] }, a.id)),
 				] }) : null,
 
@@ -325,9 +364,9 @@ window.__ModuleLoader__.load({
 					jsx("td", { colSpan: 6, style: { ...tdStyle, color: "var(--dsw-alias-label-tertiary)", textAlign: "center" }, children: "Нет действий" }) }) :
 					visibleActions.map((a) => jsxs("tr", { style: rowStyle, children: [
 						jsx("td", { style: { ...tdStyle, ...stickyCheck, width: 34 }, children: isPast(a) ? jsx("input", { type: "checkbox", checked: selected.has(a.id), onChange: () => toggleOne(a.id) }) : null }),
-						jsx("td", { style: { ...tdStyle, ...stickyName }, children: jsxs("div", { style: { display: "flex", flexDirection: "column" }, children: [
-							jsx("span", { style: { fontWeight: 500, color: "var(--dsw-alias-label-primary)" }, children: a.label }),
-							jsx("span", { style: smallText, children: a.description || a.id }),
+						jsx("td", { style: { ...tdStyle, ...stickyName }, children: jsxs("div", { style: { position: "relative", height: 36, minWidth: 0 }, children: [
+							jsx("span", { title: a.label, style: { display: "block", overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", lineHeight: "18px", maxWidth: 240, fontWeight: 500, color: "var(--dsw-alias-label-primary)" }, children: a.label }),
+							jsx("span", { title: a.description || a.id, style: { ...smallText, position: "absolute", left: 0, right: 0, bottom: 0, overflow: "hidden", textOverflow: "ellipsis", whiteSpace: "nowrap", lineHeight: "12px" }, children: a.description || a.id }),
 						] }) }),
 						jsx("td", { style: tdStyle, children: fmtSchedule(a.schedule) }),
 						jsx("td", { style: tdStyle, children: a.schedule?.type === "on-startup" ? "При запуске" : fmtDate(a.nextRunAt) }),
@@ -431,8 +470,51 @@ window.__ModuleLoader__.load({
 			const [startMode, setStartMode] = react.useState(initial?.schedule?.startMode ?? "everyStart");
 			const [expr, setExpr] = react.useState(initial?.schedule?.cronExpr ?? "0 9 * * *");
 			const [enabled, setEnabled] = react.useState(initial?.enabled ?? true);
+			// Chat target picker: "" = default, a session id = existing chat,
+			// "__new_chat__" = create one dedicated chat, "__new_per_run__" = fresh chat each run.
+			const [chatTarget, setChatTarget] = react.useState(() => {
+				if (initial?.chatPolicy === "new-per-run") return "__new_per_run__";
+				if (initial?.chatPolicy === "new-chat") return "__new_chat__";
+				return initial?.targetAgentId ?? "";
+			});
+			const [workspaceId, setWorkspaceId] = react.useState(initial?.chatWorkspaceId ?? "");
+			const [chats, setChats] = react.useState([]);
+			const [chatsState, setChatsState] = react.useState("idle"); // idle | loading | ready | error
+			const [workspaces, setWorkspaces] = react.useState([]);
+			const [workspacesState, setWorkspacesState] = react.useState("idle");
 			const [formError, setFormError] = react.useState(false);
 
+			react.useEffect(() => {
+				let alive = true;
+				setChatsState("loading");
+				rpc("listChats", {}).then((list) => {
+					if (!alive) return;
+					setChats(Array.isArray(list) ? list : []);
+					setChatsState("ready");
+				}, () => {
+					if (!alive) return;
+					setChats([]);
+					setChatsState("error");
+				});
+				return () => { alive = false; };
+			}, []);
+
+			react.useEffect(() => {
+				let alive = true;
+				setWorkspacesState("loading");
+				rpc("listWorkspaces", {}).then((list) => {
+					if (!alive) return;
+					setWorkspaces(Array.isArray(list) ? list : []);
+					setWorkspacesState("ready");
+					setWorkspaceId((cur) => cur || (Array.isArray(list) && list[0] ? list[0].id : ""));
+				}, () => {
+					if (!alive) return;
+					setWorkspaces([]);
+					setWorkspacesState("error");
+				});
+				return () => { alive = false; };
+			}, []);
+
 			const showInvalid = () => setFormError(true);
 
 			// Domain schedules "daily"/"weekly" in the browser's local IANA zone.
@@ -466,7 +548,19 @@ window.__ModuleLoader__.load({
 				else if (type === "cron") schedule = { type: "cron", cronExpr: expr };
 				else if (type === "on-startup") schedule = { type: "on-startup", startMode };
 				else schedule = { type: "one-shot", at: new Date(Date.now() + 3600000).toISOString() };
-				onSave({ label, description, kind, payload, schedule, enabled });
+				// Chat target: existing chat id -> targetAgentId; new-chat modes ->
+				// chatPolicy + chatWorkspaceId (host creates the session on dispatch).
+				let chatFields = { targetAgentId: undefined, chatPolicy: undefined, chatWorkspaceId: undefined };
+				if (kind === "agent-prompt") {
+					if (chatTarget === "__new_chat__") {
+						chatFields = { chatPolicy: "new-chat", chatWorkspaceId: workspaceId || undefined };
+					} else if (chatTarget === "__new_per_run__") {
+						chatFields = { chatPolicy: "new-per-run", chatWorkspaceId: workspaceId || undefined };
+					} else if (chatTarget && chatTarget !== "") {
+						chatFields = { targetAgentId: chatTarget };
+					}
+				}
+				onSave({ label, description, kind, payload, schedule, enabled, ...chatFields });
 			};
 
 			const field = (lbl, value, set, ph = "", type = "text", highlight = false) => jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 6 }, children: [
@@ -494,6 +588,28 @@ window.__ModuleLoader__.load({
 					jsx("span", { style: fieldLabel, children: kind === "agent-prompt" ? "Текст запроса" : "Команда" }),
 					jsx("textarea", { value: payload, rows: 3, style: { ...inputStyle, resize: "vertical", font: "inherit", padding: "8px 12px", ...(formError && !payload.trim() ? errorInputStyle : {}) }, onChange: (e) => setPayload(e.target.value) }),
 				] }),
+				kind === "agent-prompt" ? jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 6 }, children: [
+					jsx("span", { style: fieldLabel, children: "Куда выполнять запрос (необязательно)" }),
+					jsx("select", { value: chatTarget, style: inputStyle, onChange: (e) => setChatTarget(e.target.value), children: [
+						jsx("option", { value: "", children: "— по умолчанию (первый активный агент) —" }),
+						chatsState === "loading" ? jsx("option", { value: "", disabled: true, children: "Загрузка чатов…" }) : null,
+						chatsState === "error" ? jsx("option", { value: "", disabled: true, children: "Список чатов недоступен" }) : null,
+						chats.map((c) => jsx("option", { key: c.id, value: c.id, children: `${c.title} (${c.id})` })),
+						jsx("option", { value: "__new_chat__", children: "＋ Создать чат для события (имя = названию)" }),
+						jsx("option", { value: "__new_per_run__", children: "＋ Каждый раз в новом чате (имя + дата)" }),
+					] }),
+					(chatTarget === "__new_chat__" || chatTarget === "__new_per_run__") ? jsxs("div", { style: { display: "flex", flexDirection: "column", gap: 6 }, children: [
+						jsx("span", { style: fieldLabel, children: "Где создать чат (workspace)" }),
+						jsx("select", { value: workspaceId, style: inputStyle, onChange: (e) => setWorkspaceId(e.target.value), children: [
+							workspacesState === "loading" ? jsx("option", { value: "", children: "Загрузка workspace…" }) : null,
+							workspaces.map((w) => jsx("option", { key: w.id, value: w.id, children: w.title })),
+						] }),
+						jsx("span", { style: { ...smallText }, children: chatTarget === "__new_chat__"
+							? `Чат создастся при первом срабатывании с именем «${label || "название события"}».`
+							: `При каждом срабатывании создастся новый чат с именем «${label || "название события"} + дата».` }),
+					] }) : null,
+					jsx("span", { style: { ...smallText }, children: "Не выбрано — запрос уйдёт первому активному агенту, как сейчас." }),
+				] }) : null,
 				sel("Расписание", type, setType, [
 					{ v: "one-shot", t: "Одноразово" },
 					{ v: "interval", t: "Интервал" },
@@ -742,4 +858,4 @@ window.__ModuleLoader__.load({
 		module.exports = { apply, inject };
 		return module.exports;
 	}
-});
+});

package/lib/domain.js

@@ -576,6 +576,13 @@ export function createScheduledAction(input, now) {
     // executer delivers to the first root agent (or the invoking agent, for
     // actions created by a tool). Preserved through decode; not validated.
     targetAgentId: typeof input.targetAgentId === "string" ? input.targetAgentId : undefined,
+    // Chat-target policy for `agent-prompt` actions:
+    //  - "new-chat": create ONE dedicated chat (in chatWorkspaceId) on the
+    //    first run and remember its session as targetAgentId;
+    //  - "new-per-run": create a fresh chat on every run (title = label + run date).
+    // Preserved through decode; not validated further.
+    chatPolicy: typeof input.chatPolicy === "string" ? input.chatPolicy : undefined,
+    chatWorkspaceId: typeof input.chatWorkspaceId === "string" ? input.chatWorkspaceId : undefined,
   });
 }
 

package/lib/execution.js

@@ -96,19 +96,41 @@ function resolveTargetAgent(ctx, action) {
   return roots[0];
 }
 
+/** Human-readable local run stamp, e.g. "2026-09-07 14:30". */
+function runStamp(now) {
+  const d = new Date(now);
+  const p = (n) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}-${p(d.getMonth() + 1)}-${p(d.getDate())} ${p(d.getHours())}:${p(d.getMinutes())}`;
+}
+
 /**
  * Build the default host executer closure.
  *
  * @param ctx - Host context (must inject `agents` when the agent-prompt kind is
  *   used; a missing `agents` service makes agent-prompt actions fail cleanly).
+ * @param createChatFn - Optional async `({ workspaceId, title }) => Promise<{ sessionId }>`
+ *   used by the `chatPolicy: "new-chat"` / `"new-per-run"` modes.
  * @returns Async `(action) => output` for the configured service executer.
  */
-export function createExecuter(ctx) {
+export function createExecuter(ctx, createChatFn) {
   return async function executer(action) {
     if (action.kind === "shell-command") {
       return runShellCommand(action.payload);
     }
     if (action.kind === "agent-prompt") {
+      const agents = ctx.agents;
+      const policy = action.chatPolicy;
+      // new-per-run: create a fresh chat on EVERY run with a run-stamped title.
+      if (policy === "new-per-run" && createChatFn && action.chatWorkspaceId) {
+        const title = action.label.trim().length > 0
+          ? `${action.label} · ${runStamp(Date.now())}`
+          : `Запланированное событие · ${runStamp(Date.now())}`;
+        const created = await createChatFn({ workspaceId: action.chatWorkspaceId, title });
+        const sessionId = created?.sessionId;
+        const agent = agents && sessionId ? agents.get(sessionId) : undefined;
+        if (!agent) throw new Error(`agent-prompt (new-per-run): chat "${sessionId ?? "(none)"}" is not a live agent`);
+        return deliverAgentPrompt(ctx, agent, action.payload);
+      }
       const agent = resolveTargetAgent(ctx, action);
       if (!agent) throw new Error(`agent-prompt action "${action.label}" has no target agent`);
       return deliverAgentPrompt(ctx, agent, action.payload);

package/lib/index.js

@@ -24,6 +24,79 @@ export const name = "scheduled-actions";
  */
 export const inject = ["agents"];
 
+/** Latest user/auto session title from a live session's own durable events. */
+function sessionTitleOf(session) {
+  try {
+    const events = session?.ownEvents?.();
+    if (!events) return undefined;
+    const titleEvent = [...events].reverse().find((e) => e?.type === "session/title");
+    return titleEvent?.data?.title ?? undefined;
+  } catch {
+    return undefined;
+  }
+}
+
+/** Live top-level chats (root agents) with a readable title for the picker. */
+function listLiveChats(ctx) {
+  const agents = ctx.get ? ctx.get("agents") : undefined;
+  if (!agents || typeof agents.roots !== "function") return [];
+  return agents.roots().map((agent) => ({
+    id: agent.id,
+    title: sessionTitleOf(agent.session) ?? agent.id,
+  }));
+}
+
+/** Durable workspaces available for creating a new chat in. */
+function listWorkspaces(ctx) {
+  const registry = ctx.get ? ctx.get("workspaceRegistry") : undefined;
+  if (!registry || typeof registry.list !== "function") return [];
+  try {
+    return registry.list().map((w) => ({
+      id: w.id,
+      title: w.title ?? w.record?.title ?? w.path ?? w.id,
+      path: w.path ?? w.record?.path ?? "",
+    }));
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Create a new chat (session + agent) in the given workspace and give it a
+ * title, using the same host sessionController the web GUI calls. Returns the
+ * new session id, or throws when the service is unavailable / creation fails.
+ */
+async function createChat(ctx, payload) {
+  const sessionController = ctx.get ? ctx.get("sessionController") : undefined;
+  if (!sessionController || typeof sessionController.create !== "function") {
+    const err = new Error("scheduled-actions: sessionController unavailable (web app not mounted)");
+    err.code = "scheduled-actions/no-session-controller";
+    throw err;
+  }
+  const workspaceId = payload?.workspaceId;
+  if (!workspaceId || typeof workspaceId !== "string") {
+    const err = new Error("scheduled-actions: workspaceId is required");
+    err.code = "gateway/bad-request";
+    throw err;
+  }
+  const created = await sessionController.create({ workspaceId });
+  const sessionId = created?.sessionId;
+  if (!sessionId) throw new Error("scheduled-actions: session.create returned no sessionId");
+  const title = typeof payload?.title === "string" && payload.title.trim().length > 0
+    ? payload.title.trim()
+    : undefined;
+  if (title !== undefined && typeof sessionController.rename === "function") {
+    try {
+      await sessionController.rename({ sessionId, title });
+    } catch (e) {
+      ctx.logger?.warn?.(
+        `scheduled-actions: chat "${sessionId}" created but rename to "${title}" failed: ${e && e.message ? e.message : String(e)}`
+      );
+    }
+  }
+  return { sessionId };
+}
+
 /** Default store path under the DSH home directory. */
 function defaultStorePath() {
   return join(homedir(), ".dsh", "scheduled-actions.json");
@@ -37,6 +110,7 @@ export class ScheduledActionsService {
   #engine;
   #logger;
   #executer;
+  #chatProvisioner;
 
   /**
    * @param store - The action store.
@@ -65,6 +139,15 @@ export class ScheduledActionsService {
     this.#executer = executer;
   }
 
+  /**
+   * Configure the chat provisioner used by `chatPolicy: "new-chat"`: create
+   * one dedicated chat for the event on its first run and remember its session
+   * as the action's target. Async `({ workspaceId, title }) => { sessionId }`.
+   */
+  setChatProvisioner(provisioner) {
+    this.#chatProvisioner = provisioner;
+  }
+
   /** All actions. */
   list() {
     return this.#store.list();
@@ -102,6 +185,9 @@ export class ScheduledActionsService {
       const now = Date.now();
       const from = current.lastRunAt ?? current.nextRunAt ?? undefined;
       merged.nextRunAt = computeNextRun(merged.schedule, now, from);
+      // The occurrence moved on: forget any earlier «Позже» dismissal, so a
+      // genuinely missed later run can be reported again.
+      merged.dismissedNextRunAt = undefined;
     }
     await this.#store.put(merged);
     this.#engine.requestDrive();
@@ -140,6 +226,19 @@ export class ScheduledActionsService {
     let output = "";
     let error;
     try {
+      // chatPolicy "new-chat": create the one dedicated chat on the first run
+      // and remember its session as the action's target so later runs reuse it.
+      if (
+        action.kind === "agent-prompt"
+        && action.chatPolicy === "new-chat"
+        && !action.targetAgentId
+        && this.#chatProvisioner
+        && action.chatWorkspaceId
+      ) {
+        const title = action.label.trim().length > 0 ? action.label.trim() : "Запланированное событие";
+        const created = await this.#chatProvisioner({ workspaceId: action.chatWorkspaceId, title });
+        if (created?.sessionId) action = { ...action, targetAgentId: created.sessionId };
+      }
       output = await executer(action);
       success = true;
     } catch (err) {
@@ -153,6 +252,9 @@ export class ScheduledActionsService {
       runCount: action.runCount + 1,
       state: success ? "idle" : "failed",
       updatedAt: finishedAt,
+      // This occurrence is now handled (ran, or the schedule moved past it):
+      // clear any earlier «Позже» dismissal so future misses can be reported.
+      dismissedNextRunAt: undefined,
     };
     if (action.schedule.type === "one-shot" && success) {
       updated.state = "completed";
@@ -218,17 +320,37 @@ export class ScheduledActionsService {
     return this.#run(action, runner);
   }
 
-  /** Actions that are currently overdue (enabled and nextRunAt in the past). */
+  /** Actions that are currently overdue: enabled wall-clock actions whose
+   * scheduled time passed without running, minus occurrences the user already
+   * dismissed with «Позже». on-startup actions self-run at each host start and
+   * have no wall-clock deadline, so they are never reported as missed here. */
   checkOverdue() {
     const now = Date.now();
     return this.#store.list().filter((action) => {
       if (!action.enabled) return false;
-      if (action.schedule.type === "on-startup") return true;
+      if (action.schedule?.type === "on-startup") return false;
       if (action.nextRunAt === null) return false;
+      if (action.dismissedNextRunAt === action.nextRunAt) return false;
       return Date.parse(action.nextRunAt) <= now;
     });
   }
 
+  /** Remember the user's «Позже» for the current missed occurrence, so the
+   * overdue banner does not re-ask on every visit to the scheduler. The action
+   * itself is left untouched and stays in the list — it will only run when the
+   * user runs it manually (runNow) or its schedule is edited. */
+  async dismissOverdue(id) {
+    const current = this.#store.get(id);
+    if (current === undefined) return undefined;
+    const updated = {
+      ...current,
+      dismissedNextRunAt: current.nextRunAt ?? null,
+      updatedAt: new Date().toISOString(),
+    };
+    await this.#store.put(updated);
+    return updated;
+  }
+
   /**
    * Whether an on-startup action should run on THIS host start, given its
    * startMode and the last successful run.
@@ -299,12 +421,15 @@ export function apply(ctx, config) {
   // Этап 4: wire the real payload executer (shell-command + agent-prompt).
   // It reads `ctx.agents` for the agent-prompt delivery path; missing agents
   // service makes only agent-prompt actions fail cleanly, shell still works.
+  const createChatBound = (payload) => createChat(ctx, payload);
   if (typeof ctx.inject === "function") {
     ctx.inject(["agents"], (agentCtx) => {
-      service.setExecuter(createExecuter(agentCtx));
+      service.setExecuter(createExecuter(agentCtx, createChatBound));
+      service.setChatProvisioner(createChatBound);
     }, { label: "scheduled-actions.executer()" });
   } else {
-    service.setExecuter(createExecuter(ctx));
+    service.setExecuter(createExecuter(ctx, createChatBound));
+    service.setChatProvisioner(createChatBound);
   }
 
   // Этап 4: register the management tools into every live root agent scope,
@@ -354,6 +479,10 @@ export function apply(ctx, config) {
             case "toggle": return service.toggle(payload?.id);
             case "runNow": return service.runNow(payload?.id);
             case "checkOverdue": return service.checkOverdue();
+            case "dismissOverdue": return service.dismissOverdue(payload?.id);
+            case "listChats": return listLiveChats(ctx);
+            case "listWorkspaces": return listWorkspaces(ctx);
+            case "createChat": return createChat(ctx, payload);
             default: {
               const err = new Error(`scheduled-actions: unknown endpoint ${endpoint}`);
               err.code = "gateway/not-found";

package/lib/scheduler.js

@@ -79,6 +79,9 @@ export class SchedulerEngine {
       const target = Date.parse(action.nextRunAt);
       if (!Number.isFinite(target)) continue;
       if (target <= now) {
+        // The user dismissed this exact missed occurrence («Позже») and wants to
+        // run it manually — do not auto-dispatch it now or on later re-arms.
+        if (action.dismissedNextRunAt === action.nextRunAt) continue;
         // Due now — dispatch asynchronously. `#busy` stays true so no other
         // pass can start a second dispatch of the same (or another) action
         // while this one is in flight; `#dispatch` releases the flag before

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-scheduled-actions",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Host-level scheduled actions for DeepSeek Harness — create, verify, and run actions on a schedule (one-shot, interval, daily, weekly, cron, on-startup) with a JSON store and a Settings UI.",
   "keywords": [
     "cordis",