pi-onlyne 1.2.1 → 1.2.2

package/README.md

@@ -414,7 +414,7 @@ path the client's daemon bound, read when the environment carried none, §8).
 | `reconnecting in 4000ms` in a loop | the client is down or the socket was replaced | `onlyne --server-root … roles` |
 | `ready refused: internal: unknown session for …` | the plugin mounted and reported for a task the client never staged (normal when pi is started by hand outside a task) | start pi under the client, not by hand |
 | `assign` never arrives | the client's `session_command` did not spawn pi, or `inject` was dropped | the client log for the spawn line; `/onlyne status` for the capability set |
-| ledger stays `in_flight` | no completion yet: no turn has run (the injected message has not executed), or the ladder is still reminding it (`idleReminders`) | the pi session file for the `onlyne-assign` entry and the reminders injected after it; the `onlyne` panel for `reminder n of m`; `/onlyne status` for the task and phase |
+| ledger stays `in_flight` | no completion yet: no turn has run (the injected message has not executed), or the ladder is still reminding it (`idleReminders`). On pi-onlyne 1.2.1 against pi 0.87 an envelope carrying an image left nothing injected at all: pi read the flat `ImageContent` this plugin now sends, refused the nested part the older plugin built, and took the task text down with it | the pi session file for the `onlyne-assign` entry and the reminders injected after it; the `onlyne` panel for `reminder n of m`; `/onlyne status` for the task and phase; for that refusal, the pane's `Extension "<runtime>" error` line and, on 1.2.2, the plugin's `attachment carried no base64 data or no media type` log |
 | `onlyne_complete` answers `relay guard: missing handoff to: …` | the workspace's spec (or a `relay.toml` standing in for it) names a role this session never sent to | routine notices appear in the `onlyne` panel; stderr keeps refusals such as `relay guard from …`, socket errors, timeouts and framing faults; `required=…` names the policy; `relay guard: missing handoff …` names the delivered set |
 | `hello … forbidden` / connection closed right after `hello` | the mount role does not match the client's role | `hello.args.mount.role` vs the workspace's role |
 | `frame_too_large` | a body above 8 MiB | only reachable through an oversize outbound image; the ceiling is the core's |
@@ -695,7 +695,7 @@ relay_required = ["writer"]        # these roles must have received a handoff
 | `reconnecting in 4000ms` 持续循环 | 客户端已停止，或套接字已被替换 | `onlyne --server-root … roles` |
 | `ready refused: internal: unknown session for …` | 插件完成挂载并为一个客户端从未暂存的任务进行了报告（在任务之外手动启动 pi 时属于正常情况） | 在客户端下启动 pi，不手动启动 |
 | `assign` 始终未到达 | 客户端的 `session_command` 未启动 pi，或 `inject` 已被移除 | 在客户端日志中查看启动行；通过 `/onlyne status` 查看能力集合 |
-| 账本保持 `in_flight` | 尚未完成：还没有轮次运行（注入消息尚未执行），或者阶梯仍在提醒（`idleReminders`） | 在 pi 会话文件中查看 `onlyne-assign` 条目及其后注入的提醒；通过 `onlyne` 面板查看 `reminder n of m`；通过 `/onlyne status` 查看任务和阶段 |
+| 账本保持 `in_flight` | 尚未完成：还没有轮次运行（注入消息尚未执行），或者阶梯仍在提醒（`idleReminders`）。在 pi-onlyne 1.2.1 对上 pi 0.87 时，带图片附件的信封会什么都没注入：pi 读取本插件现在送出的扁平 `ImageContent`，拒掉旧插件构造的嵌套 part，任务正文随之一起丢失 | 在 pi 会话文件中查看 `onlyne-assign` 条目及其后注入的提醒；通过 `onlyne` 面板查看 `reminder n of m`；通过 `/onlyne status` 查看任务和阶段；要找那次拒绝，看窗格里的 `Extension "<runtime>" error` 行，以及 1.2.2 上插件的 `attachment carried no base64 data or no media type` 日志 |
 | `onlyne_complete` 回复 `relay guard: missing handoff to: …` | 工作区的规范（或替代该规范的 `relay.toml`）指定了一个此会话从未向其发送的角色 | 常规通知会出现在 `onlyne` 面板中；stderr 会保留拒绝消息，例如 `relay guard from …`、套接字错误、超时和分帧错误；`required=…` 指明策略；`relay guard: missing handoff …` 指明已送达的集合 |
 | `hello … forbidden`／在 `hello` 后立即关闭连接 | 挂载角色与客户端角色不匹配 | `hello.args.mount.role` 与工作区角色 |
 | `frame_too_large` | 正文超过 8 MiB | 仅可通过超大的出站图像达到；此上限来自核心 |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-onlyne",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "description": "Onlyne agent adapter for pi: the session lifecycle an onlyne role client expects from a pi host.",
   "type": "module",
   "license": "MIT",

