@omac/pi 0.0.1-beta.2 → 0.0.1-beta.4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@omac/pi",
-  "version": "0.0.1-beta.2",
-  "description": "omac's Pi integration: the Worker's turn-end report, the Coordinator's inbox delivery, and both roles' guard.",
+  "version": "0.0.1-beta.4",
+  "description": "omac's Pi integration: a session's turn-end report, the coordinator's inbox delivery, and both agents' guard.",
   "type": "module",
   "license": "MIT",
   "repository": {
@@ -26,9 +26,9 @@
   },
   "dependencies": {
     "@effect/platform-node-shared": "4.0.2",
-    "effect-herdr-sdk": "0.0.1-beta.2",
+    "effect-herdr-sdk": "0.0.1-beta.4",
     "effect": "4.0.2",
-    "@omac/cli": "0.0.1-beta.2"
+    "@omac/cli": "0.0.1-beta.4"
   },
   "devDependencies": {
     "@earendil-works/pi-coding-agent": "1.1.0"
@@ -38,6 +38,6 @@
   },
   "scripts": {
     "typecheck": "tsc --noEmit",
-    "test": "cd ../.. && bun --bun vitest run packages/pi-omac"
+    "test": "cd ../.. && bun ./node_modules/vitest/vitest.mjs run packages/pi-omac"
   }
 }

package/src/extension.ts

