Merge branch 'claude/epic-darwin-g5v4m5': per-job args + personal action worklist

https://claude.ai/code/session_01MpX6FtfqE7HqUuc6Rksgwu

Author: claude

automation/README.md

@@ -14,5 +14,16 @@ Every script takes its vault from `--vault-root`; nothing is hardcoded.
 
 Overrides: `run-vault-digest.sh` honours `PYTHON` and `HEBB_BIN` (launchd ships a
 minimal PATH). Both Python scripts take `--output`/`--json-output`; the action
-review also takes `--register-name` and `--owner` (the name highlighted under
-"My Actions"; empty by default).
+review also takes `--register-name`, `--owner` (the name highlighted under
+"My Actions"; empty by default), and `--mine-output` (off by default; with
+`--owner`, also writes a personal worklist of just the owner's actions,
+bucketed Overdue/Current/Waiting and sorted by due date).
+
+Per-vault flags: a vault passes extra arguments to its jobs via the
+`[job_args]` table in `.hebb/config.toml`; `hebb install` appends them to the
+rendered launchd program after the built-in flags. For example:
+
+```toml
+[job_args]
+action-review = ["--owner", "Alex Doe", "--mine-output", "2-Areas/_MY-OPEN-ACTIONS.md"]
+```

automation/generate-action-review.py

@@ -261,10 +261,13 @@ def extract_priority_block(output_path: Path) -> str:
 
 
 def build_review(
-    vault_root: Path, output_path: Path, register_name: str, owner_filter: str
+    vault_root: Path,
+    output_path: Path,
+    register_name: str,
+    owner_filter: str,
+    registers: list[Path],
+    actions: list[Action],
 ) -> tuple[str, str]:
-    registers, actions = collect_actions(vault_root, output_path, register_name, owner_filter)
-
     today = dt.date.today()
     overdue = [item for item in actions if normalize_status(item.status) == "overdue" or item.is_overdue]
     mine = [item for item in actions if item.is_mine]
@@ -333,25 +336,85 @@ def build_review(
     return markdown, build_json(actions, registers, vault_root)
 
 
+def sort_by_due(actions: list[Action]) -> list[Action]:
+    return sorted(
+        actions,
+        key=lambda item: (
+            item.date_value or dt.date.max,
+            item.register_title,
+            item.action.lower(),
+        ),
+    )
+
+
+def build_mine(
+    vault_root: Path, register_name: str, owner_filter: str, actions: list[Action]
+) -> str:
+    """Personal worklist: only the owner's open actions, bucketed by urgency."""
+    mine = [item for item in actions if item.is_mine]
+    overdue = sort_by_due([item for item in mine if item.is_overdue or normalize_status(item.status) == "overdue"])
+    rest = [item for item in mine if item not in overdue]
+    waiting = sort_by_due([item for item in rest if normalize_status(item.status) == "waiting"])
+    current = sort_by_due([item for item in rest if item not in waiting])
+
+    return f"""# My Open Actions
+
+Personal worklist for **{owner_filter}**, generated from all `{register_name}` files in the vault.
+
+**Generated:** {dt.date.today().isoformat()}
+**Open actions:** {len(mine)} open ({len(overdue)} overdue, {len(current)} current, {len(waiting)} waiting)
+
+---
+
+## Overdue
+
+{markdown_table(overdue, vault_root)}
+---
+
+## Current
+
+{markdown_table(current, vault_root)}
+---
+
+## Waiting
+
+{markdown_table(waiting, vault_root)}
+"""
+
+
 def main() -> int:
     parser = argparse.ArgumentParser(description=__doc__)
     parser.add_argument("--vault-root", default=".", help="Path to the vault root")
     parser.add_argument("--output", default=DEFAULT_OUTPUT, help="Output markdown file (relative to vault root)")
     parser.add_argument("--json-output", default=DEFAULT_JSON_OUTPUT, help="Output JSON file (relative to vault root)")
     parser.add_argument("--register-name", default=DEFAULT_REGISTER_NAME, help="Action-register filename to scan for")
     parser.add_argument("--owner", default="", help="Owner name to highlight under 'My Actions' (matched as a substring; empty disables)")
+    parser.add_argument(
+        "--mine-output",
+        default="",
+        help="Also write a personal worklist of the owner's actions to this file (relative to vault root; empty disables; requires --owner)",
+    )
     args = parser.parse_args()
 
+    if args.mine_output and not args.owner:
+        parser.error("--mine-output requires --owner")
+
     vault_root = Path(args.vault_root).resolve()
     output_path = (vault_root / args.output).resolve()
     json_output_path = (vault_root / args.json_output).resolve()
     output_path.parent.mkdir(parents=True, exist_ok=True)
     json_output_path.parent.mkdir(parents=True, exist_ok=True)
-    markdown, json_export = build_review(vault_root, output_path, args.register_name, args.owner)
+    registers, actions = collect_actions(vault_root, output_path, args.register_name, args.owner)
+    markdown, json_export = build_review(vault_root, output_path, args.register_name, args.owner, registers, actions)
     output_path.write_text(markdown, encoding="utf-8")
     json_output_path.write_text(json_export, encoding="utf-8")
     print(f"Wrote {display_path(output_path, vault_root)}")
     print(f"Wrote {display_path(json_output_path, vault_root)}")
+    if args.mine_output:
+        mine_path = (vault_root / args.mine_output).resolve()
+        mine_path.parent.mkdir(parents=True, exist_ok=True)
+        mine_path.write_text(build_mine(vault_root, args.register_name, args.owner, actions), encoding="utf-8")
+        print(f"Wrote {display_path(mine_path, vault_root)}")
     return 0
 
 

core/vaultconfig.go

@@ -20,10 +20,19 @@ type VaultConfig struct {
 	WebPort     int          `toml:"web_port"`
 	Jobs        []string     `toml:"jobs"`
 	Skills      []string     `toml:"skills"`
+	JobArgs     JobArgs      `toml:"job_args"`
 	Git         GitConfig    `toml:"git"`
 	Update      UpdateConfig `toml:"update"`
 }
 
+// JobArgs is the committed [job_args] block: extra command-line arguments
+// appended to a job's rendered launchd program, keyed by job name. Entries for
+// job names not listed under jobs (or unknown to hebb) are ignored, e.g.
+//
+//	[job_args]
+//	action-review = ["--owner", "Alex Doe"]
+type JobArgs map[string][]string
+
 // UpdateConfig is the committed [update] block. The scheduled update-check job
 // reports a newer release by default; with auto = true it installs it (opt-in,
 // since self-replacing a binary unattended is a deliberate choice).

core/vaultconfig_test.go

@@ -66,6 +66,29 @@ func TestLoadVaultConfigAbsent(t *testing.T) {
 	}
 }
 
