@agentprojectcontext/apx 1.25.0 → 1.27.2

package/src/{daemon/plugins/overlay.js → host/daemon/plugins/desktop.js}

@@ -1,36 +1,37 @@
-// Overlay plugin — voice/floating-window channel for the APX daemon.
+// Desktop plugin — voice/floating-window channel for the APX daemon.
 //
 // This plugin:
-//   1. Registers as a super-agent channel (type "overlay")
-//   2. Routes inbound messages (POST /overlay/message) to the super-agent
-//   3. Streams tokens + tool events back to overlay clients via WebSocket
+//   1. Registers as a super-agent channel (type "desktop")
+//   2. Routes inbound messages (POST /desktop/message) to the super-agent
+//   3. Streams tokens + tool events back to desktop clients via WebSocket
 //
-// Overlay history is kept in-memory per session (not persisted to disk).
-// Each new overlay window starts a fresh session.
+// Desktop history is kept in-memory per session (not persisted to disk).
+// Each new desktop window starts a fresh session.
 //
 // Config (in ~/.apx/config.json):
-//   "overlay": {
+//   "desktop": {
 //     "enabled": true,
 //     "route_to_agent": "",        // leave empty = use super-agent
 //     "model": "",                 // override model; leave empty = super-agent.model
 //     "max_history": 20            // turns to keep in context
 //   }
+// (legacy "overlay" block is still read as a fallback)
 
 import {
-  broadcastOverlay,
+  broadcastDesktop,
   sendToClient,
-  setOverlayMessageHandler,
-} from "../overlay-ws.js";
+  setDesktopMessageHandler,
+} from "../desktop-ws.js";
 import { runSuperAgent, isSuperAgentEnabled } from "../super-agent.js";
-import { appendGlobalMessage } from "../../core/messages-store.js";
+import { appendGlobalMessage } from "../../../core/messages-store.js";
 
