@k2b/cloud 0.25.0 → 0.26.0

package/src/ai/store.ts

@@ -8,6 +8,7 @@ import { AI_MEMORY_LEARNING_DEFAULT_ENABLED } from "./prefs";
 import type { AiTurnBlock } from "./protocol";
 import { withAiShortId, withAiShortIdForDb } from "./short-id";
 import { parseAiTodoPlan } from "./todo-contracts";
+import { activeTurnWaits } from "./turn-timing";
 import type {
   AiConversation,
   AiConversationDraft,
@@ -777,6 +778,76 @@ const messageSearchText = (message: Message): string => {
   return text.slice(0, SEARCH_TEXT_MAX_CHARS);
 };
 
+/**
+ * Record how a turn ended on its messages when its loop could not record it: a stop while an approval waits, a run
+ * time limit, or a turn the sweep finalizes. History reads the ending from the last assistant message, so such a turn
+ * never looks finished. A failure replaces the `aborted` that a loop cut off by its run time limit recorded, so the
+ * limit never looks like a user stop. A call the user approved that never returned keeps its approval in history.
+ */
+const recordTurnEnd = async (
+  db: typeof sql,
+  input: { conversationId: string; turnId: string; reason: "aborted" | "error" },
+): Promise<void> => {
+  const replaces = input.reason === "error" ? "aborted" : null;
+  for (const table of ["ai.messages", "ai.task_messages"]) {
+    await db`
+      UPDATE ${db(table)}
+      SET loop_done_reason = ${input.reason}
+      WHERE id = (
+        SELECT id
+        FROM ${db(table)}
+        WHERE conversation_id = ${input.conversationId}
+          AND loop_id = ${input.turnId}::text
+          AND compacted_at IS NULL
+          AND kind = 'message'
+          AND role = 'assistant'
+        ORDER BY seq DESC
+        LIMIT 1
+      )
+        AND (loop_done_reason IS NULL OR loop_done_reason = ${replaces}::text)
+    `;
+    // An approved call without a result keeps the decision on the message that holds the call. A decision on a custom
+    // approval belongs to the call that asked for it.
+    await db`
+      UPDATE ${db(table)} target
+      SET meta = jsonb_set(
+        COALESCE(target.meta, '{}'::jsonb),
+        '{toolOutcomes}',
+        COALESCE(target.meta->'toolOutcomes', '{}'::jsonb) || outcomes.value
+      )
+      FROM (
+        SELECT message.id, jsonb_object_agg(approved.call_id, 'approved'::text) AS value
+        FROM (
+          SELECT DISTINCT
+            CASE
+              WHEN action.kind = 'custom_approval' THEN COALESCE(substring(action.call_id FROM '^(.*)-approval-[0-9]+$'), action.call_id)
+              ELSE action.call_id
+            END AS call_id
+          FROM ai.pending_actions action
+          WHERE action.turn_id = ${input.turnId}
+            AND action.resolved_event->>'type' = 'approval_response'
+            AND action.resolved_event->>'approved' = 'true'
+        ) approved
+        JOIN ${db(table)} message
+          ON message.conversation_id = ${input.conversationId}
+          AND message.loop_id = ${input.turnId}::text
+          AND message.role = 'assistant'
+          AND message.message->'content' @> jsonb_build_array(jsonb_build_object('type', 'tool_call', 'id', approved.call_id))
+        WHERE NOT EXISTS (
+          SELECT 1
+          FROM ${db(table)} result
+          WHERE result.conversation_id = ${input.conversationId}
+            AND result.loop_id = ${input.turnId}::text
+            AND result.role = 'tool_result'
+            AND result.message->>'callId' = approved.call_id
+        )
+        GROUP BY message.id
+      ) outcomes
+      WHERE target.id = outcomes.id
+    `;
+  }
+};
+
 /** Insert a message inside an open conversation-lock transaction and bump the conversation. */
 const insertMessageLocked = async (
   input: {
@@ -925,10 +996,14 @@ const toolMessageMeta = (
   message: Message,
   presentations: ReadonlyMap<string, AiToolPresentation> | undefined,
   rejectedToolCallIds: ReadonlySet<string> | undefined,
+  approvedToolCallIds?: ReadonlySet<string>,
 ): AiStoredMessage["meta"] => {
   if (message.role === "tool_result" && rejectedToolCallIds?.has(message.callId)) {
     return { toolOutcomes: { [message.callId]: "rejected" } };
   }
+  if (message.role === "tool_result" && approvedToolCallIds?.has(message.callId)) {
+    return { toolOutcomes: { [message.callId]: "approved" } };
+  }
   if (message.role !== "assistant" || !presentations || presentations.size === 0) return null;
   const toolPresentations = Object.fromEntries(
     message.content.flatMap((block) => {
@@ -2618,10 +2693,14 @@ export const aiConversations: AiConversationService = {
       LIMIT 1
     `;
     if (!rows[0]) return null;
+    // The waits let a reconnecting client show work time without time spent waiting for the user.
+    const waits = await activeTurnWaits(rows[0].id);
     return {
       turn: rowToTurn(rows[0]),
       liveBlocks: rowToLiveBlocks(rows[0]),
       liveSeq: Number(rows[0].live_seq ?? 0),
+      actionWaitMs: Math.max(0, Math.round(waits.actionWaitMs)),
+      waitingSince: waits.waitingSince,
     };
   },
 
@@ -2822,6 +2901,11 @@ export const aiConversations: AiConversationService = {
           AND status = 'pending'
       `;
       if (input.status !== "completed") {
+        await recordTurnEnd(tx, {
+          conversationId: input.conversationId,
+          turnId: input.turnId,
+          reason: input.status === "aborted" ? "aborted" : "error",
+        });
         await tx`
           UPDATE ai.turn_steers
           SET status = 'discarded', consumed_at = COALESCE(consumed_at, now())
@@ -2922,7 +3006,7 @@ export const aiConversations: AiConversationService = {
     }));
 
     // 3) Finalize aborts: cancel-requested turns without a live lease, and expired waits.
-    const abortedRows = await sql<{ id: string; conversation_id: string; attempt: number; live_seq: number | string }[]>`
+    const abortedRows = await sql<{ id: string; conversation_id: string; attempt: number; live_seq: number | string; stopped: boolean }[]>`
       UPDATE ai.turns
       SET status = 'aborted',
           completed_at = now(),
@@ -2939,7 +3023,7 @@ export const aiConversations: AiConversationService = {
           )
         LIMIT ${limit}
       )
-      RETURNING id, conversation_id, attempt, live_seq
+      RETURNING id, conversation_id, attempt, live_seq, cancel_requested_at IS NOT NULL AS stopped
     `;
     result.aborted = abortedRows.map((row) => ({
       conversationId: row.conversation_id,
@@ -2948,7 +3032,14 @@ export const aiConversations: AiConversationService = {
       seq: Number(row.live_seq) + 1,
     }));
 
+    // History tells a stop from a turn that failed or whose wait expired, as it does for turns that end on their own.
+    const stopped = new Set(abortedRows.filter((row) => row.stopped).map((row) => row.id));
     for (const finalized of [...result.failed, ...result.aborted]) {
+      await recordTurnEnd(sql, {
+        conversationId: finalized.conversationId,
+        turnId: finalized.turnId,
+        reason: stopped.has(finalized.turnId) ? "aborted" : "error",
+      });
       await sql`
         UPDATE ai.pending_actions
         SET status = 'aborted', resolved_at = COALESCE(resolved_at, now())
@@ -3300,7 +3391,7 @@ export const aiConversations: AiConversationService = {
     append: async (message, opts) => {
       // Initial input and durable steering are already persisted transactionally before Nessi appends them.
       if (message.role === "user") return;
-      const meta = toolMessageMeta(message, input.toolPresentations, input.rejectedToolCallIds);
+      const meta = toolMessageMeta(message, input.toolPresentations, input.rejectedToolCallIds, input.approvedToolCallIds);
 
       if (input.turnId && input.leaseOwner) {
         const appended = await appendTurnOwnedMessage({

package/src/ai/stream.ts

@@ -94,6 +94,8 @@ const turnSnapshotFromActive = (active: NonNullable<Awaited<ReturnType<typeof ai
   blocks: [...active.liveBlocks],
   modelProfileId: active.turn.modelProfileId,
   createdAt: active.turn.createdAt,
+  actionWaitMs: active.actionWaitMs,
+  waitingSince: active.waitingSince,
 });
 
 /** Initial history window; older messages load on demand while scrolling up. */

package/src/ai/timeline.ts

@@ -12,9 +12,9 @@ export type AiAssistantTimelineItem = {
   /** The entry whose message-actions row (copy/retry/fork) is shown. */
   actionEntry: AiStoredMessage | null;
   /**
-   * Active work duration of the loop (nessi timing: generation + tool
-   * execution, excluding approval/client waits); legacy fallback is user
-   * message submitted → last message persisted. Retained for response metrics.
+   * Work time of the loop: wall time minus time spent waiting for user actions,
+   * from the loop's durable timing. Without timing, the time from the user
+   * message to the last persisted message.
    */
   workedMs: number;
 };
@@ -32,13 +32,6 @@ export const assistantVisibleTextFromMessage = (message: Message): string => {
     .trim();
 };
 
-export const copyTextFromAssistantEntries = (entries: AiStoredMessage[]): string =>
-  entries
-    .map((entry) => assistantVisibleTextFromMessage(entry.message))
-    .filter(Boolean)
-    .join("\n\n")
-    .trim();
-
 const isAssistantPart = (entry: AiStoredMessage): boolean =>
   entry.kind === "message" && (entry.message.role === "assistant" || entry.message.role === "tool_result");
 
@@ -123,7 +116,12 @@ export const buildAiMessageTimeline = (messages: AiStoredMessage[]): AiMessageTi
     const startedAt =
       loopId && lastUserEntry?.loopId === loopId ? timestampMs(lastUserEntry.createdAt) : timestampMs(entries[0]?.createdAt);
     const finishedAt = timestampMs(entries.at(-1)?.createdAt);
-    const workedMs = startedAt !== null && finishedAt !== null ? Math.max(0, finishedAt - startedAt) : 0;
+    const timing = entries.findLast((stored) => stored.loopAggregate?.timing)?.loopAggregate?.timing;
+    const workedMs = timing
+      ? Math.max(0, timing.wallMs - timing.actionWaitMs)
+      : startedAt !== null && finishedAt !== null
+        ? Math.max(0, finishedAt - startedAt)
+        : 0;
 
     const blocks = [
       ...steerBlocks,

package/src/ai/turn-timing.ts

@@ -80,6 +80,36 @@ export function createTurnTimingRecorder(turnId: string, db = sql) {
   };
 }
 
+/**
+ * Time a turn waited for the person: approvals and answers until they were given. A tool the browser runs by itself
+ * waits only until it starts; a secret prompt waits for its answer even though the browser claimed it. An open wait
+ * ends now.
+ */
+const actionWaits = (turnId: string, db: typeof sql) =>
+  db<{ start: Date; end: Date; open: boolean }[]>`SELECT a.created_at AS start,
+    COALESCE(w.end, now()) AS end, w.end IS NULL AS open
+    FROM ai.pending_actions a LEFT JOIN ai.tool_calls t ON t.turn_id=a.turn_id AND t.call_id=a.call_id
+    CROSS JOIN LATERAL (SELECT CASE WHEN a.kind='client_tool' AND a.tool_name<>'code_secret' THEN LEAST(t.started_at,a.resolved_at)
+      ELSE a.resolved_at END AS end) w
+    WHERE a.turn_id=${turnId}::uuid`;
+
+/**
+ * Waits of a running turn by the same rules as its durable timing: `actionWaitMs` is the time already waited, and
+ * `waitingSince` the start of the wait that is still open, overlapping waits counted once.
+ */
+export async function activeTurnWaits(turnId: string, db = sql): Promise<{ actionWaitMs: number; waitingSince: string | null }> {
+  const rows = await actionWaits(turnId, db);
+  const waits = union(rows.map((x) => ({ start: new Date(x.start).getTime(), end: new Date(x.end).getTime() })));
+  const opens = rows.filter((x) => x.open).map((x) => new Date(x.start).getTime());
+  const openStart = opens.length > 0 ? Math.min(...opens) : null;
+  // An open wait reaches until now, so the merged wait that holds it is the last one.
+  const current = openStart === null ? undefined : waits.find((x) => x.start <= openStart && openStart <= x.end);
+  return {
+    actionWaitMs: duration(waits.filter((x) => x !== current)),
+    waitingSince: current ? new Date(current.start).toISOString() : null,
+  };
+}
+
 export async function withDurableTurnTiming(turnId: string, aggregate: LoopAggregate, db = sql): Promise<LoopAggregate> {
   const [turn] = await db<
     { start: Date; end: Date }[]
@@ -95,9 +125,7 @@ export async function withDurableTurnTiming(turnId: string, aggregate: LoopAggre
   const tools = await db<
     { start: Date; end: Date }[]
   >`SELECT started_at AS start,COALESCE(completed_at,now()) AS end FROM ai.tool_calls WHERE turn_id=${turnId}::uuid AND started_at IS NOT NULL`;
-  const waits = await db<{ start: Date; end: Date }[]>`SELECT a.created_at AS start,
-    CASE WHEN a.kind='client_tool' THEN LEAST(COALESCE(t.started_at,a.resolved_at,now()),COALESCE(a.resolved_at,now())) ELSE COALESCE(a.resolved_at,now()) END AS end
-    FROM ai.pending_actions a LEFT JOIN ai.tool_calls t ON t.turn_id=a.turn_id AND t.call_id=a.call_id WHERE a.turn_id=${turnId}::uuid`;
+  const waits = await actionWaits(turnId, db);
   const intervals = (rows: { start: Date; end: Date | null }[]) =>
     rows.flatMap((x) => (x.end ? [{ start: new Date(x.start).getTime(), end: new Date(x.end).getTime() }] : []));
   return {

package/src/ai/types.ts

@@ -296,7 +296,7 @@ export type AiStoredMessage = {
       trigger: "scheduled" | "manual";
     };
     toolPresentations?: Record<string, AiToolPresentation>;
-    toolOutcomes?: Record<string, "rejected">;
+    toolOutcomes?: Record<string, "rejected" | "approved">;
   } | null;
   /** Private owner feedback for this rendered assistant response. Never enters model context. */
   feedback?: AiMessageFeedback | null;
@@ -864,7 +864,15 @@ export type AiConversationService = {
   getLatestTurn(input: { conversationId: string }): Promise<AiTurn | null>;
   getTurn(input: { conversationId: string; turnId: string }): Promise<AiTurn | null>;
   getTurnByShortId(input: { conversationId: string; shortId: string }): Promise<AiTurn | null>;
-  getActiveTurn(input: { conversationId: string }): Promise<{ turn: AiTurn; liveBlocks: AiTurnBlock[]; liveSeq: number } | null>;
+  getActiveTurn(input: { conversationId: string }): Promise<{
+    turn: AiTurn;
+    liveBlocks: AiTurnBlock[];
+    liveSeq: number;
+    /** Time spent waiting for answered user actions. */
+    actionWaitMs: number;
+    /** Start of the oldest unanswered user action, if the turn waits now. */
+    waitingSince: string | null;
+  } | null>;
   /**
    * Claim a turn attempt. Increments attempt and takes the lease atomically.
    * `from: "queue"` claims queued or lease-expired running turns; `from: "waiting"`
@@ -944,6 +952,8 @@ export type AiConversationService = {
     toolPresentations?: ReadonlyMap<string, AiToolPresentation>;
     /** Mutable call-id set read only when a rejected tool result is persisted. */
     rejectedToolCallIds?: ReadonlySet<string>;
+    /** Mutable call-id set read only when the result of a call the user approved is persisted. */
+    approvedToolCallIds?: ReadonlySet<string>;
   }): SessionStore;
 };
 

package/src/contracts/registry.ts

@@ -38,6 +38,8 @@ export type CapabilityRegistryEntry = {
   endpoint: string;
   manifest: CapabilityManifest;
   presentation?: CapabilityPresentationCatalog;
+  /** The app's own name and description overlays, so capability consumers can present the app in the reader's locale. */
+  appPresentation?: AppPresentationCatalog;
 };
 
 export type AppRegistryHelpSummary = { manifestHash: string; pageBase: string; baseLocale: string };

package/src/shared/app-presentation.ts

@@ -27,6 +27,15 @@ const mergedTranslation = (catalog: AppPresentationCatalog, requestedLocale: str
   }, {});
 };
 
+/** Resolve only an app's display name and description, for consumers that carry no other app metadata. */
+export const resolveAppIdentityPresentation = (
+  app: { name: string; description: string; presentation?: AppPresentationCatalog },
+  requestedLocale: string,
+): { name: string; description: string } => {
+  const translation = app.presentation ? mergedTranslation(app.presentation, requestedLocale) : {};
+  return { name: translation.name ?? app.name, description: translation.description ?? app.description };
+};
+
 /** Resolve only human presentation; stable app identity, routes, icons, and authorization stay untouched. */
 export const resolveAppPresentation = <T extends AppMeta>(app: T, requestedLocale: string): T => {
   if (!app.presentation) return app;
@@ -34,8 +43,7 @@ export const resolveAppPresentation = <T extends AppMeta>(app: T, requestedLocal
   if (Object.keys(translation).length === 0) return app;
   return {
     ...app,
-    name: translation.name ?? app.name,
-    description: translation.description ?? app.description,
+    ...resolveAppIdentityPresentation(app, requestedLocale),
     adminNav: app.adminNav?.map((group) => ({
       ...group,
       label: (group.id && translation.adminGroups?.[group.id]) || group.label,

package/src/styles/effects.css

@@ -27,6 +27,75 @@
   max-width: 100%;
 }
 
+/* One assistant turn in four fixed places: work line, results, newest text, actions. */
+.k2b-ui .ai-turn {
+  display: flex;
+  min-width: 0;
+  flex-direction: column;
+  gap: 0.5rem;
+}
+
+.k2b-ui .ai-turn__work {
+  min-width: 0;
+}
+
+.k2b-ui .ai-turn-work__meta {
+  font-variant-numeric: tabular-nums;
+  white-space: nowrap;
+}
+
+/* Phones keep the clock while the turn runs; the step count follows once it is finished. */
+@media (max-width: 40rem) {
+  .k2b-ui .ai-turn-work__live-steps {
+    display: none;
+  }
+}
+
+/* Expanded work: one indent, one size, no lines or boxes; intermediate texts are quiet paragraphs. */
+.k2b-ui .ai-turn-steps {
+  display: flex;
+  min-width: 0;
+  flex-direction: column;
+}
+
+.k2b-ui .ai-turn-steps__text {
+  padding-block: 0.25rem;
+  color: var(--k2b-text-muted);
+}
+
+.k2b-ui .ai-turn-steps__text .assistant-markdown-block,
+.k2b-ui .ai-turn-steps__text .assistant-markdown-block :where(h1, h2, h3, h4, h5, h6) {
+  color: inherit;
+  font-size: 0.75rem;
+  line-height: 1.55;
+}
+
+.k2b-ui .ai-turn-steps__text .assistant-markdown-block :where(p, ul, ol, pre, blockquote) {
+  margin-block: 0.375rem;
+}
+
+.k2b-ui .ai-turn-steps__thought {
+  margin: 0;
+  color: var(--k2b-text-muted);
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+
+/* A decided approval keeps focus on its receipt; the place only shows a ring for keyboard focus. */
+.k2b-ui .ai-turn__action {
+  min-width: 0;
+  border-radius: var(--k2b-radius-control);
+}
+
+.k2b-ui .ai-turn__action:focus {
+  outline: none;
+}
+
+.k2b-ui .ai-turn__action:focus-visible {
+  outline: var(--k2b-focus-width) solid var(--k2b-focus-ring);
+  outline-offset: var(--k2b-focus-offset);
+}
+
 /* Result links sit inside an already padded activity row. Keep them inline so
    they do not make linked capability results taller than neighboring rows. */
 .k2b-ui .k2b-button.ai-chat-result-link[data-size="xs"] {