Add detail view and create/finish time for task

.githooks/post-commit

@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+#
+# After a commit that bumps the crate version, create the matching
+# vX.Y.Z tag if it does not exist yet. Pushing that tag is what
+# triggers the GitHub Release pipeline (.github/workflows/release.yml).
+#
+# Enable the repo hooks once per clone:
+#   git config core.hooksPath .githooks   (or ./scripts/install-hooks.sh)
+set -euo pipefail
+
+cd "$(git rev-parse --show-toplevel)"
+
+# Only act on commits that changed the `version` line of Cargo.toml.
+if ! git diff -U0 HEAD~1 HEAD -- Cargo.toml 2>/dev/null | grep -qE '^\+version = "[0-9]+\.[0-9]+\.[0-9]+"'; then
+  exit 0
+fi
+
+VERSION="$(grep -m1 '^version = ' Cargo.toml | sed 's/version = "\(.*\)"/\1/')"
+TAG="v$VERSION"
+
+# Nothing to do if the tag already exists (e.g. created manually).
+[ -z "$(git tag -l "$TAG")" ] || exit 0
+
+git tag "$TAG"
+echo "post-commit: created tag $TAG"
+echo "publish the release with: git push origin master --tags"

.githooks/pre-commit

@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+#
+# Require every code change to bump the crate version in the SAME commit.
+# "Code" means anything that ships in the release binary: src/, tests/,
+# Cargo.toml and Cargo.lock. Docs, scripts and CI changes are exempt.
+#
+# Rationale: releases are tag-driven and the version lives in Cargo.toml,
+# so a code commit without a version bump can never become a release.
+#
+# Enable the repo hooks once per clone:
+#   git config core.hooksPath .githooks   (or ./scripts/install-hooks.sh)
+set -euo pipefail
+
+cd "$(git rev-parse --show-toplevel)"
+
+CODE_RE='^(src/|tests/|Cargo\.toml$|Cargo\.lock$)'
+
+# No code changes in this commit: nothing to check.
+git diff --cached --name-only | grep -qE "$CODE_RE" || exit 0
+
+# The commit must change the `version` line of Cargo.toml (staged).
+if ! git diff --cached -U0 -- Cargo.toml | grep -qE '^\+version = "[0-9]+\.[0-9]+\.[0-9]+"'; then
+  cat >&2 <<'EOF'
+error: this commit changes code but does not bump the version.
+
+Every code change must ship as a new release: bump the version and
+stage it together with your changes, e.g.:
+
+  ./scripts/bump-version.sh patch   # or: minor / major
+  git add Cargo.toml Cargo.lock
+
+(bypass with: git commit --no-verify)
+EOF
+  exit 1
+fi
+
+NEW_VER="$(git show :Cargo.toml | grep -m1 '^version = ' | sed 's/version = "\(.*\)"/\1/')"
+
+# The tag must be fresh — reusing a released version would clash.
+if [ -n "$(git tag -l "v$NEW_VER")" ]; then
+  echo "error: tag v$NEW_VER already exists; bump to a fresh version" >&2
+  exit 1
+fi
+
+# Cargo.lock must be staged in sync with the new version.
+LOCK_VER="$(git show :Cargo.lock | awk '/^name = "basilk"$/{getline; print; exit}' | sed 's/version = "\(.*\)"/\1/')"
+if [ "$NEW_VER" != "$LOCK_VER" ]; then
+  echo "error: Cargo.toml bumps to $NEW_VER but the staged Cargo.lock still says $LOCK_VER" >&2
+  echo "run ./scripts/bump-version.sh (it updates both) and stage Cargo.lock" >&2
+  exit 1
+fi

.github/workflows/ci.yml

@@ -0,0 +1,79 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  version-bump:
+    name: Version bumped with code changes
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      # Backstop for the local pre-commit hook: any change to the code
+      # that ships in the release binary (src/, tests/, Cargo manifests)
+      # must come with a version bump in Cargo.toml, otherwise the
+      # change can never become a GitHub Release.
+      - name: Code changes must bump the version
+        run: |
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            BASE="${{ github.event.pull_request.base.sha }}"
+          else
+            BASE="${{ github.event.before }}"
+          fi
+          if [ -z "$BASE" ] || [ "$BASE" = "0000000000000000000000000000000000000000" ]; then
+            echo "no base revision to compare against; skipping"
+            exit 0
+          fi
+          if ! git diff --name-only "$BASE" HEAD | grep -qE '^(src/|tests/|Cargo\.toml$|Cargo\.lock$)'; then
+            echo "no code changes; nothing to check"
+            exit 0
+          fi
+          OLD="$(git show "$BASE":Cargo.toml | grep -m1 '^version = ')"
+          NEW="$(grep -m1 '^version = ' Cargo.toml)"
+          if [ "$OLD" = "$NEW" ]; then
+            echo "::error::code changed but the Cargo.toml version was not bumped (still ${NEW#version = })"
+            echo "::error::bump it with ./scripts/bump-version.sh [patch|minor|major] and include it in the change"
+            exit 1
+          fi
+          echo "version bumped: $OLD -> $NEW"
+
+  check:
+    name: Build & Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - name: Cache cargo registry
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: cargo-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: cargo-${{ runner.os }}-
+
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+
+      - name: Clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+      - name: Build
+        run: cargo build --verbose
+
+      - name: Test
+        run: cargo test --verbose