-const CHANNEL = "overlay";
+const CHANNEL = "desktop";
 
 export default {
-  id: "overlay",
+  id: "desktop",
 
   init({ projects, config, log, plugins }) {
-    const cfg = config.overlay || {};
+    const cfg = config.desktop || config.overlay || {};
     const enabled = cfg.enabled !== false; // enabled by default
 
     // In-memory conversation history per connected client.
@@ -42,13 +43,13 @@ export default {
       return histories.get(ws);
     }
 
-    // Handle messages sent from the overlay renderer via WebSocket
-    setOverlayMessageHandler(async (ws, data) => {
+    // Handle messages sent from the desktop renderer via WebSocket
+    setDesktopMessageHandler(async (ws, data) => {
       if (data.type === "message") {
         await _handleMessage({ ws, text: data.text, previousMessages: getHistory(ws) }, { projects, config, log, plugins, cfg, histories });
       } else if (data.type === "cancel") {
         // Signal to abort current generation (handled via AbortController below)
-        ws._overlayAbort?.abort();
+        ws._desktopAbort?.abort();
       } else if (data.type === "ping") {
         sendToClient(ws, { type: "pong" });
       }
@@ -56,15 +57,15 @@ export default {
 
     const instance = {
       start() {
-        if (enabled) log("overlay: plugin started");
+        if (enabled) log("desktop: plugin started");
       },
       stop() {},
       status() { return { enabled }; },
 
-      // Called by the /overlay/message REST endpoint
+      // Called by the /desktop/message REST endpoint
       async handleMessage({ text, previousMessages = [] }) {
-        if (!enabled) throw new Error("overlay plugin not enabled");
-        broadcastOverlay({ type: "user_message", text });
+        if (!enabled) throw new Error("desktop plugin not enabled");
+        broadcastDesktop({ type: "user_message", text });
         await _handleMessage({ ws: null, text, previousMessages }, { projects, config, log, plugins, cfg, histories });
       },
     };
@@ -89,14 +90,14 @@ async function _handleMessage({ ws, text, previousMessages }, { projects, config
 
   // AbortController for cancel support
   const controller = new AbortController();
-  if (ws) ws._overlayAbort = controller;
+  if (ws) ws._desktopAbort = controller;
 
   // Emit "thinking" indicator
   _send(ws, { type: "thinking" });
 
-  // Persist to overlay message log
+  // Persist to desktop message log
   try {
-    await appendGlobalMessage(CHANNEL, { role: "user", content: text, ts: new Date().toISOString() });
+    await appendGlobalMessage({ channel: CHANNEL, direction: "in", type: "user", author: "user", body: text });
   } catch {}
 
   let fullResponse = "";
@@ -107,12 +108,15 @@ async function _handleMessage({ ws, text, previousMessages }, { projects, config
       throw new Error("super-agent not enabled — set super_agent.enabled + super_agent.model in ~/.apx/config.json");
     }
 
+    log(`desktop: super-agent turn start — model=${cfg.model || config?.super_agent?.model || "(default)"} text="${text.slice(0, 60)}"`);
+    const t0 = Date.now();
     const result = await runSuperAgent({
       globalConfig: config,
       projects,
       plugins,
       prompt: text,
-      contextNote: "# Channel context\nChannel: overlay (floating voice window). Reply concisely.",
+      channel: "desktop",
+      channelMeta: { voice: true }, // desktop module is voice-first → spoken mode
       previousMessages: history.slice(0, -1),
       overrideModel: cfg.model || null,
       signal: controller.signal,
@@ -134,6 +138,7 @@ async function _handleMessage({ ws, text, previousMessages }, { projects, config
       },
     });
     const finalText = fullResponse || result.text || "";
+    log(`desktop: super-agent turn done in ${Date.now() - t0}ms text_len=${finalText.length}`);
 
     // Emit done with full text
     _send(ws, { type: "done", text: finalText });
@@ -150,14 +155,17 @@ async function _handleMessage({ ws, text, previousMessages }, { projects, config
 
     // Persist assistant response
     try {
-      await appendGlobalMessage(CHANNEL, { role: "assistant", content: finalText, ts: new Date().toISOString() });
+      await appendGlobalMessage({ channel: CHANNEL, direction: "out", type: "agent", body: finalText });
     } catch {}
 
   } catch (e) {
     if (e.name === "AbortError") {
       _send(ws, { type: "cancelled" });
     } else {
-      log(`overlay: error — ${e.message}`);
+      // Verbose stack — the previous one-liner hid root causes when the
+      // model adapter threw inside runSuperAgent's promise chain.
+      log(`desktop: error — ${e.message}`);
+      console.error("desktop plugin: super-agent threw:", e.stack || e);
       _send(ws, { type: "error", message: e.message });
     }
   }
@@ -167,7 +175,7 @@ function _send(ws, msg) {
   if (ws) {
     sendToClient(ws, msg);
   } else {
-    broadcastOverlay(msg);
+    broadcastDesktop(msg);
   }
 }
 

package/src/{daemon → host/daemon}/plugins/index.js

@@ -13,9 +13,9 @@
 // Plugins are discovered by static import here. Adding a new plugin = importing
 // it and pushing into PLUGINS.
 import telegramPlugin from "./telegram.js";
-import overlayPlugin from "./overlay.js";
+import desktopPlugin from "./desktop.js";
 
-export const PLUGINS = [telegramPlugin, overlayPlugin];
+export const PLUGINS = [telegramPlugin, desktopPlugin];
 
 export class PluginManager {
   constructor({ projects, config, log, registries }) {

package/src/{daemon → host/daemon}/plugins/telegram.js

@@ -29,18 +29,59 @@
 
 import fs from "node:fs";
 import path from "node:path";
-import { TELEGRAM_STATE_PATH, APX_HOME } from "../../core/config.js";
-import { callEngine } from "../engines/index.js";
+import { TELEGRAM_STATE_PATH, APX_HOME } from "../../../core/config.js";
+import { callEngine } from "../../../core/engines/index.js";
 import { runSuperAgent, isSuperAgentEnabled } from "../super-agent.js";
 import { stripThinking } from "../thinking.js";
-import { getRecentTelegramTurnsFromFs, appendGlobalMessage } from "../../core/messages-store.js";
-import { readAgents } from "../../core/parser.js";
-import { buildAgentSystem } from "../../core/agent-system.js";
+import { getRecentTelegramTurnsFromFs, appendGlobalMessage } from "../../../core/messages-store.js";
+import { compactChannelIfNeeded } from "../../../core/memory/index.js";
+import { readAgents } from "../../../core/parser.js";
+import { buildAgentSystem } from "../../../core/agent-system.js";
 import { transcribe as transcribeAudioFile } from "../transcription.js";
+import { resolveAgentName, SUPERAGENT_ACTOR_ID } from "../../../core/identity.js";
+import { registerSender, resolveAllowedTools } from "../../../core/telegram-identity.js";
+import { buildRelationshipBlock } from "../../../core/agent/index.js";
 
 const API_BASE = "https://api.telegram.org";
 const nowIso = () => new Date().toISOString().replace(/\.\d{3}Z$/, "Z");
 
+// Build the channelMeta passed to the super-agent loop. The prompt template at
+// src/core/agent/prompts/channels/telegram.md interpolates {{projectBlock}}
+// and {{routeBlock}} verbatim, so we pre-render them as plain text here
+// (the template engine doesn't do conditionals).
+function buildTelegramMeta({ channelName, author, chatId, target, routeToAgent }) {
+  const projectBlock = target
+    ? `\nProject pin: **${target.name || "(unnamed)"}** (\`${target.path || "?"}\`).\n` +
+      "This Telegram channel belongs to that project. Default any " +
+      "project-scoped tool call (list_agents, list_tasks, list_mcps, " +
+      "list_skills, create_task, list_routines, …) to " +
+      `\`${target.name || target.path}\` without asking the user "which ` +
+      'project?". Only ask when they explicitly reference another project ' +
+      "by name."
+    : "";
+  const routeBlock = routeToAgent
+    ? `\nMaster agent for this channel: **${routeToAgent}**. Prefer ` +
+      `delegating substantive work to that agent via call_agent({ project: ` +
+      `"${target?.name || target?.path || ""}", agent: "${routeToAgent}", ` +
+      "prompt: <user message> }) rather than answering yourself, unless " +
+      "the message is small-talk or a quick factual reply."
+    : "";
+  return {
+    channelName,
+    author,
+    chatId,
+    projectBlock,
+    routeBlock,
+    // Also expose raw fields for any future surface / log that wants them.
+    ...(target ? {
+      projectId:   String(target.id),
+      projectName: target.name || "",
+      projectPath: target.path || "",
+    } : {}),
+    ...(routeToAgent ? { routeToAgent } : {}),
+  };
+}
+
 // ---------- media sending helpers -------------------------------------------
 
 /**
@@ -394,6 +435,22 @@ class ChannelPoller {
         : `${msg.from?.first_name || ""} ${msg.from?.last_name || ""}`.trim() || "unknown";
     const chat_id = msg.chat?.id;
 
+    // Resolve WHO is writing (owner / known contact / guest), keyed by the
+    // stable Telegram user_id. Records unknown senders and, on a fresh private
+    // channel with no owner yet, claims this sender as the owner. Mutates the
+    // in-memory globalConfig in place so later messages in this daemon session
+    // see the update. The resulting block is injected into whichever agent
+    // answers (super-agent OR a routed project agent).
+    const { sender } = registerSender({
+      cfg: this.globalConfig,
+      channelName: this.channel.name,
+      from: msg.from,
+      chatType: msg.chat?.type,
+    });
+    const relationshipBlock = buildRelationshipBlock(sender);
+    // Role-based tool gating for the super-agent path (guests → no tools).
+    const allowedTools = resolveAllowedTools(this.globalConfig, sender);
+
     // Default Interrupt: abort any running request for this chat_id
     if (chat_id) {
       const prev = this.activeRequests.get(chat_id);
@@ -519,9 +576,19 @@ class ChannelPoller {
     if (chat_id && !isReset) {
       previousMessages = getRecentTelegramTurnsFromFs({
         chat_id,
-        limit: 20,
+        keepRecent: 40,
         max_age_hours: 24,
       });
+      // Progressive compaction (Pieza 3) runs OUT of the reply path: if this
+      // chat is over threshold, summarize the oldest turns in the background so
+      // the next turn reads a [RESUMEN COMPACTADO] instead of raw history. Never
+      // awaited — adds zero latency to this reply, degrades gracefully.
+      compactChannelIfNeeded({
+        channel: "telegram",
+        chat_id,
+        config: this.globalConfig,
+        log: this.log,
+      }).catch(() => {});
       // Honour a /reset marker: drop everything up to and including it.
       const lastResetIdx = (() => {
         for (let i = previousMessages.length - 1; i >= 0; i--) {
@@ -576,8 +643,10 @@ class ChannelPoller {
           channel: "telegram",
           direction: "out",
           type: "agent",
-          actor_id: "apx",
-          author: "apx",
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
+          agent_slug: SUPERAGENT_ACTOR_ID,
+          author: resolveAgentName(this.globalConfig),
           body: ack,
           meta: { chat_id, tg_channel: this.channel.name, in_reply_to: u.update_id, reset: true },
         });
@@ -592,7 +661,11 @@ class ChannelPoller {
 
     let replyText;
     let replyAuthor;
+    let replyActorId;   // stable id: super_agent | agent slug
+    let replyKind;      // actor_kind: superagent | agent
     const projectCfg = target.config || this.globalConfig;
+    // Display name for the super-agent persona on this channel (Roby / APX).
+    const agentDisplay = resolveAgentName(this.globalConfig);
 
     // Try the project's chosen agent first (skipped if the legacy
     // respond_with_engine === false hint asked to bypass routed agents).
@@ -605,6 +678,7 @@ class ChannelPoller {
             invocation: "telegram",
             channel: this.channel.name,
             caller: author,
+            extraParts: [relationshipBlock],
           });
           const result = await callEngine({
             modelId: agent.fields.Model,
@@ -614,10 +688,14 @@ class ChannelPoller {
           });
           replyText = result.text;
           replyAuthor = agent.slug;
+          replyActorId = agent.slug;
+          replyKind = "agent";
         } catch (e) {
           this.log(`telegram[${this.channel.name}] agent reply failed: ${e.message}`);
           replyText = `[apx error] ${e.message.slice(0, 200)}`;
-          replyAuthor = "apx";
+          replyAuthor = agentDisplay;
+          replyActorId = SUPERAGENT_ACTOR_ID;
+          replyKind = "superagent";
         }
       } else {
         this.log(
@@ -637,9 +715,41 @@ class ChannelPoller {
     let saUsage = null;
     let streamedCount = 0;
     let lastStreamedText = "";
+    // Telegram shows the user ONLY prose — never the tool calls. On an action
+    // request the model often jumps straight to a tool with no preamble text,
+    // so the user would stare at a silent chat until the final reply. Send one
+    // short localized heads-up the moment real work starts (first tool_start),
+    // but only if the agent didn't already write its own "on it" line.
+    let sentHeadsUp = false;
+    const headsUpPhrase = () => {
+      const lang = (this.globalConfig?.user?.language || "es").slice(0, 2);
+      const byLang = {
+        es: "Dale, estoy con eso… 🛠️",
+        en: "On it — working on that… 🛠️",
+        pt: "Já estou nisso… 🛠️",
+      };
+      return byLang[lang] || byLang.es;
+    };
     if (!replyText && isSuperAgentEnabled(this.globalConfig)) {
       const onEvent = async (ev) => {
         try {
+          if (ev.type === "tool_start" && !sentHeadsUp && streamedCount === 0) {
+            sentHeadsUp = true;
+            const heads = headsUpPhrase();
+            await this._send({ chat_id, text: heads });
+            appendGlobalMessage({
+              channel: "telegram",
+              direction: "out",
+              type: "agent",
+              actor_id: SUPERAGENT_ACTOR_ID,
+              actor_kind: "superagent",
+              agent_slug: SUPERAGENT_ACTOR_ID,
+              author: agentDisplay,
+              body: heads,
+              meta: { chat_id, tg_channel: this.channel.name, in_reply_to: u.update_id, heads_up: true },
+            });
+            return;
+          }
           if (ev.type === "assistant_text" && ev.text) {
             const piece = stripThinking(ev.text).trim();
             if (!piece) return;
@@ -650,9 +760,10 @@ class ChannelPoller {
               channel: "telegram",
               direction: "out",
               type: "agent",
-              actor_id: "apx",
-              agent_slug: "apx",
-              author: "apx",
+              actor_id: SUPERAGENT_ACTOR_ID,
+              actor_kind: "superagent",
+              agent_slug: SUPERAGENT_ACTOR_ID,
+              author: agentDisplay,
               body: piece,
               meta: {
                 chat_id,
@@ -670,7 +781,8 @@ class ChannelPoller {
               direction: "out",
               type: "tool",
               actor_id: t.tool,
-              author: "apx",
+              actor_kind: "tool",
+              author: agentDisplay,
               body: `${t.tool}(${JSON.stringify(t.args || {}).slice(0, 200)})`,
               meta: {
                 chat_id,
@@ -697,12 +809,23 @@ class ChannelPoller {
           registries: this.registries,
           prompt: text,
           previousMessages,
-          contextNote: `You are replying inside Telegram right now. Telegram channel="${this.channel.name}", author=${author}, chat_id=${chat_id}. Keep the reply plain-text and concise. Previous turns of this chat are included only for local conversational context; re-call tools for facts.`,
+          channel: "telegram",
+          relationshipBlock,
+          allowedTools,
+          channelMeta: buildTelegramMeta({
+            channelName: this.channel.name,
+            author,
+            chatId: chat_id,
+            target,
+            routeToAgent: this.channel.route_to_agent,
+          }),
           signal: abortCtrl.signal,
           onEvent,
         });
         replyText = sa.text;
-        replyAuthor = sa.name;
+        replyAuthor = sa.name || agentDisplay;
+        replyActorId = SUPERAGENT_ACTOR_ID;
+        replyKind = "superagent";
         saUsage = sa.usage;
       } catch (e) {
         if (abortCtrl.signal.aborted) {
@@ -719,7 +842,9 @@ class ChannelPoller {
         // turn — otherwise from the chat side it looks like the bot ignored
         // the message. Keep the message short and non-leaking.
         replyText = `⚠️ Could not generate a reply right now (${e.message || "internal error"}).`;
-        replyAuthor = "apx";
+        replyAuthor = agentDisplay;
+        replyActorId = SUPERAGENT_ACTOR_ID;
+        replyKind = "superagent";
       }
     }
 
@@ -752,9 +877,10 @@ class ChannelPoller {
         channel: "telegram",
         direction: "out",
         type: "agent",
-        actor_id: replyAuthor || "apx",
-        agent_slug: replyAuthor || "apx",
-        author: replyAuthor || "apx",
+        actor_id: replyActorId || SUPERAGENT_ACTOR_ID,
+        actor_kind: replyKind || "superagent",
+        agent_slug: replyActorId || SUPERAGENT_ACTOR_ID,
+        author: replyAuthor || agentDisplay,
         body: toSend,
         meta,
       });
@@ -764,9 +890,10 @@ class ChannelPoller {
         channel: "telegram",
         direction: "out",
         type: "agent",
-        actor_id: replyAuthor || "apx",
-        agent_slug: replyAuthor || "apx",
-        author: replyAuthor || "apx",
+        actor_id: replyActorId || SUPERAGENT_ACTOR_ID,
+        actor_kind: replyKind || "superagent",
+        agent_slug: replyActorId || SUPERAGENT_ACTOR_ID,
+        author: replyAuthor || agentDisplay,
         body: `[send_failed] ${toSend}`,
         meta: {
           chat_id,
@@ -905,7 +1032,7 @@ export default {
       // that bot; otherwise first available bot-tokened channel. Always logs
       // the outbound on `messages` of the channel's target project so audit
       // trails are complete.
-      async send({ channel: channelName, chat_id, text, author = "apx", project }) {
+      async send({ channel: channelName, chat_id, text, author = resolveAgentName(config), project }) {
         const p =
           (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
           pollers.find((pp) => resolveBotToken(pp.channel)) ||
@@ -916,8 +1043,9 @@ export default {
           channel: "telegram",
           direction: "out",
           type: "agent",
-          actor_id: author,
-          agent_slug: author,
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
+          agent_slug: SUPERAGENT_ACTOR_ID,
           author,
           body: text,
           meta: {
@@ -934,7 +1062,7 @@ export default {
        * photo: local file path, Buffer, or public URL
        * opts: { caption, parse_mode, channel, author }
        */
-      async sendPhoto({ channel: channelName, chat_id, photo, caption, parse_mode, author = "apx" }) {
+      async sendPhoto({ channel: channelName, chat_id, photo, caption, parse_mode, author = resolveAgentName(config) }) {
         const p =
           (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
           pollers.find((pp) => resolveBotToken(pp.channel)) ||
@@ -945,7 +1073,8 @@ export default {
           channel: "telegram",
           direction: "out",
           type: "photo",
-          actor_id: author,
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
           author,
           body: caption || "[photo]",
           meta: { chat_id: chat_id || resolveChatId(p.channel), tg_channel: p.channel.name },
@@ -957,7 +1086,7 @@ export default {
        * Send a voice message (OGG/Opus preferred).
        * audio: local file path or Buffer
        */
-      async sendVoice({ channel: channelName, chat_id, audio, caption, duration, author = "apx" }) {
+      async sendVoice({ channel: channelName, chat_id, audio, caption, duration, author = resolveAgentName(config) }) {
         const p =
           (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
           pollers.find((pp) => resolveBotToken(pp.channel)) ||
@@ -968,7 +1097,8 @@ export default {
           channel: "telegram",
           direction: "out",
           type: "voice",
-          actor_id: author,
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
           author,
           body: caption || "[voice]",
           meta: { chat_id: chat_id || resolveChatId(p.channel), tg_channel: p.channel.name },
@@ -980,7 +1110,7 @@ export default {
        * Send a document (PDF, zip, txt, generated reports, etc).
        * document: local file path, Buffer, or public https URL.
        */
-      async sendDocument({ channel: channelName, chat_id, document, caption, filename, mime_type, author = "apx" }) {
+      async sendDocument({ channel: channelName, chat_id, document, caption, filename, mime_type, author = resolveAgentName(config) }) {
         const p =
           (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
           pollers.find((pp) => resolveBotToken(pp.channel)) ||
@@ -991,7 +1121,8 @@ export default {
           channel: "telegram",
           direction: "out",
           type: "document",
-          actor_id: author,
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
           author,
           body: caption || `[document${filename ? " " + filename : ""}]`,
           meta: { chat_id: chat_id || resolveChatId(p.channel), tg_channel: p.channel.name, filename, mime_type },
@@ -1003,7 +1134,7 @@ export default {
        * Send an audio file (MP3/M4A — shown in music player).
        * audio: local file path or Buffer
        */
-      async sendAudio({ channel: channelName, chat_id, audio, caption, title, performer, author = "apx" }) {
+      async sendAudio({ channel: channelName, chat_id, audio, caption, title, performer, author = resolveAgentName(config) }) {
         const p =
           (channelName && pollers.find((pp) => pp.channel.name === channelName)) ||
           pollers.find((pp) => resolveBotToken(pp.channel)) ||
@@ -1014,7 +1145,8 @@ export default {
           channel: "telegram",
           direction: "out",
           type: "audio",
-          actor_id: author,
+          actor_id: SUPERAGENT_ACTOR_ID,
+          actor_kind: "superagent",
           author,
           body: caption || title || "[audio]",
           meta: { chat_id: chat_id || resolveChatId(p.channel), tg_channel: p.channel.name },

package/src/{daemon → host/daemon}/project-config.js

@@ -74,12 +74,28 @@ export function setDottedKey(obj, dottedKey, value) {
   let cur = obj;
   for (let i = 0; i < parts.length - 1; i++) {
     const k = parts[i];
-    if (typeof cur[k] !== "object" || cur[k] === null || Array.isArray(cur[k])) {
-      cur[k] = {};
+    const nextKey = parts[i + 1];
+    if (Array.isArray(cur)) {
+      const idx = Number(k);
+      if (!Number.isInteger(idx) || idx < 0) return obj;
+      if (typeof cur[idx] !== "object" || cur[idx] === null) {
+        cur[idx] = /^\d+$/.test(nextKey) ? [] : {};
+      }
+      cur = cur[idx];
+      continue;
+    }
+    if (typeof cur[k] !== "object" || cur[k] === null) {
+      cur[k] = /^\d+$/.test(nextKey) ? [] : {};
     }
     cur = cur[k];
   }
-  cur[parts[parts.length - 1]] = value;
+  const last = parts[parts.length - 1];
+  if (Array.isArray(cur)) {
+    const idx = Number(last);
+    if (Number.isInteger(idx) && idx >= 0) cur[idx] = value;
+  } else {
+    cur[last] = value;
+  }
   return obj;
 }
 
@@ -87,11 +103,19 @@ export function unsetDottedKey(obj, dottedKey) {
   const parts = dottedKey.split(".");
   let cur = obj;
   for (let i = 0; i < parts.length - 1; i++) {
-    if (typeof cur[parts[i]] !== "object") return false;
-    cur = cur[parts[i]];
+    const key = parts[i];
+    if (Array.isArray(cur)) {
+      const idx = Number(key);
+      if (!Number.isInteger(idx) || typeof cur[idx] !== "object") return false;
+      cur = cur[idx];
+      continue;
+    }
+    if (typeof cur[key] !== "object") return false;
+    cur = cur[key];
   }
-  if (parts[parts.length - 1] in cur) {
-    delete cur[parts[parts.length - 1]];
+  const last = parts[parts.length - 1];
+  if (last in cur) {
+    delete cur[last];
     return true;
   }
   return false;