tmux-ide 2.9.4 → 2.9.6

package/packages/daemon-client/src/tmux-server-client.ts

@@ -1,5 +1,16 @@
 import {
+  TmuxAgentOpenRequestSchemaZ,
+  TmuxAgentOpenResponseSchemaZ,
+  type TmuxAgentOpenRequest,
+  PaneEditorContextTargetSchemaZ,
+  PaneEditorContextResponseSchemaZ,
+  type PaneEditorContextTarget,
+  WindowLinkTargetSchemaZ,
+  WindowSplitLayoutResourceSchemaZ,
+  type WindowLinkTarget,
   TMUX_SERVERS_API_PATH,
+  ApplicationShellProjectionInputV2SchemaZ,
+  WorkspaceCatalogLiveSessionIdSchemaZ,
   PANE_STREAM_REDEEM_PATH,
   TmuxServerIdSchemaZ,
   TmuxServerDescriptorSchemaZ,
@@ -49,6 +60,7 @@ async function request(
   body?: unknown,
   headers?: Record<string, string>,
   method?: "DELETE",
+  signal?: AbortSignal,
 ) {
   const response = await (options.fetch ?? fetch)(new URL(path, options.baseUrl), {
     method: method ?? (body === undefined ? "GET" : "POST"),
@@ -60,10 +72,14 @@ async function request(
     ...(body === undefined ? {} : { body: JSON.stringify(body) }),
     redirect: "error",
     cache: "no-store",
-    signal: AbortSignal.timeout(options.timeoutMs ?? 5_000),
+    signal: signal
+      ? AbortSignal.any([signal, AbortSignal.timeout(options.timeoutMs ?? 5_000)])
+      : AbortSignal.timeout(options.timeoutMs ?? 5_000),
   });
   if (!response.ok) throw new TmuxServerClientError("request-failed", response.status);
-  return (await response.json()) as unknown;
+  const result: unknown = await response.json();
+  signal?.throwIfAborted();
+  return result;
 }
 export async function listTmuxServers(options: TmuxServerClientOptions) {
   return TmuxServersResourceSchemaZ.parse(await request(options, TMUX_SERVERS_API_PATH));
@@ -118,9 +134,24 @@ export function createTmuxServerClient(
     if (candidate.serverId !== scope.serverId || candidate.generation !== scope.generation)
       throw new TmuxServerClientError("scope-mismatch");
   }
-  async function scopedRequest(suffix: string, body?: unknown, headers?: Record<string, string>) {
+  async function scopedRequest(
+    suffix: string,
+    body?: unknown,
+    headers?: Record<string, string>,
+    signal?: AbortSignal,
+    defaultTimeoutMs?: number,
+  ) {
     assertCurrent();
-    const result = await request(options, `${base}/${suffix}`, body, headers);
+    const result = await request(
+      defaultTimeoutMs === undefined
+        ? options
+        : { ...options, timeoutMs: options.timeoutMs ?? defaultTimeoutMs },
+      `${base}/${suffix}`,
+      body,
+      headers,
+      undefined,
+      signal,
+    );
     assertCurrent();
     return result;
   }
@@ -137,6 +168,43 @@ export function createTmuxServerClient(
       assertScope(response.server);
       return response;
     },
+    /** Authenticated directory observation only; does not open an editor or acquire input. */
+    async paneEditorContext(input: PaneEditorContextTarget, signal?: AbortSignal) {
+      const parsed = PaneEditorContextTargetSchemaZ.safeParse(input);
+      if (!parsed.success) throw new TypeError("Invalid editor context target");
+      const target = parsed.data;
+      if (target.generation !== scope.generation) throw new TmuxServerClientError("scope-mismatch");
+      signal?.throwIfAborted();
+      const raw = await scopedRequest("pane-editor-context", target, undefined, signal);
+      const response = PaneEditorContextResponseSchemaZ.safeParse(raw);
+      if (!response.success) throw new TypeError("Invalid editor context response");
+      assertScope(response.data.server);
+      if (
+        Object.entries(target).some(
+          ([key, value]) => response.data.context[key as keyof PaneEditorContextTarget] !== value,
+        )
+      )
+        throw new TmuxServerClientError("scope-mismatch");
+      return response.data;
+    },
+    /** A single admission attempt may promote a session; never automatically retry. */
+    async openAgent(liveSessionId: string, input: TmuxAgentOpenRequest, signal?: AbortSignal) {
+      const session = WorkspaceCatalogLiveSessionIdSchemaZ.parse(liveSessionId);
+      const target = TmuxAgentOpenRequestSchemaZ.parse(input);
+      signal?.throwIfAborted();
+      const raw = await scopedRequest(
+        `sessions/${encodeURIComponent(session)}/open-agent`,
+        target,
+        undefined,
+        signal,
+      );
+      const response = TmuxAgentOpenResponseSchemaZ.safeParse(raw);
+      if (!response.success) throw new TypeError("Invalid scoped agent-open response");
+      assertScope(response.data.server);
+      if (response.data.liveSessionId !== session)
+        throw new TmuxServerClientError("scope-mismatch");
+      return response.data;
+    },
     async openSession(liveSessionId: string) {
       const raw = await scopedRequest(`sessions/${encodeURIComponent(liveSessionId)}/open`, {});
       if (
@@ -161,6 +229,48 @@ export function createTmuxServerClient(
         liveSessionId,
       };
     },
+    /** Observe canonical split handles; does not acquire a channel or resize a pane. */
+    async windowSplitLayout(workspaceName: string, input: WindowLinkTarget, signal?: AbortSignal) {
+      if (
+        typeof workspaceName !== "string" ||
+        !workspaceName.length ||
+        workspaceName.length > 160 ||
+        /[\0\r\n]/u.test(workspaceName)
+      )
+        throw new TypeError("Invalid split-layout workspace name");
+      const target = WindowLinkTargetSchemaZ.parse(input);
+      signal?.throwIfAborted();
+      const raw = await scopedRequest(
+        `split-layout/${encodeURIComponent(workspaceName)}`,
+        target,
+        undefined,
+        signal,
+        // Six 5s capability probes + 6s lazy readiness + 5s owner catalog
+        // validation and transport margin. Other reads retain their 5s default.
+        45_000,
+      );
+      if (
+        !raw ||
+        typeof raw !== "object" ||
+        !("version" in raw) ||
+        raw.version !== 1 ||
+        !("server" in raw) ||
+        !("resource" in raw) ||
+        Object.keys(raw).length !== 3
+      )
+        throw new TypeError("Invalid scoped split-layout response");
+      assertScope(TmuxServerScopeSchemaZ.parse(raw.server));
+      const resource = WindowSplitLayoutResourceSchemaZ.parse(raw.resource);
+      const actual = resource.window;
+      if (
+        actual.liveSessionId !== target.liveSessionId ||
+        actual.linkId !== target.linkId ||
+        actual.expectedSemanticWindowId !== target.expectedSemanticWindowId ||
+        actual.linkRevision !== target.linkRevision
+      )
+        throw new TmuxServerClientError("scope-mismatch");
+      return { version: 1 as const, server: scope, resource };
+    },
     async inventory(workspaceName: string) {
       const raw = await scopedRequest(`inventory/${encodeURIComponent(workspaceName)}`);
       if (
@@ -179,6 +289,37 @@ export function createTmuxServerClient(
         throw new TmuxServerClientError("scope-mismatch");
       return { version: 1 as const, server: scope, resource };
     },
+    /** Observe an already registered session without opening it or issuing a pane stream. */
+    async applicationShell(workspaceName: string, liveSessionId: string, signal?: AbortSignal) {
+      if (
+        typeof workspaceName !== "string" ||
+        workspaceName.length < 1 ||
+        workspaceName.length > 160 ||
+        /[\0\r\n]/u.test(workspaceName)
+      )
+        throw new TypeError("Invalid application-shell workspace name");
+      const liveId = WorkspaceCatalogLiveSessionIdSchemaZ.parse(liveSessionId);
+      signal?.throwIfAborted();
+      const raw = await scopedRequest(
+        `application-shell/${encodeURIComponent(workspaceName)}?liveSessionId=${encodeURIComponent(liveId)}`,
+        undefined,
+        undefined,
+        signal,
+      );
+      if (
+        !raw ||
+        typeof raw !== "object" ||
+        !("version" in raw) ||
+        raw.version !== 1 ||
+        !("server" in raw) ||
+        !("resource" in raw) ||
+        Object.keys(raw).length !== 3
+      )
+        throw new TypeError("Invalid scoped application-shell response");
+      assertScope(TmuxServerScopeSchemaZ.parse(raw.server));
+      const resource = ApplicationShellProjectionInputV2SchemaZ.parse(raw.resource);
+      return { version: 1 as const, server: scope, resource };
+    },
     async createSession(operationId: string, intent: WorkspaceSessionCreateArguments) {
       const safeIntent = WorkspaceSessionCreateArgumentsSchemaZ.parse(intent);
       if (

package/packages/daemon-client/src/workspace-client-types.ts

@@ -263,6 +263,7 @@ export interface WorkspaceClient<
       update: TerminalReplicaUpdate<TerminalSnapshot, TerminalPatch, TerminalTombstone>,
       metadata?: TerminalReplicaDeliveryMetadata,
     ) => void,
+    onUnavailable?: (message: string) => void,
   ): () => void;
   requestTerminalRepair(
     target: TerminalReplicaAddress,

package/packages/daemon-client/src/workspace-client.ts

@@ -75,6 +75,9 @@ interface TerminalInterest<Snapshot, Patch, Tombstone> {
     ReturnType<WorkspaceClientRuntimePort<Snapshot, Patch, Tombstone>["subscribeTerminal"]>
   > | null;
   unsubscribeUpdate: (() => void) | null;
+  unsubscribeUnavailable: (() => void) | null;
+  unavailable: string | null;
+  readonly unavailableListeners: Set<(message: string) => void>;
   opening: boolean;
 }
 
@@ -89,6 +92,8 @@ interface PreparedTerminalBinding<Snapshot, Patch, Tombstone> {
     ReturnType<WorkspaceClientRuntimePort<Snapshot, Patch, Tombstone>["subscribeTerminal"]>
   >;
   readonly unsubscribeUpdate: () => void;
+  readonly unsubscribeUnavailable: () => void;
+  unavailable: string | null;
   readonly pending: Array<{
     readonly update: TerminalReplicaUpdate<Snapshot, Patch, Tombstone>;
     readonly metadata?: TerminalReplicaDeliveryMetadata;
@@ -518,6 +523,9 @@ export function createWorkspaceClient<
     interest: TerminalInterest<TerminalSnapshot, TerminalPatch, TerminalTombstone>,
   ): Promise<void> => {
     interest.opening = false;
+    interest.unsubscribeUnavailable?.();
+    interest.unsubscribeUnavailable = null;
+    interest.unavailable = null;
     interest.unsubscribeUpdate?.();
     interest.unsubscribeUpdate = null;
     const subscription = interest.subscription;
@@ -534,6 +542,7 @@ export function createWorkspaceClient<
     const closing: Promise<void>[] = [];
     for (const binding of prepared.bindings.values()) {
       binding.unsubscribeUpdate();
+      binding.unsubscribeUnavailable();
       closing.push(closeSubscription(binding.subscription));
     }
     prepared.bindings.clear();
@@ -562,6 +571,19 @@ export function createWorkspaceClient<
       }
     }
   };
+  const publishUnavailable = (
+    interest: TerminalInterest<TerminalSnapshot, TerminalPatch, TerminalTombstone>,
+    message: string,
+  ): void => {
+    interest.unavailable = message;
+    for (const listener of [...interest.unavailableListeners]) {
+      try {
+        listener(message);
+      } catch {
+        /* One pane observer cannot interrupt siblings. */
+      }
+    }
+  };
   const openTerminal = (
     interest: TerminalInterest<TerminalSnapshot, TerminalPatch, TerminalTombstone>,
   ): void => {
@@ -591,8 +613,19 @@ export function createWorkspaceClient<
           return closeSubscription(subscription);
         }
         interest.subscription = subscription;
+        interest.unsubscribeUnavailable =
+          subscription.onUnavailable?.((message) => {
+            if (
+              disposed ||
+              generation !== expectedGeneration ||
+              runtime !== expectedRuntime ||
+              interest.subscription !== subscription
+            )
+              return;
+            publishUnavailable(interest, message);
+          }) ?? null;
         interest.unsubscribeUpdate = subscription.onUpdate((update, metadata) => {
-          if (generation !== expectedGeneration) return;
+          if (generation !== expectedGeneration || interest.unavailable) return;
           publishTerminalUpdate(interest, expectedRuntime, update, metadata);
         });
       })
@@ -702,12 +735,17 @@ export function createWorkspaceClient<
         for (const binding of bindings) {
           binding.interest.subscription = binding.subscription;
           binding.interest.unsubscribeUpdate = binding.unsubscribeUpdate;
+          binding.interest.unsubscribeUnavailable = binding.unsubscribeUnavailable;
           binding.interest.opening = false;
         }
         prepared.bindings.clear();
         owner.prepared = null;
         prepared.activated = true;
         for (const binding of bindings) {
+          if (binding.unavailable) {
+            publishUnavailable(binding.interest, binding.unavailable);
+            binding.pending.length = 0;
+          }
           for (const delivery of binding.pending) {
             publishTerminalUpdate(
               binding.interest,
@@ -778,8 +816,9 @@ export function createWorkspaceClient<
               TerminalPatch,
               TerminalTombstone
             >["pending"] = [];
+            let subscriptionUnavailable = false;
             const unsubscribeUpdate = subscription.onUpdate((update, metadata) => {
-              if (prepared.closed) return;
+              if (prepared.closed || subscriptionUnavailable) return;
               if (prepared.activated) {
                 publishTerminalUpdate(interest, nextRuntime, update, metadata);
                 return;
@@ -821,12 +860,31 @@ export function createWorkspaceClient<
               await closeSubscription(subscription);
               return;
             }
-            prepared.bindings.set(key, {
+            const binding = {
               interest,
               subscription,
               unsubscribeUpdate,
+              unsubscribeUnavailable: () => {},
+              unavailable: null as string | null,
               pending,
-            });
+            };
+            binding.unsubscribeUnavailable =
+              subscription.onUnavailable?.((message) => {
+                if (
+                  prepared.closed ||
+                  disposed ||
+                  generation !== owner.clientGeneration ||
+                  (activeRuntimeOwner !== owner && candidateRuntimeOwner !== owner) ||
+                  terminals.get(key) !== interest
+                )
+                  return;
+                subscriptionUnavailable = true;
+                binding.unavailable = message;
+                binding.pending.length = 0;
+                if (prepared.activated && runtime === nextRuntime)
+                  publishUnavailable(interest, message);
+              }) ?? (() => {});
+            prepared.bindings.set(key, binding);
           }),
         ];
       });
@@ -1327,7 +1385,7 @@ export function createWorkspaceClient<
         throw error;
       }
     },
-    subscribeTerminal(nextTarget, listener) {
+    subscribeTerminal(nextTarget, listener, onUnavailable) {
       if (disposed) return () => undefined;
       const key = terminalKey(nextTarget);
       const interest =
@@ -1337,19 +1395,34 @@ export function createWorkspaceClient<
           listeners: new Set(),
           subscription: null,
           unsubscribeUpdate: null,
+          unsubscribeUnavailable: null,
+          unavailable: null,
+          unavailableListeners: new Set<(message: string) => void>(),
           opening: false,
         } satisfies TerminalInterest<TerminalSnapshot, TerminalPatch, TerminalTombstone>);
       terminals.set(key, interest);
       interest.listeners.add(listener);
+      if (onUnavailable) {
+        interest.unavailableListeners.add(onUnavailable);
+        if (interest.unavailable) {
+          try {
+            onUnavailable(interest.unavailable);
+          } catch {
+            /* Availability observers cannot interrupt sibling delivery. */
+          }
+        }
+      }
       openTerminal(interest);
       return () => {
         interest.listeners.delete(listener);
+        if (onUnavailable) interest.unavailableListeners.delete(onUnavailable);
         if (interest.listeners.size > 0) return;
         for (const owner of [activeRuntimeOwner, candidateRuntimeOwner]) {
           const prepared = owner?.prepared?.bindings.get(key);
           if (!prepared) continue;
           owner!.prepared!.bindings.delete(key);
           prepared.unsubscribeUpdate();
+          prepared.unsubscribeUnavailable();
           void closeSubscription(prepared.subscription);
         }
         terminals.delete(key);

package/packages/presentation/package.json

@@ -10,7 +10,8 @@
     "./pane-frame/web.css": "./src/pane-frame/web-host.css",
     "./workbench-dock": "./src/workbench-dock/index.ts",
     "./workbench-dock/web": "./src/workbench-dock/web-host-unstyled.tsx",
-    "./workbench-dock/web.css": "./src/workbench-dock/web-host.css"
+    "./workbench-dock/web.css": "./src/workbench-dock/web-host.css",
+    "./home-agent-roster": "./src/home-agent-roster.ts"
   },
   "scripts": {
     "lint": "eslint src",

package/packages/presentation/src/home-agent-roster.ts

@@ -0,0 +1,138 @@
+import type { PaneTeamMembership } from "@tmux-ide/contracts";
+import type { NativePaneIdentity } from "@tmux-ide/contracts";
+import type {
+  AgentActivity,
+  InteractionPaneEndpoint,
+  ApplicationShellResourceV2,
+  TmuxServerScope,
+} from "@tmux-ide/contracts";
+
+/** Structural catalog input; observation and transport remain with each host. */
+export interface HomeAgentCatalogSession {
+  readonly id: string;
+  readonly server?: TmuxServerScope;
+  readonly serverLabel?: string;
+  readonly liveSessionId?: string;
+  readonly workspaceName?: string;
+  readonly name: string;
+  readonly paneCount?: number;
+}
+
+export function terminalAgentStatusLabel(activity: AgentActivity): string {
+  switch (activity) {
+    case "running":
+      return "WORKING";
+    case "waiting":
+      return "BLOCKED";
+    case "complete":
+      return "DONE";
+    case "failed":
+      return "FAILED";
+    case "disconnected":
+      return "DISCONNECTED";
+    case "idle":
+      return "IDLE";
+  }
+}
+
+export interface HomeAgentRow {
+  readonly team?: PaneTeamMembership;
+  readonly nativeIdentity: NativePaneIdentity | null;
+  readonly interactionEndpoint: Extract<InteractionPaneEndpoint, { kind: "pane" }> | null;
+  readonly key: string;
+  readonly machineId?: string;
+  readonly machineLabel?: string;
+  readonly server?: TmuxServerScope;
+  readonly serverLabel?: string;
+  readonly disabled?: boolean;
+  readonly sessionKey: string;
+  readonly sessionName: string;
+  readonly liveSessionId: string;
+  readonly daemonInstanceId: string;
+  readonly agentId: string;
+  readonly paneId: string | null;
+  /** Durable window grouping from authenticated terminal inventory, when available. */
+  readonly windowId?: string | null;
+  readonly name: string;
+  readonly harness: string;
+  readonly activity: AgentActivity;
+  readonly attention: boolean;
+  readonly projectName: string;
+}
+
+export interface HomeAgentSnapshot {
+  readonly phase: "loading" | "live" | "partial" | "unavailable";
+  readonly rows: readonly HomeAgentRow[];
+  readonly observedSessions: number;
+  readonly totalSessions: number;
+  readonly loadingSessions: number;
+  readonly unavailableSessions: number;
+  readonly truncatedSessions: number;
+  readonly refreshingSessionKeys: readonly string[];
+  readonly unavailableSessionKeys: readonly string[];
+  readonly note: string | null;
+}
+
+export const homeAgentStatusLabel = terminalAgentStatusLabel;
+
+/** Keep state priority separate from stable selection identity. */
+export function sortHomeAgentRows(rows: readonly HomeAgentRow[]): HomeAgentRow[] {
+  const rank = (row: HomeAgentRow) =>
+    row.attention || row.activity === "waiting" || row.activity === "failed"
+      ? 0
+      : row.activity === "running"
+        ? 1
+        : 2;
+  return [...rows].sort(
+    (left, right) => rank(left) - rank(right) || left.key.localeCompare(right.key),
+  );
+}
+
+/** Hosts supply authenticated resource data and the identity used by the fallback. */
+export type HomeAgentShell = Pick<ApplicationShellResourceV2, "resource"> & {
+  readonly daemon: Pick<ApplicationShellResourceV2["daemon"], "instanceId">;
+};
+
+/** The authenticated shell supplies semantic identities; names never identify a row. */
+export function projectHomeAgentRows(
+  session: HomeAgentCatalogSession,
+  shell: HomeAgentShell,
+): HomeAgentRow[] {
+  return shell.resource.workspace.sidebar.agents.map((agent) => ({
+    key: `${session.id}\u0000${agent.id}`,
+    sessionKey: session.id,
+    server: session.server,
+    serverLabel: session.serverLabel,
+    sessionName: session.name,
+    // Older catalog fixtures/callers retain a generation-qualified incarnation
+    // key even when they do not expose the separately named wire field.
+    liveSessionId: session.liveSessionId ?? session.id,
+    daemonInstanceId: session.server?.generation ?? shell.daemon.instanceId,
+    agentId: agent.id,
+    paneId: agent.paneId,
+    nativeIdentity:
+      shell.resource.terminalInventory?.resources.find(
+        (resource) =>
+          resource.attachability.status === "available" &&
+          resource.attachability.semanticPaneId === agent.paneId,
+      )?.nativeIdentity ?? null,
+    interactionEndpoint:
+      shell.resource.terminalInventory?.resources.find(
+        (resource) =>
+          resource.attachability.status === "available" &&
+          resource.attachability.semanticPaneId === agent.paneId,
+      )?.interactionEndpoint ?? null,
+    windowId:
+      shell.resource.terminalInventory?.resources.find(
+        (resource) =>
+          resource.attachability.status === "available" &&
+          resource.attachability.semanticPaneId === agent.paneId,
+      )?.windowResourceId ?? null,
+    name: agent.name,
+    ...(agent.team ? { team: agent.team } : {}),
+    harness: agent.harness,
+    activity: agent.activity,
+    attention: agent.attention,
+    projectName: shell.resource.project.name,
+  }));
+}

package/packages/presentation/src/index.ts

@@ -1,2 +1,3 @@
 export * from "./pane-frame/index.ts";
 export * from "./workbench-dock/index.ts";
+export * from "./home-agent-roster.ts";

package/packages/tmux-bridge/src/index.ts

@@ -1,6 +1,7 @@
 export { TmuxError } from "./errors.ts";
 export {
   runTmux,
+  configureTmuxClientResolver,
   runTmuxBinary,
   runTmuxBinaryAsync,
   classifyTmuxError,

package/packages/tmux-bridge/src/runner.ts

@@ -58,11 +58,35 @@ export function _getSpawner(): Spawner {
   return _spawner;
 }
 
+type TmuxClientResolver = (
+  environment: NodeJS.ProcessEnv,
+  cwd?: string | URL,
+) => {
+  executable: string;
+  environment: NodeJS.ProcessEnv;
+};
+
+let clientResolver: TmuxClientResolver | undefined;
+
+/** Configure ordinary clients at the host composition root; pinned runners are unaffected. */
+export function configureTmuxClientResolver(resolver: TmuxClientResolver): () => void {
+  const previous = clientResolver;
+  clientResolver = resolver;
+  return () => {
+    clientResolver = previous;
+  };
+}
+
 export function runTmux(args: string[], options: ExecFileSyncOptions = {}): string | Buffer {
   if ((options.env ?? process.env).TMUX_IDE_RUNTIME_MODE === "development") {
     throw new Error("Development tmux operations require an explicitly pinned namespace runner");
   }
-  return runTmuxBinary("tmux", args, options);
+  const resolved = clientResolver?.(options.env ?? process.env, options.cwd);
+  return runTmuxBinary(
+    resolved?.executable ?? "tmux",
+    args,
+    resolved ? { ...options, env: resolved.environment } : options,
+  );
 }
 
 /**

package/packages/daemon/dist/native/tmux/darwin-x64/COPYING

@@ -1,13 +0,0 @@
-Copyright (c) Various Authors
-
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER
-IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
-OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/packages/daemon/dist/native/tmux/darwin-x64/licenses/interaction-journal.txt

@@ -1,13 +0,0 @@
-Copyright (c) 2026 wavyrai
-
-Permission to use, copy, modify, and distribute this software for any
-purpose with or without fee is hereby granted, provided that the above
-copyright notice and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
-WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
-ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
-WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
-ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
-OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.