Release Symphony Console 0.1.14

Author: Agent-Zero

README.md

@@ -8,8 +8,8 @@ Download packaged builds from GitHub Releases:
 
 https://github.com/TerminallyLazy/misconducting/releases/latest
 
-Current app metadata in this checkout is `0.1.13`. The public latest release page may
-still show older assets until tag `v0.1.13` is pushed and the desktop release workflow
+Current app metadata in this checkout is `0.1.14`. The public latest release page may
+still show older assets until tag `v0.1.14` is pushed and the desktop release workflow
 publishes new artifacts.
 
 The GitHub Actions workflow `.github/workflows/release-desktop.yml` is configured to build macOS, Windows, Linux x86_64, and Linux ARM64 packages from release tags.

RELEASE_WORKFLOW_NOTE.md

@@ -9,4 +9,4 @@ It builds:
 - Linux x86_64 AppImage/DEB
 - Linux ARM64 AppImage/DEB
 
-Push tag `v0.1.13` or run the workflow manually from GitHub Actions to produce release artifacts.
+Push tag `v0.1.14` or run the workflow manually from GitHub Actions to produce release artifacts.

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "symphony-desktop",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "private": true,
   "type": "module",
   "scripts": {

package.json

@@ -1,6 +1,6 @@
 [package]
 name = "symphony_desktop"
-version = "0.1.13"
+version = "0.1.14"
 edition = "2021"
 
 [build-dependencies]

src-tauri/Cargo.lock

@@ -1,6 +1,6 @@
 {
   "productName": "Symphony Console",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "identifier": "dev.symphony.console",
   "build": {
     "beforeDevCommand": "npm run dev",

src-tauri/Cargo.toml

@@ -828,6 +828,57 @@ function makeCardsFromKanban(kanban?: KanbanState): Card[] {
   );
 }
 
+function upsertMovementRunIntoKanban(kanban: KanbanState | undefined, rawRun: unknown): KanbanState {
+  const parsed = KanbanCardSchema.safeParse(rawRun);
+  const run = parsed.success ? parsed.data : (rawRun || {}) as z.infer<typeof KanbanCardSchema>;
+  const key = String(run.issue_id || run.id || run.linear_identifier || run.identifier || '');
+  const targetId = kanbanColumnIdForRun(run);
+  const generatedAt = new Date().toISOString();
+  const baseColumns = kanban?.columns?.length
+    ? kanban.columns
+    : [
+        { id: 'running', title: 'Running', count: 0, cards: [] },
+        { id: 'retrying', title: 'Retrying', count: 0, cards: [] },
+        { id: 'completed', title: 'Completed', count: 0, cards: [] }
+      ];
+
+  const columns = baseColumns.map(column => ({
+    ...column,
+    cards: column.cards.filter(card => {
+      const cardKey = String(card.issue_id || card.id || card.linear_identifier || card.identifier || '');
+      return !key || cardKey !== key;
+    })
+  }));
+
+  const targetIndex = columns.findIndex(column => column.id === targetId);
+  const targetColumn = targetIndex >= 0
+    ? columns[targetIndex]
+    : { id: targetId, title: kanbanColumnTitle(targetId), count: 0, cards: [] };
+  const updatedTarget = { ...targetColumn, cards: [run, ...targetColumn.cards], count: targetColumn.cards.length + 1 };
+  const updatedColumns = targetIndex >= 0
+    ? columns.map((column, index) => index === targetIndex ? updatedTarget : { ...column, count: column.cards.length })
+    : [...columns.map(column => ({ ...column, count: column.cards.length })), updatedTarget];
+
+  return {
+    ...(kanban || {}),
+    generated_at: generatedAt,
+    columns: updatedColumns
+  };
+}
+
+function kanbanColumnIdForRun(run: z.infer<typeof KanbanCardSchema>) {
+  const status = String(run.operator_status || run.status || run.state || run.stage || run.phase || '').toLowerCase();
+  if (status.includes('retry')) return 'retrying';
+  if (status.includes('complete') || status.includes('done')) return 'completed';
+  return 'running';
+}
+
+function kanbanColumnTitle(id: string) {
+  if (id === 'retrying') return 'Retrying';
+  if (id === 'completed') return 'Completed';
+  return 'Running';
+}
+
 function agentProfileFromCard(raw: z.infer<typeof KanbanCardSchema>) {
   const profile = raw.agent_profile;
   if (!profile || typeof profile !== 'object' || Array.isArray(profile)) return null;
@@ -1248,7 +1299,11 @@ function App() {
   const createMovement = useMutation({
     mutationFn: (payload: ManualMovementPayload) =>
       api<Record<string, unknown>>(base, '/api/movements', { method: 'POST', body: JSON.stringify(payload) }, 12_000),
-    onSuccess: () => {
+    onSuccess: data => {
+      const run = data && typeof data === 'object' ? data.run : undefined;
+      if (run && typeof run === 'object') {
+        queryClient.setQueryData<KanbanState>(['kanban', base], current => upsertMovementRunIntoKanban(current, run));
+      }
       invalidateLiveData();
       queryClient.invalidateQueries({ queryKey: ['rehearsalCheck', base] });
     }

src-tauri/tauri.conf.json

@@ -56,7 +56,12 @@ defmodule Symphony.Http.Api do
           count: length(snap.retrying),
           cards: Enum.map(snap.retrying, &retry_card/1)
         },
-        %{id: "completed", title: "Completed", count: snap.counts.completed, cards: []}
+        %{
+          id: "completed",
+          title: "Completed",
+          count: snap.counts.completed,
+          cards: Enum.map(Map.get(snap, :completed_runs, []), &completed_card/1)
+        }
       ],
       counts: snap.counts,
       codex_totals: snap.codex_totals,
@@ -969,6 +974,17 @@ defmodule Symphony.Http.Api do
   defp phase_operator_status("refiner"), do: "refining"
   defp phase_operator_status(_), do: "running"
 
+  defp completed_card(run) do
+    run
+    |> run_card()
+    |> Map.merge(%{
+      state: "Completed",
+      status: "completed",
+      operator_status: "completed",
+      operator_summary: run.last_message || "Movement completed."
+    })
+  end
+
   defp retry_card(retry) do
     agent_profile = retry.agent_profile || %{}
     phase = retry.phase || "retry"

src/main.tsx

@@ -585,12 +585,14 @@ defmodule Symphony.Orchestrator do
     }
 
   defp complete(state, id),
-    do: %{
-      state
-      | running: Map.delete(state.running, id),
-        claimed: MapSet.put(state.claimed, id),
-        completed: MapSet.put(state.completed, id)
-    }
+    do:
+      %{
+        state
+        | running: Map.delete(state.running, id),
+          claimed: MapSet.put(state.claimed, id),
+          completed: MapSet.put(state.completed, id),
+          completed_runs: completed_runs(state, id)
+      }
 
   defp retry_id(state, id, error, metadata \\ %{}) do
     {issue, attempt, run_metadata} =
@@ -1438,6 +1440,7 @@ defmodule Symphony.Orchestrator do
       },
       running: Enum.map(state.running, fn {_id, e} -> e.run end),
       retrying: Map.values(state.retry_attempts),
+      completed_runs: completed_run_values(state.completed_runs),
       codex_totals: state.codex_totals,
       rate_limits: state.codex_rate_limits,
       polling: %{
@@ -1448,4 +1451,40 @@ defmodule Symphony.Orchestrator do
       }
     }
   end
+
+  defp completed_runs(state, id) do
+    case state.running[id] do
+      %{run: run} ->
+        run =
+          %{
+            run
+            | status: :completed,
+              last_event: run.last_event || "completed",
+              last_message: run.last_message || "#{phase_label(run.phase)} run completed.",
+              last_event_at: run.last_event_at || DateTime.utc_now()
+          }
+
+        state.completed_runs
+        |> Map.put(id, run)
+        |> trim_completed_runs()
+
+      _ ->
+        state.completed_runs
+    end
+  end
+
+  defp completed_run_values(completed_runs) do
+    completed_runs
+    |> Map.values()
+    |> Enum.sort_by(&run_sort_time/1, {:desc, DateTime})
+  end
+
+  defp trim_completed_runs(completed_runs) do
+    completed_runs
+    |> completed_run_values()
+    |> Enum.take(20)
+    |> Map.new(&{&1.issue_id, &1})
+  end
+
+  defp run_sort_time(run), do: run.last_event_at || run.started_at || ~U[1970-01-01 00:00:00Z]
 end