+func TestVaultConfigJobArgs(t *testing.T) {
+	vault := t.TempDir()
+	if err := os.MkdirAll(filepath.Join(vault, ".hebb"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+	cfg := `name = "Work"
+
+[job_args]
+action-review = ["--owner", "Alex Doe", "--mine-output", "2-Areas/_MY-OPEN-ACTIONS.md"]
+`
+	if err := os.WriteFile(filepath.Join(vault, ".hebb", "config.toml"), []byte(cfg), 0o644); err != nil {
+		t.Fatal(err)
+	}
+	got, _, err := LoadVaultConfig(vault)
+	if err != nil {
+		t.Fatalf("LoadVaultConfig: %v", err)
+	}
+	want := []string{"--owner", "Alex Doe", "--mine-output", "2-Areas/_MY-OPEN-ACTIONS.md"}
+	if !reflect.DeepEqual(got.JobArgs["action-review"], want) {
+		t.Errorf("job_args[action-review] = %v, want %v", got.JobArgs["action-review"], want)
+	}
+}
+
 func TestLoadVaultConfigInvalid(t *testing.T) {
 	vault := t.TempDir()
 	if err := os.MkdirAll(filepath.Join(vault, ".hebb"), 0o755); err != nil {

install/doctor.go

@@ -158,7 +158,7 @@ func checkLaunchd(add func(string, string, string), opts Options, vc core.VaultC
 	if dir == "" {
 		return
 	}
-	jobs := VaultJobs(opts.VaultPath, Slugify(vc.Name), "hebb", resolvedAssetDir(opts), opts.Home, vc.WebPort, vc.Jobs, vc.Update.Auto)
+	jobs := VaultJobs(opts.VaultPath, Slugify(vc.Name), "hebb", resolvedAssetDir(opts), opts.Home, vc.WebPort, vc.Jobs, vc.Update.Auto, vc.JobArgs)
 	if len(jobs) == 0 {
 		return
 	}

install/launchdjobs.go

@@ -35,8 +35,10 @@ func Slugify(s string) string {
 // and action-review jobs are only included when their script exists under
 // <assetRoot>/automation, so no broken plists are written if the automation
 // scripts are absent. updateAuto makes the update-check job install updates
-// rather than only reporting them. Unknown names are skipped.
-func VaultJobs(vaultPath, slug, hebbBin, assetRoot, home string, port int, names []string, updateAuto bool) []launchd.Job {
+// rather than only reporting them. jobArgs carries the per-job extra arguments
+// from config.toml's [job_args]; they are appended to the matching job's
+// program. Unknown names are skipped.
+func VaultJobs(vaultPath, slug, hebbBin, assetRoot, home string, port int, names []string, updateAuto bool, jobArgs map[string][]string) []launchd.Job {
 	logDir := filepath.Join(home, "Library", "Logs")
 	logPath := func(job string) string {
 		return filepath.Join(logDir, "hebb-"+slug+"-"+job+".log")
@@ -52,6 +54,7 @@ func VaultJobs(vaultPath, slug, hebbBin, assetRoot, home string, port int, names
 
 	var jobs []launchd.Job
 	for _, name := range names {
+		before := len(jobs)
 		switch name {
 		case "web":
 			jobs = append(jobs, launchd.Job{
@@ -111,6 +114,14 @@ func VaultJobs(vaultPath, slug, hebbBin, assetRoot, home string, port int, names
 				LogPath:    logPath("update-check"),
 			})
 		}
+		// Per-job extra args from config.toml's [job_args] go at the end of the
+		// rendered program, after the built-in flags.
+		if len(jobs) > before {
+			if extra := jobArgs[name]; len(extra) > 0 {
+				job := &jobs[len(jobs)-1]
+				job.Program = append(job.Program, extra...)
+			}
+		}
 	}
 	return jobs
 }

install/launchdjobs_test.go

@@ -34,7 +34,7 @@ func jobByLabel(jobs []launchd.Job, label string) (launchd.Job, bool) {
 
 func TestVaultJobsWebIsBuiltIn(t *testing.T) {
 	home := t.TempDir()
-	jobs := VaultJobs("/vaults/work", "work", "/usr/local/bin/hebb", t.TempDir(), home, 4399, []string{"web"}, false)
+	jobs := VaultJobs("/vaults/work", "work", "/usr/local/bin/hebb", t.TempDir(), home, 4399, []string{"web"}, false, nil)
 	j, ok := jobByLabel(jobs, "local.hebb.work.web")
 	if !ok {
 		t.Fatalf("web job not built; got %d jobs", len(jobs))
@@ -59,7 +59,7 @@ func TestVaultJobsAutomationGatedOnScript(t *testing.T) {
 
 	// Without the scripts present, automation jobs are skipped.
 	jobs := VaultJobs("/vaults/work", "work", "hebb", assetRoot, home, 4321,
-		[]string{"daily-digest", "action-review"}, false)
+		[]string{"daily-digest", "action-review"}, false, nil)
 	if len(jobs) != 0 {
 		t.Errorf("expected automation jobs skipped when scripts absent, got %d", len(jobs))
 	}
@@ -75,7 +75,7 @@ func TestVaultJobsAutomationGatedOnScript(t *testing.T) {
 		}
 	}
 	jobs = VaultJobs("/vaults/work", "work", "hebb", assetRoot, home, 4321,
-		[]string{"daily-digest", "action-review"}, false)
+		[]string{"daily-digest", "action-review"}, false, nil)
 
 	digest, ok := jobByLabel(jobs, "local.hebb.work.daily-digest")
 	if !ok {
@@ -110,16 +110,55 @@ func TestVaultJobsAutomationGatedOnScript(t *testing.T) {
 	}
 }
 
+func TestVaultJobsAppendsPerJobArgs(t *testing.T) {
+	home := t.TempDir()
+	assetRoot := t.TempDir()
+	autoDir := filepath.Join(assetRoot, "automation")
+	if err := os.MkdirAll(autoDir, 0o755); err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(filepath.Join(autoDir, "generate-action-review.py"), []byte("#!/usr/bin/env python3\n"), 0o755); err != nil {
+		t.Fatal(err)
+	}
+
+	jobArgs := map[string][]string{
+		"action-review": {"--owner", "Alex Doe", "--mine-output", "2-Areas/_MY-OPEN-ACTIONS.md"},
+		"bogus":         {"--ignored"},
+	}
+	jobs := VaultJobs("/vaults/work", "work", "hebb", assetRoot, home, 4321,
+		[]string{"action-review", "web"}, false, jobArgs)
+
+	review, ok := jobByLabel(jobs, "local.hebb.work.action-review")
+	if !ok {
+		t.Fatal("action-review job not built")
+	}
+	prog := strings.Join(review.Program, " ")
+	for _, want := range []string{"--vault-root /vaults/work", "--owner Alex Doe", "--mine-output 2-Areas/_MY-OPEN-ACTIONS.md"} {
+		if !strings.Contains(prog, want) {
+			t.Errorf("action-review program %q missing %q", prog, want)
+		}
+	}
+
+	// Jobs without configured args are untouched.
+	web, ok := jobByLabel(jobs, "local.hebb.work.web")
+	if !ok {
+		t.Fatal("web job not built")
+	}
+	if got := strings.Join(web.Program, " "); strings.Contains(got, "--owner") || strings.Contains(got, "--ignored") {
+		t.Errorf("web program %q should not pick up other jobs' args", got)
+	}
+}
+
 func TestVaultJobsSkipsUnknown(t *testing.T) {
-	jobs := VaultJobs("/v", "v", "hebb", t.TempDir(), t.TempDir(), 4321, []string{"web", "bogus"}, false)
+	jobs := VaultJobs("/v", "v", "hebb", t.TempDir(), t.TempDir(), 4321, []string{"web", "bogus"}, false, nil)
 	if len(jobs) != 1 {
 		t.Errorf("unknown job name should be skipped, got %d jobs", len(jobs))
 	}
 }
 
 func TestVaultJobsUpdateCheck(t *testing.T) {
 	// Default: the scheduled job only checks (notifies).
-	jobs := VaultJobs("/v", "v", "hebb", t.TempDir(), t.TempDir(), 4321, []string{"update-check"}, false)
+	jobs := VaultJobs("/v", "v", "hebb", t.TempDir(), t.TempDir(), 4321, []string{"update-check"}, false, nil)
 	j, ok := jobByLabel(jobs, "local.hebb.v.update-check")
 	if !ok {
 		t.Fatal("update-check job not built")
@@ -132,7 +171,7 @@ func TestVaultJobsUpdateCheck(t *testing.T) {
 	}
 
 	// auto = true: the job applies the update instead.
-	jobs = VaultJobs("/v", "v", "hebb", t.TempDir(), t.TempDir(), 4321, []string{"update-check"}, true)
+	jobs = VaultJobs("/v", "v", "hebb", t.TempDir(), t.TempDir(), 4321, []string{"update-check"}, true, nil)
 	j, _ = jobByLabel(jobs, "local.hebb.v.update-check")
 	if got := strings.Join(j.Program, " "); !strings.Contains(got, "update") || strings.Contains(got, "--check") {
 		t.Errorf("auto update-check should run 'update' without --check, got %q", got)

install/run.go

@@ -140,7 +140,7 @@ func renderLaunchd(rep *Report, opts Options, assetDir string) error {
 		return err
 	}
 	slug := Slugify(vc.Name)
-	jobs := VaultJobs(opts.VaultPath, slug, opts.HebbBin, assetDir, opts.Home, vc.WebPort, vc.Jobs, vc.Update.Auto)
+	jobs := VaultJobs(opts.VaultPath, slug, opts.HebbBin, assetDir, opts.Home, vc.WebPort, vc.Jobs, vc.Update.Auto, vc.JobArgs)
 	changed, err := launchd.WriteJobs(jobs, opts.LaunchdDir)
 	if err != nil {
 		return err

scripts/acceptance.sh

@@ -216,6 +216,24 @@ EOF
   json="$(cat "$VAULT/2-Areas/_ACTION-REVIEW.json" 2>/dev/null)"
   has "$json" '"overdue": true'; report $? "action review flags the overdue action"
   has "$json" '"mine": true'; report $? "action review flags the owner's action"
+
+  # Personal worklist: --mine-output (off by default) writes a second note with
+  # only the owner's actions, bucketed Overdue/Current/Waiting with a counts line.
+  [ ! -f "$VAULT/2-Areas/_MY-OPEN-ACTIONS.md" ]; report $? "mine output off by default"
+  cat >> "$VAULT/2-Areas/Team/OPEN-ACTIONS.md" <<EOF
+| Waiting | Chase vendor | [[Alex Doe]] | 2999-01-01 | 2019-12-01 | [[Standup]] |
+| Open | Draft plan | [[Alex Doe]] | 2999-02-01 | 2019-12-01 | [[Standup]] |
+| Open | Not my task | [[Sam Roe]] | 2999-03-01 | 2019-12-01 | [[Standup]] |
+EOF
+  python3 "$DATA/automation/generate-action-review.py" --vault-root "$VAULT" --owner "Alex Doe" \
+    --mine-output "2-Areas/_MY-OPEN-ACTIONS.md" > "$WORK/mine.out" 2>&1
+  report $? "generate-action-review.py runs with --mine-output"
+  mine="$(cat "$VAULT/2-Areas/_MY-OPEN-ACTIONS.md" 2>/dev/null)"
+  has "$mine" "3 open (1 overdue, 1 current, 1 waiting)"; report $? "mine output counts line"
+  has "$mine" "Ship $CANARY"; report $? "mine output lists the overdue action"
+  has "$mine" "Chase vendor"; report $? "mine output lists the waiting action"
+  has "$mine" "Draft plan"; report $? "mine output lists the current action"
+  if has "$mine" "Not my task"; then report 1 "other owners excluded from mine output"; else report 0 "other owners excluded from mine output"; fi
 else
   echo "  skip  python3 unavailable"
 fi