@oriro/orirocli 0.1.0

package/skills/taskflow/SKILL.md

@@ -0,0 +1,153 @@
+---
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+watermark: ORIRO
+disable-model-invocation: true
+name: taskflow
+description: "Coordinate multi-step detached tasks as one durable TaskFlow job with owner context, state, waits, and child tasks."
+metadata: { "oriro": { "emoji": "🪝" } }
+---
+
+# TaskFlow
+
+Use TaskFlow when a job needs to outlive one prompt or one detached run, but you still want one owner session, one return context, and one place to inspect or resume the work.
+
+## When to use it
+
+- Multi-step background work with one owner
+- Work that waits on detached ACP or subagent tasks
+- Jobs that may need to emit one clear update back to the owner
+- Jobs that need small persisted state between steps
+- Plugin or tool work that must survive restarts and revision conflicts cleanly
+
+## What TaskFlow owns
+
+- flow identity
+- owner session and requester origin
+- `currentStep`, `stateJson`, and `waitJson`
+- linked child tasks and their parent flow id
+- finish, fail, cancel, waiting, and blocked state
+- revision tracking for conflict-safe mutations
+
+It does **not** own branching or business logic. Put that in Lobster, acpx, or the calling code.
+
+## Current runtime shape
+
+Canonical plugin/runtime entrypoint:
+
+- `api.runtime.tasks.flow`
+- `api.runtime.taskFlow` still exists as an alias, but `api.runtime.tasks.flow` is the canonical shape
+
+Binding:
+
+- `api.runtime.tasks.flow.fromToolContext(ctx)` when you already have trusted tool context with `sessionKey`
+- `api.runtime.tasks.flow.bindSession({ sessionKey, requesterOrigin })` when your binding layer already resolved the session and delivery context
+
+Managed-flow lifecycle:
+
+1. `createManaged(...)`
+2. `runTask(...)`
+3. `setWaiting(...)` when waiting on a person or an external system
+4. `resume(...)` when work can continue
+5. `finish(...)` or `fail(...)`
+6. `requestCancel(...)` or `cancel(...)` when the whole job should stop
+
+## Design constraints
+
+- Use **managed** TaskFlows when your code owns the orchestration.
+- One-task **mirrored** flows are created by core runtime for detached ACP/subagent work; this skill is mainly about managed flows.
+- Treat `stateJson` as the persisted state bag. There is no separate `setFlowOutput` or `appendFlowOutput` API.
+- Every mutating method after creation is revision-checked. Carry forward the latest `flow.revision` after each successful mutation.
+- `runTask(...)` links the child task to the flow. Use it instead of manually creating detached tasks when you want parent orchestration.
+
+## Example shape
+
+```ts
+const taskFlow = api.runtime.tasks.flow.fromToolContext(ctx);
+
+const created = taskFlow.createManaged({
+  controllerId: "my-plugin/inbox-triage",
+  goal: "triage inbox",
+  currentStep: "classify",
+  stateJson: {
+    businessThreads: [],
+    personalItems: [],
+    eodSummary: [],
+  },
+});
+
+const classify = taskFlow.runTask({
+  flowId: created.flowId,
+  runtime: "acp",
+  childSessionKey: "agent:main:subagent:classifier",
+  runId: "inbox-classify-1",
+  task: "Classify inbox messages",
+  status: "running",
+  startedAt: Date.now(),
+  lastEventAt: Date.now(),
+});
+
+if (!classify.created) {
+  throw new Error(classify.reason);
+}
+
+const waiting = taskFlow.setWaiting({
+  flowId: created.flowId,
+  expectedRevision: created.revision,
+  currentStep: "await_business_reply",
+  stateJson: {
+    businessThreads: ["slack:thread-1"],
+    personalItems: [],
+    eodSummary: [],
+  },
+  waitJson: {
+    kind: "reply",
+    channel: "slack",
+    threadKey: "slack:thread-1",
+  },
+});
+
+if (!waiting.applied) {
+  throw new Error(waiting.code);
+}
+
+const resumed = taskFlow.resume({
+  flowId: waiting.flow.flowId,
+  expectedRevision: waiting.flow.revision,
+  status: "running",
+  currentStep: "finalize",
+  stateJson: waiting.flow.stateJson,
+});
+
+if (!resumed.applied) {
+  throw new Error(resumed.code);
+}
+
+taskFlow.finish({
+  flowId: resumed.flow.flowId,
+  expectedRevision: resumed.flow.revision,
+  stateJson: resumed.flow.stateJson,
+});
+```
+
+## Keep conditionals above the runtime
+
+Use the flow runtime for state and task linkage. Keep decisions in the authoring layer:
+
+- `business` -> post to Slack and wait
+- `personal` -> notify the owner now
+- `later` -> append to an end-of-day summary bucket
+
+## Operational pattern
+
+- Store only the minimum state needed to resume.
+- Put human-readable wait reasons in `blockedSummary` or structured wait metadata in `waitJson`.
+- Use `getTaskSummary(flowId)` when the orchestrator needs a compact health view of child work.
+- Use `requestCancel(...)` when a caller wants the flow to stop scheduling immediately.
+- Use `cancel(...)` when you also want active linked child tasks cancelled.
+
+## Examples
+
+- See `skills/taskflow/examples/inbox-triage.lobster`
+- See `skills/taskflow/examples/pr-intake.lobster`
+- See `skills/taskflow-inbox-triage/SKILL.md` for a concrete routing pattern