package/src/activity.test.mjs

@@ -52,12 +52,6 @@ test("hostile input stays inside render bounds", () => {
   for (const line of lines) assert.ok(Array.from(line).length <= MAX_WIDTH, line);
 });
 
-test("identical state gives identical output", () => {
-  const activity = createActivity({ clock }).set({ role: "planner", connection: "connected" });
-  activity.note("in", "build it");
-  assert.deepEqual(activity.lines(), activity.lines());
-});
-
 test("default render shows the newest SHOW_EVENTS events", () => {
   const activity = createActivity({ clock });
   for (let index = 0; index < SHOW_EVENTS + 4; index += 1) activity.note("state", `event ${index}`);

package/src/agent.test.mjs

@@ -11,7 +11,6 @@ import { fileURLToPath } from "node:url";
 import { afterEach, test } from "node:test";
 
 import { OnlyneAgent } from "./agent.mjs";
-import { MAX_LINES, MAX_WIDTH } from "./activity.mjs";
 import { DEFAULT_IDLE_REMINDERS } from "./config.mjs";
 import { createFrameDecoder, encodeFrame } from "./frame.mjs";
 import { SEQ_BASE, readyReport } from "./protocol.mjs";
@@ -374,24 +373,6 @@ test("a reconnect reports the same pane", async () => {
   });
 });
 
