planning-with-files 3.9.0 → 3.10.0

package/scripts/ledger-append.ps1

@@ -0,0 +1,180 @@
+#requires -Version 5.0
+<#
+.SYNOPSIS
+    Append one structured entry to the run-ledger (PowerShell mirror, v3).
+
+.DESCRIPTION
+    The run-ledger is the machine layer of progress tracking: an append-only
+    JSON-lines file per agent under the active plan dir. Workers append here;
+    the orchestrator owns progress.md and task_plan.md. See architecture C3.
+
+    Plan-dir resolution (matches resolve-plan-dir.ps1):
+      1. $env:PLAN_ID -> .\.planning\$PLAN_ID\
+      2. .\.planning\.active_plan
+      3. Newest .\.planning\<dir>\ by LastWriteTime
+      4. Legacy: project root (ledger lands beside .\task_plan.md)
+
+    Writes ONE JSON line to <plan-dir>\ledger-<agent>.jsonl. tick = 1 + max tick
+    across ALL ledger-*.jsonl in the plan dir so concurrent agents share a
+    monotonic counter.
+
+.PARAMETER Event
+    One of: progress phase_complete error gate_block attest note.
+
+.PARAMETER Summary
+    Free text, truncated to 200 chars, newlines stripped.
+
+.PARAMETER Agent
+    Ledger owner (default "main"); sanitized to [A-Za-z0-9_-].
+
+.PARAMETER Phase
+    Phase number/name this entry concerns.
+
+.PARAMETER Files
+    Comma-separated file list recorded as a JSON array.
+#>
+[CmdletBinding()]
+param(
+    [Parameter(Mandatory = $true, Position = 0)]
+    [string] $Event,
+
+    [Parameter(Mandatory = $true, Position = 1)]
+    [string] $Summary,
+
+    [string] $Agent = "main",
+
+    [string] $Phase = "",
+
+    [string] $Files = ""
+)
+
+$ErrorActionPreference = "Stop"
+
+$validEvents = @("progress", "phase_complete", "error", "gate_block", "attest", "note")
+
+function Resolve-PlanDir {
+    $planRoot = Join-Path (Get-Location) ".planning"
+
+    if ($env:PLAN_ID) {
+        $candidate = Join-Path $planRoot $env:PLAN_ID
+        if (Test-Path -LiteralPath $candidate -PathType Container) { return $candidate }
+    }
+
+    $activePointer = Join-Path $planRoot ".active_plan"
+    if (Test-Path -LiteralPath $activePointer) {
+        $planId = (Get-Content -LiteralPath $activePointer -Raw).Trim()
+        if ($planId) {
+            $candidate = Join-Path $planRoot $planId
+            if (Test-Path -LiteralPath $candidate -PathType Container) { return $candidate }
+        }
+    }
+
+    if (Test-Path -LiteralPath $planRoot -PathType Container) {
+        $newest = Get-ChildItem -LiteralPath $planRoot -Directory -ErrorAction SilentlyContinue |
+            Where-Object { -not $_.Name.StartsWith(".") } |
+            Where-Object { Test-Path -LiteralPath (Join-Path $_.FullName "task_plan.md") } |
+            Sort-Object LastWriteTime -Descending |
+            Select-Object -First 1
+        if ($newest) { return $newest.FullName }
+    }
+
+    # Legacy single-file mode: ledger lives beside .\task_plan.md at root.
+    return (Get-Location).Path
+}
+
+function ConvertTo-JsonString {
+    param([string] $Value)
+    $sb = New-Object System.Text.StringBuilder
+    foreach ($ch in $Value.ToCharArray()) {
+        switch ($ch) {
+            '"'  { [void]$sb.Append('\"') }
+            '\'  { [void]$sb.Append('\\') }
+            "`n" { [void]$sb.Append(' ') }
+            "`r" { [void]$sb.Append(' ') }
+            "`t" { [void]$sb.Append(' ') }
+            default {
+                if ([int]$ch -lt 32) {
+                    [void]$sb.Append(' ')
+                } else {
+                    [void]$sb.Append($ch)
+                }
+            }
+        }
+    }
+    return $sb.ToString()
+}
+
+function Get-MaxTick {
+    param([string] $Dir)
+    $max = 0
+    $pattern = '"tick"\s*:\s*(\d+)'
+    Get-ChildItem -LiteralPath $Dir -Filter "ledger-*.jsonl" -File -ErrorAction SilentlyContinue | ForEach-Object {
+        foreach ($line in (Get-Content -LiteralPath $_.FullName -ErrorAction SilentlyContinue)) {
+            $m = [regex]::Match($line, $pattern)
+            if ($m.Success) {
+                $t = [int]$m.Groups[1].Value
+                if ($t -gt $max) { $max = $t }
+            }
+        }
+    }
+    return $max
+}
+
+# Validate event against the allowlist.
+if ($validEvents -notcontains $Event) {
+    Write-Error ("[ledger] invalid event '" + $Event + "' (allowed: " + ($validEvents -join ' ') + ")")
+    exit 2
+}
+
+# Sanitize agent name to [A-Za-z0-9_-]; empty result falls back to "main".
+$agentClean = ($Agent -replace '[^A-Za-z0-9_-]', '')
+if (-not $agentClean) { $agentClean = "main" }
+
+# Truncate summary to the 200-character budget before escaping, matching the
+# sh twin. .NET Substring counts characters, never bytes, so multibyte input
+# cannot be clipped mid-codepoint here and no UTF-8 tail repair is needed.
+if ($Summary.Length -gt 200) { $Summary = $Summary.Substring(0, 200) }
+
+$planDir    = Resolve-PlanDir
+$ledgerFile = Join-Path $planDir ("ledger-" + $agentClean + ".jsonl")
+$lockFile   = Join-Path $planDir ".ledger_lock"
+
+$ts = [DateTime]::UtcNow.ToString("yyyy-MM-ddTHH:mm:ssZ")
+
+# Build the files JSON array from the comma-separated list.
+$filesJson = "[]"
+if ($Files) {
+    $parts = $Files.Split(",") | Where-Object { $_ -ne "" }
+    $escaped = $parts | ForEach-Object { '"' + (ConvertTo-JsonString $_) + '"' }
+    $filesJson = "[" + ($escaped -join ",") + "]"
+}
+
+$summaryEsc = ConvertTo-JsonString $Summary
+$phaseEsc   = ConvertTo-JsonString $Phase
+
+# Acquire an exclusive lock on a sidecar so concurrent appenders do not pick
+# the same tick number, then compute tick and append inside the locked window.
+# Atomic append of a single <4KB line is the real guarantee; the lock just
+# serializes the read-tick / write-line pair.
+$fs = $null
+$acquired = $false
+for ($i = 0; $i -lt 50 -and -not $acquired; $i++) {
+    try {
+        $fs = [System.IO.File]::Open($lockFile, [System.IO.FileMode]::OpenOrCreate, [System.IO.FileAccess]::ReadWrite, [System.IO.FileShare]::None)
+        $acquired = $true
+    } catch {
+        Start-Sleep -Milliseconds 100
+    }
+}
+
+try {
+    $tick = (Get-MaxTick $planDir) + 1
+    $line = '{"tick":' + $tick + ',"ts":"' + $ts + '","agent":"' + $agentClean + '","phase":"' + $phaseEsc + '","event":"' + $Event + '","summary":"' + $summaryEsc + '","files":' + $filesJson + '}'
+    Add-Content -LiteralPath $ledgerFile -Value $line -Encoding utf8
+} finally {
+    if ($fs) { $fs.Close(); $fs.Dispose() }
+    if (Test-Path -LiteralPath $lockFile) { Remove-Item -LiteralPath $lockFile -Force -ErrorAction SilentlyContinue }
+}
+
+Write-Output ("[ledger] tick " + $tick + " -> " + $ledgerFile + " (event=" + $Event + " agent=" + $agentClean + ")")
+exit 0