package/skills/taskflow/examples/inbox-triage.lobster

@@ -0,0 +1,33 @@
+# Illustrative Lobster authoring example for a TaskFlow-style inbox triage job.
+# Swap the placeholder commands for your own tools or scripts.
+
+name: inbox-triage
+steps:
+  - id: fetch
+    command: gog.gmail.search --query 'newer_than:1d' --max 20
+
+  - id: classify
+    command: >-
+      oriro.invoke --tool llm-task --action json --args-json
+      '{"prompt":"Classify each inbox item as business, personal, or later. Return one JSON object per item with route and summary.","thinking":"low","schema":{"type":"object","properties":{"items":{"type":"array"}},"required":["items"],"additionalProperties":false}}'
+    stdin: $fetch.stdout
+
+  - id: post_business
+    command: slack-route --bucket business
+    stdin: $classify.stdout
+    condition: $classify.json.items[0].route == "business"
+
+  - id: wait_for_business_reply
+    command: echo '{"status":"waiting","reason":"slack_reply"}'
+    condition: $classify.json.items[0].route == "business"
+
+  - id: notify_personal
+    command: >-
+      oriro.invoke --tool message --action send --args-json
+      '{"provider":"telegram","to":"owner-thread","content":"Personal inbox item needs attention."}'
+    condition: $classify.json.items[0].route == "personal"
+
+  - id: stash_for_eod
+    command: summary-append --bucket eod
+    stdin: $classify.stdout
+    condition: $classify.json.items[0].route == "later"

package/skills/taskflow/examples/pr-intake.lobster

@@ -0,0 +1,32 @@
+# Illustrative Lobster authoring example for a TaskFlow-style PR intake lane.
+# Replace the placeholder commands with repo-specific tooling.
+
+name: pr-intake
+steps:
+  - id: fetch
+    command: gh pr list --repo owner/repo --state open --json number,title,body,headRefName
+
+  - id: classify
+    command: >-
+      oriro.invoke --tool llm-task --action json --args-json
+      '{"prompt":"Classify each PR as close, request_changes, refactor, or maintainer_review. Return intent and recommended next action.","thinking":"low","schema":{"type":"object","properties":{"items":{"type":"array"}},"required":["items"],"additionalProperties":false}}'
+    stdin: $fetch.stdout
+
+  - id: close_low_signal
+    command: pr-close-low-signal
+    stdin: $classify.stdout
+    condition: $classify.json.items[0].nextAction == "close"
+
+  - id: request_changes
+    command: pr-request-changes
+    stdin: $classify.stdout
+    condition: $classify.json.items[0].nextAction == "request_changes"
+
+  - id: refactor_branch
+    command: pr-refactor-branch
+    stdin: $classify.stdout
+    condition: $classify.json.items[0].nextAction == "refactor"
+
+  - id: escalate
+    command: echo '{"status":"notify","target":"maintainer"}'
+    condition: $classify.json.items[0].nextAction == "maintainer_review"

package/skills/taskflow-inbox-triage/SKILL.md

