@cuongtran001/kanna 1.2.0 → 1.3.0

package/src/server/auto-continue/read-model.ts

@@ -10,6 +10,9 @@ export interface ChatSchedulesProjection {
 export interface LoopState {
   subagentId: string
   prompt: string
+  /** Timestamp of the `loop_armed` event that armed the current loop. Used by
+   *  the Loop Progress panel to exclude delegations from before the arm. */
+  armedAt: number
 }
 
 /**
@@ -27,7 +30,7 @@ export function deriveLoopState(
   for (const event of events) {
     if (event.chatId !== chatId) continue
     if (event.kind === "loop_armed") {
-      state = { subagentId: event.subagentId, prompt: event.prompt }
+      state = { subagentId: event.subagentId, prompt: event.prompt, armedAt: event.timestamp }
     } else if (event.kind === "loop_disarmed") {
       state = null
     }

package/src/server/event-store.ts

@@ -897,6 +897,7 @@ export class EventStore implements PushEventStore {
           chatId: e.chatId,
           subagentId: e.subagentId,
           subagentName: e.subagentName,
+          label: e.label ?? null,
           provider: e.provider,
           model: e.model,
           status: "running",

package/src/server/events.ts

@@ -335,6 +335,9 @@ export type SubagentRunEvent =
       runId: string
       subagentId: string | null
       subagentName: string
+      /** Short prompt-derived label (see SubagentRunSnapshot.label). Optional for
+       *  back-compat: older events and error paths omit it. */
+      label?: string
       provider: AgentProvider
       model: string
       parentUserMessageId: string

package/src/server/read-models.ts

@@ -7,16 +7,18 @@ import type {
   CustomModelEntry,
   KannaStatus,
   LocalProjectsSnapshot,
+  LoopRateLimitInfo,
   SidebarChatRow,
   SidebarData,
   SidebarProjectGroup,
   StackSummary,
 } from "../shared/types"
 import { mergeCustomModels } from "../shared/types"
+import { buildLoopProgress } from "../shared/loop-progress"
 import type { ChatRecord, ChatTimingState, StoreState } from "./events"
 import { resolveLocalPath } from "./paths"
 import { SERVER_PROVIDERS } from "./provider-catalog"
-import { deriveChatSchedules } from "./auto-continue/read-model"
+import { deriveChatSchedules, deriveLoopState } from "./auto-continue/read-model"
 import { deriveChatTunnels } from "./cloudflare-tunnel/read-model"
 import type { CloudflareTunnelEvent } from "./cloudflare-tunnel/events"
 
@@ -336,6 +338,28 @@ export function deriveChatSnapshot(
       )
     : {}
 
+  const loopState = deriveLoopState(autoContinueEvents, chat.id)
+  const liveSchedule = liveScheduleId ? schedules[liveScheduleId] : undefined
+  const rateLimit: LoopRateLimitInfo | null =
+    loopState
+    && liveSchedule
+    && (liveSchedule.state === "proposed" || liveSchedule.state === "scheduled")
+    && liveSchedule.resetAt != null
+      ? {
+          scheduleId: liveSchedule.scheduleId,
+          resetAt: liveSchedule.resetAt,
+          tz: liveSchedule.tz ?? "system",
+          scheduled: liveSchedule.state === "scheduled",
+        }
+      : null
+  const loopProgress = buildLoopProgress({
+    chatId: chat.id,
+    armed: loopState !== null,
+    loopArmedAt: loopState?.armedAt ?? null,
+    runs: subagentRunsMap ? [...subagentRunsMap.values()] : [],
+    rateLimit,
+  })
+
   return {
     runtime,
     queuedMessages: (state.queuedMessagesByChatId.get(chat.id) ?? []).map((entry) => ({
@@ -352,6 +376,7 @@ export function deriveChatSnapshot(
     tunnels,
     liveTunnelId,
     subagentRuns,
+    loopProgress,
     ...(resolvedBindings !== undefined ? { resolvedBindings } : {}),
   }
 }

package/src/server/subagent-orchestrator.ts

@@ -1,6 +1,7 @@
 import crypto from "node:crypto"
 import { LOG_PREFIX } from "../shared/branding"
 import { log } from "../shared/log"
+import { deriveChunkLabel } from "../shared/loop-progress"
 import type {
   AgentProvider,
   ProviderUsage,
@@ -780,6 +781,7 @@ export class SubagentOrchestrator {
     runId?: string
   }): Promise<DelegationOutcome> {
     const runId = args.runId ?? crypto.randomUUID()
+    const label = deriveChunkLabel(args.userInstruction)
     await this.deps.store.appendSubagentEvent({
       v: 3,
       type: "subagent_run_started",
@@ -788,6 +790,7 @@ export class SubagentOrchestrator {
       runId,
       subagentId: args.subagent.id,
       subagentName: args.subagent.name,
+      ...(label ? { label } : {}),
       provider: args.subagent.provider,
       model: args.subagent.model,
       parentUserMessageId: args.parentUserMessageId,

package/src/shared/loop-progress.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, test } from "bun:test"
+import { buildLoopProgress, deriveChunkLabel } from "./loop-progress"
+import type { SubagentRunSnapshot } from "./types"
+
+function run(overrides: Partial<SubagentRunSnapshot>): SubagentRunSnapshot {
+  return {
+    runId: "run-1",
+    chatId: "c1",
+    subagentId: "sa-1",
+    subagentName: "subagent-general",
+    label: null,
+    provider: "claude",
+    model: "claude-sonnet-4-6",
+    status: "running",
+    parentUserMessageId: "m1",
+    parentRunId: null,
+    depth: 0,
+    startedAt: 1_000,
+    finishedAt: null,
+    finalText: null,
+    error: null,
+    usage: null,
+    entries: [],
+    pendingTool: null,
+    ...overrides,
+  }
+}
+
+describe("deriveChunkLabel", () => {
+  test("first non-blank line, trimmed", () => {
+    expect(deriveChunkLabel("\n\n  Migrate useKannaState.ts  \nmore detail")).toBe(
+      "Migrate useKannaState.ts",
+    )
+  })
+
+  test("strips a single leading markdown marker", () => {
+    expect(deriveChunkLabel("- Fix Dockerfiles for Berry")).toBe("Fix Dockerfiles for Berry")
+    expect(deriveChunkLabel("## Build + start full stack")).toBe("Build + start full stack")
+    expect(deriveChunkLabel("3. Verify service health")).toBe("Verify service health")
+    expect(deriveChunkLabel("> quoted chunk")).toBe("quoted chunk")
+  })
+
+  test("does not mistake mid-line content for a marker", () => {
+    expect(deriveChunkLabel("3D rendering pipeline")).toBe("3D rendering pipeline")
+  })
+
+  test("caps overlong labels with an ellipsis", () => {
+    const long = "x".repeat(200)
+    const label = deriveChunkLabel(long)
+    expect(label.length).toBe(80)
+    expect(label.endsWith("…")).toBe(true)
+  })
+
+  test("empty prompt → empty string", () => {
+    expect(deriveChunkLabel("   \n  ")).toBe("")
+  })
+})
+
+describe("buildLoopProgress", () => {
+  test("maps run status → row status and prefers label over subagentName", () => {
+    const snapshot = buildLoopProgress({
+      chatId: "c1",
+      armed: true,
+      loopArmedAt: 0,
+      rateLimit: null,
+      runs: [
+        run({ runId: "r1", status: "completed", label: "chunk one", startedAt: 10, finishedAt: 20 }),
+        run({ runId: "r2", status: "running", label: null, subagentName: "worker", startedAt: 30 }),
+        run({ runId: "r3", status: "failed", label: "chunk three", startedAt: 40 }),
+      ],
+    })
+    expect(snapshot.rows.map((r) => [r.runId, r.status, r.label])).toEqual([
+      ["r3", "failed", "chunk three"],
+      ["r2", "running", "worker"], // label fallback to subagentName
+      ["r1", "done", "chunk one"],
+    ])
+  })
+
+  test("excludes nested sub-spawns and runs started before the loop armed", () => {
+    const snapshot = buildLoopProgress({
+      chatId: "c1",
+      armed: true,
+      loopArmedAt: 100,
+      rateLimit: null,
+      runs: [
+        run({ runId: "pre", startedAt: 50 }), // before arm → excluded
+        run({ runId: "nested", startedAt: 150, depth: 1 }), // sub-spawn → excluded
+        run({ runId: "keep", startedAt: 200 }),
+      ],
+    })
+    expect(snapshot.rows.map((r) => r.runId)).toEqual(["keep"])
+  })
+
+  test("passes rate-limit through and reflects armed flag", () => {
+    const snapshot = buildLoopProgress({
+      chatId: "c1",
+      armed: false,
+      loopArmedAt: null,
+      rateLimit: { scheduleId: "s1", resetAt: 123, tz: "Asia/Saigon", scheduled: false },
+      runs: [],
+    })
+    expect(snapshot.armed).toBe(false)
+    expect(snapshot.rateLimit).toEqual({ scheduleId: "s1", resetAt: 123, tz: "Asia/Saigon", scheduled: false })
+    expect(snapshot.rows).toEqual([])
+  })
+})

package/src/shared/loop-progress.ts

@@ -0,0 +1,88 @@
+import type {
+  LoopProgressSnapshot,
+  LoopRateLimitInfo,
+  LoopRow,
+  LoopRowStatus,
+  SubagentRunSnapshot,
+} from "./types"
+
+/**
+ * Loop Progress — a per-chat, read-only view of an armed autonomous loop's
+ * work, surfaced as a checklist panel (mockup: a "Progress" card with one row
+ * per chunk). Event-sourced per round: each background subagent delegation the
+ * loop fires becomes one row, its status driven by the existing subagent-run
+ * lifecycle events. A rate-limited loop (see the rate-limit-resilience fix)
+ * surfaces a distinct "resume" affordance instead of looking silently stuck.
+ *
+ * These helpers are pure so the server read-model and the client share one
+ * shape; the DTO types live in ./types to avoid a runtime import cycle.
+ */
+
+const MAX_LABEL = 80
+
+/**
+ * First non-blank line of a spawn prompt, stripped of a single leading markdown
+ * marker (heading / list / quote / ordinal) and capped to a chip-friendly
+ * length. Deterministic and side-effect free so it can run at delegate time on
+ * the server and be asserted in unit tests.
+ */
+export function deriveChunkLabel(prompt: string): string {
+  const firstLine =
+    prompt
+      .split("\n")
+      .map((line) => line.trim())
+      .find((line) => line.length > 0) ?? ""
+  const stripped = firstLine.replace(/^(#{1,6}\s+|[-*+]\s+|\d+[.)]\s+|>\s+)/, "").trim()
+  const cleaned = stripped.length > 0 ? stripped : firstLine
+  if (cleaned.length <= MAX_LABEL) return cleaned
+  return `${cleaned.slice(0, MAX_LABEL - 1).trimEnd()}…`
+}
+
+function rowStatusFor(run: SubagentRunSnapshot): LoopRowStatus {
+  switch (run.status) {
+    case "running":
+      return "running"
+    case "completed":
+      return "done"
+    default:
+      // failed | cancelled | any future terminal-failure state
+      return "failed"
+  }
+}
+
+export interface BuildLoopProgressInput {
+  chatId: string
+  armed: boolean
+  /** Timestamp of the current `loop_armed` event; rows before it are excluded. */
+  loopArmedAt: number | null
+  /** All subagent runs for the chat (any order). */
+  runs: readonly SubagentRunSnapshot[]
+  rateLimit: LoopRateLimitInfo | null
+}
+
+/**
+ * Fold the chat's subagent runs + loop/rate-limit state into the panel DTO.
+ * Only top-level (depth 0) runs started since the loop was armed count as loop
+ * rows — nested sub-spawns and pre-loop delegations are excluded. Rows are
+ * sorted newest-first.
+ */
+export function buildLoopProgress(input: BuildLoopProgressInput): LoopProgressSnapshot {
+  const since = input.loopArmedAt ?? 0
+  const rows: LoopRow[] = input.runs
+    .filter((run) => run.depth === 0 && run.startedAt >= since)
+    .map((run) => ({
+      runId: run.runId,
+      label: run.label ?? run.subagentName,
+      status: rowStatusFor(run),
+      startedAt: run.startedAt,
+      finishedAt: run.finishedAt,
+    }))
+    .sort((a, b) => b.startedAt - a.startedAt)
+
+  return {
+    chatId: input.chatId,
+    armed: input.armed,
+    rows,
+    rateLimit: input.rateLimit,
+  }
+}

package/src/shared/types.ts

@@ -1889,6 +1889,14 @@ export interface SubagentRunSnapshot {
   chatId: string
   subagentId: string | null
   subagentName: string
+  /**
+   * Short human label for this run, derived from the first line of the spawn
+   * prompt (e.g. "Migrate useKannaState.ts"). Null for runs started before this
+   * field existed or by error paths that never carried a prompt. Drives the
+   * Loop Progress panel rows so each round reads as the chunk it worked on
+   * rather than an opaque run id.
+   */
+  label: string | null
   provider: AgentProvider
   model: string
   status: SubagentRunStatus
@@ -1917,6 +1925,41 @@ export interface SubagentRunSnapshot {
   pendingTool: SubagentPendingTool | null
 }
 
+export type LoopRowStatus = "pending" | "running" | "done" | "failed"
+
+export interface LoopRow {
+  runId: string
+  label: string
+  status: LoopRowStatus
+  startedAt: number
+  finishedAt: number | null
+}
+
+export interface LoopRateLimitInfo {
+  /** The live auto-continue schedule id, so the panel's Resume action can accept it. */
+  scheduleId: string
+  /** epoch ms the usage limit resets (and the resume is/would be scheduled for) */
+  resetAt: number
+  tz: string
+  /**
+   * true  → an auto-continue is already scheduled to fire at `resetAt`
+   *         (the loop resumes on its own).
+   * false → the resume is only proposed and waits on the user
+   *         (auto-resume setting off) — render a "Resume" action.
+   */
+  scheduled: boolean
+}
+
+export interface LoopProgressSnapshot {
+  chatId: string
+  /** Whether a loop is currently armed for this chat. */
+  armed: boolean
+  /** Latest first — most recent delegation at the top, mirroring PROGRESS.md. */
+  rows: LoopRow[]
+  /** Non-null while the loop is paused on a Claude usage limit. */
+  rateLimit: LoopRateLimitInfo | null
+}
+
 export interface ChatSnapshot {
   runtime: ChatRuntime
   queuedMessages: QueuedChatMessage[]
@@ -1931,6 +1974,8 @@ export interface ChatSnapshot {
   liveTunnelId: string | null
   resolvedBindings?: ResolvedStackBinding[]
   subagentRuns: Record<string, SubagentRunSnapshot>
+  /** Loop Progress panel view — armed state, per-round rows, rate-limit resume. */
+  loopProgress: LoopProgressSnapshot
 }
 
 export interface ChatHistoryPage {

package/dist/client/assets/channel-BMkhjiLI.js

@@ -1 +0,0 @@
-import{U as a,D as n}from"./mermaid.core-KYiCPJDj.js";const t=(r,o)=>a.lang.round(n.parse(r)[o]);export{t as c};

package/dist/client/assets/classDiagram-4FO5ZUOK-C5Kg1XOD.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-727SXJPM-1FNK9_nB.js";import{_ as i}from"./mermaid.core-KYiCPJDj.js";import"./chunk-FMBD7UC4-B7MLrDa7.js";import"./chunk-ND2GUHAM-D4Df05QE.js";import"./chunk-55IACEB6-9-aj4jKO.js";import"./chunk-2J33WTMH-psdZuajw.js";import"./index-zQLLeAfl.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};

package/dist/client/assets/classDiagram-v2-Q7XG4LA2-C5Kg1XOD.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-727SXJPM-1FNK9_nB.js";import{_ as i}from"./mermaid.core-KYiCPJDj.js";import"./chunk-FMBD7UC4-B7MLrDa7.js";import"./chunk-ND2GUHAM-D4Df05QE.js";import"./chunk-55IACEB6-9-aj4jKO.js";import"./chunk-2J33WTMH-psdZuajw.js";import"./index-zQLLeAfl.js";var n={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{n as diagram};