package/scripts/ledger-append.sh

@@ -0,0 +1,337 @@
+#!/bin/sh
+# planning-with-files: append one structured entry to the run-ledger (v3).
+#
+# The run-ledger is the machine layer of progress tracking: an append-only
+# JSON-lines file per agent under the active plan dir. Workers append here;
+# the orchestrator owns progress.md and task_plan.md. See architecture C3.
+#
+# Plan-dir resolution (via resolve-plan-dir.sh):
+#   1. $PLAN_ID env var -> ./.planning/$PLAN_ID/
+#   2. ./.planning/.active_plan
+#   3. Newest ./.planning/<dir>/ by mtime
+#   4. Legacy: project root (ledger lands beside ./task_plan.md)
+#
+# Usage:
+#   sh scripts/ledger-append.sh <event> <summary> [options]
+#
+# Arguments:
+#   <event>    one of: progress phase_complete error gate_block attest note
+#   <summary>  free text, truncated to 200 chars, kept valid UTF-8,
+#              newlines stripped
+#
+# Options:
+#   --agent NAME      ledger owner (default "main"); sanitized to [A-Za-z0-9_-]
+#   --phase N         phase number/name this entry concerns (default "")
+#   --files f1,f2     comma-separated file list recorded as a JSON array
+#
+# Writes ONE JSON line to <plan-dir>/ledger-<agent>.jsonl:
+#   {"tick":N,"ts":"ISO8601Z","agent":"...","phase":"...",
+#    "event":"...","summary":"...","files":["..."]}
+#
+# tick = 1 + max tick across ALL ledger-*.jsonl in the plan dir, so concurrent
+# agents share a monotonic counter and the stall detector (gate C2) sees one
+# ordered stream.
+
+set -u
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+RESOLVER="${SCRIPT_DIR}/resolve-plan-dir.sh"
+
+VALID_EVENTS="progress phase_complete error gate_block attest note"
+
+usage() {
+    printf "Usage: %s <event> <summary> [--agent NAME] [--phase N] [--files f1,f2]\n" "$0" >&2
+    printf "  event one of: %s\n" "${VALID_EVENTS}" >&2
+}
+
+resolve_plan_dir() {
+    plan_dir=""
+    if [ -f "${RESOLVER}" ]; then
+        plan_dir="$(sh "${RESOLVER}" 2>/dev/null)"
+    fi
+    if [ -n "${plan_dir}" ] && [ -d "${plan_dir}" ]; then
+        printf "%s\n" "${plan_dir}"
+        return 0
+    fi
+    # Legacy single-file mode: ledger lives beside ./task_plan.md at root.
+    printf "%s\n" "."
+    return 0
+}
+
+# Sanitize agent name to [A-Za-z0-9_-]; empty result falls back to "main".
+sanitize_agent() {
+    raw="$1"
+    clean="$(printf '%s' "${raw}" | tr -cd 'A-Za-z0-9_-')"
+    if [ -z "${clean}" ]; then
+        clean="main"
+    fi
+    printf '%s' "${clean}"
+}
+
+# Escape a string for embedding inside a JSON string literal: backslash, double
+# quote, and every bare control character JSON forbids. The single tr range
+# 0x01-0x1F maps newline, CR, tab, vertical-tab (0x0B), form-feed (0x0C) and the
+# rest of 0x01-0x08/0x0E-0x1F to spaces in one pass, matching the PS1
+# ConvertTo-JsonString behavior so JSONL stays cross-platform parseable.
+json_escape() {
+    printf '%s' "$1" \
+        | sed -e 's/\\/\\\\/g' -e 's/"/\\"/g' \
+        | tr '\001-\037' ' '
+}
+
+# Emit $1 with any trailing incomplete UTF-8 sequence removed. GNU cut -c
+# counts BYTES, so the 200 truncation below can clip a multibyte character and
+# leave a tail that strict UTF-8 readers reject, poisoning the whole JSONL
+# line. Preferred path: iconv -c drops every malformed byte (glibc, BSD/macOS,
+# Git for Windows all ship it); its output is used whenever non-empty because
+# GNU libiconv exits nonzero even after -c repaired the tail. Fallback: read
+# the last <=4 bytes with od, count trailing continuation bytes (128-191),
+# compare against the lead byte's declared length, drop the trailing character
+# only when it is incomplete. A complete multibyte character at the boundary
+# survives both paths. The fallback repairs truncation damage only; input that
+# was invalid UTF-8 before truncation passes through unchanged.
+utf8_trim_incomplete() {
+    str="$1"
+    if [ -z "${str}" ]; then
+        return 0
+    fi
+    if command -v iconv >/dev/null 2>&1; then
+        cleaned="$(printf '%s' "${str}" | iconv -f UTF-8 -t UTF-8 -c 2>/dev/null || true)"
+        if [ -n "${cleaned}" ]; then
+            printf '%s' "${cleaned}"
+            return 0
+        fi
+        # Empty output for non-empty input: iconv missing the -c flag
+        # (busybox) or a hard failure. Fall through to the byte-level trim.
+    fi
+    # The byte-level trim needs od, dd, and wc. On a PATH without them the
+    # string passes through unchanged, the pre-repair behavior: an append
+    # must never fail or lose the whole summary because a repair tool is
+    # missing.
+    if ! command -v od >/dev/null 2>&1 || ! command -v dd >/dev/null 2>&1; then
+        printf '%s' "${str}"
+        return 0
+    fi
+    # tr -cd normalizes BSD wc padding and yields empty when wc is absent.
+    nbytes="$(printf '%s' "${str}" | wc -c 2>/dev/null | tr -cd '0-9')"
+    if [ -z "${nbytes}" ] || [ "${nbytes}" -le 0 ]; then
+        printf '%s' "${str}"
+        return 0
+    fi
+    win=4
+    if [ "${nbytes}" -lt 4 ]; then
+        win="${nbytes}"
+    fi
+    # Last <win> bytes as decimal values, oldest first; a UTF-8 character is
+    # at most 4 bytes, so the window always covers the trailing character.
+    # shellcheck disable=SC2046
+    set -- $(printf '%s' "${str}" | tail -c "${win}" | od -An -tu1 | tr '\n' ' ')
+    last=""; prev1=""; prev2=""; prev3=""
+    case $# in
+        1) last="$1" ;;
+        2) last="$2"; prev1="$1" ;;
+        3) last="$3"; prev1="$2"; prev2="$1" ;;
+        4) last="$4"; prev1="$3"; prev2="$2"; prev3="$1" ;;
+        *) printf '%s' "${str}"; return 0 ;;
+    esac
+    cont=0
+    lead=""
+    for b in "${last}" "${prev1}" "${prev2}" "${prev3}"; do
+        if [ -z "${b}" ]; then
+            break
+        fi
+        if [ "${b}" -ge 128 ] && [ "${b}" -le 191 ]; then
+            cont=$((cont + 1))
+        else
+            lead="${b}"
+            break
+        fi
+    done
+    have=$((cont + 1))
+    strip=0
+    if [ -z "${lead}" ]; then
+        # 4+ trailing continuation bytes: invalid before truncation, keep.
+        strip=0
+    elif [ "${lead}" -lt 128 ]; then
+        # Stray continuations after ASCII: invalid before truncation.
+        strip="${cont}"
+    elif [ "${lead}" -ge 194 ] && [ "${lead}" -le 223 ]; then
+        if [ "${have}" -lt 2 ]; then strip="${have}"; fi
+    elif [ "${lead}" -ge 224 ] && [ "${lead}" -le 239 ]; then
+        if [ "${have}" -lt 3 ]; then strip="${have}"; fi
+    elif [ "${lead}" -ge 240 ] && [ "${lead}" -le 244 ]; then
+        if [ "${have}" -lt 4 ]; then strip="${have}"; fi
+    else
+        # 0xC0, 0xC1, 0xF5-0xFF are never valid UTF-8 lead bytes.
+        strip="${have}"
+    fi
+    if [ "${strip}" -le 0 ]; then
+        printf '%s' "${str}"
+        return 0
+    fi
+    keep=$((nbytes - strip))
+    if [ "${keep}" -le 0 ]; then
+        return 0
+    fi
+    printf '%s' "${str}" | dd bs=1 count="${keep}" 2>/dev/null
+    return 0
+}
+
+# Largest numeric tick already present across every ledger-*.jsonl in the dir.
+# Greps the "tick":N field with sed (no jq), sorts numerically, takes the max.
+# Missing/garbage files contribute nothing.
+max_tick_in_dir() {
+    dir="$1"
+    max=0
+    for f in "${dir}"/ledger-*.jsonl; do
+        [ -f "${f}" ] || continue
+        # Extract every "tick":<digits> value, one per line.
+        ticks="$(sed -n 's/.*"tick"[[:space:]]*:[[:space:]]*\([0-9][0-9]*\).*/\1/p' "${f}" 2>/dev/null)"
+        for t in ${ticks}; do
+            if [ "${t}" -gt "${max}" ] 2>/dev/null; then
+                max="${t}"
+            fi
+        done
+    done
+    printf '%s' "${max}"
+}
+
+iso_utc() {
+    # ISO8601 UTC, second precision. GNU/BSD date both honor -u; fall back to
+    # python, then a fixed epoch-zero marker that still parses as ISO8601.
+    out="$(date -u +%Y-%m-%dT%H:%M:%SZ 2>/dev/null)"
+    if [ -n "${out}" ]; then printf '%s' "${out}"; return 0; fi
+    if command -v python3 >/dev/null 2>&1; then
+        out="$(python3 -c "import datetime;print(datetime.datetime.now(datetime.timezone.utc).strftime('%Y-%m-%dT%H:%M:%SZ'))" 2>/dev/null)"
+        if [ -n "${out}" ]; then printf '%s' "${out}"; return 0; fi
+    fi
+    if command -v python >/dev/null 2>&1; then
+        out="$(python -c "import datetime;print(datetime.datetime.utcnow().strftime('%Y-%m-%dT%H:%M:%SZ'))" 2>/dev/null)"
+        if [ -n "${out}" ]; then printf '%s' "${out}"; return 0; fi
+    fi
+    printf '1970-01-01T00:00:00Z'
+}
+
+EVENT="${1:-}"
+case "${EVENT}" in
+    -h|--help|"")
+        usage
+        [ -z "${EVENT}" ] && exit 2 || exit 0
+        ;;
+esac
+shift
+
+SUMMARY="${1:-}"
+if [ -z "${SUMMARY}" ]; then
+    printf "[ledger] missing <summary> argument.\n" >&2
+    usage
+    exit 2
+fi
+shift
+
+AGENT="main"
+PHASE=""
+FILES_CSV=""
+
+while [ $# -gt 0 ]; do
+    case "$1" in
+        --agent)
+            AGENT="${2:-}"
+            shift 2 || { printf "[ledger] --agent needs a value.\n" >&2; exit 2; }
+            ;;
+        --phase)
+            PHASE="${2:-}"
+            shift 2 || { printf "[ledger] --phase needs a value.\n" >&2; exit 2; }
+            ;;
+        --files)
+            FILES_CSV="${2:-}"
+            shift 2 || { printf "[ledger] --files needs a value.\n" >&2; exit 2; }
+            ;;
+        *)
+            printf "[ledger] unknown option: %s\n" "$1" >&2
+            usage
+            exit 2
+            ;;
+    esac
+done
+
+# Validate event against the allowlist.
+valid=0
+for e in ${VALID_EVENTS}; do
+    if [ "${EVENT}" = "${e}" ]; then valid=1; break; fi
+done
+if [ "${valid}" -ne 1 ]; then
+    printf "[ledger] invalid event '%s' (allowed: %s)\n" "${EVENT}" "${VALID_EVENTS}" >&2
+    exit 2
+fi
+
+AGENT="$(sanitize_agent "${AGENT}")"
+
+# Truncate summary to 200 BEFORE escaping (200 is a source-text budget).
+# GNU cut -c counts bytes and can land mid-codepoint on multibyte input;
+# BSD cut -c counts characters and clips cleanly. The trim removes any
+# incomplete trailing UTF-8 sequence so the JSONL line stays valid UTF-8.
+SUMMARY="$(printf '%s' "${SUMMARY}" | cut -c1-200)"
+SUMMARY="$(utf8_trim_incomplete "${SUMMARY}")"
+
+PLAN_DIR="$(resolve_plan_dir)"
+LEDGER_FILE="${PLAN_DIR}/ledger-${AGENT}.jsonl"
+LOCK_FILE="${PLAN_DIR}/.ledger_lock"
+
+TS="$(iso_utc)"
+
+# Build the files JSON array from the comma-separated list.
+FILES_JSON="[]"
+if [ -n "${FILES_CSV}" ]; then
+    FILES_JSON="["
+    first=1
+    # Word-split on commas only.
+    OLD_IFS="$IFS"
+    IFS=','
+    for item in ${FILES_CSV}; do
+        IFS="$OLD_IFS"
+        [ -z "${item}" ] && { IFS=','; continue; }
+        esc="$(json_escape "${item}")"
+        if [ "${first}" -eq 1 ]; then
+            FILES_JSON="${FILES_JSON}\"${esc}\""
+            first=0
+        else
+            FILES_JSON="${FILES_JSON},\"${esc}\""
+        fi
+        IFS=','
+    done
+    IFS="$OLD_IFS"
+    FILES_JSON="${FILES_JSON}]"
+fi
+
+SUMMARY_ESC="$(json_escape "${SUMMARY}")"
+PHASE_ESC="$(json_escape "${PHASE}")"
+
+# Append under an advisory flock when available. The single printf write keeps
+# the line atomic-enough on platforms without flock (line-buffered, <4KB).
+append_line() {
+    tick="$(max_tick_in_dir "${PLAN_DIR}")"
+    tick=$((tick + 1))
+    printf '{"tick":%s,"ts":"%s","agent":"%s","phase":"%s","event":"%s","summary":"%s","files":%s}\n' \
+        "${tick}" "${TS}" "${AGENT}" "${PHASE_ESC}" "${EVENT}" "${SUMMARY_ESC}" "${FILES_JSON}" \
+        >> "${LEDGER_FILE}"
+    printf '%s' "${tick}"
+}
+
+if command -v flock >/dev/null 2>&1; then
+    # Compute tick AND write while holding the lock so concurrent appenders do
+    # not pick the same tick number. The subshell scopes fd 9 to the lock.
+    written_tick="$(
+        (
+            flock -w 5 9 || true
+            append_line
+        ) 9>"${LOCK_FILE}" 2>/dev/null
+    )"
+    rm -f "${LOCK_FILE}" 2>/dev/null || true
+else
+    written_tick="$(append_line)"
+fi
+
+printf "[ledger] tick %s -> %s (event=%s agent=%s)\n" \
+    "${written_tick:-?}" "${LEDGER_FILE}" "${EVENT}" "${AGENT}"
+exit 0

