@sjawhar/pi-legion 8.6.0 → 8.7.1

package/dist/legion.js

@@ -15309,7 +15309,7 @@ function onEnvoyRoleRegained(listener) {
 // package.json
 var package_default = {
   name: "@sjawhar/pi-legion",
-  version: "8.6.0",
+  version: "8.7.1",
   license: "Apache-2.0",
   type: "module",
   omp: {
@@ -16495,6 +16495,42 @@ function createLegionTool(deps) {
   };
 }
 
+// src/workspace-recreated.ts
+var WORKSPACE_RECREATED_VARIABLE = "LEGION_WORKSPACE_RECREATED";
+var WORKSPACE_RECREATED_MESSAGE = "legion-workspace-recreated";
+function workspaceRecreatedNotice(environment, issue2) {
+  if (environment[WORKSPACE_RECREATED_VARIABLE] !== "true")
+    return;
+  return {
+    id: crypto.randomUUID(),
+    content: `Your workspace was recreated since your last turn: it holds what was pushed to legion/${issue2} ` + "(main if nothing was), and anything you had not pushed is gone. Before you continue, check " + "the workspace against what you remember doing and re-read your last handoff."
+  };
+}
+function workspaceRecreatedMessage(notice) {
+  return {
+    customType: WORKSPACE_RECREATED_MESSAGE,
+    content: notice.content,
+    display: true,
+    details: { id: notice.id }
+  };
+}
+function isNoticeCopy(value, kind, id) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const typed = kind === "entry" ? "type" in value && value.type === "custom_message" : ("role" in value) && value.role === "custom";
+  return typed && "customType" in value && value.customType === WORKSPACE_RECREATED_MESSAGE && "details" in value && typeof value.details === "object" && value.details !== null && "id" in value.details && value.details.id === id;
+}
+function branchHoldsWorkspaceRecreatedNotice(branch, id) {
+  return branch.some((entry) => isNoticeCopy(entry, "entry", id));
+}
+function withoutRepeatedWorkspaceRecreatedNotice(messages, id) {
+  const first = messages.findIndex((message) => isNoticeCopy(message, "message", id));
+  if (first === -1)
+    return;
+  const kept = messages.filter((message, index) => index <= first || !isNoticeCopy(message, "message", id));
+  return kept.length === messages.length ? undefined : kept;
+}
+
 // extensions/legion.ts
 var exitProcess = (code) => process.exit(code);
 function setLegionBootstrapExitForTests(hook) {
@@ -16762,27 +16798,54 @@ function legionExtension(pi) {
       return;
     writeSessionTitle(sessionDirectory(process.env, sessionID), context.sessionManager.getSessionName?.() ?? title);
   };
+  let recreatedNotice;
   pi.on("session_start", async (_event, context) => {
     if (await checkSubagentSession(context))
       return;
     await titleSession(context);
     phaseStall = restorePhaseStall(context.sessionManager.getBranch?.() ?? []);
-    const { kind } = classifySession(process.env);
-    if (kind === "not-legion")
+    const session = classifySession(process.env);
+    if (session.kind === "not-legion")
       return;
     const refusal = envoyPluginRefusal();
     if (refusal !== undefined) {
       logger3.error(refusal);
       exitProcess(1);
     }
-    if (kind === "controller") {
+    if (session.kind === "controller") {
       await controllerSession.handleSessionStart(context);
       return;
     }
+    recreatedNotice = workspaceRecreatedNotice(process.env, session.kind === "root-architect" ? session.tree : session.issue);
+    if (recreatedNotice !== undefined) {
+      pi.sendMessage(workspaceRecreatedMessage(recreatedNotice), {
+        deliverAs: "steer",
+        triggerTurn: false
+      });
+    }
     await claimSession.bootstrap(context);
     registerLegionTool();
     await activateLegionTool();
   });
+  let resentNoticeId;
+  pi.on("before_agent_start", async (_event, context) => {
+    if (recreatedNotice === undefined)
+      return;
+    const branch = context.sessionManager.getBranch?.() ?? [];
+    if (branchHoldsWorkspaceRecreatedNotice(branch, recreatedNotice.id))
+      return;
+    resentNoticeId = recreatedNotice.id;
+    return { message: workspaceRecreatedMessage(recreatedNotice) };
+  });
+  pi.on("agent_start", async () => {
+    recreatedNotice = undefined;
+  });
+  pi.on("context", async (event) => {
+    if (resentNoticeId === undefined)
+      return;
+    const messages = withoutRepeatedWorkspaceRecreatedNotice(event.messages, resentNoticeId);
+    return messages === undefined ? undefined : { messages };
+  });
   const afterSessionChange = async (context) => {
     if (await checkSubagentSession(context))
       return;

package/dist/skills/legion-controller/SKILL.md

@@ -58,15 +58,15 @@ which.
 ### Started by the daemon
 
 Under `controller: daemon` the daemon launched you as a pod in the cluster and supervises you like
-a root architect: you run headless (`omp --mode rpc`), nobody types into your session, and nobody
-reads your replies as they appear. The extension registered with your launch's boot token, claimed
-the role, subscribed to the controller topic and reported ready; the daemon then sent your start
-message. When your pod dies the daemon relaunches it and resumes this same session, with a new
-start message, so run the start procedure each time one arrives. A human reaches you through
-Dispatch (a message to your session on the Agents page, a reply to an ask you opened, a mention) or
-Envoy: answer them where they will read it, a Dispatch message or reply, since text left only in
-your session reaches no one. `legion state` and `legion status <KEY> <status>` work as below. There
-is no `legion controller start` against this daemon, and nobody can replace you with one.
+a root architect. The extension registered with your launch's boot token, claimed the role,
+subscribed to the controller topic and reported ready; the daemon then sent your start message.
+When your pod dies the daemon relaunches it and resumes this same session, with a new start
+message, so run the start procedure each time one arrives. A human reaches you through Dispatch (a
+message to your session on the Agents page, a reply to an ask you opened, a mention) or Envoy. A
+plain user turn in your session other than the start message or a task an operator sent with
+`legion claims deliver` is a person writing from Dispatch's Agents page: answer it first, in the
+conversation. `legion state` and `legion status <KEY> <status>` work as below. There is no
+`legion controller start` against this daemon, and nobody can replace you with one.
 
 ### Started by the operator
 

package/dist/skills/legion-worker/SKILL.md

@@ -142,9 +142,9 @@ predecessor phases already wrote. The durable copy lives in
 `$LEGION_WORKSPACE/.legion/<issue>/<phase>.json`. If a committed handoff conflicts with memory or a prior
 transcript, the committed file wins: it is the copy that survived.
 
-If your system prompt begins with `Your workspace was recreated…`, read
-`.legion/<issue>/workspace-recovered.json`, then your phase's committed handoff, and reconcile before any
-new work.
+If your task, prompt, or a message since your last turn begins `Your workspace was recreated…`, read
+your phase's committed handoff and any `.legion/<issue>/workspace-recovered.json`, and reconcile
+before new work: anything unpushed is gone. That message stays in history; reconciled, it is done.
 
 ## jj Safety Rules
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sjawhar/pi-legion",
-  "version": "8.6.0",
+  "version": "8.7.1",
   "license": "Apache-2.0",
   "type": "module",
   "omp": {