@tt-a1i/openpi 0.1.0

package/extensions/plan-mode/index.ts

@@ -0,0 +1,539 @@
+/**
+ * plan-mode: explore read-only, then get explicit approval before writing.
+ *
+ * `/plan` arms a session flag; while armed, a `tool_call` handler allows only
+ * explicitly read-only tools and tells the model to finish planning instead.
+ * `bash` is judged per command rather than as a whole (see `bash-policy.ts`),
+ * because history and diffs are what a plan is grounded in.
+ * `/plan done` asks the model to finalize through `plan_ready`; that explicit
+ * terminating tool records the complete plan while keeping the write gate
+ * closed. A later `/plan` lets the user continue planning or prefill an
+ * implementation prompt in this session or a fresh linked session.
+ *
+ * SCOPE, deliberately stated: a `tool_call` handler gates only THIS
+ * interactive session. It cannot reach a headless subagent's or a workflow
+ * child's writes — those run in their own sessions.
+ *
+ * Delegation is still allowed, because that limitation is answered elsewhere:
+ * `subagent_spawn` narrows a child to `PLAN_MODE_CHILD_TOOLS` (see
+ * `../shared/plan-mode-state.ts`), and a child tool allowlist is enforced by
+ * the harness rather than by prompt. Blocking it outright was the first
+ * answer and it was the wrong trade: parallel read-only exploration, kept out
+ * of the main context, is one of the most useful things to do while planning.
+ * `workflow` stays blocked because `agent_type` is optional and the DSL has
+ * no run-wide plan-mode narrowing: an untyped or implementation call may
+ * still write. `subagent_send` stays blocked because it resumes a child that
+ * may predate the plan and still hold the full tool set.
+ */
+
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import { Type } from "typebox";
+import {
+  PLAN_MODE_CHANNEL,
+  type PlanModeState,
+} from "../shared/plan-mode-state.ts";
+import { sanitizeTerminalText } from "../shared/terminal-text.ts";
+import { planBashDecision } from "./bash-policy.ts";
+
+export const MAX_READY_PLAN_CHARS = 50_000;
+export const MAX_READY_PLAN_UTF8_BYTES = 48_000;
+export const PLAN_MODE_STATE_ENTRY = "my-pi-setup-plan-mode-state";
+
+export type PersistedPlanModeState =
+  | { version: 1; status: "inactive" | "planning" }
+  | { version: 1; status: "ready"; plan: string };
+
+export interface RestoredPlanModeState {
+  planning: boolean;
+  readyPlan?: string;
+  error?: string;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+function isBoundedReadyPlan(value: unknown): value is string {
+  return (
+    typeof value === "string" &&
+    sanitizeTerminalText(value) === value &&
+    value.trim().length > 0 &&
+    value.length <= MAX_READY_PLAN_CHARS &&
+    new TextEncoder().encode(value.trim()).byteLength <=
+      MAX_READY_PLAN_UTF8_BYTES
+  );
+}
+
+function decodePlanModeState(data: unknown): RestoredPlanModeState | undefined {
+  if (
+    !isRecord(data) ||
+    data.version !== 1 ||
+    typeof data.status !== "string"
+  ) {
+    return;
+  }
+  const keys = Object.keys(data).sort().join(",");
+  if (data.status === "inactive" || data.status === "planning") {
+    if (keys !== "status,version") return;
+    return { planning: data.status === "planning" };
+  }
+  if (data.status === "ready" && keys === "plan,status,version") {
+    if (!isBoundedReadyPlan(data.plan)) return;
+    return { planning: true, readyPlan: data.plan.trim() };
+  }
+}
+
+export function latestAssistantToolCallCount(entries: readonly unknown[]) {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (!isRecord(entry) || entry.type !== "message") continue;
+    const message = entry.message;
+    if (!isRecord(message) || message.role !== "assistant") continue;
+    if (!Array.isArray(message.content)) return 0;
+    return message.content.filter(
+      (part) => isRecord(part) && part.type === "toolCall",
+    ).length;
+  }
+  return 0;
+}
+
+export function planReadyBatchDecision(toolName: string, callCount: number) {
+  if (toolName !== "plan_ready" || callCount === 1) return;
+  return {
+    block: true as const,
+    reason:
+      "plan_ready must be the only tool call in its assistant message so Pi can terminate planning deterministically. Retry it alone after the other tool results return.",
+  };
+}
+
+/** Restore only the newest branch-local state; malformed state fails closed. */
+export function restorePlanModeState(
+  entries: readonly unknown[],
+): RestoredPlanModeState {
+  for (let index = entries.length - 1; index >= 0; index--) {
+    const entry = entries[index];
+    if (
+      !isRecord(entry) ||
+      entry.type !== "custom" ||
+      entry.customType !== PLAN_MODE_STATE_ENTRY
+    ) {
+      continue;
+    }
+    return (
+      decodePlanModeState(entry.data) ?? {
+        planning: true,
+        error:
+          "The latest persisted Plan Mode state is malformed; writes remain blocked. Use `/plan off` to clear it explicitly.",
+      }
+    );
+  }
+  return { planning: false };
+}
+
+export const PLAN_READY_ACTIONS = {
+  continue: "Continue planning",
+  current: "Implement in this session",
+  fresh: "Start a fresh session",
+} as const;
+
+export function buildPlanImplementationPrompt(plan: string) {
+  return [
+    "Implement the approved plan below. Re-check the repository state before editing, follow the project instructions, and verify the finished change.",
+    "",
+    "--- APPROVED PLAN ---",
+    plan,
+    "--- END APPROVED PLAN ---",
+  ].join("\n");
+}
+
+/**
+ * Fail-closed allow-list for planning. Unknown and newly installed tools are
+ * blocked until they are deliberately classified here as observational.
+ * `bash` is absent from this set on purpose but is NOT blocked outright:
+ * whether an arbitrary command is read-only cannot be decided by tool name, so
+ * it is decided one level down, per command, by `planBashDecision`.
+ */
+export const PLAN_SAFE_TOOLS = new Set([
+  // Local repository investigation.
+  "read",
+  "grep",
+  "find",
+  "ls",
+  "fd",
+  "rg",
+  // Web research without write actions.
+  "web_search",
+  "source_check",
+  "fetch_content",
+  "get_search_content",
+  // Read-only inspection of work already in flight.
+  "bg_status",
+  "bg_list",
+  "bg_watch",
+  "subagent_check",
+  "subagent_list",
+  "subagent_wait",
+  "workflow_status",
+  // Delegated investigation. Exploring several subsystems in parallel without
+  // dragging the noise into the main context is one of the most useful things
+  // to do while planning, so spawning is allowed — but only because the
+  // child's tool allowlist is enforced by the harness. See
+  // `plan-mode-state.ts`: subagents narrows a planning child to
+  // PLAN_MODE_CHILD_TOOLS, which has no write, edit, or bash in it. A
+  // tool_call handler could never gate a child's writes itself, since the
+  // child runs in its own session.
+  //
+  // `subagent_send` is NOT here for the same reason: it resumes an existing
+  // child's session, and one started before `/plan` was armed still holds the
+  // full tool set. Narrowing applies at spawn, so only spawning is safe.
+  "subagent_spawn",
+  // Advisory state reads and an explicit user clarification.
+  "tasks_list",
+  "get_goal",
+  "ask_user",
+  // The model's explicit, terminating transition from planning to ready.
+  "plan_ready",
+]);
+
+export const BLOCK_REASON =
+  "Plan mode is active: no changes yet. Keep investigating with read-only tools (read, fd, rg, web search, read-only bash like git log/diff/status, and subagent_spawn for parallel exploration — planning children get read-only tools). When the plan is decision-complete, call plan_ready alone with the complete Markdown plan; the user then chooses the next action with `/plan`, or cancels with `/plan off`.";
+
+export function planToolCallDecision(
+  toolName: string,
+  input?: Record<string, unknown>,
+) {
+  // Creating a worktree changes Git metadata before the child even starts;
+  // delegation is safe in plan mode only in the existing checkout.
+  if (toolName === "subagent_spawn" && input?.isolation === "worktree") {
+    return {
+      block: true as const,
+      reason: `Plan mode cannot create an isolated worktree. Omit isolation for read-only delegation. ${BLOCK_REASON}`,
+    };
+  }
+  if (PLAN_SAFE_TOOLS.has(toolName)) return;
+  // bash is decided per command, not per tool: the read-only investigation a
+  // plan is built on (history, diffs, PR state) lives behind it.
+  if (toolName === "bash") {
+    const decision = planBashDecision(input?.command);
+    if (decision.allowed) return;
+    return {
+      block: true as const,
+      reason: `${decision.reason ?? "plan mode could not verify this command is read-only"}. ${BLOCK_REASON}`,
+    };
+  }
+  return { block: true as const, reason: BLOCK_REASON };
+}
+
+export default function planMode(pi: ExtensionAPI) {
+  let planning = false;
+  let readyPlan: string | undefined;
+
+  /**
+   * Publish the stance and reflect it in the footer. Every place `planning`
+   * changes goes through here, because a subagent spawned while the broadcast
+   * was stale would be a child with write tools during a plan — the one thing
+   * this extension exists to prevent.
+   */
+  const setStatus = (ctx: {
+    hasUI: boolean;
+    ui: { setStatus: (key: string, value?: string) => void };
+  }) => {
+    pi.events.emit(PLAN_MODE_CHANNEL, { planning } satisfies PlanModeState);
+    if (!ctx.hasUI) return;
+    ctx.ui.setStatus(
+      "plan-mode",
+      readyPlan
+        ? "plan mode · ready"
+        : planning
+          ? "plan mode · read-only"
+          : undefined,
+    );
+  };
+
+  const commitPlanState = (
+    state: PersistedPlanModeState,
+    ctx: {
+      hasUI: boolean;
+      ui: { setStatus: (key: string, value?: string) => void };
+    },
+  ) => {
+    // Persist before mutating memory: a failed append must never open the gate
+    // or discard a ready plan only in RAM.
+    pi.appendEntry(PLAN_MODE_STATE_ENTRY, state);
+    planning = state.status !== "inactive";
+    readyPlan = state.status === "ready" ? state.plan : undefined;
+    setStatus(ctx);
+  };
+
+  const clearPlan = (ctx: {
+    hasUI: boolean;
+    ui: { setStatus: (key: string, value?: string) => void };
+  }) => {
+    commitPlanState({ version: 1, status: "inactive" }, ctx);
+  };
+
+  const continuePlanning = (ctx: ExtensionCommandContext) => {
+    commitPlanState({ version: 1, status: "planning" }, ctx);
+    ctx.ui.notify(
+      "Still in plan mode. Enter the revision you want; writes remain blocked.",
+      "info",
+    );
+  };
+
+  const implementHere = (ctx: ExtensionCommandContext) => {
+    if (!readyPlan) {
+      ctx.ui.notify("No ready plan is available.", "warning");
+      return;
+    }
+    if (!ctx.hasUI) {
+      ctx.ui.notify(
+        "Implementing a ready plan requires an interactive editor.",
+        "warning",
+      );
+      return;
+    }
+    const prompt = buildPlanImplementationPrompt(readyPlan);
+    ctx.ui.setEditorText(prompt);
+    clearPlan(ctx);
+    ctx.ui.notify(
+      "Plan mode is off. Review the implementation prompt, then submit it when ready.",
+      "info",
+    );
+  };
+
+  const implementFresh = async (ctx: ExtensionCommandContext) => {
+    if (!readyPlan) {
+      ctx.ui.notify("No ready plan is available.", "warning");
+      return;
+    }
+    if (!ctx.hasUI) {
+      ctx.ui.notify(
+        "Starting a fresh implementation requires an interactive editor.",
+        "warning",
+      );
+      return;
+    }
+    const prompt = buildPlanImplementationPrompt(readyPlan);
+    const parentSession = ctx.sessionManager.getSessionFile();
+    await ctx.waitForIdle();
+    const result = await ctx.newSession({
+      ...(parentSession ? { parentSession } : {}),
+      withSession: async (nextCtx) => {
+        nextCtx.ui.setEditorText(prompt);
+        nextCtx.ui.notify(
+          "Fresh implementation session ready. Review the prompt, then submit it when ready.",
+          "info",
+        );
+      },
+    });
+    if (result.cancelled) {
+      ctx.ui.notify(
+        "Fresh session cancelled; the plan is still ready.",
+        "info",
+      );
+    }
+  };
+
+  const showReadyActions = async (ctx: ExtensionCommandContext) => {
+    if (!readyPlan) {
+      ctx.ui.notify("No ready plan is available.", "warning");
+      return;
+    }
+    if (!ctx.hasUI) {
+      ctx.ui.notify(
+        "Use `/plan implement`, `/plan fresh`, or `/plan off` in a UI session.",
+        "warning",
+      );
+      return;
+    }
+    const choice = await ctx.ui.select(
+      "Plan Ready — choose what happens next",
+      Object.values(PLAN_READY_ACTIONS),
+    );
+    if (choice === PLAN_READY_ACTIONS.continue) {
+      continuePlanning(ctx);
+    } else if (choice === PLAN_READY_ACTIONS.current) {
+      implementHere(ctx);
+    } else if (choice === PLAN_READY_ACTIONS.fresh) {
+      await implementFresh(ctx);
+    }
+  };
+
+  pi.registerTool({
+    name: "plan_ready",
+    label: "Plan Ready",
+    description:
+      "Finish an active Plan Mode workflow with the complete implementation-ready Markdown plan. Call it alone as the final action only after research and material user decisions are complete.",
+    promptSnippet:
+      "Complete active Plan Mode with one explicit implementation-ready plan",
+    promptGuidelines: [
+      "When Plan Mode is active and the plan is decision-complete, call plan_ready alone as the final action with the complete Markdown plan; do not infer approval or begin implementation.",
+    ],
+    parameters: Type.Object({
+      plan: Type.String({
+        minLength: 1,
+        maxLength: MAX_READY_PLAN_CHARS,
+        description: "The complete implementation-ready Markdown plan",
+      }),
+    }),
+    async execute(_toolCallId, params, signal, _onUpdate, ctx) {
+      if (signal?.aborted) {
+        return {
+          content: [
+            { type: "text" as const, text: "Plan completion cancelled." },
+          ],
+          details: { status: "cancelled" as const },
+          terminate: true,
+        };
+      }
+      if (!planning) {
+        throw new Error("plan_ready requires active Plan Mode.");
+      }
+      const plan = sanitizeTerminalText(params.plan).trim();
+      if (!plan) throw new Error("plan_ready requires a non-empty plan.");
+      if (
+        new TextEncoder().encode(plan).byteLength > MAX_READY_PLAN_UTF8_BYTES
+      ) {
+        throw new Error(
+          `plan_ready plans must be at most ${MAX_READY_PLAN_UTF8_BYTES} UTF-8 bytes.`,
+        );
+      }
+      commitPlanState({ version: 1, status: "ready", plan }, ctx);
+      ctx.ui.notify(
+        "Plan ready. Run `/plan` to continue planning or prepare implementation.",
+        "info",
+      );
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: `Plan ready for explicit user action. No implementation has started.\n\n${plan}`,
+          },
+        ],
+        details: { status: "ready" as const, plan },
+        terminate: true,
+      };
+    },
+  });
+
+  pi.registerCommand("plan", {
+    description:
+      "Plan read-only, then use an explicit Plan Ready action: `/plan`, `/plan done`, `/plan implement`, `/plan fresh`, `/plan off`",
+    handler: async (rawArgs, ctx) => {
+      const action = rawArgs.trim().toLowerCase();
+
+      if (action === "off" || action === "cancel") {
+        clearPlan(ctx);
+        ctx.ui.notify("Plan mode off. No implementation was started.", "info");
+        return;
+      }
+
+      if (action === "implement" || action === "current") {
+        implementHere(ctx);
+        return;
+      }
+
+      if (action === "fresh") {
+        await implementFresh(ctx);
+        return;
+      }
+
+      if (action === "done" || action === "approve") {
+        if (readyPlan) {
+          await showReadyActions(ctx);
+          return;
+        }
+        if (!planning) {
+          ctx.ui.notify("Plan mode is not active.", "warning");
+          return;
+        }
+        pi.sendMessage(
+          {
+            customType: "plan-finalize-requested",
+            content:
+              "Finalize the plan now. Resolve any remaining material ambiguity with ask_user; otherwise call plan_ready alone with the complete implementation-ready Markdown plan. Do not implement it.",
+            display: true,
+            details: {},
+          },
+          { deliverAs: "followUp", triggerTurn: true },
+        );
+        return;
+      }
+
+      if (readyPlan && !action) {
+        await showReadyActions(ctx);
+        return;
+      }
+
+      if (planning) {
+        ctx.ui.notify(
+          "Plan mode is already active. `/plan done` requests completion; `/plan off` cancels.",
+          "info",
+        );
+        return;
+      }
+
+      commitPlanState({ version: 1, status: "planning" }, ctx);
+      const objective = rawArgs.trim();
+      pi.sendMessage(
+        {
+          customType: "plan-mode-armed",
+          content:
+            `Plan mode is on: investigate and propose a plan, but do not change anything yet. Edits and writes are blocked until the user explicitly chooses an implementation action. For files use the read, ls, grep and fd tools; bash is limited to read-only git and gh history commands such as \`git log\`, \`git diff\`, \`git status\`, \`git show\`, \`git blame\` and \`gh pr view\` — one plain command, no pipes or redirects. You can still delegate with \`subagent_spawn\` to explore several parts of the codebase at once: children spawned while planning receive read-only tools, so use them for investigation rather than for work to be done later.${objective ? `\n\nPlan for: ${objective}` : ""}` +
+            "\n\nUse read-only tools to ground the plan. When it is decision-complete, call `plan_ready` alone with the complete Markdown plan. That records the plan but does not start implementation; the user chooses the next action with `/plan`.",
+          display: true,
+          details: {},
+        },
+        { deliverAs: "followUp", triggerTurn: true },
+      );
+    },
+  });
+
+  pi.on("tool_call", (event, ctx) => {
+    if (!planning) return;
+    if (readyPlan) {
+      return {
+        block: true as const,
+        reason:
+          "The plan is ready and the write gate remains closed. Wait for the user to choose the next action with `/plan`; do not call more tools.",
+      };
+    }
+    const batchDecision =
+      event.toolName === "plan_ready"
+        ? planReadyBatchDecision(
+            event.toolName,
+            latestAssistantToolCallCount(ctx.sessionManager.getBranch()),
+          )
+        : undefined;
+    if (batchDecision) return batchDecision;
+    return planToolCallDecision(event.toolName, event.input);
+  });
+
+  const restoreRuntimeState = (ctx: ExtensionContext) => {
+    const restored = restorePlanModeState(ctx.sessionManager.getBranch());
+    planning = restored.planning;
+    readyPlan = restored.readyPlan;
+    setStatus(ctx);
+    if (restored.error) ctx.ui.notify(restored.error, "error");
+  };
+
+  pi.on("session_start", (_event, ctx) => {
+    restoreRuntimeState(ctx);
+  });
+
+  pi.on("session_tree", (_event, ctx) => {
+    restoreRuntimeState(ctx);
+  });
+
+  pi.on("session_shutdown", () => {
+    planning = false;
+    readyPlan = undefined;
+    // Broadcast without a ctx: subagents keeps its own copy of the stance, and
+    // leaving it armed would restrict children in whatever session comes next.
+    pi.events.emit(PLAN_MODE_CHANNEL, { planning } satisfies PlanModeState);
+  });
+}

