arisa 5.1.60 → 5.1.64

package/test/telegram-reply-topic-routing.test.js

@@ -0,0 +1,94 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  appendGeneralReplyRoutingInstruction,
+  extractReplyTopicMetadata,
+  isGeneralWorkspaceRoute,
+  routeGeneralWorkspaceReply
+} from "../src/transport/telegram/reply-topic-routing.js";
+
+const topics = [
+  { threadId: 23, name: "Stories", description: "Published stories and editorial work" },
+  { threadId: 87, name: "CBPR", description: "Castle Bravo press campaign" },
+  { threadId: 114, name: "CORE", description: "Arisa core engineering" }
+];
+
+const generalRoute = {
+  workspace: true,
+  ownerChatId: 42,
+  sessionId: "42",
+  scopeChatId: 42,
+  transportChatId: -100123,
+  threadId: null,
+  topicThreadId: 1,
+  generalTopicId: 1
+};
+
+test("General prompts describe conservative dynamic reply routing", () => {
+  const prompt = appendGeneralReplyRoutingInstruction("Incoming Telegram message.", topics, [
+    { name: "Infrastructure", proposedAt: "2026-08-24T00:00:00.000Z" }
+  ]);
+  assert.match(prompt, /only because the incoming message was written in General/);
+  assert.match(prompt, /never applies to a private chat/);
+  assert.match(prompt, /original message must stay in General/);
+  assert.match(prompt, /23: Stories/);
+  assert.match(prompt, /87: CBPR/);
+  assert.match(prompt, /114: CORE/);
+  assert.match(prompt, /Do not repeat these recent topic proposals: Infrastructure/);
+  assert.match(prompt, /Never create a topic without explicit confirmation/);
+});
+
+test("an allowed trailing marker is stripped and selects its topic", () => {
+  assert.deepEqual(extractReplyTopicMetadata("Implemented.\n[[ARISA_REPLY_TOPIC:114]]", topics), {
+    text: "Implemented.",
+    threadId: 114,
+    proposal: ""
+  });
+});
+
+test("invalid markers are stripped without rerouting", () => {
+  assert.deepEqual(extractReplyTopicMetadata("Keep this here.\n[[ARISA_REPLY_TOPIC:999]]", topics), {
+    text: "Keep this here.",
+    threadId: null,
+    proposal: ""
+  });
+});
+
+test("topic proposals are stripped and returned as transport metadata", () => {
+  assert.deepEqual(extractReplyTopicMetadata("Should we create it?\n[[ARISA_PROPOSE_TOPIC:Research Lab]]", topics), {
+    text: "Should we create it?",
+    threadId: null,
+    proposal: "Research Lab"
+  });
+});
+
+test("only replies originating in a supergroup General topic can change destination", () => {
+  assert.equal(isGeneralWorkspaceRoute(generalRoute), true);
+  const routed = routeGeneralWorkspaceReply({
+    route: generalRoute,
+    topics,
+    text: "Core update.\n[[ARISA_REPLY_TOPIC:114]]"
+  });
+  assert.equal(routed.text, "Core update.");
+  assert.equal(routed.route.sessionId, "42");
+  assert.equal(routed.route.threadId, 114);
+  assert.equal(routed.topic.name, "CORE");
+
+  const privateRoute = {
+    workspace: false,
+    sessionId: "42",
+    scopeChatId: 42,
+    transportChatId: 42,
+    threadId: null
+  };
+  assert.equal(isGeneralWorkspaceRoute(privateRoute), false);
+  const privateReply = routeGeneralWorkspaceReply({
+    route: privateRoute,
+    topics,
+    text: "Private response.\n[[ARISA_REPLY_TOPIC:114]]"
+  });
+  assert.equal(privateReply.route, privateRoute);
+  assert.equal(privateReply.topic, null);
+  assert.equal(privateReply.proposal, "");
+  assert.equal(privateReply.text, "Private response.");
+});

package/test/telegram-task-dispatcher.test.js

@@ -50,12 +50,33 @@ test("confirms an agent task only after prompt execution resolves", async () =>
   await new Promise((resolve) => setImmediate(resolve));
   assert.equal(calls[0][0], "enqueue");
   assert.deepEqual(calls[0][1].route, { transport: "telegram", destination: { chatId: -1001, threadId: 9 } });
+  assert.equal(calls[0][1].timeoutMs, 15 * 60_000);
   assert.equal(calls.some(([name]) => name === "complete"), false);
   confirmExecution();
   await running;
   assert.deepEqual(calls.at(-1), ["complete", "task-1"]);
 });
 
