@phux/opencode 0.2.2 → 0.3.0

package/README.md

@@ -1,6 +1,6 @@
 # @phux/opencode
 
-OpenCode V2 plugin for operating shared terminals through an external local
+OpenCode plugin for operating shared terminals through an external local
 phux server and appending cache-preserving fleet context. Installation,
 configuration, tool behavior, target precedence,
 lifecycle gaps, and safety boundaries live in the canonical
@@ -17,7 +17,7 @@ npm run gates
 npm run smoke:opencode
 ```
 
-`smoke:opencode` starts an isolated OpenCode V2 server and verifies that its
+`smoke:opencode` starts an isolated OpenCode server and verifies that its
 resolved config accepts the built plugin URL. Plugin setup, registration,
 cleanup, and tool behavior are covered by `npm run gates`. The smoke requires
 an `opencode2` executable; set `OPENCODE_BIN` to choose it.

package/dist/index.d.ts

@@ -224,6 +224,30 @@ interface AgentRecord {
     readonly attention?: AgentAttention;
     readonly session: string;
 }
+/** Closed `AgentEventsJsonlV1` record types (`docs/spec/L1.md`). */
+declare const AGENT_EVENT_TYPES: readonly ["session_start", "prompt", "tool_start", "tool_end", "notification", "ask", "stop", "session_end", "state", "provider_raw"];
+type AgentEventType = (typeof AGENT_EVENT_TYPES)[number];
+/** `phux agent session open --json` document. */
+interface AgentSessionOpenResult {
+    readonly schema_version: 1;
+    readonly resource: string;
+    readonly parent: string;
+    readonly provider: string;
+    readonly native_id: string | null;
+}
+/** `phux agent emit --json` stamped header. */
+interface AgentEmitResult {
+    readonly schema_version: 1;
+    readonly resource: string;
+    readonly seq: number;
+    readonly ts_ms: number;
+    readonly type: AgentEventType;
+}
+/** Projection of `phux agent session close`'s `@N\\tclosed` line. */
+interface AgentSessionCloseResult {
+    readonly resource: string;
+    readonly closed: true;
+}
 
 interface PhuxCliOptions {
     readonly executable?: string;
@@ -271,6 +295,13 @@ interface RunOptions extends ExecutionOptions {
 interface AgentTargetOptions extends ExecutionOptions {
     readonly target: string;
 }
+interface AgentSessionOpenOptions extends ExecutionOptions {
+    readonly provider: string;
+    readonly nativeId?: string;
+}
+interface AgentEmitOptions extends ExecutionOptions {
+    readonly data?: Readonly<Record<string, unknown>>;
+}
 type SplitDirection = "horizontal" | "vertical";
 interface PlacementOptions {
     readonly target?: string;
@@ -344,6 +375,12 @@ declare class PhuxCli {
     agentSet(target: string, record: AgentRecord, options?: ExecutionOptions): Promise<AgentRecord>;
     /** Clear a declaration and require the CLI's confirmed tombstone response. */
     agentClear(target: string, options?: ExecutionOptions): Promise<void>;
+    /** Open an AgentSession bound to a pane; the caller becomes its producer. */
+    agentSessionOpen(target: string, options: AgentSessionOpenOptions): Promise<AgentSessionOpenResult>;
+    /** Append one closed-type record. No-op-refused by the server if this client is not the opener. */
+    agentEmit(target: string, type: AgentEventType, options?: AgentEmitOptions): Promise<AgentEmitResult>;
+    /** Close a pane's AgentSession; the parent pane is untouched. */
+    agentSessionClose(target: string, options?: ExecutionOptions): Promise<AgentSessionCloseResult>;
     renderedSnapshot(options: RenderedSnapshotOptions): Promise<RenderedFrame>;
     snapshot(options?: SnapshotOptions): Promise<ScreenState>;
     wait(options?: WaitOptions): Promise<WaitOutcome>;
@@ -470,6 +507,9 @@ interface OpenCodeLifecycleAdapter {
     }): Promise<AgentStateList>;
     agentSet(target: string, record: AgentRecord, options?: ExecutionOptions): Promise<AgentRecord>;
     agentClear(target: string, options?: ExecutionOptions): Promise<void>;
+    agentSessionOpen?(target: string, options: AgentSessionOpenOptions): Promise<AgentSessionOpenResult>;
+    agentEmit?(target: string, type: AgentEventType, options?: AgentEmitOptions): Promise<AgentEmitResult>;
+    agentSessionClose?(target: string, options?: ExecutionOptions): Promise<AgentSessionCloseResult>;
 }
 interface OpenCodeLifecycleOptions {
     readonly cli?: OpenCodeLifecycleAdapter;
@@ -488,6 +528,8 @@ declare class OpenCodeLifecycle {
     private readonly target;
     private readonly states;
     private readonly owned;
+    private readonly sessions;
+    private readonly openedPanes;
     private tail;
     private disposed;
     constructor(options: OpenCodeLifecycleOptions);
@@ -502,6 +544,9 @@ declare class OpenCodeLifecycle {
     observeState(sessionId: string, state: OpenCodeLifecycleState): Promise<void>;
     /** A tool invocation is an honest working signal if no status event was seen yet. */
     targetSelected(sessionId: string): Promise<void>;
+    ask(sessionId: string, data?: Readonly<Record<string, unknown>>): Promise<void>;
+    toolStart(sessionId: string, toolName: string, toolUseId?: string): Promise<void>;
+    toolEnd(sessionId: string, toolName: string, toolUseId?: string): Promise<void>;
     deleteSession(sessionId: string): Promise<void>;
     dispose(): Promise<void>;
     settled(): Promise<void>;
@@ -510,6 +555,10 @@ declare class OpenCodeLifecycle {
     private clearSession;
     private clearOwned;
     private execution;
+    private emitter;
+    private bindSession;
+    private emit;
+    private finishSession;
 }
 interface OpenCodeLifecycleEvent {
     readonly type: string;
@@ -528,8 +577,8 @@ interface PhuxOpenCodeOptions {
     readonly env?: NodeJS.ProcessEnv;
     readonly onLifecycleError?: (error: unknown) => void;
 }
-/** Build a V2 plugin with optional test-only defaults. */
-declare function createPhuxPlugin(defaults?: PhuxOpenCodeOptions): Plugin.Plugin;
-declare const PhuxPlugin: Plugin.Plugin;
+/** Build an OpenCode plugin with optional test-only defaults. */
+declare function createPhuxPlugin(defaults?: PhuxOpenCodeOptions): Plugin;
+declare const PhuxPlugin: Plugin;
 
 export { type AgentTargetOptions, type CreateOptions, DEFAULT_SHORT_TIMEOUT_MS, type ExecutionOptions, MAX_MODEL_BYTES, MAX_MODEL_LINES, OpenCodeLifecycle, type OpenCodeLifecycleAdapter, type OpenCodeLifecycleEvent, type OpenCodeLifecycleOptions, type OpenCodeLifecycleState, PhuxCli, type PhuxCliOptions, PhuxContextAwareness, type PhuxContextAwarenessOptions, type PhuxContextEmission, type PhuxContextIdentity, type PhuxOpenCodeOptions, PhuxPlugin, type PhuxProbe, type PhuxToolDefinition, type PhuxToolMetadata, type PhuxToolRuntime, type RunOptions, type SnapshotOptions, type ToolContext, type ToolResult, type WaitOptions, type WaitOutcome, boundedResult, contextAwarenessEnabled, createPhuxPlugin, createPhuxTools, PhuxPlugin as default, handleLifecycleEvent, normalizeTerminalIdentity, resolveTarget };

package/dist/index.js

@@ -1,7 +1,9 @@
 // src/index.ts
-import { Plugin } from "@opencode-ai/plugin";
+import {
+  tool
+} from "@opencode-ai/plugin";
 
-// ../pi/src/errors.ts
+// ../runtime/src/errors.ts
 var PhuxError = class extends Error {
   code;
   argv;
@@ -17,7 +19,7 @@ var PhuxError = class extends Error {
   }
 };
 
-// ../pi/src/runner.ts
+// ../runtime/src/runner.ts
 import { spawn } from "child_process";
 var DEFAULT_MAX_OUTPUT_BYTES = 4 * 1024 * 1024;
 var nodeProcessRunner = (request) => new Promise((resolve, reject) => {
@@ -141,7 +143,19 @@ function isNoSuchProcess(error) {
   return error instanceof Error && "code" in error && error.code === "ESRCH";
 }
 
-// ../pi/src/schemas.ts
+// ../runtime/src/schemas.ts
+var AGENT_EVENT_TYPES = [
+  "session_start",
+  "prompt",
+  "tool_start",
+  "tool_end",
+  "notification",
+  "ask",
+  "stop",
+  "session_end",
+  "state",
+  "provider_raw"
+];
 var SchemaValidationError = class extends Error {
   constructor(path, expectation) {
     super(`${path} must be ${expectation}`);
@@ -555,8 +569,49 @@ function parseAgentStateList(value) {
   });
   return { schema_version: 1, agents };
 }
+function isAgentEventType(value) {
+  return AGENT_EVENT_TYPES.includes(value);
+}
+function parseAgentSessionOpenResult(value) {
+  const root = record(value, "$ (phux agent session open --json CLI shape)");
+  if (root.schema_version !== 1) {
+    throw new SchemaValidationError("$.schema_version", "the supported value 1");
+  }
+  const resource = string(root.resource, "$.resource");
+  const parent = string(root.parent, "$.parent");
+  const provider = string(root.provider, "$.provider");
+  if (resource.trim().length === 0) throw new SchemaValidationError("$.resource", "non-empty");
+  if (parent.trim().length === 0) throw new SchemaValidationError("$.parent", "non-empty");
+  if (provider.trim().length === 0) throw new SchemaValidationError("$.provider", "non-empty");
+  return {
+    schema_version: 1,
+    resource,
+    parent,
+    provider,
+    native_id: root.native_id === null || root.native_id === void 0 ? null : string(root.native_id, "$.native_id")
+  };
+}
+function parseAgentEmitResult(value) {
+  const root = record(value, "$ (phux agent emit --json CLI shape)");
+  if (root.schema_version !== 1) {
+    throw new SchemaValidationError("$.schema_version", "the supported value 1");
+  }
+  const resource = string(root.resource, "$.resource");
+  if (resource.trim().length === 0) throw new SchemaValidationError("$.resource", "non-empty");
+  const type = string(root.type, "$.type");
+  if (!isAgentEventType(type)) {
+    throw new SchemaValidationError("$.type", AGENT_EVENT_TYPES.map((item) => JSON.stringify(item)).join(", "));
+  }
+  return {
+    schema_version: 1,
+    resource,
+    seq: integer(root.seq, "$.seq", 1),
+    ts_ms: integer(root.ts_ms, "$.ts_ms", 0),
+    type
+  };
+}
 
-// ../pi/src/adapter.ts
+// ../runtime/src/adapter.ts
 var MINIMUM_PHUX_VERSION = "0.1.0";
 var VERSION_PATTERN = /^phux\s+v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/;
 var PhuxCli = class {
@@ -723,6 +778,44 @@ var PhuxCli = class {
       throw invalidResponse("agent clear", this.executable, args, "expected @N\\t- confirmation");
     }
   }
+  /** Open an AgentSession bound to a pane; the caller becomes its producer. */
+  async agentSessionOpen(target, options) {
+    if (target.trim().length === 0) throw new TypeError("target must be non-empty");
+    if (options.provider.trim().length === 0) throw new TypeError("provider must be non-empty");
+    const args = ["agent", "session", "open", target, "--provider", options.provider];
+    if (options.nativeId !== void 0) {
+      if (options.nativeId.trim().length === 0) throw new TypeError("nativeId must be non-empty");
+      args.push("--native-id", options.nativeId);
+    }
+    args.push("--json");
+    this.pushSocket(args);
+    return this.jsonCommand("agent session open", args, options, parseAgentSessionOpenResult);
+  }
+  /** Append one closed-type record. No-op-refused by the server if this client is not the opener. */
+  async agentEmit(target, type, options = {}) {
+    if (target.trim().length === 0) throw new TypeError("target must be non-empty");
+    if (!isAgentEventType(type)) {
+      throw new TypeError(`type must be one of ${AGENT_EVENT_TYPES.join(", ")}`);
+    }
+    const args = ["agent", "emit", target, "--type", type];
+    if (options.data !== void 0) {
+      if (typeof options.data !== "object" || Array.isArray(options.data)) {
+        throw new TypeError("data must be a JSON object");
+      }
+      args.push("--data", JSON.stringify(options.data));
+    }
+    args.push("--json");
+    this.pushSocket(args);
+    return this.jsonCommand("agent emit", args, options, parseAgentEmitResult);
+  }
+  /** Close a pane's AgentSession; the parent pane is untouched. */
+  async agentSessionClose(target, options = {}) {
+    if (target.trim().length === 0) throw new TypeError("target must be non-empty");
+    const args = ["agent", "session", "close", target];
+    this.pushSocket(args);
+    const result = await this.completed("agent session close", args, options, false);
+    return parseSessionClosed("agent session close", this.executable, result.stdout, args);
+  }
   async renderedSnapshot(options) {
     requirePositiveInteger(options.cols, "cols");
     requirePositiveInteger(options.rows, "rows");
@@ -942,6 +1035,15 @@ function parseAgentConfirmation(verb, executable, stdout, args) {
   }
   return parseJson(verb, executable, line.slice(tab + 1), args, parseAgentRecord);
 }
+function parseSessionClosed(verb, executable, stdout, args) {
+  const line = stdout.trim();
+  const tab = line.indexOf("	");
+  const resource = tab < 0 ? "" : line.slice(0, tab);
+  if (resource.length === 0 || line.slice(tab + 1) !== "closed") {
+    throw invalidResponse(verb, executable, args, "expected @N\\tclosed confirmation");
+  }
+  return { resource, closed: true };
+}
 function parseWatchLines(stdout, executable, args) {
   const lines = stdout.split("\n").filter((line) => line.trim().length > 0);
   return lines.map((line, index) => {
@@ -1071,8 +1173,117 @@ function requirePositiveInteger(value, name) {
     throw new RangeError(`${name} must be a positive safe integer`);
   }
 }
+function hasAgentSessionCli(cli) {
+  const candidate = cli;
+  return typeof candidate.agentSessionOpen === "function" && typeof candidate.agentEmit === "function" && typeof candidate.agentSessionClose === "function";
+}
+function isAgentSessionUnsupported(error) {
+  if (!(error instanceof PhuxError) || error.code !== "command_failed") return false;
+  const haystack = `${error.message}
+${error.stderr ?? ""}`;
+  return /unsupported_server|unrecognized subcommand|invalid subcommand|unknown command|not a valid command/i.test(haystack);
+}
+var AgentSessionEmitter = class {
+  cli;
+  provider;
+  onError;
+  target = null;
+  nativeId = null;
+  opened = false;
+  unavailable = false;
+  constructor(cli, options) {
+    this.cli = cli !== null && hasAgentSessionCli(cli) ? cli : null;
+    this.provider = options.provider;
+    this.onError = options.onError ?? (() => {
+    });
+    if (this.cli === null) this.unavailable = true;
+    if (this.provider.trim().length === 0) throw new TypeError("provider must be non-empty");
+  }
+  get isOpen() {
+    return this.opened;
+  }
+  get isUnavailable() {
+    return this.unavailable;
+  }
+  /** Take over a session this process left open (extension reload). */
+  adopt(target) {
+    this.target = target;
+    this.opened = target !== null;
+    this.nativeId = null;
+  }
+  async bind(target, nativeId, options = {}) {
+    if (this.unavailable) return;
+    if (target === this.target && this.opened && this.nativeId === nativeId) return;
+    if (this.opened && (this.target !== target || this.nativeId !== nativeId)) {
+      await this.finish(options);
+    }
+    if (target === null) return;
+    await this.open(target, nativeId, options);
+  }
+  async emit(type, data, options = {}) {
+    if (this.unavailable || !this.opened || this.target === null || this.cli === null) return;
+    try {
+      await this.cli.agentEmit(this.target, type, {
+        ...options,
+        ...data === void 0 ? {} : { data }
+      });
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+  async finish(options = {}) {
+    if (this.unavailable || !this.opened || this.target === null || this.cli === null) {
+      this.opened = false;
+      this.target = null;
+      this.nativeId = null;
+      return;
+    }
+    const target = this.target;
+    this.opened = false;
+    this.target = null;
+    this.nativeId = null;
+    try {
+      await this.cli.agentEmit(target, "session_end", options);
+    } catch (error) {
+      this.onError(error);
+    }
+    try {
+      await this.cli.agentSessionClose(target, options);
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+  async open(target, nativeId, options) {
+    if (this.cli === null) return;
+    try {
+      await this.cli.agentSessionOpen(target, {
+        provider: this.provider,
+        nativeId,
+        ...options
+      });
+    } catch (error) {
+      if (isAgentSessionUnsupported(error)) {
+        this.unavailable = true;
+        return;
+      }
+      this.onError(error);
+      return;
+    }
+    this.target = target;
+    this.nativeId = nativeId;
+    this.opened = true;
+    try {
+      await this.cli.agentEmit(target, "session_start", {
+        ...options,
+        data: { provider: this.provider, native_id: nativeId }
+      });
+    } catch (error) {
+      this.onError(error);
+    }
+  }
+};
 
-// ../pi/src/awareness.ts
+// ../runtime/src/awareness.ts
 var PHUX_CONTEXT_VERSION = 1;
 var DEFAULT_CONTEXT_TIMEOUT_MS = 1e3;
 var DEFAULT_CONTEXT_MAX_BYTES = 8 * 1024;
@@ -1320,6 +1531,8 @@ var OpenCodeLifecycle = class {
   target;
   states = /* @__PURE__ */ new Map();
   owned = /* @__PURE__ */ new Map();
+  sessions = /* @__PURE__ */ new Map();
+  openedPanes = /* @__PURE__ */ new Map();
   tail = Promise.resolve();
   disposed = false;
   constructor(options) {
@@ -1343,15 +1556,50 @@ var OpenCodeLifecycle = class {
   observeState(sessionId, state) {
     if (this.disposed) return this.tail;
     this.states.set(sessionId, state);
-    return this.enqueue(() => this.publish(sessionId));
+    return this.enqueue(async () => {
+      await this.publish(sessionId);
+      await this.emit(sessionId, state === "working" ? "prompt" : "stop");
+    });
   }
   /** A tool invocation is an honest working signal if no status event was seen yet. */
   targetSelected(sessionId) {
-    return this.observeState(sessionId, this.states.get(sessionId) ?? "working");
+    if (this.disposed) return this.tail;
+    if (!this.states.has(sessionId)) this.states.set(sessionId, "working");
+    return this.enqueue(() => this.publish(sessionId));
+  }
+  ask(sessionId, data = { kind: "permission" }) {
+    if (this.disposed) return this.tail;
+    return this.enqueue(async () => {
+      await this.publish(sessionId);
+      await this.emit(sessionId, "ask", data);
+    });
+  }
+  toolStart(sessionId, toolName, toolUseId) {
+    if (this.disposed) return this.tail;
+    const data = {
+      tool_name: toolName,
+      ...toolUseId === void 0 ? {} : { tool_use_id: toolUseId }
+    };
+    return this.enqueue(async () => {
+      await this.publish(sessionId);
+      await this.emit(sessionId, "tool_start", data);
+    });
+  }
+  toolEnd(sessionId, toolName, toolUseId) {
+    if (this.disposed) return this.tail;
+    const data = {
+      tool_name: toolName,
+      ...toolUseId === void 0 ? {} : { tool_use_id: toolUseId }
+    };
+    return this.enqueue(async () => {
+      await this.publish(sessionId);
+      await this.emit(sessionId, "tool_end", data);
+    });
   }
   deleteSession(sessionId) {
     this.states.delete(sessionId);
     return this.enqueue(async () => {
+      await this.finishSession(sessionId);
       await this.clearSession(sessionId);
     });
   }
@@ -1359,10 +1607,11 @@ var OpenCodeLifecycle = class {
     if (this.disposed) return this.tail;
     this.disposed = true;
     this.states.clear();
-    const sessions = [...this.owned.keys()];
+    const sessions = [.../* @__PURE__ */ new Set([...this.owned.keys(), ...this.sessions.keys()])];
     this.enqueue(async () => {
       for (const sessionId of sessions) {
         try {
+          await this.finishSession(sessionId);
           await this.clearSession(sessionId);
         } catch (error) {
           this.onError(error);
@@ -1388,7 +1637,11 @@ var OpenCodeLifecycle = class {
       await this.clearOwned(previous);
       this.owned.delete(sessionId);
     }
-    if (target === void 0) return;
+    if (target === void 0) {
+      await this.emitter(sessionId).bind(null, sessionId, this.execution());
+      return;
+    }
+    await this.bindSession(sessionId, target);
     if (previous !== void 0 && previous.target === target) return;
     const binding = { target, owner: `opencode:${sessionId}` };
     this.owned.set(sessionId, binding);
@@ -1416,6 +1669,43 @@ var OpenCodeLifecycle = class {
   execution() {
     return { signal: new AbortController().signal, timeoutMs: this.timeoutMs };
   }
+  emitter(sessionId) {
+    const existing = this.sessions.get(sessionId);
+    if (existing !== void 0) return existing;
+    const created = new AgentSessionEmitter(
+      hasAgentSessionCli(this.cli) ? this.cli : null,
+      { provider: "opencode", onError: this.onError }
+    );
+    this.sessions.set(sessionId, created);
+    return created;
+  }
+  async bindSession(sessionId, target) {
+    const owner = this.openedPanes.get(target);
+    if (owner !== void 0 && owner !== sessionId) return;
+    const previous = [...this.openedPanes.entries()].find((entry) => entry[1] === sessionId);
+    if (previous !== void 0 && previous[0] !== target) this.openedPanes.delete(previous[0]);
+    const emitter = this.emitter(sessionId);
+    await emitter.bind(target, sessionId, this.execution());
+    if (emitter.isOpen) this.openedPanes.set(target, sessionId);
+  }
+  async emit(sessionId, type, data) {
+    if (this.disposed) return;
+    const target = this.target();
+    if (target !== void 0) {
+      const owner = this.openedPanes.get(target);
+      if (owner !== void 0 && owner !== sessionId) return;
+    }
+    await this.emitter(sessionId).emit(type, data, this.execution());
+  }
+  async finishSession(sessionId) {
+    const emitter = this.sessions.get(sessionId);
+    if (emitter === void 0) return;
+    await emitter.finish(this.execution());
+    this.sessions.delete(sessionId);
+    for (const [pane, owner] of this.openedPanes) {
+      if (owner === sessionId) this.openedPanes.delete(pane);
+    }
+  }
 };
 function handleLifecycleEvent(lifecycle, event) {
   switch (event.type) {
@@ -1441,10 +1731,36 @@ function handleLifecycleEvent(lifecycle, event) {
       const sessionID = info !== null && typeof info === "object" ? info.id : void 0;
       return typeof sessionID === "string" ? lifecycle.deleteSession(sessionID) : Promise.resolve();
     }
+    case "permission.asked": {
+      const sessionID = sessionIdOf(event.properties);
+      return sessionID === void 0 ? Promise.resolve() : lifecycle.ask(sessionID, permissionAskData(event.properties));
+    }
     default:
       return Promise.resolve();
   }
 }
+function sessionIdOf(properties) {
+  if (typeof properties.sessionID === "string") return properties.sessionID;
+  if (typeof properties.sessionId === "string") return properties.sessionId;
+  const info = properties.info;
+  if (info !== null && typeof info === "object") {
+    const id = info.id;
+    if (typeof id === "string") return id;
+    const nested = info.sessionID;
+    if (typeof nested === "string") return nested;
+  }
+  return void 0;
+}
+function permissionAskData(properties) {
+  const id = typeof properties.id === "string" ? properties.id : typeof properties.permissionID === "string" ? properties.permissionID : void 0;
+  const permission = properties.permission;
+  const question = typeof permission === "string" ? permission : typeof properties.title === "string" ? properties.title : void 0;
+  return {
+    kind: "permission",
+    ...id === void 0 ? {} : { id },
+    ...question === void 0 ? {} : { question }
+  };
+}
 function lifecycleRecord(owner) {
   return { name: "opencode", kind: "opencode", session: owner };
 }
@@ -1720,106 +2036,144 @@ function byteLength(text) {
 
 // src/index.ts
 function createPhuxPlugin(defaults = {}) {
-  return Plugin.define({
-    id: "phux.terminal",
-    setup: async (context) => {
-      const options = mergeOptions(defaults, context.options);
-      const environment = options.env ?? process.env;
-      const environmentTarget = readEnvironmentTarget(environment.PHUX_TARGET);
-      const cli = options.cli ?? new PhuxCli(cliOptions(options, environment));
-      let selectedTarget;
-      const currentTarget = () => selectedTarget ?? environmentTarget;
-      const lifecycle = new OpenCodeLifecycle({
-        cli,
-        target: currentTarget,
-        ...options.lifecycleTimeoutMs === void 0 ? {} : { timeoutMs: options.lifecycleTimeoutMs },
-        ...options.onLifecycleError === void 0 ? {} : { onError: options.onLifecycleError }
-      });
-      const awareness = new PhuxContextAwareness(cli, {
-        enabled: options.contextAwareness ?? contextAwarenessEnabled(environment.PHUX_CONTEXT_AWARENESS),
-        ...options.contextTimeoutMs === void 0 ? {} : { timeoutMs: options.contextTimeoutMs }
-      });
-      const latestContext = /* @__PURE__ */ new Map();
-      const contextIdentity = () => {
-        const self = normalizeTerminalIdentity(environment.PHUX_TERMINAL_ID);
-        const selected = currentTarget();
-        return {
-          ...self === null ? {} : { self },
-          ...selected === void 0 ? {} : { selected }
-        };
+  return async (_input, configured) => {
+    const options = mergeOptions(defaults, configured ?? {});
+    const environment = options.env ?? process.env;
+    const environmentTarget = readEnvironmentTarget(environment.PHUX_TARGET);
+    const cli = options.cli ?? new PhuxCli(cliOptions(options, environment));
+    let selectedTarget;
+    const currentTarget = () => selectedTarget ?? environmentTarget;
+    const lifecycle = new OpenCodeLifecycle({
+      cli,
+      target: currentTarget,
+      ...options.lifecycleTimeoutMs === void 0 ? {} : { timeoutMs: options.lifecycleTimeoutMs },
+      ...options.onLifecycleError === void 0 ? {} : { onError: options.onLifecycleError }
+    });
+    const awareness = new PhuxContextAwareness(cli, {
+      enabled: options.contextAwareness ?? contextAwarenessEnabled(environment.PHUX_CONTEXT_AWARENESS),
+      ...options.contextTimeoutMs === void 0 ? {} : { timeoutMs: options.contextTimeoutMs }
+    });
+    const latestContext = /* @__PURE__ */ new Map();
+    const contextIdentity = () => {
+      const self = normalizeTerminalIdentity(environment.PHUX_TERMINAL_ID);
+      const selected = currentTarget();
+      return {
+        ...self === null ? {} : { self },
+        ...selected === void 0 ? {} : { selected }
       };
-      const tools = createPhuxTools({
-        cli,
-        ...environmentTarget === void 0 ? {} : { environmentTarget },
-        getSelectedTarget: () => selectedTarget,
-        selectTarget: (target) => {
-          selectedTarget = target;
-        },
-        targetSelected: (toolContext) => {
-          void lifecycle.targetSelected(toolContext.sessionID);
-        }
-      });
-      const toolRegistration = await context.tool.transform((draft) => {
-        for (const tool of Object.values(tools)) draft.add(tool);
-      });
-      const contextRegistration = await context.session.hook("context", async (event) => {
-        const emission = await awareness.next(event.sessionID, contextIdentity());
-        if (emission !== null) latestContext.set(event.sessionID, emission.text);
-        const text = latestContext.get(event.sessionID);
+    };
+    const tools = createPhuxTools({
+      cli,
+      ...environmentTarget === void 0 ? {} : { environmentTarget },
+      getSelectedTarget: () => selectedTarget,
+      selectTarget: (target) => {
+        selectedTarget = target;
+      },
+      targetSelected: (toolContext) => {
+        void lifecycle.targetSelected(toolContext.sessionID);
+      }
+    });
+    return {
+      tool: openCodeTools(tools),
+      "experimental.chat.system.transform": async (input, output) => {
+        if (input.sessionID === void 0) return;
+        const emission = await awareness.next(input.sessionID, contextIdentity());
+        if (emission !== null) latestContext.set(input.sessionID, emission.text);
+        const text = latestContext.get(input.sessionID);
         if (text === void 0) return;
-        event.system.push({
-          type: "text",
-          text,
-          metadata: { phuxContext: true }
-        });
-      });
-      const controller = new AbortController();
-      const eventTask = consumeEvents(
-        context.event.subscribe({ signal: controller.signal }),
-        lifecycle,
-        awareness,
-        latestContext,
-        options.onLifecycleError
-      );
-      return async () => {
-        controller.abort();
-        await Promise.all([
-          toolRegistration.dispose(),
-          contextRegistration.dispose(),
-          eventTask,
-          lifecycle.dispose()
-        ]);
-      };
-    }
-  });
-}
-var PhuxPlugin = createPhuxPlugin();
-var index_default = PhuxPlugin;
-async function consumeEvents(events, lifecycle, awareness, latestContext, onError) {
-  try {
-    for await (const event of events) {
-      if (!isLifecycleEvent(event)) continue;
-      await handleLifecycleEvent(lifecycle, event);
-      if (event.type === "session.deleted") {
+        output.system.push(text);
+      },
+      "tool.execute.before": async (input) => {
+        await lifecycle.toolStart(input.sessionID, input.tool, input.callID);
+      },
+      "tool.execute.after": async (input) => {
+        await lifecycle.toolEnd(input.sessionID, input.tool, input.callID);
+      },
+      "permission.ask": async (input) => {
+        const sessionID = input.sessionID;
+        if (typeof sessionID !== "string") return;
+        await lifecycle.ask(sessionID, { kind: "permission" });
+      },
+      event: async ({ event }) => {
+        if (!isLifecycleEvent(event)) return;
+        await handleLifecycleEvent(lifecycle, event);
+        if (event.type !== "session.deleted") return;
         const info = event.properties.info;
         const sessionID = info !== null && typeof info === "object" ? info.id : void 0;
-        if (typeof sessionID !== "string") continue;
+        if (typeof sessionID !== "string") return;
         awareness.delete(sessionID);
         latestContext.delete(sessionID);
-      }
+      },
+      dispose: async () => lifecycle.dispose()
+    };
+  };
+}
+var PhuxPlugin = createPhuxPlugin();
+var index_default = PhuxPlugin;
+var z = tool.schema;
+var localTimeoutArgument = () => z.number().int().min(1).max(36e5).optional();
+var targetArgument = () => nonBlankString(512).optional();
+function nonBlankString(maxLength) {
+  return z.string().min(1).max(maxLength).regex(/\S/);
+}
+function openCodeTools(tools) {
+  return {
+    phux_list: adaptTool(tools.phux_list, { local_timeout_ms: localTimeoutArgument() }),
+    phux_create: adaptTool(tools.phux_create, {
+      name: nonBlankString(255),
+      cwd: nonBlankString(4096).optional(),
+      command: z.array(z.string().max(65536)).min(1).max(256).optional(),
+      local_timeout_ms: localTimeoutArgument()
+    }),
+    phux_snapshot: adaptTool(tools.phux_snapshot, {
+      target: targetArgument(),
+      scrollback: z.number().int().min(0).max(1e5).optional(),
+      cells: z.boolean().optional(),
+      local_timeout_ms: localTimeoutArgument()
+    }),
+    phux_send_keys: adaptTool(tools.phux_send_keys, {
+      target: targetArgument(),
+      keys: z.array(nonBlankString(65536)).min(1).max(256),
+      local_timeout_ms: localTimeoutArgument()
+    }),
+    phux_run: adaptTool(tools.phux_run, {
+      target: targetArgument(),
+      command: nonBlankString(65536),
+      timeout_seconds: z.number().int().min(0).max(86400).optional(),
+      local_timeout_ms: localTimeoutArgument()
+    }),
+    phux_wait: adaptTool(tools.phux_wait, {
+      target: targetArgument(),
+      until: nonBlankString(4096).optional(),
+      idle_ms: z.number().int().min(0).max(864e5).optional(),
+      timeout_seconds: z.number().int().min(1).max(86400).optional(),
+      local_timeout_ms: localTimeoutArgument()
+    })
+  };
+}
+function adaptTool(definition, args) {
+  return tool({
+    description: definition.description,
+    args,
+    execute: async (input, context) => {
+      const result = await definition.execute(input, phuxToolContext(context));
+      return { output: result.content, metadata: result.metadata };
     }
-  } catch (error) {
-    if (!isAbortError(error)) onError?.(error);
-  }
+  });
+}
+function phuxToolContext(context) {
+  return {
+    sessionID: context.sessionID,
+    messageID: context.messageID,
+    agent: context.agent,
+    id: context.messageID
+  };
 }
 function isLifecycleEvent(value) {
   if (value === null || typeof value !== "object") return false;
   const candidate = value;
   return typeof candidate.type === "string" && candidate.properties !== null && typeof candidate.properties === "object";
 }
-function isAbortError(error) {
-  return error instanceof DOMException && error.name === "AbortError";
-}
 function mergeOptions(defaults, configured) {
   return { ...defaults, ...configured };
 }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@phux/opencode",
-  "version": "0.2.2",
-  "description": "OpenCode V2 tools and fleet context for shared phux terminals",
+  "version": "0.3.0",
+  "description": "OpenCode tools and fleet context for shared phux terminals",
   "type": "module",
-  "license": "MIT OR Apache-2.0",
+  "license": "Apache-2.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/no-phux/phux.git",
@@ -36,12 +36,12 @@
     "prepack": "npm run build"
   },
   "dependencies": {
-    "@opencode-ai/plugin": "0.0.0-next-17430"
+    "@opencode-ai/plugin": "1.18.30"
   },
   "devDependencies": {
-    "@types/node": "24.12.2",
+    "@types/node": "26.5.0",
     "tsup": "8.5.1",
-    "typescript": "5.9.2"
+    "typescript": "6.0.3"
   },
   "engines": {
     "node": ">=22"