timestamp for past runs

Author: justdeko

cli/src/main/kotlin/com/dk/zopf/cli/Commands.kt

@@ -5,6 +5,7 @@ import com.dk.zopf.model.WorkflowIssue
 import com.dk.zopf.runtime.UpdateCheck
 import com.dk.zopf.runtime.issues
 import com.dk.zopf.runtime.money
+import com.dk.zopf.runtime.stamp
 import com.dk.zopf.runtime.updateChecksSilenced
 import com.dk.zopf.store.AppPaths
 import com.dk.zopf.store.BrokenWorkflow
@@ -18,8 +19,6 @@ import java.io.PrintStream
 import java.nio.file.Path
 import java.time.Duration
 import java.time.Instant
-import java.time.ZoneId
-import java.time.format.DateTimeFormatter
 
 val LIST_OPTIONS = setOf("workspace")
 val VALIDATE_OPTIONS = setOf("workspace")
@@ -195,10 +194,4 @@ internal fun WorkflowIssue.render(): String {
 
 private fun RunRecord.cost(): Double? = nodes.mapNotNull { it.costUsd }.takeIf { it.isNotEmpty() }?.sum()
 
-private fun String.readable(): String =
-    runCatching {
-        DateTimeFormatter
-            .ofPattern("yyyy-MM-dd HH:mm")
-            .withZone(ZoneId.systemDefault())
-            .format(Instant.parse(this))
-    }.getOrElse { this }
+private fun String.readable(): String = runCatching { stamp(Instant.parse(this)) }.getOrElse { this }

core/src/commonMain/kotlin/com/dk/zopf/runtime/Formatting.kt

@@ -1,6 +1,9 @@
 package com.dk.zopf.runtime
 
 import java.time.Duration
+import java.time.Instant
+import java.time.ZoneId
+import java.time.format.DateTimeFormatter
 import java.util.Locale
 
 fun format(duration: Duration): String {
@@ -12,6 +15,23 @@ fun format(duration: Duration): String {
     }
 }
 
+private val TimeOfDay = DateTimeFormatter.ofPattern("HH:mm", Locale.ROOT)
+private val DateAndTime = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm", Locale.ROOT)
+
+fun stamp(
+    at: Instant,
+    zone: ZoneId = ZoneId.systemDefault(),
+): String = DateAndTime.format(at.atZone(zone))
+
+fun format(
+    at: Instant,
+    now: Instant = Instant.now(),
+    zone: ZoneId = ZoneId.systemDefault(),
+): String {
+    val local = at.atZone(zone)
+    return if (local.toLocalDate() == now.atZone(zone).toLocalDate()) TimeOfDay.format(local) else stamp(at, zone)
+}
+
 fun money(usd: Double): String = String.format(Locale.ROOT, "$%.4f", usd)
 
 fun spend(

core/src/commonMain/kotlin/com/dk/zopf/runtime/NodeRun.kt

@@ -180,6 +180,13 @@ class NodeRun(
         get() =
             if (nodeType != NodeType.AGENT) null else AgentProviders.of(provider ?: AgentProviderId.CLAUDE)
 
+    val agentLabel: String?
+        get() =
+            agent?.let { provider ->
+                listOfNotNull(provider.id.label, model?.takeIf { provider.capabilities.modelSelection })
+                    .joinToString(" · ")
+            }
+
     val canTakeOver: Boolean
         get() = agent?.capabilities?.resumeInTerminal == true && sessionId != null && cwd != null
 

core/src/commonMain/kotlin/com/dk/zopf/runtime/WorkflowRun.kt

@@ -116,6 +116,7 @@ class WorkflowRun(
                         nodeId = node.nodeId,
                         type = node.nodeType,
                         provider = node.provider,
+                        model = node.model,
                         status = node.status.name,
                         startedAt = node.startedAt.toString(),
                         finishedAt = node.finishedAt?.toString(),
@@ -135,6 +136,7 @@ class WorkflowRun(
         record.nodes.forEach { archived ->
             val node = node(archived.nodeId) ?: return@forEach
             node.sessionId = archived.sessionId
+            node.model = archived.model
             node.costUsd = archived.costUsd
             node.exitCode = archived.exitCode
             node.command = archived.command

core/src/commonMain/kotlin/com/dk/zopf/store/RunArchive.kt

@@ -34,6 +34,7 @@ data class NodeRunRecord(
     val nodeId: String,
     val type: NodeType,
     val provider: AgentProviderId? = null,
+    val model: String? = null,
     val status: String,
     val startedAt: String,
     val finishedAt: String? = null,

core/src/commonTest/kotlin/com/dk/zopf/runtime/AgentNodeTest.kt

@@ -293,6 +293,28 @@ class NodeRunTest {
         return run().apply { ClaudeEvents.parseAll(text).forEach(::consume) }
     }
 
+    private fun labelled(
+        provider: AgentProviderId?,
+        model: String?,
+        type: NodeType = NodeType.AGENT,
+    ) = NodeRun("r", "demo", "analyze", "Analyze", type, Paths.get("/tmp"), provider = provider)
+        .also { it.showing(model = model) }
+
+    @Test
+    fun `a run is labelled with the cli and the model it took`() {
+        val rows =
+            listOf(
+                labelled(AgentProviderId.CLAUDE, "claude-opus-5") to "Claude Code · claude-opus-5",
+                labelled(AgentProviderId.CODEX, null) to "codex",
+                labelled(AgentProviderId.DSH, "deepseek-chat") to "DeepSeek Harness",
+                labelled(null, "claude-opus-5", NodeType.SHELL) to null,
+            )
+
+        rows.forEach { (run, expected) ->
+            assertEquals(expected, run.agentLabel, "${run.nodeType} ${run.provider}")
+        }
+    }
+
     @Test
     fun `a schema'd turn answers in fields and keeps the object`() {
         val output = replayFixture("/claude-structured-stream.jsonl").output()

core/src/commonTest/kotlin/com/dk/zopf/runtime/RunArchiveTest.kt

@@ -1,5 +1,6 @@
 package com.dk.zopf.runtime
 
+import com.dk.zopf.model.AgentProviderId
 import com.dk.zopf.model.NodeType
 import com.dk.zopf.model.Workflow
 import com.dk.zopf.model.WorkflowEdge
@@ -66,6 +67,19 @@ class RunHistoryTest {
         )
     }
 
+    @Test
+    fun `an archived agent node comes back with its cli and model`() {
+        val run = WorkflowRun("run-1", "demo", null, isInteractive = false)
+        run.nodes +=
+            NodeRun("run-1:analyze", "demo", "analyze", "Analyze", NodeType.AGENT, null, provider = AgentProviderId.CODEX)
+                .showing(status = RunStatus.SUCCEEDED, model = "gpt-5.5")
+
+        val restored = WorkflowRun.restored(run.record(), Restore.SETTLED).node("analyze")
+
+        assertEquals(AgentProviderId.CODEX, restored?.provider)
+        assertEquals("gpt-5.5", restored?.model)
+    }
+
     @Test
     fun `replaying a transcript leaves the verdict alone`() {
         val archiveRoot = tempDir()

core/src/commonTest/kotlin/com/dk/zopf/runtime/RuntimeBasicsTest.kt

@@ -13,6 +13,8 @@ import com.dk.zopf.model.modelOptions
 import com.dk.zopf.model.withDefaultsFrom
 import com.dk.zopf.store.AppSettings
 import java.nio.file.Paths
+import java.time.ZoneId
+import java.time.ZonedDateTime
 import kotlin.io.path.readText
 import kotlin.test.Test
 import kotlin.test.assertContains
@@ -552,4 +554,22 @@ class RunSummaryTest {
 
         assertEquals("Running · 3/4 · b", run.summary())
     }
+
+    @Test
+    fun `a run is stamped with when it started`() {
+        val zone = ZoneId.of("Europe/Berlin")
+        val now = ZonedDateTime.of(2026, 9, 10, 18, 0, 0, 0, zone)
+        val rows =
+            listOf(
+                ZonedDateTime.of(2026, 9, 10, 14, 32, 0, 0, zone) to "14:32",
+                ZonedDateTime.of(2026, 9, 10, 0, 5, 0, 0, zone) to "00:05",
+                ZonedDateTime.of(2026, 9, 9, 23, 55, 0, 0, zone) to "2026-09-09 23:55",
+                ZonedDateTime.of(2026, 1, 5, 8, 0, 0, 0, zone) to "2026-01-05 08:00",
+                ZonedDateTime.of(2025, 12, 31, 23, 59, 0, 0, zone) to "2025-12-31 23:59",
+            )
+
+        rows.forEach { (started, expected) ->
+            assertEquals(expected, format(started.toInstant(), now.toInstant(), zone), started.toString())
+        }
+    }
 }

shared/src/commonMain/kotlin/com/dk/zopf/ui/AppState.kt

@@ -59,6 +59,7 @@ enum class DialogRequest { NEW_WORKFLOW, NEW_CONNECTOR }
 
 class AppState(
     val registry: WorkspaceRegistry = WorkspaceRegistry(),
+    private val archiveRoot: Path = AppPaths.runsDir,
 ) {
     var workspaces by mutableStateOf<List<OpenWorkspace>>(emptyList())
         private set
@@ -103,7 +104,7 @@ class AppState(
         RunRegistry(
             scope,
             settings,
-            archiveRoot = AppPaths.runsDir,
+            archiveRoot = archiveRoot,
             notifier = MacNotifier(),
             isForeground = { windowFocused },
             onActivate = { runId -> onActivateRun(runId) },
@@ -183,7 +184,7 @@ class AppState(
         scope.launch(Dispatchers.IO) {
             val keep = settings.current.keepRuns
             if (keep <= 0) return@launch
-            val gone = RunArchive.prune(keep = keep)
+            val gone = RunArchive.prune(root = archiveRoot, keep = keep)
             if (gone.isEmpty()) return@launch
 
             gone.forEach { RunArchive.delete(it) }

shared/src/commonMain/kotlin/com/dk/zopf/ui/runs/RunConsole.kt

@@ -141,6 +141,7 @@ private fun RunHeader(
                 Text(
                     buildString {
                         append(run.workflowName)
+                        run.agentLabel?.let { append(" · $it") }
                         append(" · ")
                         append(run.status.label)
                         append(" · ")