@kubitnodes/stellaris 0.3.0 → 0.3.2

package/dist/cli/index.js

@@ -678,6 +678,8 @@ var BOARD_EVENT_TYPES = [
   "paused.changed",
   "wake.requested",
   "turn.started",
+  "turn.steered",
+  "turn.stopped",
   "turn.completed",
   "turn.failed",
   "merge.completed",
@@ -709,7 +711,8 @@ var TurnExitReasonSchema = z5.enum([
   "timeout",
   "error",
   "interrupted",
-  "blocked"
+  "blocked",
+  "stopped"
 ]);
 var AgentEventSchema = z5.discriminatedUnion("type", [
   z5.object({
@@ -720,6 +723,16 @@ var AgentEventSchema = z5.discriminatedUnion("type", [
     /** The model the CLI reports running, when it reports one. */
     model: z5.string().optional()
   }),
+  /**
+   * The CLI took a steer into the running turn. Adapters name the steer; the server adds the
+   * messages it delivered and the text the CLI was given.
+   */
+  z5.object({
+    type: z5.literal("steered"),
+    steer: z5.string().min(1),
+    messages: z5.array(UlidSchema).optional(),
+    text: z5.string().optional()
+  }),
   z5.object({ type: z5.literal("text"), delta: z5.string() }),
   z5.object({ type: z5.literal("tool_call"), name: z5.string(), input: z5.unknown() }),
   z5.object({
@@ -767,6 +780,12 @@ var RunnerHelloSchema = z6.object({
   clis: z6.array(CliKindSchema),
   /** The CLIs whose adapter can keep a session warm between turns. */
   residentClis: z6.array(CliKindSchema).default([]),
+  /** The CLIs whose adapter can take input into a running turn; the server steers only these. */
+  steerableClis: z6.array(CliKindSchema).default([]),
+  /** The CLIs whose adapter can stop a running turn; the server stops only these. */
+  stoppableClis: z6.array(CliKindSchema).default([]),
+  /** Whether the runner answers file reads on its projects' branches; one from before never does. */
+  branchReads: z6.boolean().default(false),
   capabilities: z6.array(z6.string()).default([]),
   /** Turns the runner runs at once, or null for no limit. */
   slots: z6.number().int().positive().nullable(),
@@ -870,10 +889,54 @@ var LandRequestSchema = z6.object({
 });
 var MergeOutcomeSchema = z6.object({ ok: z6.boolean(), detail: z6.string() });
 var ModelListSchema = z6.array(ModelOptionSchema);
+var BRANCH_FILE_LIMIT_BYTES = 8 * 1024 * 1024;
+var BranchPathSchema = z6.string().max(4096).refine((value) => value === "" || value.split("/").every((segment) => segment !== "" && segment !== "." && segment !== ".." && !segment.includes("\0")), { message: "a path inside the branch, with no empty, `.`, or `..` segment" });
+var BranchNameSchema = z6.string().regex(/^[A-Za-z0-9][A-Za-z0-9._/-]*$/);
+var BranchReadSchema = z6.object({
+  repo: ProjectRepoSchema,
+  branch: BranchNameSchema,
+  path: BranchPathSchema
+});
+var BranchCommitSchema = z6.object({
+  id: z6.string().min(1),
+  at: IsoDateTimeSchema,
+  author: z6.string()
+});
+var BranchFileSchema = z6.discriminatedUnion("kind", [
+  z6.object({
+    kind: z6.literal("file"),
+    path: BranchPathSchema,
+    commit: BranchCommitSchema,
+    size: z6.number().int().nonnegative(),
+    content: z6.string().nullable()
+  }),
+  z6.object({
+    kind: z6.literal("dir"),
+    path: BranchPathSchema,
+    commit: BranchCommitSchema,
+    entries: z6.array(z6.object({
+      name: z6.string().min(1),
+      kind: z6.enum(["file", "dir"]),
+      size: z6.number().int().nonnegative().nullable()
+    }))
+  })
+]);
+var TurnSteerSchema = z6.object({ id: z6.uuid(), text: z6.string().min(1) });
 var RunnerMessageSchema = z6.discriminatedUnion("type", [
   z6.object({ type: z6.literal("turn"), job: TurnJobSchema }),
   z6.object({ type: z6.literal("land"), request: z6.string().min(1), land: LandRequestSchema }),
-  z6.object({ type: z6.literal("models"), request: z6.string().min(1), cli: CliKindSchema })
+  z6.object({ type: z6.literal("models"), request: z6.string().min(1), cli: CliKindSchema }),
+  /** Answered with a `BranchFile`, or null when the branch or the path does not exist. */
+  z6.object({ type: z6.literal("file"), request: z6.string().min(1), read: BranchReadSchema }),
+  /** Answered with whether the CLI accepted it; that it took it comes as a `steered` event. */
+  z6.object({
+    type: z6.literal("steer"),
+    request: z6.string().min(1),
+    turnId: UlidSchema,
+    steer: TurnSteerSchema
+  }),
+  /** Answered with whether the turn was there to stop; it ends `stopped`. */
+  z6.object({ type: z6.literal("stop"), request: z6.string().min(1), turnId: UlidSchema })
 ]);
 var RunnerAnswerSchema = z6.discriminatedUnion("ok", [
   z6.object({ ok: z6.literal(true), value: z6.unknown() }),
@@ -949,7 +1012,19 @@ var TurnRecordSchema = z7.object({
   /** The model the CLI reported for this turn, else the model configured for the agent, else null. */
   model: z7.string().nullable().default(null),
   /** The task branch the turn left work on, with its commit, as the runner reported it. */
-  work: TurnWorkSchema.optional()
+  work: TurnWorkSchema.optional(),
+  /** Who stopped the turn, for one that ended `stopped`. */
+  stoppedBy: NameSchema.optional()
+});
+var RunningTurnSchema = z7.object({
+  turnId: UlidSchema,
+  agent: NameSchema,
+  scope: NameSchema,
+  thread: UlidSchema.optional(),
+  cli: CliKindSchema,
+  channel: ChannelRefSchema.optional(),
+  steerable: z7.boolean(),
+  stoppable: z7.boolean()
 });
 var SessionsFileSchema = z7.object({
   claude: z7.string().optional(),
@@ -1160,7 +1235,7 @@ var RunnerConfigSchema = z10.object({
 });
 
 // packages/shared/dist/version.js
-var STELLARIS_VERSION = "0.3.0";
+var STELLARIS_VERSION = "0.3.2";
 
 // packages/board-core/dist/errors.js
 var BoardError = class extends Error {
@@ -1704,10 +1779,12 @@ var TaskPayload = z11.object({
   from: z11.string().optional()
 });
 var MessagePayload = z11.object({
+  id: z11.string().optional(),
   channel: z11.string(),
   thread: z11.string().nullable().optional(),
   mentions: z11.array(z11.string()).default([])
 });
+var SteeredPayload = z11.object({ messages: z11.array(z11.string()) });
 var SignalPayload = z11.object({
   kind: z11.string(),
   key: z11.string(),
@@ -1814,6 +1891,23 @@ function computeMetrics(input) {
         }
         break;
       }
+      case "turn.steered": {
+        const steered = SteeredPayload.safeParse(event.payload);
+        if (!steered.success) {
+          break;
+        }
+        const delivered = new Set(steered.data.messages);
+        const at = Date.parse(event.ts);
+        const answered = waiting.filter((mention) => mention.agent === event.actor && mention.message !== null && delivered.has(mention.message));
+        if (answered.length > 0) {
+          latencies.set(event.actor, [
+            ...latencies.get(event.actor) ?? [],
+            ...answered.map((mention) => at - mention.at)
+          ]);
+          waiting = waiting.filter((mention) => !answered.includes(mention));
+        }
+        break;
+      }
       case "task.completed": {
         const task2 = TaskPayload.safeParse(event.payload);
         if (counted && task2.success) {
@@ -1878,6 +1972,7 @@ function computeMetrics(input) {
           waiting.push({
             agent: name,
             at: Date.parse(event.ts),
+            message: message.data.id ?? null,
             thread: thread2,
             scopes: [project2, wakeScope(citizen, project2)].filter((scope) => scope !== null)
           });
@@ -4690,6 +4785,21 @@ ${rationale}`}`);
       });
     });
   }
+  /** Where a conversation's digest resumes: the newest message a turn there was shown. */
+  async digestCursor(agent2, scope, thread2) {
+    return this.mutex.run(async () => cursorOf(await this.readCursors(agent2), scope, thread2 ?? null));
+  }
+  /** Records that a running turn took posts delivered into it, which wake latency counts to. */
+  async recordSteered(input) {
+    await this.mutex.run(async () => {
+      await this.events.append("turn.steered", input.agent, {
+        turnId: input.turnId,
+        project: input.project,
+        ...input.thread === void 0 ? {} : { thread: input.thread },
+        messages: [...input.messages]
+      });
+    });
+  }
   /** Where a conversation's session ids and last turn are kept: the scope's home, or a thread's. */
   sessionDir(agent2, scope, thread2) {
     return thread2 === void 0 ? this.paths.agentProject(agent2, scope) : this.paths.agentThread(agent2, scope, thread2);
@@ -4759,6 +4869,14 @@ ${rationale}`}`);
       }
       await this.writeTurnRecord(parsed);
       await this.refreshMember(parsed.agent);
+      if (parsed.exitReason === "stopped") {
+        await this.events.append("turn.stopped", parsed.stoppedBy ?? USER_NAME, {
+          ...parsed.id === void 0 ? {} : { turnId: parsed.id },
+          agent: parsed.agent,
+          project: parsed.project,
+          ...parsed.thread === void 0 ? {} : { thread: parsed.thread }
+        });
+      }
       await this.events.append(failed ? "turn.failed" : "turn.completed", parsed.agent, {
         ...parsed.id === void 0 ? {} : { turnId: parsed.id },
         project: parsed.project,