@@ -0,0 +1,123 @@
+---
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+watermark: ORIRO
+disable-model-invocation: true
+name: taskflow-inbox-triage
+description: "Example TaskFlow pattern for inbox triage, intent routing, waiting on replies, and later summaries."
+metadata: { "oriro": { "emoji": "📥" } }
+---
+
+# TaskFlow inbox triage
+
+This is a concrete example of how to think about TaskFlow without turning the core runtime into a DSL.
+
+## Goal
+
+Triage inbox items with one owner flow:
+
+- business -> post to Slack and wait for reply
+- personal -> notify the owner now
+- everything else -> keep for end-of-day summary
+
+## Pattern
+
+1. Create one flow for the inbox batch.
+2. Run one detached task to classify new items.
+3. Persist the routing state in `stateJson`.
+4. Move to `waiting` only when an outside reply is required.
+5. Resume the flow when classification or human input completes.
+6. Finish when the batch has been routed.
+
+## Suggested `stateJson` shape
+
+```json
+{
+  "businessThreads": [],
+  "personalItems": [],
+  "eodSummary": []
+}
+```
+
+Suggested `waitJson` when blocked on Slack:
+
+```json
+{
+  "kind": "reply",
+  "channel": "slack",
+  "threadKey": "slack:thread-1"
+}
+```
+
+## Minimal runtime calls
+
+```ts
+const taskFlow = api.runtime.tasks.flow.fromToolContext(ctx);
+
+const created = taskFlow.createManaged({
+  controllerId: "my-plugin/inbox-triage",
+  goal: "triage inbox",
+  currentStep: "classify",
+  stateJson: {
+    businessThreads: [],
+    personalItems: [],
+    eodSummary: [],
+  },
+});
+
+const child = taskFlow.runTask({
+  flowId: created.flowId,
+  runtime: "acp",
+  childSessionKey: "agent:main:subagent:classifier",
+  task: "Classify inbox messages",
+  status: "running",
+  startedAt: Date.now(),
+  lastEventAt: Date.now(),
+});
+
+if (!child.created) {
+  throw new Error(child.reason);
+}
+
+const waiting = taskFlow.setWaiting({
+  flowId: created.flowId,
+  expectedRevision: created.revision,
+  currentStep: "await_business_reply",
+  stateJson: {
+    businessThreads: ["slack:thread-1"],
+    personalItems: [],
+    eodSummary: [],
+  },
+  waitJson: {
+    kind: "reply",
+    channel: "slack",
+    threadKey: "slack:thread-1",
+  },
+});
+
+if (!waiting.applied) {
+  throw new Error(waiting.code);
+}
+
+const resumed = taskFlow.resume({
+  flowId: waiting.flow.flowId,
+  expectedRevision: waiting.flow.revision,
+  status: "running",
+  currentStep: "route_items",
+  stateJson: waiting.flow.stateJson,
+});
+
+if (!resumed.applied) {
+  throw new Error(resumed.code);
+}
+
+taskFlow.finish({
+  flowId: resumed.flow.flowId,
+  expectedRevision: resumed.flow.revision,
+  stateJson: resumed.flow.stateJson,
+});
+```
+
+## Related example
+
+- `skills/taskflow/examples/inbox-triage.lobster`

package/skills/technical/ai-ethics/LICENSE

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

package/skills/technical/ai-ethics/SKILL.md

