pi-sage 0.2.0

package/.pi/extensions/sage/settings.ts

@@ -0,0 +1,202 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import type { ReasoningLevel, ToolProfile } from "./types.js";
+
+export type SettingsScope = "project" | "global";
+
+export interface ToolPolicySettings {
+  profile: ToolProfile;
+  customAllowedTools?: string[];
+  maxToolCalls?: number;
+  maxFilesRead?: number;
+  maxBytesPerFile?: number;
+  maxTotalBytesRead?: number;
+  sensitivePathDenylist?: string[];
+}
+
+export interface SageSettings {
+  enabled: boolean;
+  autonomousEnabled: boolean;
+  explicitRequestAlwaysAllowed: boolean;
+  invocationScope: "interactive-primary-only";
+  model: string;
+  reasoningLevel: ReasoningLevel;
+  timeoutMs: number;
+  maxCallsPerTurn: number;
+  maxCallsPerSession: number;
+  cooldownTurnsBetweenAutoCalls: number;
+  maxQuestionChars: number;
+  maxContextChars: number;
+  maxEstimatedCostPerSession?: number;
+  toolPolicy: ToolPolicySettings;
+}
+
+export interface LoadedSettings {
+  settings: SageSettings;
+  source: "project" | "global" | "default";
+  projectPath: string;
+  globalPath: string;
+}
+
+const DEFAULT_DENYLIST = [".env", ".env.", ".pem", ".key", "id_rsa", "credentials", "secrets"];
+
+export const DEFAULT_SAGE_SETTINGS: SageSettings = {
+  enabled: true,
+  autonomousEnabled: true,
+  explicitRequestAlwaysAllowed: true,
+  invocationScope: "interactive-primary-only",
+  model: "anthropic/claude-opus-4-6",
+  reasoningLevel: "high",
+  timeoutMs: 120000,
+  maxCallsPerTurn: 1,
+  maxCallsPerSession: 6,
+  cooldownTurnsBetweenAutoCalls: 1,
+  maxQuestionChars: 6000,
+  maxContextChars: 20000,
+  toolPolicy: {
+    profile: "read-only-lite",
+    maxToolCalls: 10,
+    maxFilesRead: 8,
+    maxBytesPerFile: 200 * 1024,
+    maxTotalBytesRead: 1024 * 1024,
+    sensitivePathDenylist: DEFAULT_DENYLIST
+  }
+};
+
+export function getProjectSettingsPath(cwd: string): string {
+  return join(cwd, ".pi", "sage-settings.json");
+}
+
+export function getGlobalSettingsPath(): string {
+  return join(homedir(), ".pi", "agent", "sage-settings.json");
+}
+
+function normalizeStringArray(value: unknown): string[] | undefined {
+  if (!Array.isArray(value)) return undefined;
+  return value.filter((item): item is string => typeof item === "string").map((item) => item.trim()).filter(Boolean);
+}
+
+function normalizeNumber(value: unknown): number | undefined {
+  if (typeof value !== "number" || Number.isFinite(value) === false) return undefined;
+  return value;
+}
+
+export function mergeSettings(override: Partial<SageSettings> | undefined): SageSettings {
+  const merged: SageSettings = {
+    ...DEFAULT_SAGE_SETTINGS,
+    ...override,
+    toolPolicy: {
+      ...DEFAULT_SAGE_SETTINGS.toolPolicy,
+      ...(override?.toolPolicy ?? {})
+    }
+  };
+
+  merged.timeoutMs = Math.max(1000, Math.floor(merged.timeoutMs));
+  merged.maxCallsPerTurn = Math.max(1, Math.floor(merged.maxCallsPerTurn));
+  merged.maxCallsPerSession = Math.max(1, Math.floor(merged.maxCallsPerSession));
+  merged.cooldownTurnsBetweenAutoCalls = Math.max(0, Math.floor(merged.cooldownTurnsBetweenAutoCalls));
+  merged.maxQuestionChars = Math.max(256, Math.floor(merged.maxQuestionChars));
+  merged.maxContextChars = Math.max(512, Math.floor(merged.maxContextChars));
+
+  const policy = merged.toolPolicy;
+  policy.maxToolCalls = Math.max(1, Math.floor(policy.maxToolCalls ?? 10));
+  policy.maxFilesRead = Math.max(1, Math.floor(policy.maxFilesRead ?? 8));
+  policy.maxBytesPerFile = Math.max(1024, Math.floor(policy.maxBytesPerFile ?? 200 * 1024));
+  policy.maxTotalBytesRead = Math.max(policy.maxBytesPerFile, Math.floor(policy.maxTotalBytesRead ?? 1024 * 1024));
+  policy.sensitivePathDenylist = normalizeStringArray(policy.sensitivePathDenylist) ?? [...DEFAULT_DENYLIST];
+
+  if (merged.maxEstimatedCostPerSession !== undefined && merged.maxEstimatedCostPerSession < 0) {
+    delete merged.maxEstimatedCostPerSession;
+  }
+
+  return merged;
+}
+
+function parseSettingsRaw(content: string): Partial<SageSettings> | undefined {
+  try {
+    const parsed = JSON.parse(content) as Record<string, unknown>;
+    const toolPolicyRaw = (parsed.toolPolicy ?? {}) as Record<string, unknown>;
+
+    const profile =
+      toolPolicyRaw.profile === "none" ||
+      toolPolicyRaw.profile === "read-only-lite" ||
+      toolPolicyRaw.profile === "custom-read-only" ||
+      toolPolicyRaw.profile === "git-review-readonly"
+        ? toolPolicyRaw.profile
+        : undefined;
+
+    const toolPolicy: ToolPolicySettings | undefined = profile
+      ? {
+          profile,
+          customAllowedTools: normalizeStringArray(toolPolicyRaw.customAllowedTools),
+          maxToolCalls: normalizeNumber(toolPolicyRaw.maxToolCalls),
+          maxFilesRead: normalizeNumber(toolPolicyRaw.maxFilesRead),
+          maxBytesPerFile: normalizeNumber(toolPolicyRaw.maxBytesPerFile),
+          maxTotalBytesRead: normalizeNumber(toolPolicyRaw.maxTotalBytesRead),
+          sensitivePathDenylist: normalizeStringArray(toolPolicyRaw.sensitivePathDenylist)
+        }
+      : undefined;
+
+    const raw: Partial<SageSettings> = {
+      enabled: typeof parsed.enabled === "boolean" ? parsed.enabled : undefined,
+      autonomousEnabled: typeof parsed.autonomousEnabled === "boolean" ? parsed.autonomousEnabled : undefined,
+      explicitRequestAlwaysAllowed:
+        typeof parsed.explicitRequestAlwaysAllowed === "boolean" ? parsed.explicitRequestAlwaysAllowed : undefined,
+      invocationScope:
+        parsed.invocationScope === "interactive-primary-only" ? "interactive-primary-only" : undefined,
+      model: typeof parsed.model === "string" ? parsed.model : undefined,
+      reasoningLevel:
+        parsed.reasoningLevel === "minimal" ||
+        parsed.reasoningLevel === "low" ||
+        parsed.reasoningLevel === "medium" ||
+        parsed.reasoningLevel === "high" ||
+        parsed.reasoningLevel === "xhigh"
+          ? parsed.reasoningLevel
+          : undefined,
+      timeoutMs: normalizeNumber(parsed.timeoutMs),
+      maxCallsPerTurn: normalizeNumber(parsed.maxCallsPerTurn),
+      maxCallsPerSession: normalizeNumber(parsed.maxCallsPerSession),
+      cooldownTurnsBetweenAutoCalls: normalizeNumber(parsed.cooldownTurnsBetweenAutoCalls),
+      maxQuestionChars: normalizeNumber(parsed.maxQuestionChars),
+      maxContextChars: normalizeNumber(parsed.maxContextChars),
+      maxEstimatedCostPerSession: normalizeNumber(parsed.maxEstimatedCostPerSession),
+      toolPolicy
+    };
+
+    return raw;
+  } catch {
+    return undefined;
+  }
+}
+
+function readSettingsFile(path: string): Partial<SageSettings> | undefined {
+  if (existsSync(path) === false) return undefined;
+  try {
+    return parseSettingsRaw(readFileSync(path, "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+export function loadSettings(cwd: string): LoadedSettings {
+  const projectPath = getProjectSettingsPath(cwd);
+  const globalPath = getGlobalSettingsPath();
+
+  const project = readSettingsFile(projectPath);
+  if (project) return { settings: mergeSettings(project), source: "project", projectPath, globalPath };
+
+  const global = readSettingsFile(globalPath);
+  if (global) return { settings: mergeSettings(global), source: "global", projectPath, globalPath };
+
+  return { settings: mergeSettings(undefined), source: "default", projectPath, globalPath };
+}
+
+export function saveSettings(path: string, settings: SageSettings): void {
+  mkdirSync(dirname(path), { recursive: true });
+  writeFileSync(path, `${JSON.stringify(settings, null, 2)}\n`, "utf8");
+}
+
+export function getSettingsPathForScope(cwd: string, scope: SettingsScope): string {
+  return scope === "project" ? getProjectSettingsPath(cwd) : getGlobalSettingsPath();
+}

package/.pi/extensions/sage/tool-policy.ts

@@ -0,0 +1,195 @@
+import type { BlockCode, ToolUsage, ToolProfile } from "./types.js";
+import type { ToolPolicySettings } from "./settings.js";
+
+export const READ_ONLY_LITE_TOOLS = ["ls", "glob", "grep", "read"] as const;
+export const GIT_REVIEW_READONLY_TOOLS = ["ls", "glob", "grep", "read", "bash"] as const;
+
+const CLI_TOOL_NAME_MAP: Record<string, string> = {
+  glob: "find"
+};
+
+const READ_ONLY_CUSTOM_ALLOWLIST = new Set(["ls", "glob", "find", "grep", "read"]);
+const HARD_DISALLOWED_TOOLS = new Set(["edit", "write", "bash", "sage_consult"]);
+
+const BASH_META_CHARS = /[;&|><`$\n\r]/;
+const SAFE_TOKEN = /^[A-Za-z0-9_./:@+=,~%-]+$/;
+
+const GIT_SUBCOMMAND_ALLOWLIST = new Set(["status", "diff", "show", "log", "blame", "rev-parse", "branch"]);
+
+export interface ResolvedToolPolicy {
+  profile: ToolPolicySettings["profile"];
+  allowedTools: string[];
+  cliTools: string[];
+  maxToolCalls: number;
+  maxFilesRead: number;
+  maxBytesPerFile: number;
+  maxTotalBytesRead: number;
+  sensitivePathDenylist: string[];
+}
+
+export function getDisallowedCustomTools(customAllowedTools: string[] | undefined): string[] {
+  if (!customAllowedTools) return [];
+  return customAllowedTools.filter((tool) => HARD_DISALLOWED_TOOLS.has(tool.trim()));
+}
+
+export function resolveToolPolicy(settings: ToolPolicySettings): ResolvedToolPolicy {
+  const requestedProfile = settings.profile;
+
+  if (requestedProfile === "none") {
+    return {
+      profile: "none",
+      allowedTools: [],
+      cliTools: [],
+      maxToolCalls: settings.maxToolCalls ?? 10,
+      maxFilesRead: settings.maxFilesRead ?? 8,
+      maxBytesPerFile: settings.maxBytesPerFile ?? 200 * 1024,
+      maxTotalBytesRead: settings.maxTotalBytesRead ?? 1024 * 1024,
+      sensitivePathDenylist: settings.sensitivePathDenylist ?? []
+    };
+  }
+
+  if (requestedProfile === "read-only-lite") {
+    const allowedTools = [...READ_ONLY_LITE_TOOLS];
+    return {
+      profile: "read-only-lite",
+      allowedTools,
+      cliTools: toCliTools(allowedTools),
+      maxToolCalls: settings.maxToolCalls ?? 10,
+      maxFilesRead: settings.maxFilesRead ?? 8,
+      maxBytesPerFile: settings.maxBytesPerFile ?? 200 * 1024,
+      maxTotalBytesRead: settings.maxTotalBytesRead ?? 1024 * 1024,
+      sensitivePathDenylist: settings.sensitivePathDenylist ?? []
+    };
+  }
+
+  if (requestedProfile === "git-review-readonly") {
+    const allowedTools = [...GIT_REVIEW_READONLY_TOOLS];
+    return {
+      profile: "git-review-readonly",
+      allowedTools,
+      cliTools: toCliTools(allowedTools),
+      maxToolCalls: settings.maxToolCalls ?? 20,
+      maxFilesRead: settings.maxFilesRead ?? 20,
+      maxBytesPerFile: settings.maxBytesPerFile ?? 300 * 1024,
+      maxTotalBytesRead: settings.maxTotalBytesRead ?? 2 * 1024 * 1024,
+      sensitivePathDenylist: settings.sensitivePathDenylist ?? []
+    };
+  }
+
+  const requested = settings.customAllowedTools ?? [];
+  const filtered = requested
+    .map((tool) => tool.trim())
+    .filter(Boolean)
+    .filter((tool) => HARD_DISALLOWED_TOOLS.has(tool) === false)
+    .filter((tool) => READ_ONLY_CUSTOM_ALLOWLIST.has(tool));
+
+  const deduped = [...new Set(filtered)];
+
+  return {
+    profile: "custom-read-only",
+    allowedTools: deduped,
+    cliTools: toCliTools(deduped),
+    maxToolCalls: settings.maxToolCalls ?? 10,
+    maxFilesRead: settings.maxFilesRead ?? 8,
+    maxBytesPerFile: settings.maxBytesPerFile ?? 200 * 1024,
+    maxTotalBytesRead: settings.maxTotalBytesRead ?? 1024 * 1024,
+    sensitivePathDenylist: settings.sensitivePathDenylist ?? []
+  };
+}
+
+function toCliTools(allowedTools: string[]): string[] {
+  const mapped = allowedTools.map((tool) => CLI_TOOL_NAME_MAP[tool] ?? tool);
+  return [...new Set(mapped)];
+}
+
+export function checkVolumeCaps(
+  usage: ToolUsage,
+  policy: Pick<ResolvedToolPolicy, "maxToolCalls" | "maxFilesRead" | "maxBytesPerFile" | "maxTotalBytesRead">
+): { ok: boolean; blockCode?: BlockCode; reason: string } {
+  if (usage.callsUsed > policy.maxToolCalls) {
+    return { ok: false, blockCode: "volume-cap", reason: "Exceeded max tool calls" };
+  }
+  if (usage.filesRead > policy.maxFilesRead) {
+    return { ok: false, blockCode: "volume-cap", reason: "Exceeded max files read" };
+  }
+  if (usage.bytesRead > policy.maxTotalBytesRead) {
+    return { ok: false, blockCode: "volume-cap", reason: "Exceeded max total bytes read" };
+  }
+  return { ok: true, reason: "within caps" };
+}
+
+export function isPathAllowed(
+  targetPath: string,
+  workspaceRoots: string[],
+  denylist: string[]
+): { ok: boolean; blockCode?: BlockCode; reason: string } {
+  const normalizedPath = normalizePath(targetPath);
+  const normalizedRoots = workspaceRoots.map(normalizePath);
+  const isInWorkspace = normalizedRoots.some((root) => normalizedPath.startsWith(root));
+
+  if (isInWorkspace === false) {
+    return { ok: false, blockCode: "path-denied", reason: "Path is outside workspace roots" };
+  }
+
+  const match = denylist.find((entry) => normalizedPath.includes(entry.toLowerCase()));
+  if (match) {
+    return { ok: false, blockCode: "path-denied", reason: `Path matches denylist entry: ${match}` };
+  }
+
+  return { ok: true, reason: "allowed" };
+}
+
+export function validateBashCommandForProfile(
+  profile: ToolProfile,
+  command: string
+): { ok: boolean; blockCode?: BlockCode; reason: string } {
+  if (profile !== "git-review-readonly") {
+    return { ok: false, blockCode: "tool-disallowed", reason: "bash is only allowed in git-review-readonly profile" };
+  }
+
+  const trimmed = command.trim();
+  if (!trimmed) {
+    return { ok: false, blockCode: "tool-disallowed", reason: "Empty bash command" };
+  }
+
+  if (BASH_META_CHARS.test(trimmed)) {
+    return { ok: false, blockCode: "tool-disallowed", reason: "Shell control characters are not allowed" };
+  }
+
+  const tokens = trimmed.split(/\s+/).filter(Boolean);
+  if (tokens.length < 2 || tokens[0] !== "git") {
+    return { ok: false, blockCode: "tool-disallowed", reason: "Only git read-only commands are allowed" };
+  }
+
+  const subcommand = tokens[1] ?? "";
+  if (!GIT_SUBCOMMAND_ALLOWLIST.has(subcommand)) {
+    return { ok: false, blockCode: "tool-disallowed", reason: `Git subcommand not allowed: ${subcommand}` };
+  }
+
+  for (const token of tokens.slice(2)) {
+    if (!SAFE_TOKEN.test(token)) {
+      return { ok: false, blockCode: "tool-disallowed", reason: `Unsafe token in command: ${token}` };
+    }
+  }
+
+  if (subcommand === "branch") {
+    const args = tokens.slice(2);
+    if (args.length !== 1 || args[0] !== "--show-current") {
+      return { ok: false, blockCode: "tool-disallowed", reason: "Only 'git branch --show-current' is allowed" };
+    }
+  }
+
+  if (subcommand === "rev-parse") {
+    const args = tokens.slice(2);
+    const allowedArgs = new Set(["--abbrev-ref", "HEAD"]);
+    if (args.some((arg) => !allowedArgs.has(arg))) {
+      return { ok: false, blockCode: "tool-disallowed", reason: "Unsupported git rev-parse arguments" };
+    }
+  }
+
+  return { ok: true, reason: "allowed" };
+}
+
+function normalizePath(pathValue: string): string {
+  return pathValue.replace(/\\/g, "/").toLowerCase();
+}

package/.pi/extensions/sage/types.ts

@@ -0,0 +1,108 @@
+export type SageMode = "autonomous" | "user-requested";
+
+export type ReasoningLevel = "minimal" | "low" | "medium" | "high" | "xhigh";
+
+export type Objective = "debug" | "design" | "review" | "refactor" | "general";
+
+export type Urgency = "low" | "medium" | "high";
+
+export type BlockCode =
+  | "ineligible-caller"
+  | "non-interactive"
+  | "ci-mode"
+  | "rpc-role"
+  | "subagent"
+  | "unknown-context"
+  | "tool-disallowed"
+  | "path-denied"
+  | "volume-cap"
+  | "disabled"
+  | "model-unavailable"
+  | "timeout"
+  | "cost-cap"
+  | "soft-limit"
+  | "execution-error";
+
+export interface CallerContext {
+  session: { interactive: boolean };
+  agent: {
+    role: string;
+    isSubagent: boolean;
+    isRpcOrchestrated: boolean;
+  };
+  runtime: { mode: "interactive" | "ci" | "non-interactive" | "rpc" };
+}
+
+export interface CallerDecision {
+  ok: boolean;
+  reason: string;
+  blockCode?: BlockCode;
+}
+
+export type ToolProfile = "none" | "read-only-lite" | "custom-read-only" | "git-review-readonly";
+
+export interface ToolPolicyCaps {
+  maxToolCalls: number;
+  maxFilesRead: number;
+  maxBytesPerFile: number;
+  maxTotalBytesRead: number;
+}
+
+export interface ToolUsage {
+  profile: ToolProfile;
+  callsUsed: number;
+  filesRead: number;
+  bytesRead: number;
+}
+
+export interface UsageBreakdown {
+  input: number;
+  output: number;
+  cacheRead: number;
+  cacheWrite: number;
+  totalTokens: number;
+  costTotal?: number;
+}
+
+export interface SagePolicyMetadata {
+  mode: SageMode;
+  allowedByContext: boolean;
+  contextReason?: string;
+  blockCode?: BlockCode;
+  allowedByBudget: boolean;
+  budgetReason?: string;
+}
+
+export interface SageConsultDetails {
+  model: string;
+  reasoningLevel: ReasoningLevel;
+  latencyMs: number;
+  stopReason: string;
+  usage?: UsageBreakdown;
+  toolUsage?: ToolUsage;
+  policy: SagePolicyMetadata;
+}
+
+export interface SageToolResult {
+  content: Array<{ type: "text"; text: string }>;
+  details: SageConsultDetails;
+  isError?: boolean;
+}
+
+export interface SageConsultInput {
+  question: string;
+  context?: string;
+  files?: string[];
+  evidence?: string[];
+  objective?: Objective;
+  urgency?: Urgency;
+  force?: boolean;
+}
+
+export interface SageBudgetState {
+  currentTurn: number;
+  callsThisTurn: number;
+  sessionCalls: number;
+  lastAutoTurn: number | undefined;
+  sessionCostTotal: number;
+}

package/AGENTS.md

@@ -0,0 +1,87 @@
+# Sage Project North Star (agents.md)
+
+This file is the entry point for contributors and autonomous agents working in this repository.
+
+## 1) Mission
+
+Build Sage as a **safe, advisory, interactive-only reasoning assistant** for Pi.
+
+Sage should improve decision quality for complex tasks while preserving strict safety and control boundaries.
+
+## 2) Product Invariants (Do Not Violate)
+
+1. Sage invocation is restricted to **interactive top-level primary** sessions.
+2. RPC-orchestrated roles (`supervisor`, `worker`, `reviewer`, `merger`) cannot invoke Sage.
+3. Sage is **single-shot** per call.
+4. Sage cannot recursively invoke Sage.
+5. Sage is **advisory-only** (analysis/recommendations, not implementation execution).
+6. Unknown caller context is denied by default.
+
+## 3) Canonical Project Documents
+
+Read in this order:
+
+1. `docs/SAGE_SPEC.md` — locked product/architecture contract (implementation baseline)
+2. `docs/coding-standards.md` — implementation standards and review checklist
+3. `docs/testing-standards.md` — required quality gates and test methodology
+4. `docs/interactive-e2e-harness.md` — interactive-only E2E strategy (tmux-driven)
+
+If docs conflict, resolve by updating the spec and standards together in the same change.
+
+## 4) Engineering Priorities (in order)
+
+1. **Safety & policy correctness**
+2. **Deterministic behavior and clear blocking semantics**
+3. **Observability and debuggability**
+4. **Developer ergonomics**
+5. **Performance/cost optimization**
+
+## 5) Development Workflow Expectations
+
+For every meaningful code change:
+
+1. Update implementation
+2. Run quality gates (including lint)
+3. Run tests appropriate to change scope
+4. Update docs when behavior/contract changes
+
+Minimum continuous test gates:
+- lint
+- typecheck
+- unit
+- integration
+- e2e (for behavior-impacting changes)
+
+Testing runner policy:
+- Use Node’s built-in test runner (`node:test` via `node --test`) for all test layers.
+- Vitest is not permitted in this repository.
+
+## 6) Definition of Ready for Implementation Tasks
+
+Before coding, ensure:
+- scope is clear and mapped to spec section(s)
+- acceptance criteria are explicit
+- safety/policy impact is identified
+- required tests are listed
+
+## 7) Definition of Done for Implementation Tasks
+
+A task is complete when:
+- behavior matches `docs/SAGE_SPEC.md`
+- coding standards are satisfied
+- testing standards pass (including lint)
+- docs/spec are updated for contract changes
+- no regression in caller gating, tool policy, or recursion protections
+
+## 8) Change Management Guidance
+
+For policy-sensitive changes (caller scope, tool access, recursion, safety limits), require:
+- explicit rationale in PR notes
+- test updates in the same PR
+- acceptance criteria updates when applicable
+
+## 9) Repo Intent
+
+This repository is currently spec-and-foundation heavy. Prefer small, verifiable increments over broad changes.
+
+When uncertain: choose stricter safety defaults and document the decision.

package/LICENSE

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