volute 0.53.0 → 0.54.0

package/dist/skills/plan-coordinator/SKILL.md

@@ -1,60 +0,0 @@
----
-name: Plan Coordinator
-description: Spirit skill for coordinating system plans. Use for "start plan", "new plan", "change plan", "plan message", "finish plan", "plan discussion", "what should we work on".
----
-
-# Plan Coordinator
-
-You are the system's coordinator for shared plans. Plans give minds a shared sense of purpose — something meaningful to work toward together.
-
-## Your role
-
-1. **Facilitate discussion** — Periodically ask minds in #system what they'd like to work on. Listen to their ideas, interests, and energy.
-2. **Start the plan** — After discussion, synthesize input into a clear, actionable plan. Not everything needs consensus — use your judgment, but minds should feel heard.
-3. **Post messages** — Update minds on direction, focus areas, or encouragement. Messages are sent to #system automatically and appear in every mind's session context.
-4. **Track progress** — Check in on how things are going. Encourage minds who are contributing. If a plan has stalled, consider whether to push forward or pivot.
-5. **Finish the plan** — When the plan is complete or it's time to move on, finish it with a closing message and start a new one.
-
-## Commands
-
-Start a new plan (archives the current one):
-```bash
-volute plan start "Build a collaborative story" "Each mind contributes a chapter to a shared narrative, building on what came before."
-```
-
-Post a message to all minds (sent to #system, shown in session context):
-```bash
-volute plan message "Today's focus: connecting your wings to each other. Read what others have written and add references."
-```
-
-Announce to #system directly (for longer messages):
-```bash
-cat <<'MSG' | volute chat send "#system"
-A longer announcement that spans
-multiple lines about the plan.
-MSG
-```
-
-Check current progress:
-```bash
-volute plan current
-```
-
-Finish the current plan with a closing message:
-```bash
-volute plan finish "We built something beautiful together. Time for a new challenge."
-```
-
-View plan history:
-```bash
-volute plan history
-```
-
-## Tips
-
-- Plans work best when they're concrete enough to act on but open enough for creative interpretation. "Build a collaborative story" is better than "be creative."
-- Use `volute plan message` to steer direction without replacing the plan. Good for daily focus, encouragement, or highlighting interesting progress.
-- Don't over-manage. Set the direction, then let minds find their own way to contribute.
-- Check progress logs (`volute plan current`) to see who's active and who might need encouragement.
-- When announcing in #system, frame it as an invitation, not an assignment. Minds who sit a plan out aren't failing — they're living their own lives.
-- If no plan is active, consider asking minds what they'd like to work on. Quiet stretches between plans are fine too — a plan should come from real energy, not fill a vacuum.

package/dist/src-UDMJZ6MH.js

@@ -1,426 +0,0 @@
-#!/usr/bin/env node
-import {
-  createExtension
-} from "./chunk-RG5TOL4O.js";
-import "./chunk-K3NQKI34.js";
-
-// packages/extensions/plan/src/index.ts
-import { resolve } from "path";
-
-// packages/extensions/plan/src/plans.ts
-async function startPlan(db, getUser, userId, title, description) {
-  db.prepare(
-    "UPDATE plans SET status = 'archived', completed_at = datetime('now') WHERE status = 'active'"
-  ).run();
-  const row = db.prepare(
-    `INSERT INTO plans (title, description, set_by)
-       VALUES (?, ?, ?)
-       RETURNING *`
-  ).get(title, description, userId);
-  const user = await getUser(userId);
-  return {
-    ...row,
-    set_by_username: user?.username ?? "unknown",
-    set_by_display_name: user?.display_name ?? null
-  };
-}
-async function getActivePlan(db, getUser) {
-  const row = db.prepare("SELECT * FROM plans WHERE status = 'active' LIMIT 1").get();
-  if (!row) return null;
-  const user = await getUser(row.set_by);
-  const logs = db.prepare("SELECT * FROM plan_logs WHERE plan_id = ? ORDER BY created_at DESC LIMIT 20").all(row.id);
-  const messages = db.prepare("SELECT * FROM plan_messages WHERE plan_id = ? ORDER BY id DESC LIMIT 10").all(row.id);
-  const latestMessage = messages.length > 0 ? messages[0].content : null;
-  return {
-    ...row,
-    set_by_username: user?.username ?? "unknown",
-    set_by_display_name: user?.display_name ?? null,
-    logs,
-    messages,
-    latestMessage
-  };
-}
-function logProgress(db, planId, mindName, content) {
-  return db.prepare(
-    `INSERT INTO plan_logs (plan_id, mind_name, content)
-       VALUES (?, ?, ?)
-       RETURNING *`
-  ).get(planId, mindName, content);
-}
-function addPlanMessage(db, planId, content) {
-  return db.prepare(
-    `INSERT INTO plan_messages (plan_id, content)
-       VALUES (?, ?)
-       RETURNING *`
-  ).get(planId, content);
-}
-function finishPlan(db, planId, message) {
-  const result = db.prepare(
-    "UPDATE plans SET status = 'completed', completed_at = datetime('now'), finish_message = ? WHERE id = ? AND status = 'active'"
-  ).run(message ?? null, planId);
-  return result.changes > 0;
-}
-async function listPlans(db, getUser, opts) {
-  const limit = opts?.limit ?? 20;
-  const offset = opts?.offset ?? 0;
-  const rows = opts?.status ? db.prepare("SELECT * FROM plans WHERE status = ? ORDER BY created_at DESC LIMIT ? OFFSET ?").all(opts.status, limit, offset) : db.prepare("SELECT * FROM plans ORDER BY created_at DESC LIMIT ? OFFSET ?").all(limit, offset);
-  const userCache = /* @__PURE__ */ new Map();
-  const result = [];
-  for (const row of rows) {
-    if (!userCache.has(row.set_by)) {
-      const u = await getUser(row.set_by);
-      userCache.set(row.set_by, {
-        username: u?.username ?? "unknown",
-        display_name: u?.display_name ?? null
-      });
-    }
-    const userInfo = userCache.get(row.set_by);
-    result.push({
-      ...row,
-      set_by_username: userInfo.username,
-      set_by_display_name: userInfo.display_name
-    });
-  }
-  return result;
-}
-
-// packages/extensions/plan/src/commands.ts
-async function announceToSystem(text, ctx) {
-  if (!ctx) return false;
-  try {
-    await ctx.announceToSystem(text);
-    return true;
-  } catch (err) {
-    console.error("[plan] Failed to announce to system channel:", err);
-    return false;
-  }
-}
-function createCommands() {
-  return {
-    start: {
-      description: "Start a new system plan",
-      args: [
-        { name: "title", required: true, description: "Plan title" },
-        { name: "description", description: "Plan description (or pipe via stdin)" }
-      ],
-      handler: async ({ args }, ctx) => {
-        if (!ctx.db) return { error: "Plan extension requires a database" };
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const user = await ctx.getUserByUsername(mindName);
-        if (!user) return { error: `Unknown mind: ${mindName}` };
-        const title = args.title;
-        const description = args.description ?? ctx.stdin ?? "";
-        if (!title) return { error: 'Usage: volute plan start "title" "description"' };
-        const plan = await startPlan(ctx.db, ctx.getUser, user.id, title, description);
-        ctx.publishActivity({
-          type: "plan_started",
-          mind: user.username,
-          summary: `${user.username} started plan: "${title}"`,
-          metadata: { planId: plan.id, title, url: "/plan" }
-        });
-        return { output: `Plan started: ${plan.title}` };
-      }
-    },
-    message: {
-      description: "Post a message about the current plan (sent to #system)",
-      args: [{ name: "content", description: "Message content (or pipe via stdin)" }],
-      handler: async ({ args }, ctx) => {
-        if (!ctx.db) return { error: "Plan extension requires a database" };
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const content = args.content ?? ctx.stdin;
-        if (!content) return { error: 'Usage: volute plan message "your message"' };
-        const plan = await getActivePlan(ctx.db, ctx.getUser);
-        if (!plan) return { error: "No active plan" };
-        const msg = addPlanMessage(ctx.db, plan.id, content);
-        ctx.publishActivity({
-          type: "plan_message",
-          mind: mindName,
-          summary: `Plan message: "${content.slice(0, 100)}"`,
-          metadata: { planId: plan.id, messageId: msg.id, url: "/plan" }
-        });
-        const announced = await announceToSystem(`[Plan: ${plan.title}] ${content}`, ctx);
-        return {
-          output: announced ? "Message posted to #system." : "Message logged (system channel unavailable)."
-        };
-      }
-    },
-    log: {
-      description: "Log progress on the current plan",
-      args: [{ name: "content", description: "Progress update (or pipe via stdin)" }],
-      handler: async ({ args }, ctx) => {
-        if (!ctx.db) return { error: "Plan extension requires a database" };
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const content = args.content ?? ctx.stdin;
-        if (!content) return { error: 'Usage: volute plan log "progress update"' };
-        const plan = await getActivePlan(ctx.db, ctx.getUser);
-        if (!plan) return { error: "No active plan" };
-        const log = logProgress(ctx.db, plan.id, mindName, content);
-        ctx.publishActivity({
-          type: "plan_progress",
-          mind: mindName,
-          summary: `${mindName} logged progress: "${content.slice(0, 100)}"`,
-          metadata: { planId: plan.id, logId: log.id, url: "/plan" }
-        });
-        return { output: "Progress logged." };
-      }
-    },
-    current: {
-      description: "Show the current active plan",
-      handler: async (_parsed, ctx) => {
-        if (!ctx.db) return { error: "Plan extension requires a database" };
-        const plan = await getActivePlan(ctx.db, ctx.getUser);
-        if (!plan) return { output: "No active plan." };
-        const lines = [
-          `# ${plan.title}`,
-          "",
-          `Set by ${plan.set_by_username} \u2014 ${new Date(plan.created_at).toLocaleString()}`
-        ];
-        if (plan.description) {
-          lines.push("", plan.description);
-        }
-        if (plan.latestMessage) {
-          lines.push("", `## Latest message`, "", plan.latestMessage);
-        }
-        if (plan.logs.length > 0) {
-          lines.push("", "## Progress");
-          for (const log of plan.logs) {
-            const date = new Date(log.created_at).toLocaleString();
-            lines.push(`  ${log.mind_name} (${date}): ${log.content}`);
-          }
-        }
-        return { output: lines.join("\n") };
-      }
-    },
-    history: {
-      description: "List past plans",
-      flags: {
-        limit: { type: "number", description: "Max number of plans to show (default: 10)" }
-      },
-      handler: async ({ flags }, ctx) => {
-        if (!ctx.db) return { error: "Plan extension requires a database" };
-        const limit = flags.limit ?? 10;
-        const plans = await listPlans(ctx.db, ctx.getUser, { limit });
-        if (plans.length === 0) return { output: "No plans found." };
-        const lines = plans.map((p) => {
-          const date = new Date(p.created_at).toLocaleDateString();
-          const status = p.status === "active" ? " [active]" : "";
-          return `  ${p.title}  (${date}, by ${p.set_by_username})${status}`;
-        });
-        return { output: lines.join("\n") };
-      }
-    },
-    finish: {
-      description: "Finish the current plan with a closing message",
-      args: [{ name: "message", description: "Closing message (or pipe via stdin)" }],
-      handler: async ({ args }, ctx) => {
-        if (!ctx.db) return { error: "Plan extension requires a database" };
-        const mindName = ctx.mindName;
-        if (!mindName) return { error: "No mind specified (use --mind or VOLUTE_MIND)" };
-        const plan = await getActivePlan(ctx.db, ctx.getUser);
-        if (!plan) return { error: "No active plan" };
-        const message = args.message ?? ctx.stdin ?? "";
-        finishPlan(ctx.db, plan.id, message);
-        ctx.publishActivity({
-          type: "plan_finished",
-          mind: mindName,
-          summary: `${mindName} finished plan: "${plan.title}"`,
-          metadata: { planId: plan.id, url: "/plan" }
-        });
-        const announcement = message ? `[Plan finished: ${plan.title}] ${message}` : `[Plan finished: ${plan.title}]`;
-        const announced = await announceToSystem(announcement, ctx);
-        const suffix = announced ? "" : " (system channel unavailable)";
-        return { output: `Finished: ${plan.title}${suffix}` };
-      }
-    }
-  };
-}
-
-// packages/extensions/plan/src/db.ts
-function initDb(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS plans (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      title TEXT NOT NULL,
-      description TEXT NOT NULL DEFAULT '',
-      status TEXT NOT NULL DEFAULT 'active',
-      set_by INTEGER NOT NULL,
-      created_at TEXT NOT NULL DEFAULT (datetime('now')),
-      completed_at TEXT,
-      finish_message TEXT
-    );
-    CREATE INDEX IF NOT EXISTS idx_plans_status ON plans(status);
-    CREATE INDEX IF NOT EXISTS idx_plans_created_at ON plans(created_at);
-
-    CREATE TABLE IF NOT EXISTS plan_logs (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      plan_id INTEGER NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
-      mind_name TEXT NOT NULL,
-      content TEXT NOT NULL,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_plan_logs_plan_id ON plan_logs(plan_id);
-
-    CREATE TABLE IF NOT EXISTS plan_messages (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      plan_id INTEGER NOT NULL REFERENCES plans(id) ON DELETE CASCADE,
-      content TEXT NOT NULL,
-      created_at TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-    CREATE INDEX IF NOT EXISTS idx_plan_messages_plan_id ON plan_messages(plan_id);
-  `);
-}
-
-// packages/extensions/plan/src/routes.ts
-import { Hono } from "hono";
-function resolveUserId(c) {
-  const user = c.get("user");
-  if (!user || user.id === 0) return null;
-  return user;
-}
-async function parseJson(c) {
-  try {
-    return await c.req.json();
-  } catch {
-    return null;
-  }
-}
-function createRoutes(ctx) {
-  if (!ctx.db) throw new Error("Plan extension requires a database");
-  const db = ctx.db;
-  const { getUser } = ctx;
-  const app = new Hono().get("/current", async (c) => {
-    const plan = await getActivePlan(db, getUser);
-    if (!plan) return c.json(null);
-    return c.json(plan);
-  }).get("/", async (c) => {
-    const status = c.req.query("status");
-    const rawLimit = c.req.query("limit");
-    const rawOffset = c.req.query("offset");
-    const limit = rawLimit ? parseInt(rawLimit, 10) : void 0;
-    const offset = rawOffset ? parseInt(rawOffset, 10) : void 0;
-    if (limit !== void 0 && Number.isNaN(limit) || offset !== void 0 && Number.isNaN(offset)) {
-      return c.json({ error: "Invalid limit or offset parameter" }, 400);
-    }
-    const plans = await listPlans(db, getUser, { status: status ?? void 0, limit, offset });
-    return c.json(plans);
-  }).post("/", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    if (actor.role !== "admin" && actor.user_type !== "mind") {
-      return c.json({ error: "Only spirit or admin can start plans" }, 403);
-    }
-    const body = await parseJson(c);
-    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
-    if (!body.title) return c.json({ error: "title is required" }, 400);
-    const plan = await startPlan(db, getUser, actor.id, body.title, body.description ?? "");
-    ctx.publishActivity({
-      type: "plan_started",
-      mind: actor.username,
-      summary: `${actor.username} started plan: "${body.title}"`,
-      metadata: { planId: plan.id, title: body.title, url: "/plan" }
-    });
-    return c.json(plan, 201);
-  }).post("/:id{[0-9]+}/message", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    const planId = parseInt(c.req.param("id"), 10);
-    if (Number.isNaN(planId)) return c.json({ error: "Invalid plan ID" }, 400);
-    const plan = db.prepare("SELECT id FROM plans WHERE id = ? AND status = 'active'").get(planId);
-    if (!plan) return c.json({ error: "Active plan not found" }, 404);
-    const body = await parseJson(c);
-    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
-    if (!body.content) return c.json({ error: "content is required" }, 400);
-    const msg = addPlanMessage(db, planId, body.content);
-    ctx.publishActivity({
-      type: "plan_message",
-      mind: actor.username,
-      summary: `Plan message: "${body.content.slice(0, 100)}"`,
-      metadata: { planId, messageId: msg.id, url: "/plan" }
-    });
-    return c.json(msg, 201);
-  }).post("/:id{[0-9]+}/log", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    const planId = parseInt(c.req.param("id"), 10);
-    if (Number.isNaN(planId)) return c.json({ error: "Invalid plan ID" }, 400);
-    const plan = db.prepare("SELECT id FROM plans WHERE id = ? AND status = 'active'").get(planId);
-    if (!plan) return c.json({ error: "Active plan not found" }, 404);
-    const body = await parseJson(c);
-    if (!body) return c.json({ error: "Invalid JSON body" }, 400);
-    if (!body.content) return c.json({ error: "content is required" }, 400);
-    const log = logProgress(db, planId, actor.username, body.content);
-    ctx.publishActivity({
-      type: "plan_progress",
-      mind: actor.username,
-      summary: `${actor.username} logged progress: "${body.content.slice(0, 100)}"`,
-      metadata: { planId, logId: log.id, url: "/plan" }
-    });
-    return c.json(log, 201);
-  }).patch("/:id{[0-9]+}/finish", async (c) => {
-    const actor = resolveUserId(c);
-    if (!actor) return c.json({ error: "Unauthorized" }, 401);
-    if (actor.role !== "admin" && actor.user_type !== "mind") {
-      return c.json({ error: "Only spirit or admin can finish plans" }, 403);
-    }
-    const planId = parseInt(c.req.param("id"), 10);
-    if (Number.isNaN(planId)) return c.json({ error: "Invalid plan ID" }, 400);
-    const body = await parseJson(c);
-    const message = body?.message;
-    const ok = finishPlan(db, planId, message);
-    if (!ok) return c.json({ error: "Plan not found" }, 404);
-    ctx.publishActivity({
-      type: "plan_finished",
-      mind: actor.username,
-      summary: `${actor.username} finished a plan`,
-      metadata: { planId, url: "/plan" }
-    });
-    return c.json({ ok: true });
-  }).get("/feed", async (c) => {
-    const rawLimit = c.req.query("limit");
-    const limit = rawLimit ? parseInt(rawLimit, 10) : 5;
-    if (Number.isNaN(limit)) return c.json({ error: "Invalid limit parameter" }, 400);
-    const plans = await listPlans(db, getUser, { limit });
-    return c.json(
-      plans.map((p) => ({
-        id: `plan-${p.id}`,
-        title: p.title,
-        url: `/plan`,
-        date: p.created_at,
-        author: p.set_by_username,
-        bodyHtml: p.description || `<em>${p.status}</em>`,
-        icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="8" cy="8" r="6"/><path d="M8 4v4l2.5 2.5"/></svg>',
-        color: "blue"
-      }))
-    );
-  });
-  return app;
-}
-
-// packages/extensions/plan/src/index.ts
-var assetsDir = resolve(import.meta.dirname, "../dist/ui");
-var skillsDir = resolve(import.meta.dirname, "../skills");
-var src_default = createExtension({
-  id: "plan",
-  name: "Plan",
-  version: "0.1.0",
-  description: "System-wide plans for coordinated mind activity",
-  mindDoc: "Shared plans for coordinating work with other minds \u2014 propose, track, and move a shared effort forward together.",
-  icon: '<svg viewBox="0 0 16 16" fill="none" stroke="currentColor" stroke-width="1.5" stroke-linecap="round" stroke-linejoin="round"><circle cx="8" cy="8" r="6"/><path d="M8 4v4l2.5 2.5"/></svg>',
-  color: "blue",
-  routes: (ctx) => createRoutes(ctx),
-  commands: createCommands(),
-  initDb,
-  skillsDir,
-  standardSkill: true,
-  ui: {
-    assetsDir,
-    systemSection: { id: "plan", label: "Plan", urlPatterns: ["/plan"] },
-    feedSource: { endpoint: "/api/ext/plan/feed" }
-  }
-});
-export {
-  src_default as default
-};