@bastani/atomic 0.5.3 → 0.5.4-0

package/src/sdk/define-workflow.test.ts

@@ -1,5 +1,6 @@
 import { test, expect, describe } from "bun:test";
 import { defineWorkflow, WorkflowBuilder } from "./define-workflow.ts";
+import type { WorkflowInput } from "./types.ts";
 
 describe("defineWorkflow", () => {
   test("returns a WorkflowBuilder", () => {
@@ -43,6 +44,106 @@ describe("WorkflowBuilder.compile()", () => {
     expect(def.__brand).toBe("WorkflowDefinition");
   });
 
+  test("defaults inputs to an empty array when none are declared", () => {
+    const def = defineWorkflow({ name: "test" })
+      .run(async () => {})
+      .compile();
+    expect(def.inputs).toEqual([]);
+  });
+
+  test("preserves declared inputs in order", () => {
+    const def = defineWorkflow({
+      name: "gen-spec",
+      inputs: [
+        {
+          name: "research_doc",
+          type: "string",
+          required: true,
+          description: "path",
+        },
+        {
+          name: "focus",
+          type: "enum",
+          required: true,
+          values: ["minimal", "standard", "exhaustive"],
+          default: "standard",
+        },
+      ],
+    })
+      .run(async () => {})
+      .compile();
+    expect(def.inputs).toHaveLength(2);
+    expect(def.inputs[0]?.name).toBe("research_doc");
+    expect(def.inputs[1]?.name).toBe("focus");
+    expect(def.inputs[1]?.type).toBe("enum");
+  });
+
+  test("freezes declared inputs to prevent downstream mutation", () => {
+    const def = defineWorkflow({
+      name: "test",
+      inputs: [{ name: "foo", type: "string" }],
+    })
+      .run(async () => {})
+      .compile();
+    expect(() => {
+      (def.inputs as unknown as WorkflowInput[])[0]!.name = "bar";
+    }).toThrow();
+  });
+
+  test("rejects enum inputs with no values", () => {
+    expect(() =>
+      defineWorkflow({
+        name: "bad",
+        inputs: [{ name: "mode", type: "enum" }],
+      })
+        .run(async () => {})
+        .compile(),
+    ).toThrow("declares no `values`");
+  });
+
+  test("rejects enum defaults outside the allowed values", () => {
+    expect(() =>
+      defineWorkflow({
+        name: "bad",
+        inputs: [
+          {
+            name: "mode",
+            type: "enum",
+            values: ["a", "b"],
+            default: "c",
+          },
+        ],
+      })
+        .run(async () => {})
+        .compile(),
+    ).toThrow(/not one of its declared values/);
+  });
+
+  test("rejects input names that are not valid CLI flag tails", () => {
+    expect(() =>
+      defineWorkflow({
+        name: "bad",
+        inputs: [{ name: "1bad", type: "string" }],
+      })
+        .run(async () => {})
+        .compile(),
+    ).toThrow(/invalid/);
+  });
+
+  test("rejects duplicate input names", () => {
+    expect(() =>
+      defineWorkflow({
+        name: "bad",
+        inputs: [
+          { name: "foo", type: "string" },
+          { name: "foo", type: "string" },
+        ],
+      })
+        .run(async () => {})
+        .compile(),
+    ).toThrow(/duplicate input name/);
+  });
+
   test("preserves name and description", () => {
     const def = defineWorkflow({ name: "my-wf", description: "A description" })
       .run(async () => {})

package/src/sdk/define-workflow.ts

@@ -10,7 +10,49 @@
  *     .compile()
  */
 
-import type { AgentType, WorkflowOptions, WorkflowContext, WorkflowDefinition } from "./types.ts";
+import type {
+  AgentType,
+  WorkflowOptions,
+  WorkflowContext,
+  WorkflowDefinition,
+  WorkflowInput,
+} from "./types.ts";
+
+/**
+ * Validate a single declared workflow input, throwing on authoring
+ * mistakes that would otherwise surface as confusing runtime errors
+ * inside the picker or the flag parser.
+ */
+function validateWorkflowInput(input: WorkflowInput, workflowName: string): void {
+  if (!input.name || input.name.trim() === "") {
+    throw new Error(
+      `Workflow "${workflowName}" has an input with an empty name.`,
+    );
+  }
+  if (!/^[a-zA-Z][a-zA-Z0-9_-]*$/.test(input.name)) {
+    throw new Error(
+      `Workflow "${workflowName}" input "${input.name}" has an invalid ` +
+        `name — must start with a letter and contain only letters, ` +
+        `digits, underscores, and dashes (so it can be used as a ` +
+        `\`--${input.name}\` CLI flag).`,
+    );
+  }
+  if (input.type === "enum") {
+    if (!Array.isArray(input.values) || input.values.length === 0) {
+      throw new Error(
+        `Workflow "${workflowName}" input "${input.name}" is an enum but ` +
+          `declares no \`values\`.`,
+      );
+    }
+    if (input.default !== undefined && !input.values.includes(input.default)) {
+      throw new Error(
+        `Workflow "${workflowName}" input "${input.name}" has a default ` +
+          `"${input.default}" that is not one of its declared values: ` +
+          `${input.values.join(", ")}.`,
+      );
+    }
+  }
+}
 
 /**
  * Chainable workflow builder. Records the run callback,
@@ -61,10 +103,28 @@ export class WorkflowBuilder<A extends AgentType = AgentType> {
 
     const runFn = this.runFn;
 
+    // Freeze the declared inputs so consumers can read the schema without
+    // worrying that picker or executor code has mutated it upstream.
+    const declaredInputs = this.options.inputs ?? [];
+    const seen = new Set<string>();
+    for (const input of declaredInputs) {
+      validateWorkflowInput(input, this.options.name);
+      if (seen.has(input.name)) {
+        throw new Error(
+          `Workflow "${this.options.name}" has duplicate input name "${input.name}".`,
+        );
+      }
+      seen.add(input.name);
+    }
+    const inputs = Object.freeze(
+      declaredInputs.map((i) => Object.freeze({ ...i })),
+    ) as readonly WorkflowInput[];
+
     return {
       __brand: "WorkflowDefinition" as const,
       name: this.options.name,
       description: this.options.description ?? "",
+      inputs,
       run: runFn,
     };
   }
@@ -90,7 +150,7 @@ export class WorkflowBuilder<A extends AgentType = AgentType> {
  *       {},
  *       async (s) => {
  *         // s.client: CopilotClient, s.session: CopilotSession
- *         await s.session.sendAndWait({ prompt: s.userPrompt });
+ *         await s.session.sendAndWait({ prompt: s.inputs.prompt ?? "" });
  *         s.save(await s.session.getMessages());
  *       },
  *     );

package/src/sdk/runtime/discovery.ts

@@ -13,7 +13,8 @@ import { readdir, writeFile } from "fs/promises";
 import { existsSync, readdirSync } from "fs";
 import { homedir } from "os";
 import ignore from "ignore";
-import type { AgentType } from "../types.ts";
+import type { AgentType, WorkflowInput } from "../types.ts";
+import { WorkflowLoader } from "./loader.ts";
 
 export interface DiscoveredWorkflow {
   name: string;
@@ -175,30 +176,88 @@ function discoverBuiltinWorkflows(
 
 /**
  * Discover all available workflows from built-in, global, and local sources.
- * Optionally filter by agent. Precedence: local > global > builtin.
+ * Optionally filter by agent.
+ *
+ * **Merge precedence:** `builtin > local > global`.
+ *
+ * Builtin names are **strictly reserved** — a user-defined local or
+ * global workflow whose name matches any built-in workflow is dropped
+ * entirely from discovery. It will not be registered, returned from
+ * `findWorkflow`, appear in the interactive picker, or show up in
+ * `atomic workflow -l`. This protects SDK-shipped workflows (e.g.
+ * `ralph`) from being silently overridden or even visibly "competing
+ * with" a user's own definition, which would otherwise be confusing
+ * when someone tries to run the canonical version.
+ *
+ * Reservation is by **name only**, across all agents: if a builtin
+ * defines `ralph` for any agent, a local `ralph` for any other agent is
+ * also dropped. Local still overrides global for every non-builtin
+ * name, so project-scoped customisation of user-scoped workflows
+ * continues to work.
+ *
+ * By default, the result is **merged by precedence** — if a workflow is
+ * defined in both local and global sources, only the higher-precedence
+ * entry is returned. This is the right shape for `findWorkflow`, which
+ * needs the single resolved entry per (name, agent) pair.
+ *
+ * Pass `{ merge: false }` to get the **unmerged** result — local and
+ * global contribute their entries independently, so `--list` can show
+ * both a local and a global copy of the same workflow when they coexist
+ * on disk. (Builtin reservation still applies in both modes.)
  */
 export async function discoverWorkflows(
   projectRoot: string = process.cwd(),
-  agentFilter?: AgentType
+  agentFilter?: AgentType,
+  options: { merge?: boolean } = {},
 ): Promise<DiscoveredWorkflow[]> {
+  const { merge = true } = options;
+
   const localDir = getLocalWorkflowsDir(projectRoot);
   const globalDir = getGlobalWorkflowsDir();
 
-  const builtinResults = discoverBuiltinWorkflows(agentFilter);
+  // Collect ALL builtin names (ignoring agentFilter) so reservation is
+  // name-based across every agent: a local `ralph` for copilot is still
+  // reserved by a builtin `ralph` for claude, even when the discovery
+  // call was filtered to copilot.
+  const allBuiltins = discoverBuiltinWorkflows();
+  const reservedNames = new Set<string>(allBuiltins.map((w) => w.name));
+  const builtinResults = agentFilter
+    ? allBuiltins.filter((w) => w.agent === agentFilter)
+    : allBuiltins;
+
   const [globalResults, localResults] = await Promise.all([
     discoverFromBaseDir(globalDir, "global", agentFilter),
     discoverFromBaseDir(localDir, "local", agentFilter),
   ]);
 
-  // Merge with precedence: builtin (lowest) → global → local (highest)
+  // Drop any local/global workflow whose name matches a reserved
+  // builtin. This happens BEFORE both merge and unmerged code paths so
+  // reserved names never leak into `findWorkflow`, the picker, or
+  // `--list` — there is exactly one canonical entry per reserved name,
+  // the SDK-shipped one.
+  const filteredGlobal = globalResults.filter((w) => !reservedNames.has(w.name));
+  const filteredLocal = localResults.filter((w) => !reservedNames.has(w.name));
+
+  if (!merge) {
+    // Unmerged: keep local and global independent so `--list` can show
+    // both copies of a non-reserved name when they coexist. Order lowest
+    // → highest precedence so callers that want the winning entry can
+    // take the last one by (agent, name).
+    return [...filteredGlobal, ...filteredLocal, ...builtinResults];
+  }
+
+  // Merge with precedence: global (lowest) → local → builtin (highest).
+  // Builtin is layered last as a belt-and-braces guarantee — though
+  // reserved-name filtering above already makes this overwrite
+  // impossible in practice.
   const byKey = new Map<string, DiscoveredWorkflow>();
-  for (const wf of builtinResults) {
+  for (const wf of filteredGlobal) {
     byKey.set(`${wf.agent}/${wf.name}`, wf);
   }
-  for (const wf of globalResults) {
+  for (const wf of filteredLocal) {
     byKey.set(`${wf.agent}/${wf.name}`, wf);
   }
-  for (const wf of localResults) {
+  for (const wf of builtinResults) {
     byKey.set(`${wf.agent}/${wf.name}`, wf);
   }
 
@@ -217,4 +276,48 @@ export async function findWorkflow(
   return all.find((w) => w.name === name) ?? null;
 }
 
+/**
+ * A discovered workflow enriched with the metadata the picker needs to
+ * render it: the human description and the declared input schema.
+ *
+ * Populated by {@link loadWorkflowsMetadata}, which runs each discovered
+ * workflow through {@link WorkflowLoader.loadWorkflow} and extracts just
+ * the display-relevant fields — the full compiled definition is
+ * discarded after extraction so re-imports during execution are cheap.
+ */
+export interface WorkflowWithMetadata extends DiscoveredWorkflow {
+  /** Workflow description, empty string when none was declared. */
+  description: string;
+  /** Declared input schema, empty array for free-form workflows. */
+  inputs: readonly WorkflowInput[];
+}
+
+/**
+ * Load metadata (description + inputs) for a batch of discovered workflows.
+ *
+ * Workflows that fail to import are **skipped silently** so one broken
+ * entry can never prevent the picker from rendering. Callers that need
+ * to surface load errors (e.g. `atomic workflow -n broken`) should use
+ * {@link WorkflowLoader.loadWorkflow} directly — that path produces
+ * structured error reports.
+ */
+export async function loadWorkflowsMetadata(
+  discovered: DiscoveredWorkflow[],
+): Promise<WorkflowWithMetadata[]> {
+  const results = await Promise.all(
+    discovered.map(async (wf): Promise<WorkflowWithMetadata | null> => {
+      const loaded = await WorkflowLoader.loadWorkflow(wf);
+      if (!loaded.ok) return null;
+      return {
+        ...wf,
+        description: loaded.value.definition.description,
+        inputs: loaded.value.definition.inputs,
+      };
+    }),
+  );
+  return results.filter(
+    (r): r is WorkflowWithMetadata => r !== null,
+  );
+}
+
 

package/src/sdk/runtime/executor.ts

@@ -35,7 +35,7 @@ import type { SessionEvent } from "@github/copilot-sdk";
 import type { SessionPromptResponse } from "@opencode-ai/sdk/v2";
 import type { SessionMessage } from "@anthropic-ai/claude-agent-sdk";
 import * as tmux from "./tmux.ts";
-import { getMuxBinary } from "./tmux.ts";
+import { spawnMuxAttach, SOCKET_NAME } from "./tmux.ts";
 import { WorkflowLoader } from "./loader.ts";
 import {
   clearClaudeSession,
@@ -90,8 +90,13 @@ export interface WorkflowRunOptions {
   definition: WorkflowDefinition;
   /** Agent type */
   agent: AgentType;
-  /** The user's prompt */
-  prompt: string;
+  /**
+   * Structured inputs for this run. Free-form workflows model their
+   * single positional prompt as `{ prompt: "..." }` so workflow
+   * authors can read `ctx.inputs.prompt` uniformly regardless of
+   * whether the workflow declares a schema. Empty record is valid.
+   */
+  inputs?: Record<string, string>;
   /** Absolute path to the workflow's index.ts file (from discovery) */
   workflowFile: string;
   /** Project root (defaults to cwd) */
@@ -253,6 +258,31 @@ export function escPwsh(s: string): string {
     .replace(/\r/g, "`r");
 }
 
+/**
+ * Decode the ATOMIC_WF_INPUTS env var (base64-encoded JSON) into a
+ * `Record<string, string>`. Returns an empty record when the variable
+ * is missing, malformed, or does not decode to a string-map object —
+ * structured inputs are optional, so a corrupt payload must never
+ * prevent free-form workflows from running.
+ */
+export function parseInputsEnv(raw: string | undefined): Record<string, string> {
+  if (!raw) return {};
+  try {
+    const decoded = Buffer.from(raw, "base64").toString("utf-8");
+    const parsed: unknown = JSON.parse(decoded);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return {};
+    }
+    const out: Record<string, string> = {};
+    for (const [k, v] of Object.entries(parsed as Record<string, unknown>)) {
+      if (typeof v === "string") out[k] = v;
+    }
+    return out;
+  } catch {
+    return {};
+  }
+}
+
 // ============================================================================
 // Entry point called by the CLI command
 // ============================================================================
@@ -269,7 +299,7 @@ export async function executeWorkflow(
   const {
     definition,
     agent,
-    prompt,
+    inputs = {},
     workflowFile,
     projectRoot = process.cwd(),
   } = options;
@@ -289,13 +319,20 @@ export async function executeWorkflow(
   const launcherPath = join(sessionsBaseDir, `orchestrator.${launcherExt}`);
   const logPath = join(sessionsBaseDir, "orchestrator.log");
 
+  // Inputs are passed through as base64-encoded JSON so long multiline
+  // text values survive shell quoting without any further escaping.
+  // Free-form workflows ride the same pipe — their single positional
+  // prompt is stored under the `prompt` key so workflow authors always
+  // read the user's prompt via `ctx.inputs.prompt`.
+  const inputsB64 = Buffer.from(JSON.stringify(inputs)).toString("base64");
+
   const launcherScript = isWin
     ? [
         `Set-Location "${escPwsh(projectRoot)}"`,
         `$env:ATOMIC_WF_ID = "${escPwsh(workflowRunId)}"`,
         `$env:ATOMIC_WF_TMUX = "${escPwsh(tmuxSessionName)}"`,
         `$env:ATOMIC_WF_AGENT = "${escPwsh(agent)}"`,
-        `$env:ATOMIC_WF_PROMPT = "${escPwsh(Buffer.from(prompt).toString("base64"))}"`,
+        `$env:ATOMIC_WF_INPUTS = "${escPwsh(inputsB64)}"`,
         `$env:ATOMIC_WF_FILE = "${escPwsh(workflowFile)}"`,
         `$env:ATOMIC_WF_CWD = "${escPwsh(projectRoot)}"`,
         `bun run "${escPwsh(thisFile)}" 2>"${escPwsh(logPath)}"`,
@@ -306,7 +343,7 @@ export async function executeWorkflow(
         `export ATOMIC_WF_ID="${escBash(workflowRunId)}"`,
         `export ATOMIC_WF_TMUX="${escBash(tmuxSessionName)}"`,
         `export ATOMIC_WF_AGENT="${escBash(agent)}"`,
-        `export ATOMIC_WF_PROMPT="${escBash(Buffer.from(prompt).toString("base64"))}"`,
+        `export ATOMIC_WF_INPUTS="${escBash(inputsB64)}"`,
         `export ATOMIC_WF_FILE="${escBash(workflowFile)}"`,
         `export ATOMIC_WF_CWD="${escBash(projectRoot)}"`,
         `bun run "${escBash(thisFile)}" 2>"${escBash(logPath)}"`,
@@ -314,26 +351,31 @@ export async function executeWorkflow(
 
   await writeFile(launcherPath, launcherScript, { mode: 0o755 });
 
-  // Create tmux session with orchestrator as the initial window
-  const shellCmd = isWin
-    ? `pwsh -NoProfile -File "${escPwsh(launcherPath)}"`
-    : `bash "${escBash(launcherPath)}"`;
-  tmux.createSession(tmuxSessionName, shellCmd, "orchestrator");
+  console.log(`[atomic] Session: ${tmuxSessionName} (FYI all atomic sessions run on tmux -L ${SOCKET_NAME})`);
 
-  // Attach or switch depending on whether we're already inside tmux
+  // Attach or spawn depending on whether we're already inside tmux
   if (tmux.isInsideTmux()) {
-    // Inside tmux: switch the current client to the workflow session
-    // to avoid creating a nested tmux client
-    tmux.switchClient(tmuxSessionName);
+    // Inside tmux: create the session with just a shell (agent windows live here),
+    // then run the orchestrator directly in the user's current pane.
+    const defaultShell = process.env.SHELL || (isWin ? "pwsh" : "sh");
+    tmux.createSession(tmuxSessionName, defaultShell, "orchestrator");
+
+    const launcherCmd = isWin
+      ? ["pwsh", "-NoProfile", "-File", launcherPath]
+      : ["bash", launcherPath];
+    const proc = Bun.spawn(launcherCmd, {
+      stdio: ["inherit", "inherit", "inherit"],
+      cwd: projectRoot,
+    });
+    await proc.exited;
   } else {
-    // Outside tmux: attach normally (blocks until session ends)
-    const muxBinary = getMuxBinary() ?? "tmux";
-    const attachProc = Bun.spawn(
-      [muxBinary, "attach-session", "-t", tmuxSessionName],
-      {
-        stdio: ["inherit", "inherit", "inherit"],
-      },
-    );
+    // Outside tmux: create session with the orchestrator and attach to it
+    const shellCmd = isWin
+      ? `pwsh -NoProfile -File "${escPwsh(launcherPath)}"`
+      : `bash "${escBash(launcherPath)}"`;
+    tmux.createSession(tmuxSessionName, shellCmd, "orchestrator");
+
+    const attachProc = spawnMuxAttach(tmuxSessionName);
     await attachProc.exited;
   }
 }
@@ -428,7 +470,13 @@ interface SharedRunnerState {
   tmuxSessionName: string;
   sessionsBaseDir: string;
   agent: AgentType;
-  prompt: string;
+  /**
+   * Structured inputs for this workflow run. Free-form workflows use
+   * `{ prompt: "..." }`; structured workflows use their declared field
+   * names. Workflow authors read both shapes via `ctx.inputs` — and
+   * specifically via `ctx.inputs.prompt` for the free-form case.
+   */
+  inputs: Record<string, string>;
   panel: OrchestratorPanel;
   /** Sessions that have been spawned (for name uniqueness + cleanup). */
   activeRegistry: Map<string, ActiveSession>;
@@ -748,10 +796,14 @@ function createSessionRunner(
         );
 
       // ── 13. Construct SessionContext ──
+      // Free-form workflows read their prompt via `s.inputs.prompt`;
+      // structured workflows read their declared fields the same way.
+      // A single uniform access pattern means workflow code never has
+      // to branch on "is this workflow structured or free-form".
       const ctx: SessionContext = {
         client: providerClient as SessionContext["client"],
         session: providerSession as SessionContext["session"],
-        userPrompt: shared.prompt,
+        inputs: shared.inputs,
         agent: shared.agent,
         sessionDir,
         paneId,
@@ -837,12 +889,11 @@ export async function runOrchestrator(): Promise<void> {
     "ATOMIC_WF_ID",
     "ATOMIC_WF_TMUX",
     "ATOMIC_WF_AGENT",
-    "ATOMIC_WF_PROMPT",
     "ATOMIC_WF_FILE",
     "ATOMIC_WF_CWD",
   ] as const;
   for (const key of requiredEnvVars) {
-    if (!process.env[key]) {
+    if (process.env[key] === undefined) {
       throw new Error(`Missing required environment variable: ${key}`);
     }
   }
@@ -850,9 +901,15 @@ export async function runOrchestrator(): Promise<void> {
   const workflowRunId = process.env.ATOMIC_WF_ID!;
   const tmuxSessionName = process.env.ATOMIC_WF_TMUX!;
   const agent = process.env.ATOMIC_WF_AGENT! as AgentType;
-  const prompt = Buffer.from(process.env.ATOMIC_WF_PROMPT!, "base64").toString(
-    "utf-8",
-  );
+  // ATOMIC_WF_INPUTS carries the full input payload. Free-form
+  // workflows store their single positional prompt under the `prompt`
+  // key so workflow authors always read it via `ctx.inputs.prompt`.
+  // An unset, missing, or malformed payload falls back to an empty
+  // record so `ctx.inputs.prompt` gracefully becomes `undefined`.
+  const inputs = parseInputsEnv(process.env.ATOMIC_WF_INPUTS);
+  // A bare prompt string is still useful for the panel header and the
+  // session-dir metadata.json — both just want something displayable.
+  const prompt = inputs.prompt ?? "";
   const workflowFile = process.env.ATOMIC_WF_FILE!;
   const cwd = process.env.ATOMIC_WF_CWD!;
 
@@ -887,7 +944,7 @@ export async function runOrchestrator(): Promise<void> {
     tmuxSessionName,
     sessionsBaseDir,
     agent,
-    prompt,
+    inputs,
     panel,
     activeRegistry: new Map(),
     completedRegistry: new Map(),
@@ -936,7 +993,7 @@ export async function runOrchestrator(): Promise<void> {
     const sessionRunner = createSessionRunner(shared, "orchestrator");
 
     const workflowCtx: WorkflowContext = {
-      userPrompt: prompt,
+      inputs,
       agent,
       stage: sessionRunner as WorkflowContext["stage"],
       transcript: async (ref: SessionRef): Promise<Transcript> => {

package/src/sdk/runtime/tmux.conf

@@ -0,0 +1,55 @@
+# Atomic tmux configuration — injected automatically via -f
+# Shared by tmux (macOS/Linux) and psmux (Windows)
+#
+# True color + passthrough for rich TUI rendering
+set-option -sa terminal-overrides ",xterm*:Tc"
+set -g set-clipboard on
+set -g allow-passthrough on
+
+# Mouse mode — scroll works out of the box
+set-option -g mouse on
+
+# Prevent processes from overwriting window titles
+set-option -g allow-rename off
+
+# Sane defaults (inlined from tmux-sensible)
+set -g escape-time 0
+set -g history-limit 50000
+set -g display-time 4000
+set -g status-interval 5
+set -g focus-events on
+setw -g aggressive-resize on
+
+# Status bar — minimal
+set -g status-left " "
+set -g status-right " #{session_name} | %H:%M "
+set -g status-right-length 60
+set -g status-style "bg=#1e1e2e,fg=#cdd6f4"
+set -g status-right-style "fg=#6c7086"
+
+# Pane splitting
+bind - split-window -v -c "#{pane_current_path}"
+bind | split-window -h -c "#{pane_current_path}"
+
+# Pane resizing
+bind -r l resize-pane -R 5
+bind -r h resize-pane -L 5
+bind -r k resize-pane -U 5
+bind -r j resize-pane -D 5
+
+# Vi-mode
+set-window-option -g mode-keys vi
+bind-key -T copy-mode-vi v send-keys -X begin-selection
+bind-key -T copy-mode-vi C-v send-keys -X rectangle-toggle
+bind-key -T copy-mode-vi y send-keys -X copy-selection-and-cancel
+
+# Escape exits copy-mode (clear selection first if one exists, otherwise cancel)
+bind-key -T copy-mode-vi Escape if-shell -F "#{selection_present}" "send-keys -X clear-selection" "send-keys -X cancel"
+
+# Copy-mode mouse bindings:
+#   - Drag: begin selection + disable scroll-exit (prevents losing selection if dragged to bottom)
+#   - Drag end: copy to system clipboard (via OSC52) and exit copy-mode
+#   - Click: clear any selection (but stay in copy-mode for continued scrolling)
+bind -T copy-mode-vi MouseDrag1Pane    select-pane \; send-keys -X begin-selection \; send-keys -X scroll-exit-off
+bind -T copy-mode-vi MouseDragEnd1Pane send-keys -X copy-pipe-and-cancel
+bind -T copy-mode-vi MouseDown1Pane    send-keys -X clear-selection \; select-pane