@@ -0,0 +1,92 @@
+---
+watermark: ORIRO
+name: ai-ethics
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+description: >
+
+
+
+  AI ethics — bias, fairness, transparency, privacy, safety, responsible AI development, and AI governance.
+
+  Sources: Technical documentation, public guidelines, industry best practices.
+---
+
+# AI Ethics
+
+## Core principles
+
+**Fairness:** AI systems should not discriminate based on race, gender, religion, disability, or other protected characteristics.
+**Accountability:** Clear responsibility for AI system behavior. Humans must remain responsible for consequential AI decisions.
+**Transparency:** Users should know when AI is making decisions affecting them and understand how.
+**Privacy:** AI systems must handle personal data in accordance with privacy laws and ethical principles.
+**Safety:** AI systems should behave as intended and avoid harmful outcomes.
+**Human oversight:** High-stakes AI decisions should have meaningful human review.
+
+## Bias in AI systems
+
+### Types of bias
+
+**Training data bias:** Model trained on historical data that reflects historical discrimination. Predicts past patterns → perpetuates them.
+Example: Résumé screening model trained on past hires (mostly white males in tech) → learns to penalize female names, women's colleges.
+
+**Measurement bias:** What you measure poorly reflects what you care about. Predictive policing: arrests ≠ crime (over-policed communities have more arrests → model sends more police → circular).
+
+**Feedback loops:** Model predictions change the world in ways that reinforce the model's predictions.
+
+**Representation bias:** Training data doesn't represent all users. Face recognition performs worse on darker skin tones when trained mostly on lighter skin images.
+
+### Testing for fairness
+
+**Demographic parity:** Positive prediction rate equal across groups.
+**Equal opportunity:** True positive rate equal across groups (pass rates equal for qualified individuals).
+**Predictive parity:** Precision equal across groups.
+Note: These definitions are mathematically incompatible in most real-world scenarios.
+
+**Fairness tools:** IBM AI Fairness 360 (open source), Google What-If Tool, Microsoft Fairlearn.
+
+## Privacy in AI
+
+**Training data:** Collecting training data must comply with GDPR/CCPA. Consent for specific use.
+**Model memorization:** Large models can memorize and regurgitate training data (including PII). Differential privacy techniques reduce this risk.
+**Inference from predictions:** Even anonymized predictions can reveal sensitive information through inference.
+**Right to explanation (GDPR Article 22):** Automated decisions with significant effects on individuals → right to explanation and human review.
+
+## Explainability / Interpretability
+
+**Interpretable models:** Linear regression, decision trees — you can understand why they predict what they predict.
+**Black-box models:** Deep learning, large ensembles — high performance but opaque.
+**Post-hoc explanation tools:** LIME, SHAP — explain individual predictions from any model.
+**When required:** High-stakes decisions (credit, hiring, bail, medical), regulatory compliance, debugging biased behavior.
+
+## Responsible AI development
+
+### Technical practices
+
+- Curate training data carefully. Audit for representation.
+- Evaluate model performance across demographic subgroups, not just overall.
+- Test for adversarial inputs.
+- Monitor production for distribution shift and bias drift.
+- Document model cards (model capabilities, limitations, intended use, out-of-scope uses, evaluation results).
+
+### Process practices
+
+- Diverse development teams (different perspectives catch more problems).
+- Ethical review before deployment for high-stakes applications.
+- User research with affected communities.
+- Incident response plan for when model causes harm.
+- Ongoing monitoring, not just pre-deployment evaluation.
+
+## AI safety
+
+**Alignment:** AI systems pursuing the goals humans actually intend, not proximate goals that fail at scale.
+Classic example: Maximize paperclips → convert all matter to paperclips (Bostrom).
+Real examples: Social media optimizing engagement → optimizes for outrage. Ad systems optimizing clicks → fraud.
+
+**Current concerns:**
+Misinformation: Generative AI makes cheap creation of misleading content.
+Deepfakes: Synthetic media eroding trust in authentic media.
+Automation displacement: Economic impacts on workers.
+Dual use: AI capabilities used for both beneficial and harmful purposes.
+
+Sources: NIST AI Risk Management Framework (nist.gov/aiRMF — free), EU AI Act (eur-lex.europa.eu — free), Montreal Declaration for Responsible AI (free), ACM FAccT conference papers (many open access), Partnership on AI (partnershiponai.org — free)

package/skills/technical/ai-product-builder/LICENSE

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

package/skills/technical/ai-product-builder/SKILL.md