package/extensions/post-edit/index.ts

@@ -0,0 +1,129 @@
+/**
+ * post-edit: run ONE configured command after a turn with successful Write/Edit operations.
+ *
+ * Deliberately not an event-hook engine. The trust surface is a single
+ * user-typed command string in the package config, off (empty) by default. The
+ * tool_result handler only flips a flag — it never awaits or executes, so it
+ * cannot slow or wedge the tool pipeline. Execution happens once per turn on
+ * agent_settled, which debounces an edit burst into a single run, and is
+ * fire-and-forget so a failing command cannot block the session.
+ */
+
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  loadSetupConfig,
+  SETUP_CONFIG_CHANGED_CHANNEL,
+} from "../shared/setup-config.ts";
+import { sanitizeTerminalText } from "../shared/terminal-text.ts";
+
+/** Tools whose success means a file on disk changed. */
+const MUTATING_TOOLS = new Set(["write", "edit"]);
+
+export default function postEdit(
+  pi: ExtensionAPI,
+  loadCommand: () => string = () => loadSetupConfig().postEdit.command,
+) {
+  let command = loadCommand();
+  let filesChanged = false;
+  let pendingRuns = 0;
+  let generation = 0;
+  let active: { controller: AbortController } | undefined;
+
+  // Re-read on change, matching the sibling extensions' pattern.
+  pi.events.on(SETUP_CONFIG_CHANGED_CHANNEL, () => {
+    command = loadCommand();
+    if (!command) pendingRuns = 0;
+  });
+
+  const runNext = (ctx: ExtensionContext, runGeneration: number) => {
+    if (
+      runGeneration !== generation ||
+      active ||
+      pendingRuns === 0 ||
+      !command
+    ) {
+      return;
+    }
+    pendingRuns--;
+    const ran = command;
+    const controller = new AbortController();
+    active = { controller };
+
+    // Notification is best-effort: the context can go stale (session change,
+    // shutdown) while the command runs, and a throwing notify must not become
+    // an unhandled rejection that takes the process down.
+    const warn = (message: string) => {
+      if (generation !== runGeneration) return;
+      try {
+        if (ctx.mode === "tui" && ctx.hasUI) {
+          ctx.ui.notify(sanitizeTerminalText(message), "warning");
+        }
+      } catch {
+        // Nothing better to do — the session that would have shown it is gone.
+      }
+    };
+
+    // Fire-and-forget: never block settlement on the command. Runs are drained
+    // serially so two closely settled changed turns cannot lose the latter.
+    void pi
+      .exec("sh", ["-c", ran], {
+        cwd: ctx.cwd,
+        signal: controller.signal,
+      })
+      .then((result) => {
+        if (result.code === 0) return;
+        const detail = sanitizeTerminalText(
+          result.stderr || result.stdout || "",
+        )
+          .trim()
+          .slice(0, 500);
+        warn(
+          `post-edit command failed (exit ${result.code}): ${sanitizeTerminalText(ran)}${detail ? `\n${detail}` : ""}`,
+        );
+      })
+      .catch((error: unknown) => {
+        const detail = error instanceof Error ? error.message : String(error);
+        warn(`post-edit command could not run: ${detail}`);
+      })
+      .finally(() => {
+        if (active?.controller === controller) active = undefined;
+        if (generation === runGeneration) runNext(ctx, runGeneration);
+      });
+  };
+
+  pi.on("tool_result", (event) => {
+    // Hot path: only a boolean flip. No await, no exec, no config read that
+    // could throw — anything heavier here would tax every tool call.
+    if (event.isError) return;
+    if (MUTATING_TOOLS.has(event.toolName)) filesChanged = true;
+  });
+
+  pi.on("agent_settled", (_event, ctx: ExtensionContext) => {
+    if (!filesChanged) return;
+    filesChanged = false;
+    // `hasUI` is also true in headless RPC mode. This command is intentionally
+    // limited to the interactive terminal session that configured it.
+    if (ctx.mode !== "tui" || !command) return;
+    pendingRuns++;
+    runNext(ctx, generation);
+  });
+
+  pi.on("session_start", () => {
+    generation++;
+    filesChanged = false;
+    pendingRuns = 0;
+    active?.controller.abort();
+    active = undefined;
+  });
+
+  pi.on("session_shutdown", () => {
+    generation++;
+    filesChanged = false;
+    pendingRuns = 0;
+    active?.controller.abort();
+    active = undefined;
+  });
+}

package/extensions/sessions/LICENSE.upstream

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+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.