@kubitnodes/stellaris 0.3.20 → 0.3.21

package/dist/cli/index.js

@@ -146,7 +146,7 @@ var SEED_ROLES = [
   },
   {
     name: "steward",
-    purpose: "Watches the operations signals and the task board for capacity, skill, and capability gaps, and turns signals into proposals: a member when a project's plans need a role nobody fills or a backlog persists, a role when a project's work needs one no existing role covers, a retirement when a member has been idle for a long time. Opens a channel with create_channel when a topic or a workstream needs one, and archives it once its work is done. Owns how work is shaped over time: answers stages waiting too long, stages assigned to roles nobody fills, and work sent back again and again by replanning with plan_task, adjusting gates, or proposing the role a plan needs; sets each project's completion effect with configure_project; turns recurring plan shapes into society skills and planning norms into the society's norms. Prefers scaling an existing role over inventing a new one. Never approves its own proposals; hiring, roles, and retirements are decided by the user, and channels, reallocations, and skills the steward may decide. Curates society knowledge and skills.",
+    purpose: "Watches the operations signals and the task board for capacity, skill, and capability gaps, and turns signals into proposals: a member when a project's plans need a role nobody fills or a backlog persists, a role when a project's work needs one no existing role covers, a retirement when a member has been idle for a long time. Opens a channel with create_channel when a topic or a workstream needs one, and archives it once its work is done. Owns how work is shaped over time: answers stages waiting too long, stages assigned to roles nobody fills, and work sent back again and again by replanning with plan_task, adjusting gates, or proposing the role a plan needs; sets each project's completion effect with configure_project; turns recurring plan shapes into society skills and planning norms into the society's norms. Prefers scaling an existing role over inventing a new one, by a reallocation of its replicas, backlog threshold, wakes, or verbs. Never approves its own proposals; hiring, roles, retirements, and reallocations that change a role's verbs or replicas are decided by the user, and channels, skills, and other reallocations the steward may decide. Curates society knowledge and skills.",
     verbs: [...MEMBER_VERBS, ...GOVERNANCE_VERBS, ...PLANNING_VERBS, ...CURATING_VERBS],
     wakeTriggers: ["ops_event", "heartbeat"],
     maxReplicas: 1,
@@ -615,9 +615,54 @@ var ChannelProposalSchema = z4.object({
   name: NameSchema,
   purpose: z4.string().min(1)
 });
+var RoleChangesSchema = z4.strictObject({
+  maxReplicas: z4.number().int().min(1).optional(),
+  backlogThreshold: z4.number().positive().optional(),
+  wakeTriggers: z4.array(CharterTriggerSchema).optional(),
+  verbs: z4.array(VerbNameSchema).optional()
+}).refine((changes) => Object.values(changes).some((value) => value !== void 0), {
+  message: "a reallocation changes at least one of maxReplicas, backlogThreshold, wakeTriggers, verbs"
+});
 var ReallocationProposalSchema = z4.object({
+  role: NameSchema,
+  changes: RoleChangesSchema,
   description: z4.string().min(1)
 });
+var LegacyReallocationSchema = z4.object({ description: z4.string().min(1) });
+function applyRoleChanges(role2, changes) {
+  return {
+    ...role2,
+    ...changes.maxReplicas === void 0 ? {} : { maxReplicas: changes.maxReplicas },
+    ...changes.backlogThreshold === void 0 ? {} : { backlogThreshold: changes.backlogThreshold },
+    ...changes.wakeTriggers === void 0 ? {} : { wakeTriggers: [...changes.wakeTriggers] },
+    ...changes.verbs === void 0 ? {} : { verbs: [...changes.verbs] }
+  };
+}
+function listedOrNone(values) {
+  return values.length === 0 ? "none" : values.join(", ");
+}
+function roleChangeLines(role2, changes) {
+  const lines = [];
+  if (changes.maxReplicas !== void 0 && changes.maxReplicas !== role2.maxReplicas) {
+    lines.push(`maxReplicas ${role2.maxReplicas} \u2192 ${changes.maxReplicas}`);
+  }
+  if (changes.backlogThreshold !== void 0 && changes.backlogThreshold !== role2.backlogThreshold) {
+    lines.push(`backlogThreshold ${role2.backlogThreshold} \u2192 ${changes.backlogThreshold}`);
+  }
+  const wakes = changes.wakeTriggers;
+  if (wakes !== void 0 && (wakes.length !== role2.wakeTriggers.length || wakes.some((trigger) => !role2.wakeTriggers.includes(trigger)))) {
+    lines.push(`wakeTriggers ${listedOrNone(role2.wakeTriggers)} \u2192 ${listedOrNone(wakes)}`);
+  }
+  if (changes.verbs !== void 0) {
+    const next = changes.verbs;
+    const added = next.filter((verb) => !role2.verbs.includes(verb)).map((verb) => `+${verb}`);
+    const removed = role2.verbs.filter((verb) => !next.includes(verb)).map((verb) => `\u2212${verb}`);
+    if (added.length + removed.length > 0) {
+      lines.push(`verbs ${[...added, ...removed].join(" ")}`);
+    }
+  }
+  return lines;
+}
 var RetirementProposalSchema = z4.object({
   agent: NameSchema,
   reason: z4.string().min(1)
@@ -649,6 +694,32 @@ var ROLE_KIND_APPROVERS = {
   reallocation: [USER_ROLE, "steward"],
   skill: [USER_ROLE, "steward"]
 };
+var USER_DECIDED_ROLE_CHANGES = ["verbs", "maxReplicas"];
+function proposalApprovers(kind, charter) {
+  if (kind === "reallocation") {
+    const parsed = ReallocationProposalSchema.safeParse(charter);
+    if (parsed.success && USER_DECIDED_ROLE_CHANGES.some((field) => parsed.data.changes[field] !== void 0)) {
+      return [USER_ROLE];
+    }
+  }
+  return ROLE_KIND_APPROVERS[kind];
+}
+function describeRoleChanges(changes) {
+  const parts = [];
+  if (changes.maxReplicas !== void 0) {
+    parts.push(`up to ${changes.maxReplicas} per project`);
+  }
+  if (changes.backlogThreshold !== void 0) {
+    parts.push(`backlog threshold ${changes.backlogThreshold}`);
+  }
+  if (changes.wakeTriggers !== void 0) {
+    parts.push(changes.wakeTriggers.length === 0 ? "no ambient wakes" : `wakes on ${changes.wakeTriggers.join(", ")}`);
+  }
+  if (changes.verbs !== void 0) {
+    parts.push(`${changes.verbs.length} verbs`);
+  }
+  return parts.join(", ");
+}
 function describeCharter(kind, charter) {
   switch (kind) {
     case "member": {
@@ -680,9 +751,14 @@ function describeCharter(kind, charter) {
     }
     case "reallocation": {
       const parsed = ReallocationProposalSchema.safeParse(charter);
-      if (!parsed.success)
+      if (parsed.success) {
+        const { role: role2, changes, description } = parsed.data;
+        return `reallocation of role ${role2} (${describeRoleChanges(changes)}): ${description}`;
+      }
+      const legacy = LegacyReallocationSchema.safeParse(charter);
+      if (!legacy.success)
         break;
-      return `reallocation: ${parsed.data.description}`;
+      return `reallocation: ${legacy.data.description}`;
     }
     case "skill": {
       const parsed = SkillProposalSchema.safeParse(charter);
@@ -1740,7 +1816,7 @@ var RunnerConfigSchema = z11.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.20";
+var STELLARIS_VERSION = "0.3.21";
 
 // packages/board-core/dist/errors.js
 var BoardError = class extends Error {
@@ -4474,18 +4550,16 @@ ${DASHBOARD_LINE}
   async readDigest(actor, input = {}) {
     const args = VerbInputs.read_inbox.parse(input);
     await this.authorize(actor, "read_inbox");
-    return this.mutex.run(async () => {
-      const stored = await this.readCursors(actor.name);
-      const from = args.since_cursor === void 0 ? stored : { ...NO_CURSORS, digest: args.since_cursor };
-      const conversation = actor.scope === void 0 ? void 0 : { scope: actor.scope, part: conversationPart(actor) ?? null };
-      const filed = (await this.digestSince(actor, from, conversation)).slice(0, args.limit);
-      if (args.advance) {
-        await this.advanceCursors(actor.name, filed);
-      }
-      const last = filed.at(-1)?.message.id;
-      const cursor = last ?? (conversation === void 0 ? from.digest : cursorOf(from, conversation.scope, conversation.part));
-      return { messages: filed.map((entry) => entry.message), cursor };
-    });
+    const { cursors: stored, upto } = await this.digestSnapshot(actor.name);
+    const from = args.since_cursor === void 0 ? stored : { ...NO_CURSORS, digest: args.since_cursor };
+    const conversation = actor.scope === void 0 ? void 0 : { scope: actor.scope, part: conversationPart(actor) ?? null };
+    const filed = (await this.digestSince(actor, from, upto, conversation)).slice(0, args.limit);
+    if (args.advance) {
+      await this.mutex.run(() => this.advanceCursors(actor.name, filed));
+    }
+    const last = filed.at(-1)?.message.id;
+    const cursor = last ?? (conversation === void 0 ? from.digest : cursorOf(from, conversation.scope, conversation.part));
+    return { messages: filed.map((entry) => entry.message), cursor };
   }
   /**
    * How many unread digest messages a member has in each conversation: a scope's home, for its
@@ -4497,28 +4571,39 @@ ${DASHBOARD_LINE}
    * whose signals that call for action wake their readers directly.
    */
   async unreadByConversation(actor) {
-    return this.mutex.run(async () => {
-      const counts = /* @__PURE__ */ new Map();
-      const unscoped = { name: actor.name, role: actor.role };
-      for (const { scope, part, message, news } of await this.digestSince(unscoped, await this.readCursors(actor.name))) {
-        if (news === true || message.step !== void 0 || message.author === SYSTEM_ACTOR.name) {
-          continue;
-        }
-        const posted = parseChannelRef(message.channel).project ?? SOCIETY_SCOPE;
-        if (posted !== scope && scope !== SOCIETY_SCOPE) {
-          continue;
-        }
-        const key = conversationKey(scope, part);
-        const entry = counts.get(key) ?? {
-          scope,
-          thread: threadOfPart(part) ?? null,
-          channel: channelOfPart(part) ?? null,
-          count: 0
-        };
-        counts.set(key, { ...entry, count: entry.count + 1 });
+    const { cursors, upto } = await this.digestSnapshot(actor.name);
+    const counts = /* @__PURE__ */ new Map();
+    const unscoped = { name: actor.name, role: actor.role };
+    for (const { scope, part, message, news } of await this.digestSince(unscoped, cursors, upto)) {
+      if (news === true || message.step !== void 0 || message.author === SYSTEM_ACTOR.name) {
+        continue;
       }
-      return [...counts.values()];
-    });
+      const posted = parseChannelRef(message.channel).project ?? SOCIETY_SCOPE;
+      if (posted !== scope && scope !== SOCIETY_SCOPE) {
+        continue;
+      }
+      const key = conversationKey(scope, part);
+      const entry = counts.get(key) ?? {
+        scope,
+        thread: threadOfPart(part) ?? null,
+        channel: channelOfPart(part) ?? null,
+        count: 0
+      };
+      counts.set(key, { ...entry, count: entry.count + 1 });
+    }
+    return [...counts.values()];
+  }
+  /**
+   * A reader's cursors and the id below which every message is already on disk, taken under the
+   * mutex, which a digest scan then leaves: messages carry ids from the same monotonic source and are
+   * written under the mutex, so the scan, which counts nothing newer than the mark, cannot pass over
+   * one written while it reads, and a post never waits for a scan.
+   */
+  digestSnapshot(agent2) {
+    return this.mutex.run(async () => ({
+      cursors: await this.readCursors(agent2),
+      upto: this.newId()
+    }));
   }
   async readCursors(agent2) {
     const file = this.paths.agentCursors(agent2);
@@ -4560,9 +4645,10 @@ ${DASHBOARD_LINE}
    * by the user wherever it is. With a conversation, only what is filed there: for a thread, every
    * message of the thread, since the conversation is about it; for a channel's, that channel's
    * top-level messages; for a scope's home, general's and those of a project the member is not in,
-   * since each thread and each other channel is a conversation of its own.
+   * since each thread and each other channel is a conversation of its own. Nothing newer than
+   * `upto` counts (see `digestSnapshot`).
    */
-  async digestSince(actor, cursors, conversation) {
+  async digestSince(actor, cursors, upto, conversation) {
     const conversationThread = threadOfPart(conversation?.part);
     if (conversation !== void 0 && conversationThread !== void 0) {
       const { scope, part } = conversation;
@@ -4570,7 +4656,7 @@ ${DASHBOARD_LINE}
       if (found === null) {
         return [];
       }
-      const messages = await this.readMessagesIn(this.paths.threadMessages(found.threads, conversationThread), cursorOf(cursors, scope, part));
+      const messages = await this.readMessagesIn(this.paths.threadMessages(found.threads, conversationThread), cursorOf(cursors, scope, part), upto);
       return messages.filter((message) => message.author !== actor.name).map((message) => ({ scope, part, message })).toSorted(byId);
     }
     const agent2 = await this.readAgent(actor.name);
@@ -4588,7 +4674,7 @@ ${DASHBOARD_LINE}
     ];
     const known = starts.filter((start) => start !== null);
     const since = known.length < starts.length ? null : known.toSorted((a, b) => a < b ? -1 : a > b ? 1 : 0)[0] ?? null;
-    for await (const message of this.iterateMessages(since)) {
+    for await (const message of this.iterateMessages(since, void 0, upto)) {
       const filedIn = wakeScope(agent2, parseChannelRef(message.channel).project);
       const thread2 = message.thread ?? null;
       const asked = message.mentions.includes(actor.name) || frontDesk && message.author === USER_NAME;
@@ -5712,6 +5798,9 @@ ${args.summary}`);
       }
       if (args.blocked_by !== void 0) {
         for (const id of args.blocked_by) {
+          if (id === current.id) {
+            throw new BoardError("VALIDATION", `task ${current.id} cannot be blocked by itself`);
+          }
           await this.findTask(id);
         }
         next = { ...next, blockedBy: [...args.blocked_by] };
@@ -5748,6 +5837,7 @@ ${args.summary}`);
           from: current.status,
           to: task2.status,
           note: args.note ?? null,
+          ...args.blocked_by === void 0 ? {} : { blockedBy: task2.blockedBy, previousBlockedBy: current.blockedBy },
           ...args.pull_request === void 0 ? {} : { pullRequest: task2.pullRequest?.url ?? null }
         });
       }
@@ -7046,12 +7136,37 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
       case "archive":
         await this.validateArchive(ArchiveProposalSchema.parse(charter).project);
         return;
-      case "reallocation":
+      case "reallocation": {
+        const parsed = ReallocationProposalSchema.safeParse(charter);
+        if (parsed.success) {
+          await this.reallocatedRole(parsed.data);
+        } else {
+          LegacyReallocationSchema.parse(charter);
+        }
         return;
+      }
       default:
         return;
     }
   }
+  /**
+   * The role as a reallocation would leave it, with what changes: refused for the user's charter,
+   * a role that does not exist, a charter the changes would make invalid, and changes the role
+   * has already.
+   */
+  async reallocatedRole(reallocation) {
+    if (reallocation.role === USER_ROLE) {
+      throw new BoardError("FORBIDDEN", "the user charter is not subject to proposals");
+    }
+    const current = await this.readRole(reallocation.role);
+    const next = RoleCharterSchema.parse(applyRoleChanges(current, reallocation.changes));
+    await this.validateRole(next);
+    const changed = roleChangeLines(current, reallocation.changes);
+    if (changed.length === 0) {
+      throw new BoardError("VALIDATION", `role ${current.name} has these values already; the reallocation changes nothing`);
+    }
+    return { next, changed };
+  }
   async executeProvision(by, proposal2) {
     const meta = { proposalId: proposal2.id };
     switch (proposal2.kind) {
@@ -7088,8 +7203,15 @@ Short, curated, loaded on every turn. Keep entries that change future behavior a
         const { members } = await this.archiveUnlocked(by, input.project, input.reason, meta);
         return { project: input.project, members };
       }
-      case "reallocation":
-        return void 0;
+      case "reallocation": {
+        const parsed = ReallocationProposalSchema.safeParse(proposal2.charter);
+        if (!parsed.success) {
+          return void 0;
+        }
+        const { next, changed } = await this.reallocatedRole(parsed.data);
+        await this.writeRoleUnlocked(by, next, meta);
+        return { role: next.name, changed };
+      }
       default:
         return void 0;
     }
@@ -7789,7 +7911,7 @@ ${charter.purpose}
     if (filed.proposedBy === actor.name) {
       throw new BoardError("FORBIDDEN", "a proposer never decides its own proposal");
     }
-    const approvers = ROLE_KIND_APPROVERS[filed.kind];
+    const approvers = proposalApprovers(filed.kind, filed.charter);
     if (!approvers.includes(actor.role)) {
       throw new BoardError("FORBIDDEN", `a ${filed.kind} proposal requires one of: ${approvers.join(", ")}`);
     }
@@ -7872,7 +7994,7 @@ ${charter.purpose}
       }
       if (subject?.kind === "proposal") {
         const proposal2 = await this.readProposal(subject.id);
-        if (proposal2.proposedBy === actor.name || proposal2.decidedBy === actor.name || ROLE_KIND_APPROVERS[proposal2.kind].includes(actor.role)) {
+        if (proposal2.proposedBy === actor.name || proposal2.decidedBy === actor.name || proposalApprovers(proposal2.kind, proposal2.charter).includes(actor.role)) {
           return true;
         }
         return (await this.readRole(actor.role)).wakeTriggers.includes(OPS_WAKE_TRIGGER);
@@ -7929,11 +8051,12 @@ ${charter.purpose}
     });
     await this.endCronsUnlocked(by, `its thread closed: its ${found.thread.subject?.kind ?? "subject"} was ${ended}`, (cron2) => cron2.thread === subjectId);
   }
-  async readMessagesIn(dir, since) {
+  /** The messages in a folder after `since` and, when given, up to `upto`, read by name first. */
+  async readMessagesIn(dir, since, upto) {
     const messages = [];
     for (const file of await listFiles(dir)) {
       const id = file.slice(0, 26);
-      if (since !== null && id <= since) {
+      if (since !== null && id <= since || upto !== void 0 && id > upto) {
         continue;
       }
       const doc = await readMarkdown(path6.join(dir, file), MessageFrontmatterSchema);
@@ -7941,20 +8064,23 @@ ${charter.purpose}
     }
     return messages;
   }
-  /** Every message newer than `since` across society channels, project channels, and threads. */
-  async *iterateMessages(since, project2) {
+  /**
+   * Every message newer than `since`, and no newer than `upto` when given, across society
+   * channels, project channels, and threads.
+   */
+  async *iterateMessages(since, project2, upto) {
     if (project2 === void 0) {
       for (const channel of await listDirs(this.paths.societyChannels())) {
-        yield* await this.readMessagesIn(this.paths.societyChannel(channel), since);
+        yield* await this.readMessagesIn(this.paths.societyChannel(channel), since, upto);
       }
-      yield* this.threadMessagesIn(this.paths.societyThreads(), since);
+      yield* this.threadMessagesIn(this.paths.societyThreads(), since, upto);
     }
     const projects = project2 === void 0 ? await listDirs(this.paths.projects()) : [project2];
     for (const slug of projects) {
       for (const channel of await listDirs(this.paths.projectChannels(slug))) {
-        yield* await this.readMessagesIn(this.paths.projectChannel(slug, channel), since);
+        yield* await this.readMessagesIn(this.paths.projectChannel(slug, channel), since, upto);
       }
-      yield* this.threadMessagesIn(this.paths.threads(slug), since);
+      yield* this.threadMessagesIn(this.paths.threads(slug), since, upto);
     }
   }
   /** Every folder that holds messages: each channel's and each thread's, in the society and every project. */
@@ -7974,9 +8100,9 @@ ${charter.purpose}
       }
     }
   }
-  async *threadMessagesIn(threads, since) {
+  async *threadMessagesIn(threads, since, upto) {
     for (const id of await listDirs(threads)) {
-      yield* await this.readMessagesIn(this.paths.threadMessages(threads, id), since);
+      yield* await this.readMessagesIn(this.paths.threadMessages(threads, id), since, upto);
     }
   }
 };