@omac/pi 0.0.0-stage → 0.0.1-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 iamdin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,43 @@
 {
   "name": "@omac/pi",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.1-beta.0",
+  "description": "omac's Pi integration: the Worker's turn-end report, the Coordinator's inbox delivery, and both roles' guard.",
+  "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/iamdin/orchestrate-my-agent-cli.git",
+    "directory": "packages/pi-omac"
+  },
+  "files": [
+    "src",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "pi-package"
+  ],
+  "pi": {
+    "extensions": [
+      "./src/extension.ts"
+    ]
+  },
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "cd ../.. && bun --bun vitest run packages/pi-omac"
+  },
+  "dependencies": {
+    "@effect/platform-node-shared": "4.0.2",
+    "effect-herdr-sdk": "0.0.1-beta.0",
+    "effect": "4.0.2",
+    "@omac/cli": "0.0.1-beta.0"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-coding-agent": "1.1.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-coding-agent": "*"
+  }
+}

package/src/extension.ts

@@ -0,0 +1,166 @@
+// 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.
+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 * 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"
+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. */
+const guarded = (rules: Guard.Rules) =>
+  Effect.gen(function* () {
+    const pi = yield* Pi
+    yield* pi.handle("tool_call", (e, ctx) =>
+      rules({ tool: e.toolName, input: e.input, cwd: ctx.cwd }).pipe(Effect.map((reason) => (reason ? { block: true, reason } : undefined))),
+    )
+  })
+
+type AgentMessage = AgentEndEvent["messages"][number]
+type AssistantMessage = Extract<AgentMessage, { readonly role: "assistant" }>
+
+/** Text and error of the last assistant message of a run. */
+const lastReply = (messages: ReadonlyArray<AgentMessage>) => {
+  const message = messages.findLast((m): m is AssistantMessage => m.role === "assistant")
+  const text = (message?.content ?? []).flatMap((c) => (c.type === "text" ? [c.text] : [])).join("")
+  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. */
+type Role = Layer.Layer<never, Config.ConfigError, Pi | ClientServices | FileSystem.FileSystem>
+
+const worker = (workerId: 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.
+      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"))
+      yield* pi.handle("agent_end", (e) => Ref.set(reply, lastReply(e.messages)))
+      yield* pi.handle("agent_settled", (e, ctx) =>
+        Effect.gen(function* () {
+          if (!(yield* Ref.get(root)) || !ctx.isIdle()) return
+          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 }))
+          // 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.scoped,
+            Effect.timeout("500 millis"),
+            Effect.ignore,
+          )
+        }),
+      )
+    }),
+  )
+
+/**
+ * `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.
+ */
+const reportSession = Effect.fn("reportSession")(function* (launchId: 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.
+      yield* connect(layout.socket).pipe(
+        Effect.flatMap((client) => client.CoordinatorSessionReady({ launchId, harness: "pi", sessionId, reportedAt })),
+        Effect.scoped,
+        Effect.timeout("1 second"),
+        Effect.andThen(Ref.set(reported, sessionId)),
+        // 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")),
+        ),
+        Effect.forkIn(scope),
+      )
+    }),
+  )
+})
+
+/** Inbox rows for this pane, as custom messages the model sees but the TUI hides: a turn starts when Pi is idle, otherwise they queue as follow-ups. */
+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 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) =>
+      client["Inbox.Subscribe"](undefined).pipe(
+        Stream.runForEach((content) => pi.sendMessage({ customType: "omac", content, display: false }, { triggerTurn: true, deliverAs: "followUp" })),
+      ),
+    ).pipe(
+      // The connection dropped or omacd closed the stream (omacd restarted): subscribe again; rows not yet taken stay pending.
+      Effect.retry({ while: (e) => e._tag === "RpcClientError", schedule: Schedule.spaced("2 seconds") }),
+      Effect.repeat(Schedule.spaced("2 seconds")),
+    )
+    // Anything else ends the subscription; no handler is running, so tell the user.
+    yield* Deferred.await(started).pipe(
+      Effect.flatMap((ctx) =>
+        subscribe.pipe(
+          Effect.catchCause((cause) =>
+            Cause.hasInterruptsOnly(cause) ? Effect.void : Effect.sync(() => ctx.ui.notify(`omac: inbox subscription ended: ${Cause.pretty(cause)}`, "error")),
+          ),
+        ),
+      ),
+      Effect.forkScoped,
+    )
+  }),
+)
+
+/** The role from the environment: Worker, Coordinator, or 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 omacCommand = Layer.effect(
+  OmacCommand,
+  Config.schema(Schema.fromJsonString(Schema.Array(Schema.String)), "OMAC_COMMAND").pipe(Config.withDefault(["omac"])),
+)
+
+export const services = Layer.mergeAll(
+  Layout.layer,
+  NodeChildProcessSpawner.layer.pipe(Layer.provide(NodeFileSystem.layer)),
+  NodeFileSystem.layer,
+  Layer.succeed(SocketConnector, (endpoint) => NodeSocket.makeNet({ path: endpoint })),
+  omacCommand,
+).pipe(Layer.provideMerge(NodePath.layer))
+
+export default (api: ExtensionAPI) => Pi.runMain(api, extension.pipe(Layer.provide(services)))

package/src/pi.ts

@@ -0,0 +1,61 @@
+// The Pi extension API as an Effect service. Only this file touches `api`. `runMain` is the entry, like
+// NodeRuntime.runMain: Pi calls the extension factory once per session and awaits it, then awaits `session_shutdown`.
+import type {
+  AgentEndEvent,
+  AgentSettledEvent,
+  BeforeAgentStartEvent,
+  ExtensionAPI,
+  ExtensionContext,
+  SessionStartEvent,
+  ToolCallEvent,
+  ToolCallEventResult,
+} from "@earendil-works/pi-coding-agent"
+import { Context, Effect, Exit, FiberSet, Layer, Scope } from "effect"
+
+/** The events omac handles: what Pi passes, and what the handler may return to it. */
+interface Events {
+  readonly session_start: { readonly event: SessionStartEvent; readonly result: void }
+  readonly before_agent_start: { readonly event: BeforeAgentStartEvent; readonly result: void }
+  readonly tool_call: { readonly event: ToolCallEvent; readonly result: ToolCallEventResult | undefined }
+  readonly agent_end: { readonly event: AgentEndEvent; readonly result: void }
+  readonly agent_settled: { readonly event: AgentSettledEvent; readonly result: void }
+}
+
+export class Pi extends Context.Service<Pi, {
+  /** Handle `event` while the scope is open; Pi awaits the Effect and uses its value, and reports its failure. */
+  readonly handle: <K extends keyof Events, E, R>(
+    event: K,
+    f: (event: Events[K]["event"], ctx: ExtensionContext) => Effect.Effect<Events[K]["result"], E, R>,
+  ) => Effect.Effect<void, never, R | Scope.Scope>
+  readonly sendMessage: (...args: Parameters<ExtensionAPI["sendMessage"]>) => Effect.Effect<void>
+}>()("@omac/pi/Pi") {
+  static readonly layer = (api: ExtensionAPI) =>
+    Layer.succeed(
+      Pi,
+      Pi.of({
+        handle: <K extends keyof Events, E, R>(event: K, f: (event: Events[K]["event"], ctx: ExtensionContext) => Effect.Effect<Events[K]["result"], E, R>) =>
+          Effect.gen(function* () {
+            const run = yield* FiberSet.makeRuntimePromise<R>()
+            // `on` is overloaded per event name; `Events` pins each name to its overload's types.
+            const on = api.on as (event: K, handler: (e: Events[K]["event"], ctx: ExtensionContext) => Promise<Events[K]["result"]>) => () => void
+            yield* Effect.acquireRelease(Effect.sync(() => on(event, (e, ctx) => run(f(e, ctx)))), (off) => Effect.sync(off))
+          }),
+        sendMessage: (...args) => Effect.sync(() => api.sendMessage(...args)),
+      }),
+    )
+
+  /**
+   * Build `extension` in a scope that lives as long as this session; the factory's promise resolves once it is built
+   * (its handlers are registered before Pi goes on to `session_start`), and rejects when that fails, so Pi reports
+   * the extension as failed to load. `session_shutdown` closes the scope and waits for the finalizers; that handler
+   * stays outside the scope, which would remove it along with everything else.
+   */
+  static readonly runMain = <E>(api: ExtensionAPI, extension: Layer.Layer<never, E, Pi>) =>
+    Effect.runPromise(
+      Effect.gen(function* () {
+        const scope = yield* Scope.make()
+        api.on("session_shutdown", () => Effect.runPromise(Scope.close(scope, Exit.void)))
+        yield* Layer.buildWithScope(extension, scope).pipe(Effect.provide(Pi.layer(api)))
+      }),
+    )
+}

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.