+test("passes bounded execution deadlines to scheduled prompts", async () => {
+  const { calls, dispatcher } = createHarness({
+    dependencies: { taskTimeouts: { agentTimeoutMs: 900, eventTimeoutMs: 300 } }
+  });
+  await dispatcher.runClaimedTask({
+    id: "deadline-task",
+    kind: "agent_task",
+    payload: { chatId: 123, prompt: "work" }
+  });
+  await dispatcher.runClaimedTask({
+    id: "deadline-event",
+    kind: "agent_event",
+    payload: { chatId: 123, prompt: "event" }
+  });
+
+  const enqueues = calls.filter(([name]) => name === "enqueue");
+  assert.equal(enqueues[0][1].timeoutMs, 900);
+  assert.equal(enqueues[1][1].timeoutMs, 300);
+});
+
 test("acknowledges an agent event before executing it", async () => {
   const { calls, dispatcher } = createHarness();
   await dispatcher.runClaimedTask({
@@ -155,6 +176,36 @@ test("notifies the routed Telegram topic once retries are exhausted", async () =
   assert.equal(calls.at(-1)[2].includes("private payload"), false);
 });
 
+test("serializes tasks within one destination while independent destinations continue", async () => {
+  const tasks = [
+    { id: "first", kind: "agent_task", payload: { chatId: 123, prompt: "first" }, route: { transport: "telegram", destination: { chatId: -1001, threadId: 87 } } },
+    { id: "second", kind: "agent_task", payload: { chatId: 123, prompt: "second" }, route: { transport: "telegram", destination: { chatId: -1001, threadId: 87 } } },
+    { id: "other", kind: "agent_task", payload: { chatId: 123, prompt: "other" }, route: { transport: "telegram", destination: { chatId: -1001, threadId: 23 } } }
+  ];
+  let releaseFirst;
+  const firstExecution = new Promise((resolve) => { releaseFirst = resolve; });
+  const { calls, dispatcher } = createHarness({
+    taskStore: { async claimDue() { return tasks; } },
+    dependencies: {
+      enqueueAsyncPrompt: async (input) => {
+        calls.push(["enqueue", input.label]);
+        if (input.label.includes("first")) await firstExecution;
+      }
+    }
+  });
+
+  const dispatching = dispatcher.dispatchDueTasks();
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.ok(calls.some((call) => call[0] === "enqueue" && call[1].includes("first")));
+  assert.ok(calls.some((call) => call[0] === "enqueue" && call[1].includes("other")));
+  assert.equal(calls.some((call) => call[0] === "enqueue" && call[1].includes("second")), false);
+
+  releaseFirst();
+  await dispatching;
+  const enqueueOrder = calls.filter((call) => call[0] === "enqueue").map((call) => call[1]);
+  assert.ok(enqueueOrder.indexOf("scheduled task first") < enqueueOrder.indexOf("scheduled task second"));
+});
+
 test("due-task dispatch retries one failure without blocking another task", async () => {
   const tasks = [
     { id: "bad", kind: "agent_task", payload: { chatId: 123, prompt: "fail" } },

package/test/telegram-workspace-topic-store.test.js

@@ -0,0 +1,124 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import os from "node:os";
+import path from "node:path";
+import { mkdtemp, readFile, rm } from "node:fs/promises";
+import {
+  migrateLegacyReplyTopics,
+  WorkspaceTopicStore
+} from "../src/transport/telegram/workspace-topic-store.js";
+
+async function fixture(now = Date.parse("2026-08-24T12:00:00.000Z")) {
+  const directory = await mkdtemp(path.join(os.tmpdir(), "arisa-workspace-topics-"));
+  const file = path.join(directory, "topics.json");
+  return {
+    file,
+    store: new WorkspaceTopicStore({ resolveFile: () => file, now: () => now }),
+    cleanup: () => rm(directory, { recursive: true, force: true })
+  };
+}
+
+test("workspace topics are learned, renamed, closed, and reopened dynamically", async () => {
+  const { store, cleanup } = await fixture();
+  try {
+    const route = {
+      workspace: true,
+      ownerChatId: 42,
+      transportChatId: -100123,
+      topicThreadId: 25,
+      generalTopicId: 1
+    };
+    await store.observeMessage(route, { forum_topic_created: { name: "Research" } });
+    assert.equal((await store.listTopics(42, -100123))[0].name, "Research");
+
+    await store.observeMessage(route, { forum_topic_edited: { name: "Research Lab" } });
+    assert.equal((await store.listTopics(42, -100123))[0].name, "Research Lab");
+
+    await store.observeMessage(route, { forum_topic_closed: {} });
+    assert.deepEqual(await store.listTopics(42, -100123), []);
+    assert.equal((await store.listTopics(42, -100123, { includeClosed: true }))[0].status, "closed");
+
+    await store.observeMessage(route, { forum_topic_reopened: {} });
+    assert.equal((await store.listTopics(42, -100123))[0].status, "open");
+  } finally {
+    await cleanup();
+  }
+});
+
+test("Arisa topic initialization persists semantic context", async () => {
+  const { store, cleanup } = await fixture();
+  try {
+    await store.upsertTopic(42, -100123, {
+      threadId: 114,
+      name: "CORE",
+      description: "Arisa runtime and Telegram engineering",
+      source: "arisa-initialized"
+    });
+    assert.deepEqual((await store.listTopics(42, -100123)).map(({ threadId, name, description, source }) => ({
+      threadId,
+      name,
+      description,
+      source
+    })), [{
+      threadId: 114,
+      name: "CORE",
+      description: "Arisa runtime and Telegram engineering",
+      source: "arisa-initialized"
+    }]);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("concurrent topic updates preserve every workspace entry", async () => {
+  const { store, file, cleanup } = await fixture();
+  try {
+    await Promise.all(Array.from({ length: 30 }, (_, index) => store.upsertTopic(42, -100123, {
+      threadId: index + 2,
+      name: `Topic ${index + 2}`
+    })));
+    assert.equal((await store.listTopics(42, -100123)).length, 30);
+    assert.equal(JSON.parse(await readFile(file, "utf8")).version, 1);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("legacy configured topics migrate once into dynamic state", async () => {
+  const { store, cleanup } = await fixture();
+  try {
+    const config = {
+      telegram: {
+        ownerWorkspaceGroups: {
+          "-100123": {
+            ownerChatId: 42,
+            generalTopicId: 1,
+            replyTopics: {
+              "1": { name: "General" },
+              "23": { name: "Stories", description: "Editorial work" }
+            }
+          }
+        }
+      }
+    };
+    assert.equal(await migrateLegacyReplyTopics(config, store), 1);
+    assert.equal(config.telegram.ownerWorkspaceGroups["-100123"].replyTopics, undefined);
+    assert.deepEqual((await store.listTopics(42, -100123)).map((topic) => topic.name), ["Stories"]);
+    assert.equal(await migrateLegacyReplyTopics(config, store), 0);
+  } finally {
+    await cleanup();
+  }
+});
+
+test("recent proposals are deduplicated and scoped by supergroup", async () => {
+  const { store, cleanup } = await fixture();
+  try {
+    await store.recordProposal(42, -100123, "Research Lab");
+    await store.recordProposal(42, -100123, "research lab");
+    await store.recordProposal(42, -100999, "Another Group");
+    assert.deepEqual((await store.listRecentProposals(42, -100123)).map((item) => item.name), ["research lab"]);
+    assert.deepEqual((await store.listRecentProposals(42, -100999)).map((item) => item.name), ["Another Group"]);
+  } finally {
+    await cleanup();
+  }
+});

package/test/tool-registry-run.test.js

@@ -157,6 +157,22 @@ test("lists optional semantic metadata with stable defaults", async () => {
 
   assert.equal(registry.list()[0].category, null);
   assert.deepEqual(registry.list()[0].keywords, []);
+  assert.equal(registry.get("fake-tool").execution, null);
+});
+
+test("loads weighted execution metadata from the tool manifest", async () => {
+  await resetHome();
+  await createFakeTool("heavy-tool", {
+    execution: { resourceClass: "browser", weight: 2 }
+  });
+
+  const registry = new ToolRegistry();
+  await registry.load();
+
+  assert.deepEqual(registry.get("heavy-tool").execution, {
+    resourceClass: "browser",
+    weight: 2
+  });
 });
 
 test("shows semantic metadata in tool help", async () => {
@@ -193,6 +209,31 @@ test("reports dependency status in help and blocks a tool with a missing depende
   );
 });
 
+test("wraps declared tool runs in the shared execution governor", async () => {
+  await resetHome();
+  await createFakeTool("heavy-tool", {
+    execution: { resourceClass: "browser", weight: 1 }
+  });
+  const calls = [];
+  const executionGovernor = {
+    acquire: async (execution, label) => {
+      calls.push({ type: "acquire", execution, label });
+      return { release: () => calls.push({ type: "release", label }) };
+    },
+    snapshot: () => ({ resources: {} })
+  };
+  const registry = new ToolRegistry({ executionGovernor });
+  await registry.load();
+
+  const result = await registry.run({ name: "heavy-tool", request: { args: {} } });
+
+  assert.equal(result.ok, true);
+  assert.deepEqual(calls, [
+    { type: "acquire", execution: { resourceClass: "browser", weight: 1 }, label: "heavy-tool" },
+    { type: "release", label: "heavy-tool" }
+  ]);
+});
+
 test("runs a registered tool process with an enriched request and cleans up request files", async () => {
   await resetHome();
   await createFakeTool("fake-tool");

package/test/weighted-resource-governor.test.js

@@ -0,0 +1,95 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  normalizeToolExecution,
+  normalizeToolExecutionPolicy,
+  WeightedResourceGovernor
+} from "../src/core/tools/weighted-resource-governor.js";
+
+function deferred() {
+  let resolve;
+  const promise = new Promise((done) => { resolve = done; });
+  return { promise, resolve };
+}
+
+test("normalizes manifest weights and configurable class capacities", () => {
+  assert.deepEqual(normalizeToolExecution({ resourceClass: "browser", weight: 2 }), {
+    resourceClass: "browser",
+    weight: 2
+  });
+  assert.equal(normalizeToolExecution(undefined), null);
+  assert.throws(() => normalizeToolExecution({ resourceClass: "Browser!", weight: 1 }), /Invalid tool execution resource class/);
+  assert.throws(() => normalizeToolExecution({ resourceClass: "browser", weight: 0 }), /positive integer/);
+  assert.deepEqual(normalizeToolExecutionPolicy({
+    defaultCapacity: 3,
+    maxQueuedPerClass: 12,
+    capacities: { browser: 4 }
+  }), {
+    defaultCapacity: 3,
+    maxQueuedPerClass: 12,
+    capacities: { browser: 4 }
+  });
+});
+
+test("queues weighted work fairly within one resource class", async () => {
+  let time = 100;
+  const governor = new WeightedResourceGovernor({
+    policy: { defaultCapacity: 2 },
+    now: () => time,
+    memoryUsage: () => ({ rss: 100 * 1024 * 1024 })
+  });
+  const execution = { resourceClass: "browser", weight: 1 };
+  const first = await governor.acquire(execution, "first");
+  const second = await governor.acquire(execution, "second");
+  const thirdLease = governor.acquire(execution, "third");
+  const fourthLease = governor.acquire(execution, "fourth");
+
+  assert.deepEqual(governor.snapshot().resources.browser, {
+    capacity: 2,
+    activeWeight: 2,
+    queued: 2
+  });
+
+  const thirdGranted = deferred();
+  thirdLease.then((lease) => thirdGranted.resolve(lease));
+  time = 140;
+  first.release();
+  const third = await thirdGranted.promise;
+  assert.equal(third.waitedMs, 40);
+  assert.equal(governor.snapshot().resources.browser.queued, 1);
+
+  second.release();
+  const fourth = await fourthLease;
+  assert.equal(fourth.waitedMs, 40);
+  third.release();
+  fourth.release();
+  assert.equal(governor.snapshot().resources.browser.activeWeight, 0);
+});
+
+test("undeclared lightweight work bypasses constrained resource queues", async () => {
+  const governor = new WeightedResourceGovernor({ policy: { defaultCapacity: 1 } });
+  const heavy = await governor.acquire({ resourceClass: "browser", weight: 1 }, "heavy");
+  const queued = governor.acquire({ resourceClass: "browser", weight: 1 }, "queued");
+  const light = await governor.acquire(null, "light");
+  assert.equal(light.waitedMs, 0);
+  assert.equal(governor.snapshot().resources.browser.queued, 1);
+  light.release();
+  heavy.release();
+  (await queued).release();
+});
+
+test("larger weights consume shared capacity and worker RSS peaks are retained", async () => {
+  let rss = 120 * 1024 * 1024;
+  const governor = new WeightedResourceGovernor({
+    policy: { defaultCapacity: 3 },
+    memoryUsage: () => ({ rss })
+  });
+  const large = await governor.acquire({ resourceClass: "browser", weight: 2 }, "large");
+  const waiting = governor.acquire({ resourceClass: "browser", weight: 2 }, "waiting");
+  assert.equal(governor.snapshot().resources.browser.queued, 1);
+  rss = 180 * 1024 * 1024;
+  large.release();
+  const next = await waiting;
+  assert.equal(governor.snapshot().peakRssBytes, rss);
+  next.release();
+});