@@ -1,13 +1,13 @@
-// omac's Pi extension. OMAC_WORKER_ID makes it a Worker (turn-end result file), OMAC_COORDINATOR=1 a Coordinator (inbox
-// rows delivered in process instead of typed into the pane); otherwise it is inert. Either way tool calls go through
-// that role's rules in omac's guard.ts, in process. Both roles run omac itself as `omac` commands in Pi's bash tool.
+// omac's Pi extension. OMAC_AGENT=coordinator makes it the coordinator (inbox rows delivered in process instead of typed
+// into the pane), any other agent with OMAC_SESSION_ID a session (turn-end result file); otherwise it is inert. Either way
+// tool calls go through that agent's rules in omac's guard.ts, in process. Both run omac itself as `omac` commands in Pi's bash tool.
 import type { AgentEndEvent, ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent"
 import * as NodeChildProcessSpawner from "@effect/platform-node-shared/NodeChildProcessSpawner"
 import * as NodeFileSystem from "@effect/platform-node-shared/NodeFileSystem"
 import * as NodePath from "@effect/platform-node-shared/NodePath"
 import * as NodeSocket from "@effect/platform-node-shared/NodeSocket"
 import { SocketConnector } from "effect-herdr-sdk"
-import { type ClientServices, connect, withOmac } from "@omac/cli/src/client.ts"
+import { type ClientServices, connect, protocolHeaders, withOmac } from "@omac/cli/src/client.ts"
 import * as Guard from "@omac/cli/src/guard.ts"
 import { Layout, OmacCommand, writeAtomic } from "@omac/cli/src/paths.ts"
 import { Cause, Clock, Config, Deferred, Effect, FileSystem, Layer, Option, Path, Ref, Schedule, Schema, Stream } from "effect"
@@ -15,7 +15,7 @@ import { Pi } from "./pi.ts"
 
 const encodeJson = Schema.encodeSync(Schema.fromJsonString(Schema.Unknown))
 
-/** omac's tool-call rules for this role, as Pi's tool_call result. */
+/** omac's tool-call rules for this agent, as Pi's tool_call result. */
 const guarded = (rules: Guard.Rules) =>
   Effect.gen(function* () {
     const pi = yield* Pi
@@ -34,16 +34,15 @@ const lastReply = (messages: ReadonlyArray<AgentMessage>) => {
   return { text, error: message?.stopReason === "error" ? message.errorMessage || "error" : "" }
 }
 
-/** What a role's layer needs; the roles share one type, so picking one is a plain conditional. */
+/** What an agent's layer needs; they share one type, so picking one is a plain conditional. */
 type Role = Layer.Layer<never, Config.ConfigError, Pi | ClientServices | FileSystem.FileSystem>
 
-const worker = (workerId: string): Role =>
+const session = (sessionId: string): Role =>
   Layer.effectDiscard(
     Effect.gen(function* () {
       const pi = yield* Pi
       const layout = yield* Layout
-      yield* guarded(Guard.worker)
-      // TUI only: RPC / JSON / print modes have no PTY, so they are not the Worker's root session.
+      // TUI only: RPC / JSON / print modes have no PTY, so they are not the session's root (harness) session.
       const root = yield* Ref.make(false)
       const reply = yield* Ref.make({ text: "", error: "" })
       yield* pi.handle("session_start", (_e, ctx) => Ref.set(root, ctx.mode === "tui"))
@@ -54,10 +53,10 @@ const worker = (workerId: string): Role =>
           const { text, error } = yield* Ref.get(reply)
           const ts = Math.floor((yield* Clock.currentTimeMillis) / 1000)
           const payload = { text, error: error || (e.aborted ? "aborted" : ""), aborted: e.aborted }
-          yield* writeAtomic(layout.resultFile(workerId), encodeJson({ harness: "pi", ts, payload }))
+          yield* writeAtomic(layout.resultFile(sessionId), encodeJson({ harness: "pi", ts, payload }))
           // omacd also finds the file on its next check; the call only makes that immediate.
           yield* connect(layout.socket).pipe(
-            Effect.flatMap((client) => client.ResultReady({ workerId })),
+            Effect.flatMap((client) => client.ResultReady({ sessionId }, { headers: protocolHeaders() })),
             Effect.scoped,
             Effect.timeout("500 millis"),
             Effect.ignore,
@@ -68,31 +67,28 @@ const worker = (workerId: string): Role =>
   )
 
 /**
- * `omac launch pi` reopens the session it reported: after a TUI turn (Pi has written the session by `agent_end`) whose
- * session id is not reported yet, send it in the background, so neither the turn nor omacd's absence holds Pi up. omacd
- * keeps the newest by `reportedAt`, whatever order sends arrive in; one omacd did not answer warns and is sent again after
- * the next turn. Only from the process `omac launch` exec'd: a Pi nested in the Coordinator inherits OMAC_LAUNCH_ID.
+ * `omac launch pi` reopens the conversation it reported: after a TUI turn (Pi has written the session by `agent_end`)
+ * whose id is not reported yet, send it in the background. The last report wins. A Pi child in print / RPC mode does
+ * not report (this runs only for the TUI).
  */
-const reportSession = Effect.fn("reportSession")(function* (launchId: string) {
+const reportSession = Effect.fn("reportSession")(function* (sessionId: string) {
   const pi = yield* Pi
   const layout = yield* Layout
-  if ((yield* Config.String("OMAC_LAUNCH_PID").pipe(Config.withDefault(""))) !== String(process.pid)) return
   const scope = yield* Effect.scope
   const reported = yield* Ref.make("")
   yield* pi.handle("agent_end", (_e, ctx) =>
     Effect.gen(function* () {
-      const sessionId = ctx.sessionManager.getSessionId()
-      if (ctx.mode !== "tui" || (yield* Ref.get(reported)) === sessionId) return
-      const reportedAt = yield* Clock.currentTimeMillis
-      // Never starts omacd: `omac launch` already did, and the launch is in omac.db for whichever omacd answers.
+      const harnessSessionId = ctx.sessionManager.getSessionId()
+      if (ctx.mode !== "tui" || (yield* Ref.get(reported)) === harnessSessionId) return
+      // Never starts omacd: `omac launch` already did.
       yield* connect(layout.socket).pipe(
-        Effect.flatMap((client) => client.CoordinatorSessionReady({ launchId, harness: "pi", sessionId, reportedAt })),
+        Effect.flatMap((client) => client.CoordinatorSessionReady({ sessionId, harness: "pi", harnessSessionId }, { headers: protocolHeaders() })),
         Effect.scoped,
         Effect.timeout("1 second"),
-        Effect.andThen(Ref.set(reported, sessionId)),
+        Effect.andThen(Ref.set(reported, harnessSessionId)),
         // Unanswered is not unsaved: omacd may still apply it (and keeps the newest either way).
         Effect.catchCause((cause) =>
-          Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.sync(() => ctx.ui.notify(`omac: the Coordinator session may not have been saved: ${Cause.pretty(cause)}`, "warning")),
+          Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.sync(() => ctx.ui.notify(`omac: the coordinator's conversation may not have been saved: ${Cause.pretty(cause)}`, "warning")),
         ),
         Effect.forkIn(scope),
       )
@@ -104,20 +100,17 @@ const reportSession = Effect.fn("reportSession")(function* (launchId: string) {
 const coordinator: Role = Layer.effectDiscard(
   Effect.gen(function* () {
     const pi = yield* Pi
-    yield* guarded(Guard.coordinator)
     // Clear the prompt sections other extensions add for a coding agent. Pi runs these handlers in extension load order,
     // so only sections added by extensions loaded before pi-omac are cleared; ones loaded after it keep theirs.
     // Turns started by inbox rows skip this event and get the base prompt, which never has them.
     yield* pi.handle("before_agent_start", (e) => Effect.sync(() => { e.systemPromptOptions.sections = {} }))
-    const launchId = yield* Config.option(Config.String("OMAC_LAUNCH_ID"))
-    if (Option.isSome(launchId)) yield* reportSession(launchId.value)
-    const paneId = yield* Config.option(Config.String("HERDR_PANE_ID"))
-    // Outside a herdr pane there is no inbox to subscribe to.
-    if (Option.isNone(paneId)) return
-    // Pi children of a Coordinator (print / RPC mode) inherit OMAC_COORDINATOR; only the TUI session takes the rows.
+    const sessionId = yield* Config.option(Config.String("OMAC_SESSION_ID"))
+    if (Option.isNone(sessionId)) return
+    yield* reportSession(sessionId.value)
+    // Pi children of the coordinator (print / RPC mode) inherit OMAC_AGENT; only the TUI session takes the rows.
     const started = yield* Deferred.make<ExtensionContext>()
     yield* pi.handle("session_start", (_e, ctx) => (ctx.mode === "tui" ? Deferred.succeed(started, ctx).pipe(Effect.asVoid) : Effect.void))
-    const subscribe = withOmac({ paneId: paneId.value }, (client) =>
+    const subscribe = withOmac({ _tag: "session", sessionId: sessionId.value }, (client) =>
       client["Inbox.Subscribe"](undefined).pipe(
         Stream.runForEach((content) => pi.sendMessage({ customType: "omac", content, display: false }, { triggerTurn: true, deliverAs: "followUp" })),
       ),
@@ -140,13 +133,18 @@ const coordinator: Role = Layer.effectDiscard(
   }),
 )
 
-/** The role from the environment: Worker, Coordinator, or nothing at all. */
+/**
+ * The agent from the environment: OMAC_AGENT alone decides the tool rules, as in the hook script; the coordinator also
+ * takes its inbox rows, another agent with OMAC_SESSION_ID writes its turn's result. No OMAC_AGENT: nothing at all.
+ */
 export const extension = Layer.unwrap(
   Effect.gen(function* () {
-    const workerId = Option.getOrUndefined(yield* Config.option(Config.String("OMAC_WORKER_ID")))
-    const isCoordinator = Option.contains(yield* Config.option(Config.String("OMAC_COORDINATOR")), "1")
-    if (!workerId && !isCoordinator) return Layer.empty
-    return workerId ? worker(workerId) : coordinator
+    const agent = Option.getOrUndefined(yield* Config.option(Config.String("OMAC_AGENT")))
+    if (!agent) return Layer.empty
+    const guard: Role = Layer.effectDiscard(guarded(Guard.rulesOf(agent)))
+    if (agent === Guard.COORDINATOR) return coordinator.pipe(Layer.provideMerge(guard))
+    const sessionId = Option.getOrUndefined(yield* Config.option(Config.String("OMAC_SESSION_ID")))
+    return sessionId ? session(sessionId).pipe(Layer.provideMerge(guard)) : guard
   }),
 )