@@ -0,0 +1,180 @@
+---
+watermark: ORIRO
+name: ai-product-builder
+provider: ORIRO.ai
+copyright: Copyright (c) 2026 ORIRO.ai
+description: >
+
+
+
+  AI product development — LLM integration, RAG, prompt engineering, AI UX patterns, streaming, and building with AI APIs.
+
+
+  Sources: Stripe docs, Anthropic docs, Sanity/Contentful docs, industry-specific technical resources.
+---
+
+# AI Product Development
+
+## LLM integration fundamentals
+
+### Calling the API (Anthropic)
+
+```ts
+import Anthropic from "@anthropic-ai/sdk";
+
+const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
+
+const response = await client.messages.create({
+  model: "claude-opus-4-5", // or claude-sonnet-4-5, claude-haiku-4-5-20251001
+  max_tokens: 1024,
+  system: "You are a helpful assistant for a financial planning app.",
+  messages: [{ role: "user", content: userMessage }],
+});
+
+const text = response.content[0].type === "text" ? response.content[0].text : "";
+```
+
+### Streaming responses (essential for good UX)
+
+```ts
+// Long AI responses should stream — users see output as it generates
+const stream = await client.messages.create({
+  model: 'claude-sonnet-4-5',
+  max_tokens: 2048,
+  stream: true,
+  messages: [{ role: 'user', content: prompt }],
+});
+
+// In Next.js App Router:
+export async function POST(req: Request) {
+  const body = await req.json();
+  const encoder = new TextEncoder();
+  const stream = new ReadableStream({
+    async start(controller) {
+      const anthropicStream = client.messages.stream({ ... });
+      for await (const event of anthropicStream) {
+        if (event.type === 'content_block_delta' && event.delta.type === 'text_delta') {
+          controller.enqueue(encoder.encode(event.delta.text));
+        }
+      }
+      controller.close();
+    }
+  });
+  return new Response(stream, { headers: { 'Content-Type': 'text/plain; charset=utf-8' } });
+}
+```
+
+## RAG (Retrieval Augmented Generation)
+
+### Why RAG
+
+LLMs have knowledge cutoffs. RAG = search your own data, inject into context.
+Better than fine-tuning for: changing data, specific documents, proprietary knowledge.
+
+### RAG pipeline
+
+```
+User query → Embed query → Vector search → Top-k chunks → Augmented prompt → LLM → Answer
+```
+
+### Implementation
+
+```ts
+import OpenAI from "openai"; // or use Anthropic for embeddings
+import { Pinecone } from "@pinecone-database/pinecone";
+
+// 1. Embed user query
+const embedding = await openai.embeddings.create({
+  model: "text-embedding-3-small",
+  input: userQuery,
+});
+
+// 2. Search vector store
+const results = await pinecone.index("knowledge-base").query({
+  vector: embedding.data[0].embedding,
+  topK: 5,
+  includeMetadata: true,
+});
+
+// 3. Build augmented prompt
+const context = results.matches.map((m) => m.metadata.text).join("\n\n");
+const augmentedPrompt = `
+Context information:
+${context}
+
+User question: ${userQuery}
+
+Answer based on the context above. If the information isn't in the context, say so.
+`;
+
+// 4. Generate with context
+const response = await anthropic.messages.create({
+  model: "claude-sonnet-4-5",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: augmentedPrompt }],
+});
+```
+
+## Tool use (function calling)
+
+```ts
+const tools = [
+  {
+    name: "get_weather",
+    description: "Get current weather for a location",
+    input_schema: {
+      type: "object",
+      properties: {
+        location: { type: "string", description: "City name or coordinates" },
+        units: { type: "string", enum: ["celsius", "fahrenheit"] },
+      },
+      required: ["location"],
+    },
+  },
+];
+
+const response = await client.messages.create({
+  model: "claude-sonnet-4-5",
+  max_tokens: 1024,
+  tools,
+  messages: [{ role: "user", content: "What's the weather in Paris?" }],
+});
+
+// Check if model wants to use a tool
+if (response.stop_reason === "tool_use") {
+  const toolUse = response.content.find((c) => c.type === "tool_use");
+  const result = await executeToolCall(toolUse.name, toolUse.input);
+  // Continue conversation with tool result
+}
+```
+
+## AI UX patterns
+
+**Streaming text:** Always stream for long responses. Users disengage if they wait.
+**Optimistic UI:** Show user message immediately, wait for AI response.
+**Stop generation:** Provide ability to stop mid-stream.
+**Retry / regenerate:** Always offer re-generation.
+**Citation / sources:** For RAG responses, cite the source documents.
+**Feedback:** Thumbs up/down on responses. Improves model or prompt over time.
+**Guardrails UI:** If request refused, explain why and offer alternatives.
+**Conversation history:** Maintain context across turns. Summarize long conversations.
+**Token awareness:** Show remaining context. Warn when approaching limits.
+
+## Prompt engineering
+
+**Be specific:** Vague prompts → vague outputs.
+**System prompt:** Set role, behavior, constraints, output format.
+**Few-shot examples:** 2-5 examples of desired input→output.
+**Chain of thought:** "Think step by step" or "Let's reason through this."
+**Output format:** "Respond in JSON", "Use markdown headers", "Maximum 3 bullet points."
+**Role assignment:** "You are an expert [role] who specializes in [domain]."
+
+## Cost management
+
+Claude Haiku: cheapest for simple tasks. Sonnet: balanced. Opus: most capable.
+Cache common prompts (Anthropic prompt caching).
+Set max_tokens appropriately. Don't over-generate.
+Log and monitor token usage per feature.
+Rate limit users to prevent runaway costs.
+
+Sources: Anthropic documentation (docs.anthropic.com — free), Vercel AI SDK (sdk.vercel.ai/docs — free), LangChain documentation (free), Building AI Products by Lenny Rachitsky (Substack)

package/skills/technical/analytics-setup/LICENSE

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