feat: compaction indicator in token bar

frontend/src/components/TokenBar.tsx

@@ -29,6 +29,14 @@ export function TokenBar({ tokenState }: Props) {
   // Show only session total in that case — the agent context bar is meaningless.
   const isCompleted = agentContext === 0 && sessionTotal > 0;
 
+  if (tokenState.compacting) {
+    return (
+      <div className="token-bar token-bar--compacting" aria-label="Compacting context">
+        <span className="token-bar-compacting-label">COMPACTING</span>
+      </div>
+    );
+  }
+
   return (
     <>
       <button

frontend/src/components/__tests__/TokenBar.test.tsx

@@ -12,6 +12,7 @@ function makeState(overrides: Partial<TokenState> = {}): TokenState {
     numTurns: 0,
     turnIndex: 0,
     numCompactions: 0,
+    compacting: false,
     ...overrides,
   };
 }
@@ -104,6 +105,16 @@ describe('TokenBar', () => {
     expect(screen.getByText(/Session tokens/)).toBeTruthy();
   });
 
+  it('shows compacting indicator when compacting is true', () => {
+    const { container } = render(
+      <TokenBar tokenState={makeState({ agentContext: 170000, turnIndex: 3, compacting: true })} />,
+    );
+    expect(container.querySelector('.token-bar--compacting')).toBeTruthy();
+    expect(screen.getByText(/COMPACTING/)).toBeTruthy();
+    // Normal token display should not be visible
+    expect(screen.queryByText(/170k/)).toBeNull();
+  });
+
   it('expands detail panel on tap', () => {
     render(
       <TokenBar

frontend/src/pages/TodoDetailView.tsx

@@ -116,7 +116,12 @@ export function TodoDetailView() {
       const res = await apiFetch(`/api/workload/items/${currentItem.id}/promote`, {
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
-        body: JSON.stringify({ description: '' }),
+        body: JSON.stringify({
+          description: '',
+          title: currentItem.summary,
+          contextHints: currentItem.contextHints,
+          sources: currentItem.sources,
+        }),
       });
 
       if (!res.ok) {

frontend/src/pages/__tests__/DesktopChatView.test.tsx

@@ -112,6 +112,7 @@ function createMockStore() {
       numTurns: 0,
       turnIndex: 0,
       numCompactions: 0,
+      compacting: false,
     },
     progress: { blocks: {}, toolIndex: {} },
     sendError: null,

frontend/src/styles/global.css

@@ -3462,6 +3462,35 @@ textarea:focus {
   animation: token-flash 0.8s ease-in-out infinite alternate;
 }
 
+.token-bar--compacting {
+  color: #fbbf24;
+  border-color: rgba(251, 191, 36, 0.6);
+  background: rgba(251, 191, 36, 0.15);
+  animation: compaction-pulse 1s ease-in-out infinite alternate;
+  cursor: default;
+  pointer-events: none;
+}
+
+.token-bar-compacting-label {
+  font-weight: 700;
+  font-size: var(--text-xxs);
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+@keyframes compaction-pulse {
+  from {
+    opacity: 1;
+    border-color: rgba(251, 191, 36, 0.6);
+    box-shadow: 0 0 6px rgba(251, 191, 36, 0.3);
+  }
+  to {
+    opacity: 0.5;
+    border-color: rgba(251, 191, 36, 0.3);
+    box-shadow: 0 0 2px rgba(251, 191, 36, 0.1);
+  }
+}
+
 @keyframes token-flash {
   from {
     opacity: 1;

frontend/src/types/ws-messages.ts

@@ -250,6 +250,7 @@ export type ServerMessage =
   | TaskUpdatedMsg
   | TaskDeletedMsg
   | TokenUpdateMsg
+  | CompactionStatusMsg
   | LoopStatusMsg
   | ProgressStartMsg
   | ProgressUpdateMsg
@@ -301,6 +302,11 @@ export interface TokenUpdateMsg {
   turnIndex: number;
 }
 
+export interface CompactionStatusMsg {
+  type: 'compaction_status';
+  active: boolean;
+}
+
 export interface LoopStatusMsg {
   type: 'loop_status';
   state: 'idle' | 'running' | 'paused';

packages/client/__tests__/protocol-parser.test.ts

@@ -529,6 +529,24 @@ describe('token_update', () => {
     expect('sessionTotal' in r.tokensUpdate!).toBe(false);
     expect('numTurns' in r.tokensUpdate!).toBe(false);
   });
+
+  it('compaction_status sets compacting flag on tokensUpdate', () => {
+    const active = parseServerMessage(
+      { type: 'compaction_status', active: true },
+      makeState(),
+      makeCallbacks(),
+      POOL_KEY,
+    );
+    expect(active.tokensUpdate).toEqual({ compacting: true });
+
+    const done = parseServerMessage(
+      { type: 'compaction_status', active: false },
+      makeState(),
+      makeCallbacks(),
+      POOL_KEY,
+    );
+    expect(done.tokensUpdate).toEqual({ compacting: false });
+  });
 });
 
 // ─── Inbox ────────────────────────────────────────────────────────────────────

packages/client/src/protocol-parser.ts

@@ -522,6 +522,10 @@ export function parseServerMessage(
       break;
     }
 
+    case 'compaction_status':
+      result.tokensUpdate = { compacting: Boolean(msg.active) };
+      break;
+
     // Progress tracking messages
     case 'progress_start':
       result.progressUpdate = {

packages/client/src/slices/tokens.ts

@@ -5,6 +5,7 @@ export interface TokensState {
   numTurns: number;
   turnIndex: number;
   numCompactions: number;
+  compacting: boolean;
 }
 
 export const DEFAULT_CONTEXT_CEILING = 200_000;
@@ -16,4 +17,5 @@ export const INITIAL_TOKENS_STATE: TokensState = {
   numTurns: 0,
   turnIndex: 0,
   numCompactions: 0,
+  compacting: false,
 };

server/__tests__/token-update.test.ts

@@ -389,6 +389,24 @@ describe('token_update emission', () => {
       },
       { type: 'stream_event', event: { type: 'content_block_stop', index: 0 } },
       { type: 'assistant', message: { content: [] }, session_id: 'sess-compact' },
+      // SDK compaction content block — start, delta, stop
+      {
+        type: 'stream_event',
+        event: {
+          type: 'content_block_start',
+          index: 1,
+          content_block: { type: 'compaction' },
+        },
+      },
+      {
+        type: 'stream_event',
+        event: {
+          type: 'content_block_delta',
+          index: 1,
+          delta: { type: 'compaction_delta', content: 'Summary of prior context...' },
+        },
+      },
+      { type: 'stream_event', event: { type: 'content_block_stop', index: 1 } },
       // SDK system status: compaction completed
       {
         type: 'system',
@@ -429,6 +447,59 @@ describe('token_update emission', () => {
     // The final token_update should include numCompactions: 1
     const last = tokenUpdates[tokenUpdates.length - 1];
     expect(last).toMatchObject({ numCompactions: 1 });
+
+    // compaction_status events should bracket the compaction
+    const compactionStatuses = transport.sent.filter((m) => m.type === 'compaction_status');
+    expect(compactionStatuses).toHaveLength(2);
+    expect(compactionStatuses[0]).toMatchObject({ type: 'compaction_status', active: true });
+    expect(compactionStatuses[1]).toMatchObject({ type: 'compaction_status', active: false });
+  });
+
+  it('resets compacting flag on result when success signal is missing', async () => {
+    const events: Record<string, unknown>[] = [
+      {
+        type: 'stream_event',
+        parent_tool_use_id: null,
+        event: {
+          type: 'message_start',
+          message: { id: 'msg-crash', usage: { input_tokens: 180000 } },
+        },
+      },
+      {
+        type: 'stream_event',
+        event: { type: 'content_block_start', index: 0, content_block: { type: 'text' } },
+      },
+      { type: 'stream_event', event: { type: 'content_block_stop', index: 0 } },
+      { type: 'assistant', message: { content: [] }, session_id: 'sess-crash' },
+      // Compaction starts but SDK never sends compact_result: 'success'
+      {
+        type: 'stream_event',
+        event: {
+          type: 'content_block_start',
+          index: 1,
+          content_block: { type: 'compaction' },
+        },
+      },
+      { type: 'stream_event', event: { type: 'content_block_stop', index: 1 } },
+      // Result arrives directly — no compact_result system message
+      {
+        type: 'result',
+        session_id: 'sess-crash',
+        usage: { input_tokens: 180000, output_tokens: 500 },
+        total_cost_usd: 0.01,
+        num_turns: 1,
+        duration_ms: 3000,
+        duration_api_ms: 2000,
+      },
+    ];
+
+    await runQueryLoop(eventStream(events), clientId, registry, abortController);
+
+    const compactionStatuses = transport.sent.filter((m) => m.type === 'compaction_status');
+    // Should have active:true from block_start and active:false from safety reset
+    expect(compactionStatuses).toHaveLength(2);
+    expect(compactionStatuses[0]).toMatchObject({ active: true });
+    expect(compactionStatuses[1]).toMatchObject({ active: false });
   });
 
   it('handles missing usage on message_start gracefully', async () => {

server/__tests__/workload-routes.test.ts

@@ -509,7 +509,7 @@ describe('workload routes', () => {
     expect(res.body.item.goalId).toBe(res.body.task.id);
   });
 
-  it('POST /api/workload/items/:id/promote — returns 404 for missing item', async () => {
+  it('POST /api/workload/items/:id/promote — returns 404 for missing item with no body title', async () => {
     const res = await request(app)
       .post('/api/workload/items/nonexistent-id/promote')
       .set('Cookie', authCookie)
@@ -518,6 +518,49 @@ describe('workload routes', () => {
     expect(res.status).toBe(404);
   });
 
+  it('POST /api/workload/items/:id/promote — creates task from body fallback (Telos item)', async () => {
+    const res = await request(app)
+      .post('/api/workload/items/telos-item-123/promote')
+      .set('Cookie', authCookie)
+      .send({
+        title: 'Telos task title',
+        description: 'Extra context',
+        contextHints: {
+          repos: ['mitzo'],
+          taskHint: 'Check the API layer',
+        },
+        sources: [{ type: 'telos', url: 'https://example.com', title: 'Source doc' }],
+      });
+
+    expect(res.status).toBe(201);
+    expect(res.body.task).toMatchObject({
+      title: 'Telos task title',
+      status: 'pending',
+    });
+    expect(res.body.task.description).toContain('Extra context');
+    expect(res.body.task.description).toContain('Check the API layer');
+    expect(res.body.task.annotations).toEqual(
+      expect.arrayContaining([expect.stringContaining('Source doc')]),
+    );
+    expect(res.body.item).toBeUndefined();
+  });
+
+  it('POST /api/workload/items/:id/promote — fallback does not broadcast workload update', async () => {
+    const broadcasts: unknown[] = [];
+    const origBroadcast = (app as any)._workloadBroadcast;
+    (app as any)._workloadBroadcast = (msg: unknown) => broadcasts.push(msg);
+
+    await request(app)
+      .post('/api/workload/items/telos-no-broadcast/promote')
+      .set('Cookie', authCookie)
+      .send({ title: 'No broadcast test' });
+
+    const workloadBroadcasts = broadcasts.filter((b: any) => b.type === 'workload_item_updated');
+    expect(workloadBroadcasts).toHaveLength(0);
+
+    (app as any)._workloadBroadcast = origBroadcast;
+  });
+
   it('POST /api/workload/items/:id/promote — broadcasts workload_item_updated', async () => {
     // Create an item first
     const signal = {

server/api-schemas.ts

@@ -234,6 +234,30 @@ export const WorkloadItemUpdateBody = z.object({
 
 export const WorkloadPromoteBody = z.object({
   description: z.string().optional(),
+  title: z.string().optional(),
+  contextHints: z
+    .object({
+      repos: z.array(z.string()).optional(),
+      paths: z.array(z.string()).optional(),
+      issues: z.array(z.string()).optional(),
+      docIds: z.array(z.string()).optional(),
+      people: z.array(z.string()).optional(),
+      jiraKeys: z.array(z.string()).optional(),
+      keywords: z.array(z.string()).optional(),
+      taskHint: z.string().optional(),
+    })
+    .optional(),
+  sources: z
+    .array(
+      z.object({
+        type: z.string(),
+        url: z.string(),
+        title: z.string(),
+        author: z.string().optional(),
+        snippet: z.string().optional(),
+      }),
+    )
+    .optional(),
 });
 
 // -- Session creation schemas --