-test("a second task in the same pane reports the same pane", async () => {
-  await inOrcaPane(PANE_ENV, async () => {
-    const { host } = await mountedAgent();
-    host.notify("assign", assignArgs());
-    await waitFor(() => (host.of("assign_ack").length === 1 ? true : null));
-    host.notify("probe", {});
-    await waitFor(() => (heartbeats(host).length ? true : null));
-
-    // The binding belongs to the process, not to the task: handing this pane
-    // another task cannot change where the process runs.
-    host.notify("assign", { ...assignArgs(), task_id: "22222222-2222-4222-8222-222222222222" });
-    await waitFor(() => (host.of("assign_ack").length === 2 ? true : null));
-    host.notify("probe", {});
-    const reports = await waitFor(() => (heartbeats(host).length >= 2 ? heartbeats(host) : null));
-    assert.deepEqual(reports.at(-1).host, reports[0].host);
-  });
-});
-
 test("a pi outside an Orca pane reports no host at all", async () => {
   await inOrcaPane({}, async () => {
     const { host } = await mountedAgent();
@@ -405,22 +386,6 @@ test("a pi outside an Orca pane reports no host at all", async () => {
   });
 });
 
-test("a pane that exports no handle reports the pane without inventing one", async () => {
-  await inOrcaPane({ ORCA_PANE_KEY: PANE_KEY }, async () => {
-    const { host } = await mountedAgent();
-    host.notify("assign", assignArgs());
-    await waitFor(() => (host.of("assign_ack").length === 1 ? true : null));
-    host.notify("probe", {});
-
-    const [observed] = await waitFor(() => (heartbeats(host).length ? heartbeats(host) : null));
-    // The pane key carries both ids; the handle is a field the environment
-    // either has or has not, and a missing one is absent rather than empty.
-    assert.deepEqual(observed.host, {
-      orca: { pane_key: PANE_KEY, tab_id: PANE_TAB, leaf_id: PANE_LEAF },
-    });
-  });
-});
-
 test("the binding is the environment the process was spawned with", async () => {
   await inOrcaPane(PANE_ENV, async () => {
     const { host } = await mountedAgent();
@@ -687,26 +652,6 @@ test("a busy pi holds the settle decision until it is waiting for input", async
   assert.match(reminded[1].text, /build it/, "the decision waits for the idle it is about");
 });
 
-test("queued input keeps the session non-idle and holds the ladder off", async () => {
-  let queued = false;
-  const surface = fakeSurface({ waiting: () => !queued });
-  const { agent, host } = await startAgent({ surface, options: { settleFallbackMs: 40 } });
-  agent.start();
-  await waitFor(() => host.of("report").length >= 1);
-  host.notify("assign", assignArgs());
-  await waitFor(() => (surface.calls.wakeUser.length === 1 ? true : null));
-
-  agent.onTurnStart();
-  queued = true;
-  agent.onTurnEnd();
-  agent.onSettled();
-  await waitFor(() => heartbeats(host).at(-1)?.agent === "running");
-  await new Promise((resolve) => setTimeout(resolve, 80));
-
-  assert.equal(surface.calls.wakeUser.length, 1, "a queued continuation is not an idle episode");
-  assert.deepEqual(surface.calls.exits, []);
-});
-
 test("a live background task holds the ladder off until its task is terminal", async () => {
   let backgroundWork = true;
   const surface = fakeSurface({ backgroundWork: () => backgroundWork });
@@ -968,24 +913,6 @@ test("the exit waits for the client's acknowledgement of the completion report",
   assert.deepEqual(surface.calls.exits, ["done"]);
 });
 
-test("the completion report is the last frame the host receives before the exit", async () => {
-  const { agent, host, surface } = await startAgent();
-  agent.start();
-  await waitFor(() => host.of("report").length >= 1);
-  host.notify("assign", assignArgs());
-  await waitFor(() => (surface.calls.wakeUser.length === 1 ? true : null));
-  agent.onTurnStart();
-  await waitFor(() =>
-    host.of("report").find((report) => report.data?.observed?.agent === "running"),
-  );
-  agent.noteAssistantText("OK");
-
-  await agent.complete(TASK_ID, "done", "OK");
-  const reports = host.of("report").filter((report) => report.kind !== "ready");
-  assert.equal(reports.at(-1).kind, "complete", "a running beat is not followed by a settled observation");
-  assert.deepEqual(surface.calls.exits, ["done"]);
-});
-
 test("a reconnect beat re-derives the phase from the surface", async () => {
   let waiting = true;
   const surface = fakeSurface({ waiting: () => waiting });
@@ -1442,27 +1369,6 @@ test("a repeating fault folds into one panel line with a count", () => {
   assert.equal(surface.calls.widget.length, 3, "every event redraws the same panel");
 });
 
-test("the panel stays inside its line and width budget", () => {
-  const surface = fakeSurface({ widget: true });
-  const agent = new OnlyneAgent({
-    socketPath: join(tmpdir(), "pi-onlyne-unused-socket"),
-    cwd: tmpdir(),
-    role: "planner",
-    sessionId: SESSION_ID,
-    taskId: TASK_ID,
-    surface,
-    log: () => {},
-  });
-  for (let index = 0; index < 40; index += 1) {
-    agent.notice("in", `task ${index} from gateway:wechat:room ${"长".repeat(400)}`);
-  }
-  const [render] = surface.calls.widget.slice(-1);
-  assert.ok(render.length <= MAX_LINES, `panel grew to ${render.length} lines`);
-  for (const line of render) {
-    assert.ok(Array.from(line).length <= MAX_WIDTH, `line overruns its width: ${line}`);
-  }
-});
-
 test("a host without the widget keeps the footer line and the stderr line", async () => {
   const surface = fakeSurface();
   const { agent, host, logs } = await startAgent({ surface });

package/src/config.test.mjs

@@ -8,8 +8,6 @@ import assert from "node:assert/strict";
 import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { readFileSync } from "node:fs";
-import { fileURLToPath } from "node:url";
 import { afterEach, test } from "node:test";
 
 import { CONFIG_RELATIVE_PATH, DEFAULT_CONFIG, loadConfig, sessionIdentity } from "./config.mjs";
@@ -80,9 +78,3 @@ test("the session identity gate needs all three variables", () => {
   assert.equal(sessionIdentity({}), null);
   assert.equal(sessionIdentity({ ONLYNE_ROLE: "", ONLYNE_SESSION_ID: "s", ONLYNE_TASK_ID: "t" }), null);
 });
-
-test("the shipped switch file documents only the keys the plugin reads", () => {
-  const path = fileURLToPath(new URL("../onlyne.json.example", import.meta.url));
-  const example = JSON.parse(readFileSync(path, "utf8"));
-  assert.deepEqual(example, { enabled: true, watch: { autoStart: true } });
-});

package/src/pi-surface.mjs

@@ -2,7 +2,7 @@
 // through the pi extension API, with a probe for each optional member so an
 // older pi degrades instead of throwing.
 //
-// Probed members (measured against pi 0.85.1):
+// Probed members (measured against pi 0.87.1):
 //   wakeUser      pi.sendUserMessage(content, { deliverAs: "followUp" })
 //   proseContext  pi.sendMessage({customType,...}, { deliverAs:"followUp", triggerTurn:false })
 //   customEntry   pi.appendEntry(customType, data)
@@ -83,19 +83,35 @@ export function createSurface({ pi, log, context }) {
     }
   };
 
-  /** One pi user message; images ride along as pi image content parts. */
+  /**
+   * One pi user message; images ride along as pi image content parts.
+   *
+   * pi reads an image part as the flat `ImageContent` of its message types —
+   * `data` plus `mimeType` — and normalizes every part before the message is
+   * built, so a part missing either string stops the whole delivery inside pi.
+   * pi reports that failure in its own pane and hands nothing back to this
+   * plugin, so an unusable part is dropped here and the assignment still
+   * travels: the injection text already names the file that was written.
+   */
   const wakeUser = (text, parts = []) => {
     if (!available.wakeUser) {
       log("pi has no sendUserMessage; the assignment reached the session log only");
       return false;
     }
-    const content = parts.length === 0
+    const images = parts.filter(
+      (part) => typeof part?.data === "string" && typeof part?.mime === "string" && part.mime,
+    );
+    if (images.length !== parts.length) {
+      log(`attachment carried no base64 data or no media type; ${parts.length - images.length} dropped, the task text still went`);
+    }
+    const content = images.length === 0
       ? text
       : [
           { type: "text", text },
-          ...parts.map((part) => ({
+          ...images.map((part) => ({
             type: "image",
-            source: { type: "base64", mediaType: part.mime, data: part.data },
+            data: part.data,
+            mimeType: part.mime,
           })),
         ];
     try {

package/src/pi-surface.test.mjs

@@ -0,0 +1,160 @@
+// The pi-facing half of the surface: exactly what `wakeUser` hands
+// `pi.sendUserMessage`. Every shape asserted here is pi's own declaration —
+// `sendUserMessage(content: string | (TextContent | ImageContent)[])`, with
+// `ImageContent` the flat `{ type: "image", data, mimeType }` of
+// `@earendil-works/pi-ai` (measured against pi 0.87.1). pi normalizes each part
+// before it builds the message, so a part in any other shape — the nested
+// Anthropic `source: { type, media_type, data }` this plugin once sent — stops
+// the whole delivery inside pi, and pi reports that in its own pane without
+// handing anything back to the plugin.
+
+import assert from "node:assert/strict";
+import { test } from "node:test";
+
+import { createSurface } from "./pi-surface.mjs";
+
+/** The injection text `agent.mjs` builds for one assignment. */
+const TASK_TEXT = "[onlyne] task 11111111-1111-4111-8111-111111111111 from role:planner";
+
+/** One inline image part in the shape the agent hands the surface. */
+const PNG_PART = { type: "image", mime: "image/png", data: "iVBORw0KGgoAAAANSUhEUg==", name: "shot.png" };
+
+/** pi's own `UserMessage.content` for that text and that part, key for key. */
+const PNG_CONTENT = [
+  { type: "text", text: TASK_TEXT },
+  { type: "image", data: "iVBORw0KGgoAAAANSUhEUg==", mimeType: "image/png" },
+];
+
+/**
+ * A surface over a hand-written fake pi: every `sendUserMessage` arrives with
+ * the arguments it was given, recorded whole, and every surface log line with
+ * it. `refuse` makes one call throw synchronously, the way a pi that does not
+ * know an option does.
+ * @param {{ refuse?: (content: unknown, options: unknown) => boolean }} [options]
+ */
+function fakeSurface({ refuse = null } = {}) {
+  const calls = [];
+  const lines = [];
+  const surface = createSurface({
+    pi: {
+      sendUserMessage(content, options) {
+        calls.push({ content, options });
+        if (refuse?.(content, options)) throw new Error("this pi does not take that option");
+      },
+    },
+    log: (line) => lines.push(line),
+    context: () => null,
+  });
+  return { calls, lines, surface };
+}
+
+test("an image attachment reaches pi as one flat image content part beside the task text", () => {
+  const { calls, lines, surface } = fakeSurface();
+
+  assert.equal(surface.wakeUser(TASK_TEXT, [PNG_PART]), true);
+  assert.equal(calls.length, 1, "one message, not one call per part");
+  // The whole array, key for key: a nested `source` / `mediaType` part carries
+  // keys pi does not declare and lacks the two it does, so it cannot pass this.
+  assert.deepEqual(calls[0].content, PNG_CONTENT);
+  assert.deepEqual(lines, [], "a readable attachment is delivered, not reported");
+});
+
+test("task text with no attachments reaches pi as a bare string", () => {
+  const { calls, surface } = fakeSurface();
+
+  assert.equal(surface.wakeUser(TASK_TEXT, []), true);
+  assert.equal(calls.length, 1);
+  // pi takes the string path of `content`; a one-element array of text parts is
+  // a different message and a needless normalization round trip.
+  assert.equal(calls[0].content, TASK_TEXT);
+});
+
+test("an attachment pi cannot read is dropped, logged, and the task text still travels", () => {
+  const { calls, lines, surface } = fakeSurface();
+
+  // Each part below fails one clause of what pi needs: no base64 data, no media
+  // type, an empty media type. Sending any of them stops the whole delivery
+  // inside pi, so all three go and the text goes alone.
+  assert.equal(
+    surface.wakeUser(TASK_TEXT, [
+      { type: "image", mime: "image/png", name: "no-data.png" },
+      { type: "image", data: "iVBORw0KGgoAAAANSUhEUg==", name: "no-mime.png" },
+      { type: "image", data: "iVBORw0KGgoAAAANSUhEUg==", mime: "" },
+    ]),
+    true,
+  );
+  assert.equal(calls.length, 1);
+  assert.equal(calls[0].content, TASK_TEXT);
+  assert.equal(lines.length, 1);
+  assert.match(lines[0], /3 dropped/);
+  assert.match(lines[0], /the task text still went/);
+
+  // Dropping is per part: a usable image beside an unusable one still rides.
+  assert.equal(surface.wakeUser(TASK_TEXT, [{ type: "image", mime: "image/png" }, PNG_PART]), true);
+  assert.deepEqual(calls[1].content, PNG_CONTENT);
+  assert.equal(lines.length, 2);
+  assert.match(lines[1], /1 dropped/);
+});
+
+test("delivery asks for followUp and a refusal of that option retries with the same content", () => {
+  const asked = fakeSurface();
+
+  assert.equal(asked.surface.wakeUser(TASK_TEXT, [PNG_PART]), true);
+  assert.deepEqual(asked.calls, [{ content: PNG_CONTENT, options: { deliverAs: "followUp" } }]);
+
+  // An older pi throws on the option it does not know. The message itself is
+  // fine, so the retry drops the option and keeps the content.
+  const refusing = fakeSurface({ refuse: (_content, options) => Boolean(options) });
+
+  assert.equal(refusing.surface.wakeUser(TASK_TEXT, [PNG_PART]), true);
+  assert.equal(refusing.calls.length, 2);
+  assert.deepEqual(refusing.calls[0].options, { deliverAs: "followUp" });
+  assert.equal(refusing.calls[1].options, undefined);
+  assert.deepEqual(refusing.calls[1].content, PNG_CONTENT);
+  assert.deepEqual(refusing.lines, [], "a delivery that landed on the retry is not a failure");
+});
+
+/**
+ * A surface over a fake pi that answers the two questions the phase is read
+ * from, plus the cases where pi answers neither.
+ * @param {{ isIdle?: () => boolean, hasPendingMessages?: () => boolean, throwOn?: "idle" | "pending" }} [pi]
+ */
+function idleSurface(pi = {}) {
+  const lines = [];
+  return {
+    lines,
+    surface: createSurface({ pi, log: (line) => lines.push(line), context: () => pi }),
+  };
+}
+
+test("only a session waiting on its next message reads as idle", async () => {
+  const waiting = idleSurface({ isIdle: () => true, hasPendingMessages: () => false });
+  assert.equal(await waiting.surface.waitingForInput(), true);
+
+  // A queued continuation is input already on its way, so the session is not
+  // waiting for the user even though no turn is running.
+  const queued = idleSurface({ isIdle: () => true, hasPendingMessages: () => true });
+  assert.equal(await queued.surface.waitingForInput(), false);
+
+  // A turn in flight, a retry, and a compaction all read as not idle here.
+  const busy = idleSurface({ isIdle: () => false, hasPendingMessages: () => false });
+  assert.equal(await busy.surface.waitingForInput(), false);
+});
+
+test("a phase pi was never asked about reads as running, not idle", async () => {
+  // The probes are optional members of an older pi, and a session with no
+  // context yet has witnessed nothing: both answer `false` rather than guess.
+  const noProbes = idleSurface({});
+  assert.equal(await noProbes.surface.waitingForInput(), false);
+
+  const noContext = createSurface({ pi: { isIdle: () => true }, log: () => {}, context: () => null });
+  assert.equal(await noContext.waitingForInput(), false);
+
+  const throwing = idleSurface({
+    isIdle: () => true,
+    hasPendingMessages: () => {
+      throw new Error("pi is mid-replay");
+    },
+  });
+  assert.equal(await throwing.surface.waitingForInput(), false);
+});

package/src/protocol.test.mjs

@@ -219,16 +219,6 @@ test("observationFor attaches the host only when there is one", () => {
   assert.deepEqual(dimensions, bare);
 });
 
-test("heartbeatReport carries the host inside observed", () => {
-  const report = heartbeatReport({ taskId: "t1", generation: 1, seq: SEQ_BASE + 1, agent: "idle", host: hostBinding(PANE_ENV) });
-  assert.equal(report.data.observed.host.orca.pane_key, PANE_KEY);
-  assert.equal(report.data.observed.agent, "idle");
-  assert.equal(
-    "host" in heartbeatReport({ taskId: "t1", generation: 1, seq: SEQ_BASE + 2, agent: "idle" }).data.observed,
-    false
-  );
-});
-
 test("a completion names an outcome and a single-line head", () => {
   assert.deepEqual(completeReport({ taskId: "t1", outcome: "failed", head: "broke\non line two" }), {
     kind: "complete",