package/scripts/ledger-summary.ps1

@@ -0,0 +1,128 @@
+#requires -Version 5.0
+<#
+.SYNOPSIS
+    Emit a fixed-shape, cache-stable run-ledger summary (PowerShell mirror, v3).
+
+.DESCRIPTION
+    Replaces raw progress.md tail injection in autonomous mode. Output is
+    synthesized from the machine ledger and task_plan.md status counts only:
+    NO free text from disk reaches model context, and NO timestamps, so the
+    injected block is KV-cache stable by construction (architecture C3).
+
+    Plan-dir resolution matches resolve-plan-dir.ps1:
+      1. $env:PLAN_ID -> .\.planning\$PLAN_ID\
+      2. .\.planning\.active_plan
+      3. Newest .\.planning\<dir>\ by LastWriteTime
+      4. Legacy: project root
+
+    Output block (stable shape):
+      === RUN LEDGER ===
+      entries: <N>
+      phases: <complete>/<total> complete
+      in_progress: <phase heading or none>
+      agent <name>: <last event type>
+      ==================
+#>
+[CmdletBinding()]
+param()
+
+$ErrorActionPreference = "Stop"
+
+function Resolve-PlanDir {
+    $planRoot = Join-Path (Get-Location) ".planning"
+
+    if ($env:PLAN_ID) {
+        $candidate = Join-Path $planRoot $env:PLAN_ID
+        if (Test-Path -LiteralPath $candidate -PathType Container) { return $candidate }
+    }
+
+    $activePointer = Join-Path $planRoot ".active_plan"
+    if (Test-Path -LiteralPath $activePointer) {
+        $planId = (Get-Content -LiteralPath $activePointer -Raw).Trim()
+        if ($planId) {
+            $candidate = Join-Path $planRoot $planId
+            if (Test-Path -LiteralPath $candidate -PathType Container) { return $candidate }
+        }
+    }
+
+    if (Test-Path -LiteralPath $planRoot -PathType Container) {
+        $newest = Get-ChildItem -LiteralPath $planRoot -Directory -ErrorAction SilentlyContinue |
+            Where-Object { -not $_.Name.StartsWith(".") } |
+            Where-Object { Test-Path -LiteralPath (Join-Path $_.FullName "task_plan.md") } |
+            Sort-Object LastWriteTime -Descending |
+            Select-Object -First 1
+        if ($newest) { return $newest.FullName }
+    }
+
+    return (Get-Location).Path
+}
+
+$planDir  = Resolve-PlanDir
+$planFile = Join-Path $planDir "task_plan.md"
+
+# --- Phase counts: same patterns as check-complete.ps1 ---
+$TOTAL = 0
+$COMPLETE = 0
+$IN_PROGRESS = 0
+$inProgressHeading = "none"
+
+if (Test-Path -LiteralPath $planFile) {
+    $content = Get-Content -LiteralPath $planFile -Raw
+    $TOTAL = ([regex]::Matches($content, "### Phase")).Count
+    $COMPLETE = ([regex]::Matches($content, "\*\*Status:\*\* complete")).Count
+    $IN_PROGRESS = ([regex]::Matches($content, "\*\*Status:\*\* in_progress")).Count
+
+    if ($COMPLETE -eq 0 -and $IN_PROGRESS -eq 0) {
+        $c2 = ([regex]::Matches($content, "\[complete\]")).Count
+        $i2 = ([regex]::Matches($content, "\[in_progress\]")).Count
+        if ($c2 -gt 0 -or $i2 -gt 0) {
+            $COMPLETE = $c2
+            $IN_PROGRESS = $i2
+        }
+    }
+
+    # Heading of the first phase block whose status is in_progress.
+    $heading = ""
+    foreach ($line in (Get-Content -LiteralPath $planFile)) {
+        if ($line -match "^### Phase") {
+            $heading = $line
+        } elseif ($line -match "\*\*Status:\*\* in_progress" -or $line -match "\[in_progress\]") {
+            if ($heading) {
+                $inProgressHeading = $heading
+                break
+            }
+        }
+    }
+}
+
+# --- Ledger stats ---
+$totalEntries = 0
+$ledgerFiles = Get-ChildItem -LiteralPath $planDir -Filter "ledger-*.jsonl" -File -ErrorAction SilentlyContinue
+foreach ($f in $ledgerFiles) {
+    $lines = Get-Content -LiteralPath $f.FullName -ErrorAction SilentlyContinue
+    foreach ($line in $lines) {
+        if ($line -match '"tick"') { $totalEntries++ }
+    }
+}
+
+Write-Output "=== RUN LEDGER ==="
+Write-Output ("entries: " + $totalEntries)
+Write-Output ("phases: " + $COMPLETE + "/" + $TOTAL + " complete")
+Write-Output ("in_progress: " + $inProgressHeading)
+
+foreach ($f in $ledgerFiles) {
+    $agent = $f.Name -replace '^ledger-', '' -replace '\.jsonl$', ''
+    # @(...) forces array semantics: a single-line file returns a string from
+    # Get-Content and $lines[-1] would otherwise index the last character.
+    $lines = @(Get-Content -LiteralPath $f.FullName -ErrorAction SilentlyContinue)
+    $lastEvent = "none"
+    if ($lines.Count -gt 0) {
+        $lastLine = $lines[$lines.Count - 1]
+        $m = [regex]::Match($lastLine, '"event"\s*:\s*"([A-Za-z_]+)"')
+        if ($m.Success) { $lastEvent = $m.Groups[1].Value }
+    }
+    Write-Output ("agent " + $agent + ": " + $lastEvent)
+}
+
+Write-Output "=================="
+exit 0