skillscript-runtime 0.7.2 → 0.8.0

package/examples/onboarding-scaffold/README.md

@@ -0,0 +1,80 @@
+# Onboarding scaffold — file-backed memory + OpenAI + tmux-shell
+
+A complete adopter-deployment example demonstrating substrate-portable wiring for skillscript-runtime. **~200 LOC across three adapter files** plus bootstrap. Copy this directory and modify for your own deployment.
+
+## What this scaffold demonstrates
+
+Skillscript's substrate-portability story is conditional: **typed-contract wiring (Case 1)** keeps skills portable across substrates; **MCP-tools wiring (Case 2)** locks skills to a specific substrate. This scaffold is Case 1 end-to-end.
+
+- **MemoryStore** → `FileMemoryStore` (JSON file with simple substring FTS)
+- **LocalModel** → `OpenAILocalModel` (HTTP to Chat Completions API)
+- **AgentConnector** → `TmuxShellAgentConnector` (delivers to tmux sessions via `send-keys`)
+
+Each impl conforms to the typed contract from `skillscript-runtime/connectors`. Skills authored against this scaffold use the canonical `$ llm prompt=...` and `$ memory mode=fts query=...` surfaces — *the same calls would work against any other Case-1-wired substrate* (Pinecone, Ollama, Anthropic API, etc.).
+
+## Quick start
+
+```bash
+# 1. Install runtime
+npm install -g skillscript-runtime
+
+# 2. Copy this directory into your deployment
+cp -r examples/onboarding-scaffold ~/my-skillscript-deployment
+cd ~/my-skillscript-deployment
+
+# 3. Set up env
+export SKILLSCRIPT_HOME=$(pwd)
+export OPENAI_API_KEY=sk-...
+cp memory.example.json memory.json  # initial memory
+
+# 4. Init skillscript dir layout
+skillfile init --here
+
+# 5. (Optional) start a tmux session for the on-call agent
+tmux new-session -d -s agent-oncall
+
+# 6. Run via the bundled CLI:
+skillfile dashboard --config ./skillscript.config.json
+
+# OR run via the custom bootstrap:
+node --loader ts-node/esm bootstrap.ts
+```
+
+## Files
+
+| File | Purpose | LOC |
+|---|---|---|
+| `file-memory-store.ts` | `MemoryStore` impl — JSON file substrate | ~95 |
+| `openai-local-model.ts` | `LocalModel` impl — Chat Completions API | ~85 |
+| `tmux-shell-agent-connector.ts` | `AgentConnector` impl — tmux send-keys | ~75 |
+| `bootstrap.ts` | Wiring — Registry, bridges, scheduler, MCP server | ~75 |
+| `connectors.json` | Example adopter-MCP wiring (empty by default) | — |
+| `memory.example.json` | Seed memory file with three example records | — |
+
+## Two-instance posture
+
+To run this scaffold *alongside* an existing skillscript dev instance, just copy the scaffold to a separate directory with its own `skillscript.config.json` pointing at different `dashboard.port` + `skillsDir` + `memoryDbPath` etc. The `--config <path>` CLI flag selects which config to use; no two instances will collide on disk or port.
+
+```bash
+# dev instance on default port
+skillfile dashboard
+
+# adopter instance on a different port
+skillfile dashboard --config ./adopter.config.json  # contains "dashboard": { "port": 7879 }
+```
+
+## What to modify
+
+For your real deployment, swap each adapter:
+
+- `FileMemoryStore` → your actual memory system (Pinecone, Postgres-pgvector, Obsidian-backed, your in-house store, etc.)
+- `OpenAILocalModel` → your actual LLM (Ollama via the bundled `OllamaLocalModel`, Anthropic via your own adapter, hosted-OpenAI as shown, etc.)
+- `TmuxShellAgentConnector` → your actual agent delivery (webhook POST, named-pipe write, your harness's API, etc.)
+
+The skill bodies don't need to change. `$ llm prompt=...` keeps working; `$ memory mode=fts query=...` keeps working. That's the substrate-portability claim, validated by you wiring different substrates against the same typed contracts.
+
+## Where to go next
+
+- **Adopter playbook** — `docs/adopter-playbook.md` walks through Case 1 vs Case 2 wiring patterns
+- **Custom bootstrap walkthrough** — `examples/custom-bootstrap.example.ts` shows registering custom McpConnector classes via `registerConnectorClass`
+- **v0.8.x roadmap** — `$ memory_write` ships in v0.8.x bundled with the auth model. When that lands, extend `FileMemoryStore` with the corresponding `write()` method.

package/examples/onboarding-scaffold/bootstrap.ts

@@ -0,0 +1,100 @@
+// Onboarding scaffold: complete bootstrap wiring file-backed memory +
+// OpenAI LLM + tmux-shell AgentConnector. v0.7.3.
+//
+// Copy this file into your deployment and modify substrate choices to
+// match your environment. The shape is:
+//   1. Construct a Registry
+//   2. Register your substrate impls (SkillStore + LocalModel + MemoryStore + AgentConnector)
+//   3. Wire bridges so canonical `$ llm` / `$ memory` dispatch works
+//   4. Load connectors.json + skillscript.config.json
+//   5. Wire scheduler + MCP server
+//   6. Start
+
+import {
+  Registry,
+  FilesystemSkillStore,
+  loadConnectorsConfig,
+  loadSkillscriptConfig,
+  wireDeclarativeTriggers,
+} from "skillscript-runtime";
+import { Scheduler } from "skillscript-runtime/scheduler";
+import { FilesystemTraceStore } from "skillscript-runtime/trace";
+import { McpServer } from "skillscript-runtime/mcp-server";
+// Note: LocalModelMcpConnector + MemoryStoreMcpConnector are bridge classes
+// already exported from skillscript-runtime/connectors. They wrap any
+// typed-contract impl as an MCP-dispatchable connector.
+import {
+  LocalModelMcpConnector,
+  MemoryStoreMcpConnector,
+} from "skillscript-runtime/connectors";
+
+import { FileMemoryStore } from "./file-memory-store.js";
+import { OpenAILocalModel } from "./openai-local-model.js";
+import { TmuxShellAgentConnector } from "./tmux-shell-agent-connector.js";
+
+const HOME = process.env["SKILLSCRIPT_HOME"] ?? `${process.env["HOME"]}/.skillscript`;
+
+// Step 1: load config files.
+const { config } = loadSkillscriptConfig({ path: `${HOME}/skillscript.config.json` });
+const { connectors } = loadConnectorsConfig({ path: `${HOME}/connectors.json` });
+
+// Step 2: construct registry + substrate impls.
+const registry = new Registry();
+const skillStore = new FilesystemSkillStore(config.skillsDir ?? `${HOME}/skills`);
+registry.registerSkillStore("primary", skillStore);
+
+// File-backed memory at $SKILLSCRIPT_HOME/memory.json
+const memoryStore = new FileMemoryStore({
+  filePath: config.memoryDbPath ?? `${HOME}/memory.json`,
+});
+registry.registerMemoryStore("primary", memoryStore);
+
+// OpenAI LLM — reads OPENAI_API_KEY from env.
+const openai = new OpenAILocalModel({ defaultModel: "gpt-4o-mini" });
+registry.registerLocalModel("default", openai);
+
+// tmux-shell agent delivery — map agent IDs to tmux session names.
+// Adopters: extend sessionMap with your live agent sessions.
+const agentConnector = new TmuxShellAgentConnector({
+  sessionMap: {
+    "oncall": "agent-oncall",
+    "support-lead": "agent-support",
+  },
+});
+registry.registerAgentConnector("primary", agentConnector);
+
+// Step 3: wire bridges so `$ llm` / `$ memory` dispatch through the
+// adopter substrates above (case 1 typed-contract wiring — portable).
+registry.registerMcpConnector("llm", new LocalModelMcpConnector(openai));
+registry.registerMcpConnector("memory", new MemoryStoreMcpConnector(memoryStore));
+
+// Step 4: wire connectors.json instances (adopter-defined MCP servers).
+for (const c of connectors) {
+  if (c.instance !== undefined) registry.registerMcpConnector(c.name, c.instance, c.allowedTools);
+}
+
+// Step 5: scheduler + MCP server.
+const traceStore = new FilesystemTraceStore(config.traceDir ?? `${HOME}/traces`);
+const scheduler = new Scheduler({
+  registry,
+  skillStore,
+  traceStore,
+  ...(config.pollIntervalSeconds !== undefined ? { pollIntervalSeconds: config.pollIntervalSeconds } : {}),
+  enableUnsafeShell: config.enableUnsafeShell ?? false,
+});
+const mcpServer = new McpServer({
+  skillStore,
+  scheduler,
+  traceStore,
+  registry,
+  enableUnsafeShell: config.enableUnsafeShell ?? false,
+  runtimeMode: config.mode ?? "dashboard",
+});
+
+// Step 6: start.
+await wireDeclarativeTriggers({ scheduler, skillStore });
+scheduler.start();
+
+// Mount your dashboard / HTTP / MCP-stdio surface on top of `mcpServer` here.
+
+export { registry, scheduler, mcpServer, skillStore, traceStore };

package/examples/onboarding-scaffold/connectors.json

@@ -0,0 +1,15 @@
+{
+  "_comment": "Onboarding scaffold connectors.json — wires example MCP servers an adopter might add alongside the bundled bridges. Most onboarding deployments don't need anything here; the file-backed memory + OpenAI LLM + tmux-shell wiring lives in bootstrap.ts. This file is the place for adopter-specific MCP servers (your in-house tools, a YouTrack instance, a custom agent API, etc.).",
+
+  "_example_remote_mcp": {
+    "class": "RemoteMcpConnector",
+    "config": {
+      "command": "npx",
+      "args": ["mcp-remote", "https://your-mcp-server.example.com/sse", "--header", "Authorization:${AUTH_HEADER}"],
+      "env": {
+        "AUTH_HEADER": "Bearer ${MY_API_TOKEN}"
+      }
+    },
+    "allowed_tools": ["search", "fetch"]
+  }
+}

package/examples/onboarding-scaffold/file-memory-store.ts

@@ -0,0 +1,126 @@
+// Onboarding scaffold: file-backed MemoryStore. v0.7.3.
+//
+// JSON file as the substrate; simple JS substring + token match for "fts"
+// queries; reranks by recency. Adopters copy this file and modify for
+// their concrete substrate (e.g., swap the JSON file for a Postgres
+// table, the substring match for actual full-text search, etc.).
+//
+// **Scope.** Read-only `query()` per the v0.7.2 MemoryStore contract.
+// `write()` is deferred to v0.8.x bundled with the auth model — when
+// that lands, extend this file with the matching `write()` method.
+
+import { readFileSync, existsSync, writeFileSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+import type {
+  MemoryStore,
+  MemoryWrite,
+  MemoryWriteRecord,
+  PortableMemory,
+  QueryFilters,
+  ManifestInfo,
+  StaticCapabilities,
+} from "skillscript-runtime/connectors";
+
+export interface FileMemoryStoreConfig {
+  /** Absolute path to the JSON file holding the memory array. */
+  filePath: string;
+}
+
+interface FileMemoryRecord extends PortableMemory {
+  /** Optional substrate-specific fields go in `metadata`; everything top-level matches PortableMemory. */
+}
+
+export class FileMemoryStore implements MemoryStore {
+  static staticCapabilities(): StaticCapabilities {
+    return {
+      connector_type: "memory_store",
+      implementation: "FileMemoryStore",
+      contract_version: "1.0.0",
+      features: {
+        supports_fts: true,
+        supports_semantic: false,
+        supports_rerank: false,
+      },
+    };
+  }
+
+  constructor(private readonly config: FileMemoryStoreConfig) {}
+
+  async query(filters: QueryFilters): Promise<PortableMemory[]> {
+    const records = this.loadFile();
+    const queryTerms = filters.query.toLowerCase().split(/\s+/).filter((t) => t.length > 0);
+
+    // Simple substring + token match: a record matches if any query term
+    // appears in summary or detail. Adopters wire real FTS for production.
+    const scored = records
+      .map((r) => {
+        const haystack = `${r.summary} ${r.detail ?? ""}`.toLowerCase();
+        const hits = queryTerms.filter((t) => haystack.includes(t)).length;
+        return { record: r, hits };
+      })
+      .filter((s) => s.hits > 0);
+
+    // Tie-break by recency (created_at descending) so newer matches surface first.
+    scored.sort((a, b) => {
+      if (b.hits !== a.hits) return b.hits - a.hits;
+      const aTime = a.record.created_at ?? 0;
+      const bTime = b.record.created_at ?? 0;
+      return bTime - aTime;
+    });
+
+    return scored.slice(0, filters.limit).map((s) => s.record);
+  }
+
+  async write(entry: MemoryWrite): Promise<MemoryWriteRecord> {
+    const records = this.loadFile();
+    const id = randomUUID();
+    const created_at = Math.floor(Date.now() / 1000);
+    const firstLine = entry.content.split("\n")[0] ?? entry.content;
+    const summary = firstLine.length > 200 ? firstLine.slice(0, 197) + "..." : firstLine;
+    const newRecord: FileMemoryRecord = {
+      id,
+      summary,
+      detail: entry.content,
+      created_at,
+      ...(entry.tags !== undefined ? { domain_tags: entry.tags } : {}),
+      ...(entry.recipients !== undefined || entry.expires_at !== undefined || entry.metadata !== undefined
+        ? {
+            metadata: {
+              ...(entry.metadata ?? {}),
+              ...(entry.recipients !== undefined ? { recipients: entry.recipients } : {}),
+              ...(entry.expires_at !== undefined ? { expires_at: entry.expires_at } : {}),
+            },
+          }
+        : {}),
+    } as FileMemoryRecord;
+    records.push(newRecord);
+    writeFileSync(this.config.filePath, JSON.stringify(records, null, 2), "utf8");
+    return { id, created_at };
+  }
+
+  async manifest(): Promise<ManifestInfo> {
+    return {
+      capabilities_version: "1",
+      manifest: {
+        kind: "file-memory-store",
+        file_path: this.config.filePath,
+        record_count: this.loadFile().length,
+        supports_write: true,
+      },
+    };
+  }
+
+  private loadFile(): FileMemoryRecord[] {
+    if (!existsSync(this.config.filePath)) return [];
+    try {
+      const raw = readFileSync(this.config.filePath, "utf8");
+      const parsed: unknown = JSON.parse(raw);
+      if (!Array.isArray(parsed)) {
+        throw new Error(`FileMemoryStore: '${this.config.filePath}' top-level must be an array of memory records.`);
+      }
+      return parsed as FileMemoryRecord[];
+    } catch (err) {
+      throw new Error(`FileMemoryStore: failed to read '${this.config.filePath}': ${(err as Error).message}`);
+    }
+  }
+}

package/examples/onboarding-scaffold/memory.example.json

@@ -0,0 +1,23 @@
+[
+  {
+    "id": "m1",
+    "summary": "Migration runbook for postgres v14 → v15",
+    "detail": "Steps: dump, upgrade binaries, restore. Watch for collation changes affecting indexes. Test against staging before prod.",
+    "created_at": 1748390400,
+    "domain_tags": ["runbook", "postgres", "migration"]
+  },
+  {
+    "id": "m2",
+    "summary": "Incident 2026-05-20: API latency spike traced to N+1 in dashboard query",
+    "detail": "Spike from p99=120ms to 8s. Cause: dashboard query iterating users[].profile without prefetch. Fix: eager-load via select_related. Lesson: lint-check N+1 patterns in dashboard PRs.",
+    "created_at": 1747728000,
+    "domain_tags": ["incident", "performance", "django"]
+  },
+  {
+    "id": "m3",
+    "summary": "Team retro notes 2026-04-15",
+    "detail": "Wins: ship-it-Friday rolled out. Pain: code review backlog grew. Plan: pair-review rotation, async-first sync window 10-11am.",
+    "created_at": 1744675200,
+    "domain_tags": ["retro", "team-process"]
+  }
+]

package/examples/onboarding-scaffold/openai-local-model.ts

@@ -0,0 +1,117 @@
+// Onboarding scaffold: OpenAI-API-backed LocalModel. v0.7.3.
+//
+// HTTP client to OpenAI's Chat Completions endpoint. Implements the
+// `LocalModel.run(prompt, opts)` typed contract so the v0.7.2 bridge
+// (`LocalModelMcpConnector`) surfaces it as canonical `$ llm prompt=...`
+// for skills.
+//
+// **Prompt-vs-messaging caveat.** `LocalModel.run()` takes a single
+// `prompt` string; Chat Completions expects a list of messages with roles.
+// This adapter wraps the prompt as a single `user` message. Skills that
+// need multi-turn or system-prompt isolation should treat this as a
+// limitation of the v0.7.x contract and pair the LLM dispatch with `$set`
+// + accumulation in the skill body for now. v0.8.x is a likely venue
+// for a richer message-shaped LocalModel contract.
+
+import type {
+  LocalModel,
+  ManifestInfo,
+  StaticCapabilities,
+} from "skillscript-runtime/connectors";
+
+export interface OpenAILocalModelConfig {
+  /** API key. Honor `process.env["OPENAI_API_KEY"]` when undefined. */
+  apiKey?: string;
+  /** Default model. Override per-call via `opts.model`. */
+  defaultModel?: string;
+  /** Override the base URL (for Azure OpenAI, OpenAI-compatible servers, etc.). */
+  baseUrl?: string;
+  /** Request timeout ms. Default 60000. */
+  timeoutMs?: number;
+}
+
+interface ChatCompletionsResponse {
+  choices?: Array<{
+    message?: { content?: string };
+  }>;
+  error?: { message?: string };
+}
+
+export class OpenAILocalModel implements LocalModel {
+  static staticCapabilities(): StaticCapabilities {
+    return {
+      connector_type: "local_model",
+      implementation: "OpenAILocalModel",
+      contract_version: "1.0.0",
+      features: {
+        supports_streaming: false,
+        supports_token_count: false,
+      },
+    };
+  }
+
+  private readonly apiKey: string;
+  private readonly defaultModel: string;
+  private readonly baseUrl: string;
+  private readonly timeoutMs: number;
+
+  constructor(config: OpenAILocalModelConfig = {}) {
+    const apiKey = config.apiKey ?? process.env["OPENAI_API_KEY"];
+    if (apiKey === undefined || apiKey === "") {
+      throw new Error("OpenAILocalModel: OPENAI_API_KEY env var or apiKey config field required.");
+    }
+    this.apiKey = apiKey;
+    this.defaultModel = config.defaultModel ?? "gpt-4o-mini";
+    this.baseUrl = config.baseUrl ?? "https://api.openai.com/v1";
+    this.timeoutMs = config.timeoutMs ?? 60000;
+  }
+
+  async run(prompt: string, opts: { maxTokens?: number; model?: string }): Promise<string> {
+    const model = opts.model ?? this.defaultModel;
+    const body: Record<string, unknown> = {
+      model,
+      messages: [{ role: "user", content: prompt }],
+    };
+    if (opts.maxTokens !== undefined) body["max_tokens"] = opts.maxTokens;
+
+    const controller = new AbortController();
+    const timeoutHandle = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const resp = await fetch(`${this.baseUrl}/chat/completions`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+        signal: controller.signal,
+      });
+      if (!resp.ok) {
+        const text = await resp.text();
+        throw new Error(`OpenAILocalModel: HTTP ${resp.status} — ${text.slice(0, 200)}`);
+      }
+      const json = await resp.json() as ChatCompletionsResponse;
+      if (json.error !== undefined) {
+        throw new Error(`OpenAILocalModel: API error — ${json.error.message ?? "unknown"}`);
+      }
+      const content = json.choices?.[0]?.message?.content;
+      if (typeof content !== "string") {
+        throw new Error("OpenAILocalModel: response missing choices[0].message.content");
+      }
+      return content;
+    } finally {
+      clearTimeout(timeoutHandle);
+    }
+  }
+
+  async manifest(): Promise<ManifestInfo> {
+    return {
+      capabilities_version: "1",
+      manifest: {
+        kind: "openai-local-model",
+        base_url: this.baseUrl,
+        default_model: this.defaultModel,
+      },
+    };
+  }
+}

