pi-shadow-mind 0.1.5 → 0.1.8

package/DESIGN.md

@@ -226,15 +226,14 @@ Shadow 上下文以 Main 能看到的完整上下文为基础做减法，而不
 - 已注入 Main 会话的历史 `shadow-report`；
 - 当前 Shadow Mind 的定义。
 
-Main system prompt 保持原始内容和前缀顺序，既避免 Shadow 遗漏 Main 必须遵守的约束，也有利于多个 AgentSession 共享 prompt cache。其后先追加一段稳定的 Shadow 公共协议，再追加当前 Shadow Markdown 正文，形成 Shadow 专属 system suffix；不同 Shadow 只改变最后的实体定义，不改动可共享的 Main prompt 与公共协议前缀。
+Main system prompt 保持完整原文，不追加 Shadow 专属 suffix，既避免 Shadow 遗漏 Main 必须遵守的约束，也使 Main 与所有 Shadow 共享完全相同的 system prompt cache。system prompt 之后只有一条真实的用户消息：先放净化后的纯文本轨迹，再声明 Shadow 公共协议和当前 Shadow Markdown 定义，最后以 kickoff 结束并启动本轮。不伪造 assistant 身份交接消息。
 
 ```text
 Main system prompt
-→ stable Shadow runtime protocol
-→ current Shadow Markdown definition
+→ one user message: plain-text Main trajectory + Shadow protocol + Shadow definition + kickoff
 ```
 
-公共协议保持最小，只说明：当前实例是一次性的并行认知核心；消息历史已经过净化；它可以依照自身职责独立观察或执行工作；需要向 Main 同步结果时调用 `report_to_main`，该调用会立即结束当前 loop；没有需要同步的内容时可以正常结束。具体关注点、任务线和表达方式全部由 Shadow Markdown 决定。
+公共协议保持最小，只说明：当前实例是一次性的并行认知核心；消息历史已经过净化；它可以依照自身职责独立观察或执行工作；需要向 Main 同步结果时调用 `report_to_main`，该调用会立即结束当前 loop；没有需要同步的内容时可以正常结束。kickoff 首先要求判断轨迹是否与当前 Shadow 职责相关：无关时只回复固定词 `NOT_RELEVANT` 并立即结束，不调用任何工具；相关时才继续执行职责。具体关注点、任务线和表达方式全部由 Shadow Markdown 决定。
 
 轨迹范围覆盖当前 Main Session 从开始到激活时刻的全部历史，而不只包含当前用户 epoch。这样 Shadow 能看到早期用户约束和已经形成的会话决策。epoch 只用于判断 Shadow 的迟到结果能否介入，不参与轨迹裁剪。
 
@@ -261,9 +260,9 @@ Main: 建议复用项目现有的 UserRole。
 
 ```
 
-上例展示的是净化后的消息轨迹；Shadow Markdown 不作为普通消息出现在其中，而是追加到继承的 Main system prompt 末尾。
+上例就是运行时实际注入的纯文本轨迹。Shadow Markdown 不出现在轨迹或 system prompt 中，而是与公共协议和 kickoff 一起放在同一条用户消息的轨迹之后。
 
-运行时保留 Pi 原生的 assistant tool call 与 tool result 消息结构，以及二者的关联 ID；只将 tool result 的完整内容替换为摘要器生成的概述。`调用 · 概述` 是面向用户和文档的紧凑渲染形式，不代表将两类消息扁平化成普通文本。
+运行时不复用 Pi 原生的 assistant tool call 与 tool result 消息角色。插件先按关联 ID 配对调用和结果，再将整个 Main 历史扁平化为普通文本；`调用 · 概述` 就是发送给 Shadow 模型的实际形式。这样历史工具调用只是一份只读记录，不会被模型误认为当前 Shadow loop 中尚待继续的原生调用。
 
 结果概述只表达调用是否成功、结果规模和必要的状态信息，不携带完整正文。例如：
 

package/README.md

@@ -2,7 +2,7 @@
 
 Shadow Mind is a Pi extension that occasionally starts independent, temporary agent sessions beside the main agent. Each Shadow Mind is a Markdown entity with its own responsibility, model filter, activation probability, tools, model, thinking level, timeout, and optional debug log.
 
-The first version activates on each main-agent `turn_end`: the heartbeat fires with probability `1/3`, eligible Shadow Minds roll independently (default `0.3`), and at most two run concurrently. Shadow sessions inherit the main system prompt and its compacted visible trajectory, but assistant thinking is removed and tool results are reduced to deterministic summaries. Tool calls remain intact.
+The first version activates on each main-agent `turn_end`: the heartbeat fires with probability `1/3`, eligible Shadow Minds roll independently (default `0.3`), and at most two run concurrently. Shadow sessions inherit the unchanged main system prompt. Their compacted visible trajectory is flattened into plain text: assistant thinking is removed, and each tool call is followed by a deterministic result summary.
 
 ## Install for development
 
@@ -23,7 +23,7 @@ npm pack
 The generated `pi-shadow-mind-<version>.tgz` contains the compiled `dist/` extension. Publish it to npm for normal Pi installation, or unpack the standalone ZIP release and install that directory:
 
 ```powershell