.github/workflows/lint_rust.yaml

@@ -9,10 +9,21 @@ jobs:
   lint_rust:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - uses: hecrj/setup-rust-action@v2
         with:
           rust-version: "stable"
       - name: "Lint Rust"
         run: "cargo fmt --all -- --check"
-...
+      - name: "Install cargo-llvm-cov"
+        uses: taiki-e/install-action@cargo-llvm-cov
+      - name: "Add llvm-tools-preview"
+        run: "rustup component add llvm-tools-preview"
+      # The whole test suite runs under coverage instrumentation. Local runs
+      # measure ~99.5% line coverage; the only uncovered lines are the
+      # real-terminal glue in main.rs (main/init_terminal/restore_terminal
+      # and CrosstermSource::next_key) which cannot run inside a unit test.
+      # The 95% gate catches regressions without being flaky across
+      # platforms. Measure locally with: cargo llvm-cov --workspace
+      - name: "Test with coverage"
+        run: "cargo llvm-cov --workspace --fail-under-lines 95"

.github/workflows/release.yml

@@ -0,0 +1,126 @@
+---
+name: Release
+
+# Tag-driven release pipeline:
+# - Pushing a `vX.Y.Z` tag builds release binaries for Linux, macOS
+#   (Intel + Apple Silicon) and Windows and publishes them to a GitHub
+#   Release with auto-generated notes.
+# - The version number is bumped manually with each code change
+#   (./scripts/bump-version.sh or by editing Cargo.toml) and committed
+#   alongside the code; the post-commit hook creates the vX.Y.Z tag.
+#   The workflow never bumps versions or commits on its own.
+# - The tag must match the version declared in Cargo.toml.
+# - workflow_dispatch: re-publish an existing tag (e.g. after a build fix).
+on:
+  push:
+    tags: ['v*']
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Existing tag to build & publish, e.g. v0.2.6 (must match Cargo.toml)'
+        required: true
+
+permissions:
+  contents: write
+
+# One release at a time; concurrent runs queue up instead of racing.
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  release:
+    name: Resolve & verify version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.meta.outputs.version }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Resolve version from tag
+        id: meta
+        run: |
+          if [ "$GITHUB_EVENT_NAME" = "workflow_dispatch" ]; then
+            TAG="${{ github.event.inputs.tag }}"
+          else
+            TAG="${GITHUB_REF_NAME}"
+          fi
+          echo "version=${TAG#v}" >> "$GITHUB_OUTPUT"
+
+      # Build from the exact release commit, not the latest master
+      - uses: actions/checkout@v5
+        with:
+          ref: v${{ steps.meta.outputs.version }}
+
+      - name: Verify tag matches Cargo.toml
+        run: |
+          CARGO_VERSION="$(grep -m1 '^version = ' Cargo.toml | sed 's/version = "\(.*\)"/\1/')"
+          if [ "$CARGO_VERSION" != "${{ steps.meta.outputs.version }}" ]; then
+            echo "::error::tag v${{ steps.meta.outputs.version }} but Cargo.toml declares $CARGO_VERSION"
+            exit 1
+          fi
+
+  build:
+    name: Build ${{ matrix.target }}
+    needs: release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            bin: basilk
+            asset: basilk-x86_64-unknown-linux-gnu
+          - os: macos-14
+            target: aarch64-apple-darwin
+            bin: basilk
+            asset: basilk-aarch64-apple-darwin
+          # Cross-compiled from the ARM runner; the project has no C deps
+          - os: macos-14
+            target: x86_64-apple-darwin
+            bin: basilk
+            asset: basilk-x86_64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+            bin: basilk.exe
+            asset: basilk-x86_64-pc-windows-msvc.exe
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: v${{ needs.release.outputs.version }}
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+      - name: Build release binary
+        run: cargo build --release --target ${{ matrix.target }}
+      - name: Stage binary with platform name
+        run: cp target/${{ matrix.target }}/release/${{ matrix.bin }} ${{ matrix.asset }}
+        shell: bash
+      - name: Upload artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ matrix.asset }}
+          path: ${{ matrix.asset }}
+          if-no-files-found: error
+
+  publish:
+    name: Publish GitHub Release
+    needs: [release, build]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          path: artifacts
+          merge-multiple: true
+      - name: List artifacts
+        run: ls -lh artifacts
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v3
+        with:
+          tag_name: v${{ needs.release.outputs.version }}
+          name: v${{ needs.release.outputs.version }}
+          files: artifacts/*
+          generate_release_notes: true