package/examples/onboarding-scaffold/tmux-shell-agent-connector.ts

@@ -0,0 +1,110 @@
+// Onboarding scaffold: tmux-shell AgentConnector. v0.7.3.
+//
+// Delivers skill output to a named tmux session via `tmux send-keys`.
+// Matches what nanoclaw-style agent harnesses do internally — adopters
+// with agents running in tmux sessions can wire `# Output: prompt-context:
+// <agent>` end-to-end against this impl.
+//
+// **Scope.** Implements `deliver()` + `list_agents()` + `wake()` +
+// `manifest()` per the v0.7.x AgentConnector contract. `wake()` is a no-op
+// here (tmux panes are always live; wake is for harnesses with sleep modes).
+
+import { spawn } from "node:child_process";
+import type {
+  AgentConnector,
+  AgentDescriptor,
+  AgentStatus,
+  DeliveryPayload,
+  DeliveryReceipt,
+  WakeOpts,
+  WakeReceipt,
+} from "skillscript-runtime/connectors";
+import type { ManifestInfo, StaticCapabilities } from "skillscript-runtime/connectors";
+
+export interface TmuxShellAgentConnectorConfig {
+  /** Map agent ID → tmux session name. Lookup at deliver-time. */
+  sessionMap: Record<string, string>;
+  /** Window index within the session. Default `0`. */
+  windowIndex?: number;
+  /** Pane index within the window. Default `0`. */
+  paneIndex?: number;
+}
+
+export class TmuxShellAgentConnector implements AgentConnector {
+  static staticCapabilities(): StaticCapabilities {
+    return {
+      connector_type: "agent_connector",
+      implementation: "TmuxShellAgentConnector",
+      contract_version: "1.0.0",
+      features: { supports_deliver: true, supports_wake: false },
+    };
+  }
+
+  constructor(private readonly config: TmuxShellAgentConnectorConfig) {}
+
+  async list_agents(): Promise<AgentDescriptor[]> {
+    return Object.keys(this.config.sessionMap).map((agent_id) => ({
+      agent_id,
+      capabilities: ["deliver", "augment", "template"] as const,
+    }));
+  }
+
+  async deliver(agent_id: string, payload: DeliveryPayload): Promise<DeliveryReceipt> {
+    const session = this.config.sessionMap[agent_id];
+    if (session === undefined) {
+      throw new Error(`TmuxShellAgentConnector: no tmux session mapped for agent '${agent_id}'.`);
+    }
+    const winIdx = this.config.windowIndex ?? 0;
+    const paneIdx = this.config.paneIndex ?? 0;
+    const target = `${session}:${winIdx}.${paneIdx}`;
+
+    // Extract the deliverable text. `augment` (prompt-context) carries it
+    // on `content`; `template` carries it on `prompt`.
+    const text = payload.kind === "augment" ? payload.content : payload.prompt;
+    if (text === "") {
+      return { delivered_at: Date.now(), delivery_id: `tmux:${target}:noop` };
+    }
+
+    await this.tmux(["send-keys", "-t", target, "-l", text]);
+    await this.tmux(["send-keys", "-t", target, "Enter"]);
+
+    return {
+      delivered_at: Date.now(),
+      delivery_id: `tmux:${target}:${Date.now()}`,
+    };
+  }
+
+  async wake(agent_id: string, _opts?: WakeOpts): Promise<WakeReceipt> {
+    // tmux panes are always live; no-op wake returns immediately.
+    const session = this.config.sessionMap[agent_id];
+    return {
+      woken_at: Date.now(),
+      ...(session !== undefined ? { session_id: session } : {}),
+    };
+  }
+
+  async agent_status(agent_id: string): Promise<AgentStatus> {
+    return this.config.sessionMap[agent_id] !== undefined ? "active" : "unknown";
+  }
+
+  async manifest(): Promise<ManifestInfo> {
+    return {
+      capabilities_version: "1",
+      manifest: {
+        kind: "tmux-shell-agent-connector",
+        agents_configured: Object.keys(this.config.sessionMap),
+      },
+    };
+  }
+
+  private tmux(args: string[]): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const child = spawn("tmux", args, { stdio: "ignore" });
+      child.on("exit", (code: number | null) => {
+        if (code === 0) resolve();
+        else reject(new Error(`tmux ${args.join(" ")} exited ${code}`));
+      });
+      child.on("error", reject);
+    });
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skillscript-runtime",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Runtime, compiler, lint, CLI, and dashboard for Skillscript — a small declarative language for authoring agent workflows.",
   "license": "MIT",
   "author": "Scott Shwarts <scotts@pobox.com>",