agent-hours 0.3.0

package/dist/cli.js

@@ -0,0 +1,658 @@
+#!/usr/bin/env node
+/**
+ * agent-hours — billable hours from local coding-agent session logs
+ * (Claude Code today; Codex adapter planned), including the three-state
+ * split: hands-on / supervised / AI-autonomous.
+ *
+ * Data source: ~/.claude/projects/<project-hash>/*.jsonl (local only,
+ * retroactive, zero setup — nothing leaves your machine).
+ */
+import { parseArgs } from "node:util";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { PROJECTS_BASE, activeMinutes, activeMinutesStrict, bucketMinutesByDay, computeRefinedSplit, countByDay, dayKey, detectOverlaps, findPauses, findProjectDir, loadProject, mergeEvents, parseDate, } from "./core.js";
+import { WORKLOG_LLM_TEMPLATE, collectWorklog, describeLog, mergeLogs, shortPath, } from "./worklog.js";
+import { CODEX_SESSIONS_BASE, loadCodexSessions } from "./sources/codex.js";
+import { runInstall } from "./install.js";
+const HELP = `agent-hours — billable hours from coding-agent session logs
+
+Usage:
+  npx agent-hours install            integrate with your agents (one shot):
+                                     drops a skill so you can just ask
+                                     "what did I work on this week?"
+  npx agent-hours                    current project, cap overview
+  npx agent-hours --split            hands-on / supervised / AI-autonomous
+  npx agent-hours --by-day --split   per-day table with split
+  npx agent-hours --worklog          hourly worklog (invoice attachment)
+  npx agent-hours --worklog --csv    hourly CSV incl. what-was-done column
+  npx agent-hours --worklog --csv --by-day   daily CSV incl. descriptions
+  npx agent-hours --csv > hours.csv  CSV export (invoice tools)
+  npx agent-hours --json             machine-readable output
+  npx agent-hours --all-projects     overview across all projects
+
+Options:
+  --project <path|hash>  project to analyze (default: cwd)
+  --source <s>           auto | claude | codex (default: auto — merges all
+                         agents into ONE timeline, no double counting)
+  --summarize            refine worklog descriptions via \`claude -p\`
+                         (opt-in, the ONLY feature that costs API money)
+  --since <date>         start, inclusive (YYYY-MM-DD [HH:MM], UTC)
+  --until <date>         end, inclusive (YYYY-MM-DD [HH:MM], UTC)
+  --cap <min>            idle cap for total time (default: 10)
+  --prompt-cap <min>     idle cap for hands-on reaction tails (default: 10)
+  --split                show the three-state human/AI split
+  --by-day               per-day breakdown
+  --by-session           per-session breakdown (parallel-session debugging)
+  --worklog              hourly what-was-done log (markdown)
+  --worklog-json         hourly worklog as JSON + LLM prompt template
+  --csv                  CSV output (semicolon-separated)
+  --json                 JSON output (always includes the split)
+  --tz-offset <h>        UTC offset for day bucketing (default: 2)
+  --pauses               list longest pauses (> cap)
+  --top-pauses <n>       how many pauses to list (default: 10)
+  --all-projects         scan every project under ~/.claude/projects
+  -h, --help             this help
+  -v, --version          version
+
+Methodology — three states, honest band instead of fake precision:
+  hands-on     gaps ending in a prompt: you read/thought/typed (lower bound)
+  supervised   agent working while evidence says you watched (reaction < 30s
+               => 100%, < 5min => 50%; mid-turn typing / external file edits
+               force 100%)
+  AI-autonomous the rest of agent runtime
+Browser/call time is NOT in the logs — rule of thumb: add 15-25 %.`;
+function fail(msg) {
+    process.stderr.write(msg + "\n");
+    process.exit(1);
+}
+function fmtH(minutes) {
+    return (minutes / 60).toFixed(2);
+}
+function hhmm(minutes) {
+    const m = Math.floor(minutes);
+    return `${Math.floor(m / 60)}:${String(m % 60).padStart(2, "0")}`;
+}
+function main() {
+    let args;
+    let positionals = [];
+    try {
+        const parsed = parseArgs({
+            allowPositionals: true,
+            options: {
+                project: { type: "string" },
+                source: { type: "string", default: "auto" },
+                summarize: { type: "boolean", default: false },
+                since: { type: "string" },
+                until: { type: "string" },
+                cap: { type: "string", default: "10" },
+                "prompt-cap": { type: "string", default: "10" },
+                split: { type: "boolean", default: false },
+                "by-day": { type: "boolean", default: false },
+                "by-session": { type: "boolean", default: false },
+                worklog: { type: "boolean", default: false },
+                "worklog-json": { type: "boolean", default: false },
+                csv: { type: "boolean", default: false },
+                json: { type: "boolean", default: false },
+                "tz-offset": { type: "string", default: "2" },
+                pauses: { type: "boolean", default: false },
+                "top-pauses": { type: "string", default: "10" },
+                "all-projects": { type: "boolean", default: false },
+                help: { type: "boolean", short: "h", default: false },
+                version: { type: "boolean", short: "v", default: false },
+            },
+        });
+        args = parsed.values;
+        positionals = parsed.positionals;
+    }
+    catch (e) {
+        fail(`${e.message}\n\nRun agent-hours --help for usage.`);
+    }
+    if (positionals[0] === "install") {
+        const target = (positionals[1] ?? "all");
+        if (!["claude", "codex", "all"].includes(target)) {
+            fail("Usage: agent-hours install [claude|codex|all]");
+        }
+        for (const r of runInstall(target)) {
+            if (r.status === "skipped")
+                console.log(`- skipped: ${r.reason}`);
+            else
+                console.log(`- ${r.status}: ${r.path}`);
+        }
+        console.log();
+        console.log("Done. Now just ask your agent things like:");
+        console.log(`  "How many hours did I work on this project last week?"`);
+        console.log(`  "What did I work on yesterday? Export a CSV for my invoice."`);
+        console.log();
+        console.log("Tip (fewer permission prompts): allow \"Bash(npx agent-hours *)\"");
+        console.log("in ~/.claude/settings.json under permissions.allow.");
+        return;
+    }
+    else if (positionals.length > 0) {
+        fail(`Unknown command '${positionals[0]}'. Run agent-hours --help for usage.`);
+    }
+    if (args.help) {
+        console.log(HELP);
+        return;
+    }
+    if (args.version) {
+        const pkg = JSON.parse(fs.readFileSync(new URL("../package.json", import.meta.url), "utf8"));
+        console.log(pkg.version);
+        return;
+    }
+    const cap = Number(args.cap);
+    const promptCap = Number(args["prompt-cap"]);
+    const tzOffset = Number(args["tz-offset"]);
+    const topPauses = Number(args["top-pauses"]);
+    if (!Number.isFinite(cap) || cap <= 0)
+        fail("--cap must be a positive number of minutes.");
+    if (!Number.isFinite(promptCap) || promptCap <= 0)
+        fail("--prompt-cap must be a positive number of minutes.");
+    if (!Number.isFinite(tzOffset))
+        fail("--tz-offset must be a number of hours.");
+    let sinceMs = 0;
+    let untilMs = Date.parse("2100-01-01T00:00:00Z");
+    try {
+        if (args.since)
+            sinceMs = parseDate(args.since);
+        if (args.until) {
+            untilMs =
+                args.until.includes(" ") || args.until.includes("T")
+                    ? parseDate(args.until)
+                    : parseDate(args.until + "T23:59:59Z");
+        }
+    }
+    catch (e) {
+        fail(e.message);
+    }
+    if (args["all-projects"]) {
+        runAllProjects(sinceMs, untilMs, cap, promptCap, tzOffset, args.split, args.json);
+        return;
+    }
+    const source = String(args.source).toLowerCase();
+    if (!["auto", "claude", "codex"].includes(source)) {
+        fail("--source must be auto, claude or codex.");
+    }
+    const wantClaude = source === "auto" || source === "claude";
+    const wantCodex = source === "auto" || source === "codex";
+    const projectDir = findProjectDir(args.project);
+    // Codex matching needs a real path; a bare Claude hash can't be mapped back.
+    const projectPath = args.project === undefined
+        ? process.cwd()
+        : args.project.includes(path.sep) || args.project.startsWith("/")
+            ? path.resolve(args.project)
+            : null;
+    const sessions = [];
+    let claudeCount = 0;
+    if (wantClaude && fs.existsSync(projectDir)) {
+        sessions.push(...loadProject(projectDir, sinceMs, untilMs));
+        claudeCount = sessions.length;
+    }
+    if (wantCodex && projectPath && fs.existsSync(CODEX_SESSIONS_BASE)) {
+        sessions.push(...loadCodexSessions(projectPath, sinceMs, untilMs));
+    }
+    const codexCount = sessions.length - claudeCount;
+    if (sessions.length === 0) {
+        fail(`ERROR: no sessions found.\n` +
+            `  Claude logs checked: ${projectDir}\n` +
+            (wantCodex ? `  Codex logs checked:  ${CODEX_SESSIONS_BASE} (cwd match)\n` : "") +
+            `Tip: pass --project <path> or run from the project root.`);
+    }
+    const merged = mergeEvents(sessions);
+    const overlapping = detectOverlaps(sessions);
+    const refined = computeRefinedSplit(merged, {
+        capMinutes: cap,
+        promptCapMinutes: promptCap,
+        tzOffsetHours: tzOffset,
+    });
+    const allTimes = merged.map((e) => e.ts);
+    if (args["worklog"] || args["worklog-json"]) {
+        if (args.csv && !args["worklog-json"]) {
+            printWorklogCsv(projectDir, sinceMs, untilMs, tzOffset, refined, args["by-day"], args.summarize);
+        }
+        else {
+            printWorklog(projectDir, sinceMs, untilMs, tzOffset, refined, args["worklog-json"], args.summarize);
+        }
+        return;
+    }
+    if (args.json) {
+        printJson(projectDir, args, sessions, merged, refined, cap, promptCap, tzOffset, overlapping);
+        return;
+    }
+    if (args.csv) {
+        printCsv(refined, args.split);
+        return;
+    }
+    // Human-readable output
+    console.log(`Project logs: ${projectDir}`);
+    console.log(`Range: ${args.since ?? "beginning"} – ${args.until ?? "now"}`);
+    console.log(`Sessions in range: ${sessions.length}` +
+        (codexCount > 0 ? ` (claude ${claudeCount}, codex ${codexCount})` : ""));
+    console.log(`Total events: ${merged.length.toLocaleString("en-US")}`);
+    console.log();
+    console.log("Activity at different idle caps:");
+    console.log(`  ${"Cap".padEnd(8)} ${"with cap bonus".padEnd(16)} ${"strict (pause>cap=0)".padEnd(22)}`);
+    for (const c of [1, 2, 3, 5, 10, 15]) {
+        const h = fmtH(activeMinutes(allTimes, c));
+        const hs = fmtH(activeMinutesStrict(allTimes, c));
+        let marker = c === Math.round(cap) ? "  ← standard" : "";
+        if (c === 2)
+            marker += "  ← pure working time";
+        console.log(`  ${String(c).padStart(2)}min    ${h.padStart(6)}h          ${hs.padStart(6)}h${marker}`);
+    }
+    console.log();
+    console.log("  with cap bonus: industry standard (pause > cap counts cap minutes).");
+    console.log("  strict        : pause > cap counts 0 — honest lower bound for");
+    console.log("                  background-heavy sessions (orchestrator waits).");
+    console.log();
+    if (args.split) {
+        console.log(`Human/AI split — three-state model (cap ${cap}min / prompt cap ${promptCap}min):`);
+        console.log(`  Hands-on (provably human):     ${fmtH(refined.handsOnMinutes).padStart(7)} h   (${refined.promptCount} prompts)`);
+        console.log(`  Supervised (weighted est.):    ${fmtH(refined.supervisedMinutes).padStart(7)} h`);
+        console.log(`  = Human attention (model):     ${fmtH(refined.attentionMinutes).padStart(7)} h`);
+        console.log(`  Upper bound (inter-prompt):    ${fmtH(refined.upperBoundMinutes).padStart(7)} h`);
+        console.log(`  AI autonomous (model):         ${fmtH(refined.aiAutonomousMinutes).padStart(7)} h`);
+        console.log(`  Total (merged timeline):       ${fmtH(refined.totalMinutes).padStart(7)} h`);
+        console.log();
+        console.log("  Band: hands-on is the defensible lower bound, inter-prompt the upper.");
+        console.log("  The model weighs agent-working windows by watch evidence (reaction");
+        console.log("  < 30s / mid-turn typing / external edits). Billing decision is yours.");
+        console.log();
+        console.log("  Range across caps (cap and prompt cap varied together):");
+        for (const c of [5, 10, 15]) {
+            const s = computeRefinedSplit(merged, {
+                capMinutes: c,
+                promptCapMinutes: c,
+                tzOffsetHours: tzOffset,
+            });
+            console.log(`    cap ${String(c).padStart(2)}min: total ${fmtH(s.totalMinutes).padStart(6)}h | attention ${fmtH(s.attentionMinutes).padStart(6)}h | AI ${fmtH(s.aiAutonomousMinutes).padStart(6)}h`);
+        }
+        console.log();
+    }
+    const realPauses = findPauses(allTimes, cap);
+    if (realPauses.length > 0 && (args.pauses || !args.split)) {
+        const n = Math.min(topPauses, realPauses.length);
+        const idleTotal = realPauses.reduce((acc, p) => acc + p.minutes, 0);
+        const capBonus = realPauses.length * cap;
+        console.log(`Pauses > ${cap}min cap (${realPauses.length} total, ${fmtH(idleTotal)}h idle):`);
+        console.log(`  Cap-bonus effect: ${capBonus.toFixed(0)}min (${fmtH(capBonus)}h) still counted as work by the standard method.`);
+        console.log();
+        console.log(`  Top ${n} longest pauses (shown at tz offset ${tzOffset >= 0 ? "+" : ""}${tzOffset}h):`);
+        for (let i = 0; i < n; i++) {
+            const p = realPauses[i];
+            const s = new Date(p.startMs + tzOffset * 3600_000).toISOString().slice(11, 19);
+            const e = new Date(p.endMs + tzOffset * 3600_000).toISOString().slice(11, 19);
+            const dur = p.minutes >= 60
+                ? `${Math.floor(p.minutes / 60)}h${String(Math.floor(p.minutes % 60)).padStart(2, "0")}m`
+                : `${p.minutes.toFixed(1)} min`;
+            const day = dayKey(p.startMs, tzOffset);
+            console.log(`    ${String(i + 1).padStart(2)}. ${day} ${s} – ${e}  →  ${dur}`);
+        }
+        console.log();
+    }
+    if (overlapping) {
+        console.log("⚠  NOTE: multiple sessions/subagents ran IN PARALLEL.");
+        console.log("   Hours above use the merged timeline (every real minute counted");
+        console.log("   once — no double counting). Details per session: --by-session");
+        console.log();
+    }
+    if (args["by-session"]) {
+        console.log(`Per session (cap ${cap}min):`);
+        for (const s of sessions) {
+            const times = s.events.map((e) => e.ts);
+            const a = fmtH(activeMinutes(times, cap));
+            const f = new Date(times[0] + tzOffset * 3600_000).toISOString().slice(0, 16).replace("T", " ");
+            const l = new Date(times[times.length - 1] + tzOffset * 3600_000).toISOString().slice(0, 16).replace("T", " ");
+            console.log(`  ${s.name}`);
+            console.log(`    ${f} – ${l} | ${String(times.length).padStart(4)} events | ${a.padStart(6)}h active`);
+        }
+        const sumH = sessions.reduce((acc, s) => acc + activeMinutes(s.events.map((e) => e.ts), cap), 0);
+        console.log();
+        console.log(`  Sum of individual sessions (double-counts overlap): ${fmtH(sumH)}h`);
+        console.log(`  Merged timeline (real active time):                 ${fmtH(refined.totalMinutes)}h`);
+        console.log();
+    }
+    if (args["by-day"]) {
+        if (args.split) {
+            const days = aggregateDays(refined);
+            console.log(`Per day (cap ${cap}min / prompt cap ${promptCap}min):`);
+            console.log(`  Date        |  Total | Hands-on | Superv. | AI-auto`);
+            for (const day of [...days.keys()].sort()) {
+                const d = days.get(day);
+                console.log(`  ${day}  | ${fmtH(d.total).padStart(5)}h | ${fmtH(d.handsOn).padStart(7)}h | ${fmtH(d.supervised).padStart(6)}h | ${fmtH(d.ai).padStart(6)}h`);
+            }
+        }
+        else {
+            const dayTotal = bucketMinutesByDay(allTimes, cap, tzOffset);
+            const dayMsgs = countByDay(allTimes, tzOffset);
+            console.log(`Per day (cap ${cap}min):`);
+            for (const day of [...dayTotal.keys()].sort()) {
+                console.log(`  ${day} | ${fmtH(dayTotal.get(day) ?? 0).padStart(5)}h | ${String(dayMsgs.get(day) ?? 0).padStart(4)} events`);
+            }
+        }
+        console.log();
+        console.log(`Sum: ${(refined.totalMinutes / 60).toFixed(1)} h`);
+    }
+}
+function aggregateDays(refined) {
+    const days = new Map();
+    for (const [hour, st] of refined.byHour) {
+        const day = hour.slice(0, 10);
+        const d = days.get(day) ?? { total: 0, handsOn: 0, supervised: 0, ai: 0 };
+        d.total += st.total;
+        d.handsOn += st.handsOn;
+        d.supervised += st.supervised;
+        d.ai += st.ai;
+        days.set(day, d);
+    }
+    return days;
+}
+function printCsv(refined, withSplit) {
+    const days = aggregateDays(refined);
+    const header = ["Datum", "Dauer (h)", "Dauer (Stunden:Minuten)"];
+    if (withSplit)
+        header.push("Hands-on (h)", "Supervised (h)", "Mensch gesamt (h)", "AI-solo (h)");
+    console.log(header.join(";"));
+    for (const day of [...days.keys()].sort()) {
+        const d = days.get(day);
+        const row = [day, fmtH(d.total), hhmm(d.total)];
+        if (withSplit) {
+            row.push(fmtH(d.handsOn), fmtH(d.supervised), fmtH(d.handsOn + d.supervised), fmtH(d.ai));
+        }
+        console.log(row.join(";"));
+    }
+}
+function csvField(s) {
+    return /[;"\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+/**
+ * Optional AI refinement — the ONLY feature that spends API money, therefore
+ * strictly opt-in via --summarize. One `claude -p` call for ALL buckets.
+ */
+function aiSummarize(buckets) {
+    const instruction = "You receive JSON evidence buckets extracted from coding-agent session logs. " +
+        "For EACH bucket output exactly one line in the format <key>\\t<summary> " +
+        "(summary: max 14 words, dominant language of the evidence, invoice-attachment tone). " +
+        "Finish with one line OVERALL\\t<2-3 sentence summary of the whole period>. Output nothing else.";
+    const res = spawnSync("claude", ["-p", instruction], {
+        input: JSON.stringify(buckets),
+        encoding: "utf8",
+        maxBuffer: 16 * 1024 * 1024,
+    });
+    if (res.error || res.status !== 0) {
+        fail("--summarize shells out to `claude -p` and needs the claude CLI on PATH.\n" +
+            `Error: ${res.error?.message ?? (res.stderr || "exit code " + res.status)}`);
+    }
+    const map = new Map();
+    for (const line of res.stdout.split("\n")) {
+        const idx = line.indexOf("\t");
+        if (idx > 0)
+            map.set(line.slice(0, idx).trim(), line.slice(idx + 1).trim());
+    }
+    return map;
+}
+/**
+ * Worklog as CSV with rule-based descriptions — hourly by default, daily with
+ * --by-day. Always ends with a GESAMT row describing the whole range.
+ */
+function printWorklogCsv(projectDir, sinceMs, untilMs, tzOffset, refined, byDay, summarize = false) {
+    const log = collectWorklog(projectDir, sinceMs, untilMs, tzOffset);
+    const keys = [...new Set([...refined.byHour.keys(), ...log.keys()])].sort();
+    // Optional AI pass: collect evidence per row key, one claude -p call.
+    let ai = new Map();
+    if (summarize) {
+        const buckets = [];
+        const rowKeys = byDay ? [...new Set(keys.map((k) => k.slice(0, 10)))].sort() : keys;
+        for (const rk of rowKeys) {
+            const logs = byDay
+                ? keys.filter((k) => k.startsWith(rk)).map((k) => log.get(k)).filter((l) => !!l)
+                : [log.get(rk)].filter(Boolean);
+            const m = mergeLogs(logs);
+            buckets.push({
+                key: rk,
+                commits: m.commits.slice(0, 8),
+                prompts: m.prompts.slice(0, 6),
+                files: [...m.filesEdited].map(shortPath).slice(0, 10),
+                awaySummaries: m.awaySummaries.slice(-2),
+            });
+        }
+        ai = aiSummarize(buckets);
+    }
+    const describe = (key, l, maxLen) => ai.get(key) ?? describeLog(l, maxLen);
+    if (byDay) {
+        console.log(["Datum", "Aktiv (h)", "Hands-on (h)", "Supervised (h)", "AI (h)", "Beschreibung"].join(";"));
+        const days = [...new Set(keys.map((k) => k.slice(0, 10)))].sort();
+        for (const day of days) {
+            const dayHours = keys.filter((k) => k.startsWith(day));
+            const st = dayHours.reduce((acc, h) => {
+                const s = refined.byHour.get(h);
+                if (s) {
+                    acc.total += s.total;
+                    acc.handsOn += s.handsOn;
+                    acc.supervised += s.supervised;
+                    acc.ai += s.ai;
+                }
+                return acc;
+            }, { total: 0, handsOn: 0, supervised: 0, ai: 0 });
+            const merged = mergeLogs(dayHours.map((h) => log.get(h)).filter((l) => !!l));
+            console.log([day, fmtH(st.total), fmtH(st.handsOn), fmtH(st.supervised), fmtH(st.ai), csvField(describe(day, merged))].join(";"));
+        }
+    }
+    else {
+        console.log(["Datum", "Stunde", "Aktiv (min)", "Hands-on (min)", "Supervised (min)", "AI (min)", "Beschreibung"].join(";"));
+        for (const k of keys) {
+            const st = refined.byHour.get(k) ?? { total: 0, handsOn: 0, supervised: 0, ai: 0 };
+            const l = log.get(k);
+            console.log([
+                k.slice(0, 10),
+                k.slice(11),
+                st.total.toFixed(0),
+                st.handsOn.toFixed(0),
+                st.supervised.toFixed(0),
+                st.ai.toFixed(0),
+                csvField(l ? describe(k, l) : ""),
+            ].join(";"));
+        }
+    }
+    // Project-level summary row (chronological merge)
+    const all = mergeLogs(keys.map((k) => log.get(k)).filter((l) => !!l));
+    const label = byDay ? "GESAMT" : "GESAMT;";
+    console.log([
+        label,
+        byDay ? fmtH(refined.totalMinutes) : refined.totalMinutes.toFixed(0),
+        byDay ? fmtH(refined.handsOnMinutes) : refined.handsOnMinutes.toFixed(0),
+        byDay ? fmtH(refined.supervisedMinutes) : refined.supervisedMinutes.toFixed(0),
+        byDay ? fmtH(refined.aiAutonomousMinutes) : refined.aiAutonomousMinutes.toFixed(0),
+        csvField(ai.get("OVERALL") ?? describeLog(all, 400)),
+    ].join(";"));
+}
+function printWorklog(projectDir, sinceMs, untilMs, tzOffset, refined, asJson, summarize = false) {
+    const log = collectWorklog(projectDir, sinceMs, untilMs, tzOffset);
+    const hours = [...new Set([...refined.byHour.keys(), ...log.keys()])].sort();
+    let ai = new Map();
+    if (summarize && !asJson) {
+        ai = aiSummarize(hours
+            .filter((h) => log.has(h))
+            .map((h) => {
+            const l = log.get(h);
+            return {
+                key: h,
+                commits: l.commits.slice(0, 8),
+                prompts: l.prompts.slice(0, 6),
+                files: [...l.filesEdited].map(shortPath).slice(0, 10),
+                awaySummaries: l.awaySummaries.slice(-2),
+            };
+        }));
+    }
+    if (asJson) {
+        const out = hours.map((h) => {
+            const st = refined.byHour.get(h);
+            const l = log.get(h);
+            return {
+                hour: h,
+                minutes: st
+                    ? {
+                        total: +st.total.toFixed(1),
+                        handsOn: +st.handsOn.toFixed(1),
+                        supervised: +st.supervised.toFixed(1),
+                        aiAutonomous: +st.ai.toFixed(1),
+                    }
+                    : null,
+                prompts: l?.prompts ?? [],
+                filesEdited: l ? [...l.filesEdited] : [],
+                commands: l?.commands ?? [],
+                commits: l?.commits ?? [],
+                awaySummaries: l?.awaySummaries ?? [],
+            };
+        });
+        console.log(JSON.stringify({ llmTemplate: WORKLOG_LLM_TEMPLATE, hours: out }, null, 2));
+        return;
+    }
+    console.log(`# Worklog ${projectDir.split("/").pop()}`);
+    let currentDay = "";
+    for (const h of hours) {
+        const day = h.slice(0, 10);
+        if (day !== currentDay) {
+            currentDay = day;
+            console.log(`\n## ${day}`);
+        }
+        const st = refined.byHour.get(h);
+        const l = log.get(h);
+        const mins = st
+            ? `${st.total.toFixed(0)} min active (${st.handsOn.toFixed(0)} hands-on / ${st.supervised.toFixed(0)} supervised / ${st.ai.toFixed(0)} AI)`
+            : "evidence only";
+        console.log(`\n### ${h.slice(11)} · ${mins}`);
+        const summary = ai.get(h);
+        if (summary)
+            console.log(`- **Summary:** ${summary}`);
+        if (l) {
+            if (l.prompts.length) {
+                console.log(`- Prompts (${l.prompts.length}): ${l.prompts.slice(0, 3).map((p) => `"${p}"`).join(" | ")}${l.prompts.length > 3 ? " …" : ""}`);
+            }
+            if (l.filesEdited.size) {
+                const files = [...l.filesEdited].map(shortPath);
+                console.log(`- Files edited (${files.length}): ${files.slice(0, 6).join(", ")}${files.length > 6 ? " …" : ""}`);
+            }
+            if (l.commits.length)
+                console.log(`- Commits: ${l.commits.map((c) => `"${c}"`).join(", ")}`);
+            if (l.commands.length)
+                console.log(`- Commands (${l.commands.length}): ${l.commands.slice(0, 3).join(" | ")}${l.commands.length > 3 ? " …" : ""}`);
+            for (const a of l.awaySummaries)
+                console.log(`- Away summary: ${a}`);
+        }
+    }
+    console.log();
+    console.log(`---`);
+    const overall = ai.get("OVERALL");
+    if (overall)
+        console.log(`**Overall:** ${overall}\n`);
+    console.log(`Totals: ${fmtH(refined.totalMinutes)}h | hands-on ${fmtH(refined.handsOnMinutes)}h | supervised ${fmtH(refined.supervisedMinutes)}h | AI ${fmtH(refined.aiAutonomousMinutes)}h`);
+    if (!summarize) {
+        console.log(`Tip: --summarize refines descriptions via claude -p (paid), or pipe --worklog-json into your AI chat for free.`);
+    }
+}
+function printJson(projectDir, args, sessions, merged, refined, cap, promptCap, tzOffset, overlapping) {
+    const allTimes = merged.map((e) => e.ts);
+    const days = aggregateDays(refined);
+    const caps = {};
+    for (const c of [5, 10, 15]) {
+        const s = computeRefinedSplit(merged, {
+            capMinutes: c,
+            promptCapMinutes: c,
+            tzOffsetHours: tzOffset,
+        });
+        caps[String(c)] = {
+            totalHours: +(s.totalMinutes / 60).toFixed(2),
+            attentionHours: +(s.attentionMinutes / 60).toFixed(2),
+            aiAutonomousHours: +(s.aiAutonomousMinutes / 60).toFixed(2),
+        };
+    }
+    console.log(JSON.stringify({
+        projectDir,
+        since: args.since ?? null,
+        until: args.until ?? null,
+        capMinutes: cap,
+        promptCapMinutes: promptCap,
+        tzOffsetHours: tzOffset,
+        sessions: sessions.length,
+        events: merged.length,
+        prompts: refined.promptCount,
+        parallelSessions: overlapping,
+        totalHours: +(refined.totalMinutes / 60).toFixed(2),
+        strictTotalHours: +(activeMinutesStrict(allTimes, cap) / 60).toFixed(2),
+        handsOnHours: +(refined.handsOnMinutes / 60).toFixed(2),
+        supervisedHours: +(refined.supervisedMinutes / 60).toFixed(2),
+        attentionHours: +(refined.attentionMinutes / 60).toFixed(2),
+        upperBoundHours: +(refined.upperBoundMinutes / 60).toFixed(2),
+        aiAutonomousHours: +(refined.aiAutonomousMinutes / 60).toFixed(2),
+        capRange: caps,
+        byDay: [...days.keys()].sort().map((day) => {
+            const d = days.get(day);
+            return {
+                date: day,
+                totalHours: +(d.total / 60).toFixed(2),
+                handsOnHours: +(d.handsOn / 60).toFixed(2),
+                supervisedHours: +(d.supervised / 60).toFixed(2),
+                attentionHours: +((d.handsOn + d.supervised) / 60).toFixed(2),
+                aiAutonomousHours: +(d.ai / 60).toFixed(2),
+            };
+        }),
+    }, null, 2));
+}
+function runAllProjects(sinceMs, untilMs, cap, promptCap, tzOffset, withSplit, asJson) {
+    let dirs;
+    try {
+        dirs = fs
+            .readdirSync(PROJECTS_BASE, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name)
+            .sort();
+    }
+    catch {
+        fail(`ERROR: cannot read ${PROJECTS_BASE}`);
+    }
+    const rows = [];
+    for (const dir of dirs) {
+        const sessions = loadProject(path.join(PROJECTS_BASE, dir), sinceMs, untilMs);
+        if (sessions.length === 0)
+            continue;
+        const merged = mergeEvents(sessions);
+        const refined = computeRefinedSplit(merged, {
+            capMinutes: cap,
+            promptCapMinutes: promptCap,
+            tzOffsetHours: tzOffset,
+        });
+        rows.push({
+            project: dir,
+            totalHours: +(refined.totalMinutes / 60).toFixed(2),
+            attentionHours: +(refined.attentionMinutes / 60).toFixed(2),
+            aiAutonomousHours: +(refined.aiAutonomousMinutes / 60).toFixed(2),
+            events: merged.length,
+            lastActivity: dayKey(merged[merged.length - 1].ts, tzOffset),
+        });
+    }
+    rows.sort((a, b) => b.totalHours - a.totalHours);
+    if (asJson) {
+        console.log(JSON.stringify({ capMinutes: cap, promptCapMinutes: promptCap, projects: rows }, null, 2));
+        return;
+    }
+    console.log(`All projects (cap ${cap}min)${withSplit ? " — with split" : ""}:`);
+    console.log();
+    const head = withSplit
+        ? `  ${"Hours".padStart(7)} ${"Attn".padStart(7)} ${"AI-auto".padStart(8)}  ${"Last".padEnd(11)} Project`
+        : `  ${"Hours".padStart(7)} ${"Events".padStart(7)}  ${"Last".padEnd(11)} Project`;
+    console.log(head);
+    let sum = 0;
+    for (const r of rows) {
+        sum += r.totalHours;
+        if (withSplit) {
+            console.log(`  ${r.totalHours.toFixed(2).padStart(6)}h ${r.attentionHours.toFixed(2).padStart(6)}h ${r.aiAutonomousHours.toFixed(2).padStart(7)}h  ${r.lastActivity.padEnd(11)} ${r.project}`);
+        }
+        else {
+            console.log(`  ${r.totalHours.toFixed(2).padStart(6)}h ${String(r.events).padStart(7)}  ${r.lastActivity.padEnd(11)} ${r.project}`);
+        }
+    }
+    console.log();
+    console.log(`  ${rows.length} projects, ${sum.toFixed(1)} h total in range.`);
+}
+main();