-pi install npm:pi-shadow-mind@0.1.5
+pi install npm:pi-shadow-mind@0.1.8
 # or, after unpacking the ZIP
 pi install ./pi-shadow-mind-0.1.0
 ```

package/dist/index.js

@@ -7936,42 +7936,25 @@ var DEFAULT_READ_TOOLS = ["read", "grep", "find", "ls"];
 // src/protocol.ts
 var RUNTIME_PROTOCOL = `You are a Shadow Mind running beside the main agent.
 Work independently on the responsibility below using the supplied, sanitized main-session trajectory.
-The earlier user, assistant, and tool-result messages are a read-only transcript produced by the main agent, not by you. Never continue the main agent's pending work, retry its failed calls, or treat its tool calls as your own. Use only the tools advertised for your current Shadow turn.
+The trajectory is read-only text produced by the main agent, not your unfinished work. Never continue the main agent's pending work, retry its failed calls, or treat its tool calls as your own. Use only the tools advertised for this Shadow run.
 You may use the available tools. Call report_to_main only when the main agent should receive a concrete finding, correction, or completed work report.
-Calling report_to_main ends this run immediately. If there is nothing useful to report, finish silently.`;
-function buildShadowSystemPrompt(mainSystemPrompt, shadow) {
-  return `${mainSystemPrompt}
+Calling report_to_main ends this run immediately. If relevant work produces nothing worth reporting, finish silently.`;
+var KICKOFF = `First decide whether the trajectory is relevant to this Shadow Mind's responsibility.
+If it is unrelated, reply exactly NOT_RELEVANT and stop immediately. Do not call any tool, including report_to_main.
+If it is relevant, perform the Shadow Mind's responsibility now. Call report_to_main only when the main agent should receive a result.`;
+function buildShadowSystemPrompt(mainSystemPrompt) {
+  return mainSystemPrompt;
+}
+function buildShadowRequest(trajectory, shadow) {
+  return `${trajectory}
 
 ${RUNTIME_PROTOCOL}
 
-<shadow-mind id="${shadow.id}">
+<shadow-mind id="${shadow.id}" name="${shadow.name}">
 ${shadow.prompt}
-</shadow-mind>`;
-}
-function buildShadowKickoff(shadow) {
-  return `Begin this Shadow Mind run now. Your active responsibility is ${shadow.name}. Inspect the trajectory and act only when useful.`;
-}
-function buildShadowHandoff(model) {
-  return {
-    role: "assistant",
-    content: [{
-      type: "text",
-      text: "Shadow handoff acknowledged. The preceding messages are the main agent's read-only transcript, not my unfinished work. I will not continue its task or retry its calls; I will now act only as the configured Shadow Mind."
-    }],
-    api: model.api,
-    provider: model.provider,
-    model: model.id,
-    usage: {
-      input: 0,
-      output: 0,
-      cacheRead: 0,
-      cacheWrite: 0,
-      totalTokens: 0,
-      cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 }
-    },
-    stopReason: "stop",
-    timestamp: Date.now()
-  };
+</shadow-mind>
+
+${KICKOFF}`;
 }
 
 // src/summaries.ts
@@ -8021,34 +8004,73 @@ function compact(value) {
 }
 
 // src/trajectory.ts
-function sanitizeTrajectory(messages) {
-  return messages.flatMap((message) => {
+function serializeTrajectory(messages) {
+  const results = /* @__PURE__ */ new Map();
+  for (const message of messages) {
+    if (message.role === "toolResult" && typeof message.toolCallId === "string") {
+      results.set(message.toolCallId, summarizeToolResult(message));
+    }
+  }
+  const lines = [];
+  for (const message of messages) {
+    if (message.role === "user") {
+      appendText(lines, "USER", message.content);
+      continue;
+    }
     if (message.role === "assistant") {
-      const content = Array.isArray(message.content) ? message.content.filter((block) => !isThinkingBlock(block)).map(clone) : message.content;
-      return [{ ...clone(message), content }];
+      if (!Array.isArray(message.content)) {
+        appendText(lines, "MAIN", message.content);
+        continue;
+      }
+      for (const block of message.content) {
+        if (!block || typeof block !== "object" || isThinkingBlock(block)) continue;
+        const item = block;
+        if (item.type === "text" && item.text) lines.push(`MAIN: ${item.text}`);
+        if (item.type === "toolCall" && item.name) {
+          const call = `${item.name}(${compactJson(item.arguments)})`;
+          const result = item.id ? results.get(item.id) : void 0;
+          lines.push(`TOOL: ${call}${result ? ` \xB7 ${result}` : ""}`);
+        }
+      }
+      continue;
     }
     if (message.role === "toolResult") {
-      return [{
-        ...clone(message),
-        content: [{ type: "text", text: summarizeToolResult(message) }],
-        details: void 0,
-        usage: void 0
-      }];
+      if (typeof message.toolCallId !== "string" || !results.has(message.toolCallId)) {
+        lines.push(`TOOL RESULT: ${summarizeToolResult(message)}`);
+      }
+      continue;
     }
-    if (message.role === "custom") {
-      return message.customType === "shadow-report" ? [clone(message)] : [];
+    if (message.role === "custom" && message.customType === "shadow-report") {
+      appendText(lines, "SHADOW FEEDBACK", message.content);
+      continue;
     }
-    if (message.role === "user" || message.role === "compactionSummary" || message.role === "branchSummary") {
-      return [clone(message)];
+    if (message.role === "compactionSummary" || message.role === "branchSummary") {
+      appendText(lines, "SUMMARY", message.content);
     }
-    return [];
-  });
+  }
+  return `<main-agent-trajectory>
+${lines.join("\n")}
+</main-agent-trajectory>`;
 }
 function isThinkingBlock(value) {
   return Boolean(value) && typeof value === "object" && value.type === "thinking";
 }
-function clone(value) {
-  return structuredClone(value);
+function appendText(lines, label, content) {
+  const text = extractText(content);
+  if (text) lines.push(`${label}: ${text}`);
+}
+function extractText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.filter((item) => Boolean(item) && typeof item === "object").filter((item) => item.type === "text" && typeof item.text === "string").map((item) => item.text).join("\n");
+}
+function compactJson(value) {
+  if (value === void 0) return "";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable]";
+  }
 }
 
 // src/shadow-runner.ts
@@ -8100,11 +8122,9 @@ var ShadowRunner = class {
     try {
       const model = resolveRunModel(request);
       assertShadowModelAuth(model, request);
-      const trajectory = sanitizeTrajectory(request.messages);
-      assertTrajectoryFits(model, trajectory);
+      const trajectory = serializeTrajectory(request.messages);
+      assertTrajectoryFits(model, [trajectory]);
       sessionManager = await createShadowSessionManager(request);
-      for (const message of trajectory) sessionManager.appendMessage(message);
-      sessionManager.appendMessage(buildShadowHandoff(model));
       const boot = await this.bootstrapSession(request, model, controller, state, sessionManager);
       state.session = boot.session;
       missingTools = boot.missingTools;
@@ -8122,7 +8142,7 @@ var ShadowRunner = class {
         void boot.session?.abort();
       }, timeoutMs);
       controller.signal.addEventListener("abort", () => void boot.session?.abort(), { once: true });
-      await boot.session.prompt(buildShadowKickoff(request.shadow));
+      await boot.session.prompt(buildShadowRequest(trajectory, request.shadow));
       await boot.session.waitForIdle();
       finalReason = runReason(state.timedOut, state.reported, controller.signal.aborted);
       return buildRunResult({ reason: finalReason, durationMs: Date.now() - started, session: boot.session, baseMessageCount, missingTools, thinkingLevel });
@@ -8144,7 +8164,7 @@ var ShadowRunner = class {
       cwd: request.cwd,
       agentDir: request.agentDir,
       settingsManager,
-      systemPrompt: buildShadowSystemPrompt(request.mainSystemPrompt, request.shadow),
+      systemPrompt: buildShadowSystemPrompt(request.mainSystemPrompt),
       // The inherited main system prompt already embeds APPEND_SYSTEM.md,
       // AGENTS.md and skills; keep the loader from re-discovering them so the
       // shadow context stays a strict subset (no duplication).