@caddis/cli 0.4.96 → 0.4.97
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +2 -0
- package/bundles/antigravity-plugin/plugin.json +1 -1
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_exit.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_file_lock.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_frontmatter.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_redact.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_roadmap.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_rows.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_status.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_tidy.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_todo.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_workstreams.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/__pycache__/caddis_worktree_safety.cpython-311.pyc +0 -0
- package/bundles/antigravity-plugin/scripts/caddis_fleet.py +31 -21
- package/bundles/antigravity-plugin/scripts/caddis_guide.json +2 -2
- package/bundles/antigravity-plugin/scripts/caddis_hub_collect.py +51 -10
- package/bundles/antigravity-plugin/scripts/caddis_lanes.py +154 -130
- package/bundles/antigravity-plugin/scripts/caddis_todo.py +180 -3
- package/bundles/antigravity-plugin/scripts/schemas/hub-collect.schema.json +57 -0
- package/bundles/antigravity-plugin/scripts/schemas/hub-plans.schema.json +57 -0
- package/bundles/antigravity-plugin/scripts/templates/coordinator.md +3 -3
- package/bundles/antigravity-plugin/skills/coordinate/SKILL.md +4 -1
- package/bundles/antigravity-plugin/skills/handoff/SKILL.md +21 -8
- package/bundles/manifest.json +2 -2
- package/dist/cli.js +214 -71
- package/dist/export/assets/{export-CMtV-slT.css → export-B5Lzo-9e.css} +1 -1
- package/dist/export/assets/{export-DtlDFN4L.js → export-PF4z_ff4.js} +29 -29
- package/dist/export/index.html +2 -2
- package/dist/ui/assets/{Activity-BDjet2xd.js → Activity-DN1XBfsH.js} +1 -1
- package/dist/ui/assets/{Guide-Czn5sK0f.js → Guide-D-lZVEKf.js} +1 -1
- package/dist/ui/assets/{RoadmapTab-Bd8geyQx.js → RoadmapTab-tqQd2sYq.js} +7 -7
- package/dist/ui/assets/{index-CmngQ8Mk.js → index-CWslZIzV.js} +44 -44
- package/dist/ui/assets/{index-Bd0Z4jR8.css → index-CwgRPpjT.css} +1 -1
- package/dist/ui/index.html +2 -2
- package/package.json +1 -1
|
@@ -9,6 +9,7 @@ release as a no-op, because an older /handoff still calls it from its Step 6.
|
|
|
9
9
|
from __future__ import annotations
|
|
10
10
|
|
|
11
11
|
import argparse
|
|
12
|
+
import copy
|
|
12
13
|
import json
|
|
13
14
|
import os
|
|
14
15
|
import re
|
|
@@ -250,6 +251,68 @@ def _plan_entry_text(rel: str, text: str) -> dict:
|
|
|
250
251
|
"tracker": tracker, "open_rows": sum(1 for row in tracker if not _is_done(row["status"]))}
|
|
251
252
|
|
|
252
253
|
|
|
254
|
+
PLAN_STATUS_RANK: dict[str, int] = {"draft": 0, "proposed": 0, "ready": 0, "current": 1, "done": 2, "superseded": 2}
|
|
255
|
+
|
|
256
|
+
|
|
257
|
+
def _status_rank(status: object) -> int:
|
|
258
|
+
return PLAN_STATUS_RANK.get(status, 0) if isinstance(status, str) else 0
|
|
259
|
+
|
|
260
|
+
|
|
261
|
+
def pick_pr(cands: list[dict]) -> tuple[dict, list[int]]:
|
|
262
|
+
"""D6: the PR with the newest `updated_at` (ISO text compare; tie: higher number) and the others' numbers."""
|
|
263
|
+
best = max(cands, key=lambda pr: (pr["updated_at"], pr["number"]))
|
|
264
|
+
return best, sorted(pr["number"] for pr in cands if pr is not best)
|
|
265
|
+
|
|
266
|
+
|
|
267
|
+
def _first_by_key(rows: list[dict]) -> dict[str, dict]:
|
|
268
|
+
"""D4.6: the first row with each non-empty key."""
|
|
269
|
+
out: dict[str, dict] = {}
|
|
270
|
+
for row in rows:
|
|
271
|
+
if row["key"] and row["key"] not in out:
|
|
272
|
+
out[row["key"]] = row
|
|
273
|
+
return out
|
|
274
|
+
|
|
275
|
+
|
|
276
|
+
def overlay_plan(main: dict | None, base: dict | None, head: dict, pr: dict, also: list[int]) -> dict:
|
|
277
|
+
"""One plan with an open PR branch laid over main: rows by D4, plan status by D5. Inputs are never changed."""
|
|
278
|
+
overlay = {"pr": pr["number"], "draft": bool(pr.get("draft")), "head_ref": pr["head_ref"], "also": list(also)}
|
|
279
|
+
if main is None: # D5: a plan only on the branch takes every field from the head entry
|
|
280
|
+
out = copy.deepcopy(head)
|
|
281
|
+
out["tracker"] = [{**row, "source": "branch"} for row in out["tracker"]]
|
|
282
|
+
out["changed_at"] = None
|
|
283
|
+
else:
|
|
284
|
+
out = copy.deepcopy(main)
|
|
285
|
+
heads = _first_by_key(head["tracker"])
|
|
286
|
+
bases = _first_by_key(base["tracker"]) if base is not None else {}
|
|
287
|
+
|
|
288
|
+
def untouched(h: dict) -> bool: # D4.2 / D4.4: the branch left the row as it was at the merge base
|
|
289
|
+
b = bases.get(h["key"])
|
|
290
|
+
return b is not None and h["status"] == b["status"]
|
|
291
|
+
|
|
292
|
+
tracker: list[dict] = []
|
|
293
|
+
matched: set[str] = set()
|
|
294
|
+
for m in out["tracker"]:
|
|
295
|
+
h = heads.get(m["key"]) if m["key"] and m["key"] not in matched else None
|
|
296
|
+
if m["key"]:
|
|
297
|
+
matched.add(m["key"])
|
|
298
|
+
if h is None or untouched(h): # D4.1, D4.2 (and D4.5: an empty key is kept)
|
|
299
|
+
tracker.append({**m, "source": "main"})
|
|
300
|
+
elif m["state"] in ("done", "moved") and h["state"] not in ("done", "moved"): # D4.3: done never goes back
|
|
301
|
+
tracker.append({**m, "source": "main"})
|
|
302
|
+
else:
|
|
303
|
+
tracker.append({**copy.deepcopy(h), "source": "branch"})
|
|
304
|
+
for key, h in heads.items(): # D4.4: dict order is head order
|
|
305
|
+
if key not in matched and not untouched(h):
|
|
306
|
+
tracker.append({**copy.deepcopy(h), "source": "branch"})
|
|
307
|
+
out["tracker"] = tracker
|
|
308
|
+
base_status = base.get("status") if base is not None else None
|
|
309
|
+
if (base is None or head.get("status") != base_status) and _status_rank(main.get("status")) != 2:
|
|
310
|
+
out["status"] = head.get("status")
|
|
311
|
+
out["open_rows"] = sum(1 for row in out["tracker"] if not _is_done(row["status"]))
|
|
312
|
+
out["overlay"] = overlay
|
|
313
|
+
return out
|
|
314
|
+
|
|
315
|
+
|
|
253
316
|
class _Batch:
|
|
254
317
|
"""One `git cat-file --batch` process, asked object by object (local git only, no network)."""
|
|
255
318
|
|
|
@@ -381,12 +444,119 @@ def _entry_or_error(rel: str, read) -> dict:
|
|
|
381
444
|
return {"path": rel, "error": (str(exc).splitlines() or [type(exc).__name__])[0]}
|
|
382
445
|
|
|
383
446
|
|
|
384
|
-
|
|
447
|
+
MAX_PRS = 20 # D3: per repo, only the newest open PRs are looked at (bounds the merge-base cost)
|
|
448
|
+
_HEAD_REF = re.compile(r"^(?!-|/)(?!.*\.\.)[^\x00-\x20\x7f:~^?*\[\\]+$") # D3: a ref name git and `cat-file --batch` accept
|
|
449
|
+
_PLANS_DIR = ".caddis/plans"
|
|
450
|
+
|
|
451
|
+
|
|
452
|
+
def branch_plan_changes(batch: _Batch, root: Path, default_branch: str, head_ref: str
|
|
453
|
+
) -> dict[str, tuple[str, str | None]] | None:
|
|
454
|
+
"""The plan files a PR branch changed: `{".caddis/plans/<name>.md": (head_text, merge_base_text_or_None)}`.
|
|
455
|
+
|
|
456
|
+
Local git only. None when `refs/remotes/origin/<head_ref>` is missing or `git merge-base` fails; {} when the
|
|
457
|
+
plans folder is the same tree on head and default (no `merge-base` runs) or no plan file differs.
|
|
458
|
+
"""
|
|
459
|
+
head_ref_name = f"refs/remotes/origin/{head_ref}"
|
|
460
|
+
default_ref_name = f"refs/remotes/origin/{default_branch}"
|
|
461
|
+
if batch.get(head_ref_name) is None:
|
|
462
|
+
return None
|
|
463
|
+
head_tree = batch.get(f"{head_ref_name}:{_PLANS_DIR}")
|
|
464
|
+
default_tree = batch.get(f"{default_ref_name}:{_PLANS_DIR}")
|
|
465
|
+
if head_tree is None or head_tree[1] != "tree":
|
|
466
|
+
return {} # the branch has no plan folder: it deletes or never had plans, nothing to overlay
|
|
467
|
+
if default_tree is not None and default_tree[0] == head_tree[0]:
|
|
468
|
+
return {}
|
|
469
|
+
try:
|
|
470
|
+
found = subprocess.run(["git", "-C", str(root), "merge-base", default_ref_name, head_ref_name],
|
|
471
|
+
capture_output=True, timeout=30, creationflags=_NO_WINDOW)
|
|
472
|
+
except (OSError, subprocess.SubprocessError):
|
|
473
|
+
return None
|
|
474
|
+
base = found.stdout.decode("ascii", errors="replace").strip()
|
|
475
|
+
if found.returncode != 0 or not base:
|
|
476
|
+
return None
|
|
477
|
+
base_tree = batch.get(f"{base}:{_PLANS_DIR}")
|
|
478
|
+
base_blobs = dict(_tree_blobs(base_tree[2], len(base_tree[0]) // 2)) if base_tree and base_tree[1] == "tree" else {}
|
|
479
|
+
changes: dict[str, tuple[str, str | None]] = {}
|
|
480
|
+
for name, oid in sorted(_tree_blobs(head_tree[2], len(head_tree[0]) // 2)):
|
|
481
|
+
if not name.endswith(".md") or base_blobs.get(name) == oid:
|
|
482
|
+
continue
|
|
483
|
+
head_blob = batch.get(oid)
|
|
484
|
+
if head_blob is None:
|
|
485
|
+
continue
|
|
486
|
+
base_blob = batch.get(base_blobs[name]) if name in base_blobs else None
|
|
487
|
+
changes[f"{_PLANS_DIR}/{name}"] = (
|
|
488
|
+
head_blob[2].decode("utf-8", errors="replace").replace("\r\n", "\n"),
|
|
489
|
+
base_blob[2].decode("utf-8", errors="replace").replace("\r\n", "\n") if base_blob else None)
|
|
490
|
+
return changes
|
|
491
|
+
|
|
492
|
+
|
|
493
|
+
def _usable_prs(prs: list[dict], branch: str) -> list[dict]:
|
|
494
|
+
"""D3: same-repo PRs with a safe head ref that is not the default branch; the newest MAX_PRS of them."""
|
|
495
|
+
usable = []
|
|
496
|
+
for pr in prs:
|
|
497
|
+
if not isinstance(pr, dict) or pr.get("fork") or isinstance(pr.get("number"), bool) \
|
|
498
|
+
or not isinstance(pr.get("number"), int):
|
|
499
|
+
continue
|
|
500
|
+
ref = pr.get("head_ref")
|
|
501
|
+
if not isinstance(ref, str) or not ref or ref == branch or not _HEAD_REF.fullmatch(ref):
|
|
502
|
+
continue
|
|
503
|
+
usable.append({**pr, "updated_at": pr["updated_at"] if isinstance(pr.get("updated_at"), str) else ""})
|
|
504
|
+
usable.sort(key=lambda pr: (pr["updated_at"], pr["number"]), reverse=True)
|
|
505
|
+
return usable[:MAX_PRS]
|
|
506
|
+
|
|
507
|
+
|
|
508
|
+
def _overlay_prs(root: Path, branch: str, plans: list[dict], prs: list[dict]) -> int:
|
|
509
|
+
"""Lay open PR branches over `plans` (changed in place). Returns how many plans got an overlay."""
|
|
510
|
+
usable = _usable_prs(prs, branch)
|
|
511
|
+
if not usable:
|
|
512
|
+
return 0
|
|
513
|
+
try:
|
|
514
|
+
batch = _Batch(root)
|
|
515
|
+
except OSError:
|
|
516
|
+
return 0
|
|
517
|
+
cands: dict[str, list[tuple[dict, dict, dict | None]]] = {} # plan path -> [(pr, head entry, base entry)]
|
|
518
|
+
try:
|
|
519
|
+
for pr in usable:
|
|
520
|
+
try:
|
|
521
|
+
changes = branch_plan_changes(batch, root, branch, pr["head_ref"])
|
|
522
|
+
except (OSError, ValueError):
|
|
523
|
+
changes = None
|
|
524
|
+
for path, (head_text, base_text) in (changes or {}).items():
|
|
525
|
+
try:
|
|
526
|
+
head = _plan_entry_text(path, head_text)
|
|
527
|
+
base = _plan_entry_text(path, base_text) if base_text is not None else None
|
|
528
|
+
except Exception: # a branch plan that does not parse is skipped; main shows
|
|
529
|
+
continue
|
|
530
|
+
cands.setdefault(path, []).append((pr, head, base))
|
|
531
|
+
finally:
|
|
532
|
+
batch.close()
|
|
533
|
+
by_path = {plan["path"]: i for i, plan in enumerate(plans)}
|
|
534
|
+
count = 0
|
|
535
|
+
for path, found in cands.items():
|
|
536
|
+
pr, also = pick_pr([item[0] for item in found])
|
|
537
|
+
_, head, base = next(item for item in found if item[0] is pr)
|
|
538
|
+
at = by_path.get(path)
|
|
539
|
+
if at is None:
|
|
540
|
+
if base is not None:
|
|
541
|
+
continue # main deleted a plan the branch still edits: a deleted plan is not shown from the branch
|
|
542
|
+
plans.append(overlay_plan(None, None, head, pr, also))
|
|
543
|
+
elif "error" in plans[at]:
|
|
544
|
+
continue
|
|
545
|
+
else:
|
|
546
|
+
plans[at] = overlay_plan(plans[at], base, head, pr, also)
|
|
547
|
+
count += 1
|
|
548
|
+
return count
|
|
549
|
+
|
|
550
|
+
|
|
551
|
+
def plans_json(root: Path, branch: str | None = None, prs: list[dict] | None = None) -> dict:
|
|
385
552
|
"""Every current plan as data: `{"schema": 1, "source": ..., "plans": [...]}`. Never prints, never exits.
|
|
386
553
|
|
|
387
554
|
With `branch`, read the plans from the local `origin/<branch>` ref (the hub: a pushed Tracker edit shows with
|
|
388
555
|
no pull); when git cannot read that ref, read the working tree. `source` names which one was read. A file that
|
|
389
556
|
does not parse gives `{"path", "error"}`; the other plans still come back.
|
|
557
|
+
|
|
558
|
+
With `prs` (the open PRs, D2 items) and an origin source, plans a PR branch changed get that branch's Tracker
|
|
559
|
+
laid over main's (`overlay_plan`) and the result carries `overlay`. Without `prs` the output has no overlay key.
|
|
390
560
|
"""
|
|
391
561
|
root = Path(root)
|
|
392
562
|
origin = _origin_plan_texts(root, branch) if branch else None
|
|
@@ -397,14 +567,21 @@ def plans_json(root: Path, branch: str | None = None) -> dict:
|
|
|
397
567
|
for plan in plans:
|
|
398
568
|
if "error" not in plan:
|
|
399
569
|
plan["changed_at"] = times.get(plan["path"])
|
|
400
|
-
|
|
570
|
+
data = {"schema": 1, "source": f"origin/{branch}", "commit": commit[:12], "commit_at": commit_at, "plans": plans}
|
|
571
|
+
if prs is not None:
|
|
572
|
+
count = _overlay_prs(root, branch, plans, prs)
|
|
573
|
+
data["overlay"] = {"state": "on", "reason": None, "count": count}
|
|
574
|
+
return data
|
|
401
575
|
plans = []
|
|
402
576
|
for path in _plan_files(root):
|
|
403
577
|
plan = _entry_or_error(path.relative_to(root).as_posix(), lambda path=path: _plan_entry(root, path))
|
|
404
578
|
if "error" not in plan:
|
|
405
579
|
plan["changed_at"] = _file_time(path)
|
|
406
580
|
plans.append(plan)
|
|
407
|
-
|
|
581
|
+
data = {"schema": 1, "source": "working-tree", "plans": plans}
|
|
582
|
+
if prs is not None:
|
|
583
|
+
data["overlay"] = {"state": "off", "reason": "no git", "count": 0}
|
|
584
|
+
return data
|
|
408
585
|
|
|
409
586
|
|
|
410
587
|
def main(argv: list[str] | None = None) -> int:
|
|
@@ -364,6 +364,31 @@
|
|
|
364
364
|
}
|
|
365
365
|
]
|
|
366
366
|
},
|
|
367
|
+
"overlay": {
|
|
368
|
+
"type": "object",
|
|
369
|
+
"required": [
|
|
370
|
+
"state",
|
|
371
|
+
"reason",
|
|
372
|
+
"count"
|
|
373
|
+
],
|
|
374
|
+
"properties": {
|
|
375
|
+
"state": {
|
|
376
|
+
"enum": [
|
|
377
|
+
"on",
|
|
378
|
+
"off"
|
|
379
|
+
]
|
|
380
|
+
},
|
|
381
|
+
"reason": {
|
|
382
|
+
"type": [
|
|
383
|
+
"string",
|
|
384
|
+
"null"
|
|
385
|
+
]
|
|
386
|
+
},
|
|
387
|
+
"count": {
|
|
388
|
+
"type": "integer"
|
|
389
|
+
}
|
|
390
|
+
}
|
|
391
|
+
},
|
|
367
392
|
"plans": {
|
|
368
393
|
"type": "array",
|
|
369
394
|
"items": {
|
|
@@ -425,6 +450,12 @@
|
|
|
425
450
|
"done",
|
|
426
451
|
"moved"
|
|
427
452
|
]
|
|
453
|
+
},
|
|
454
|
+
"source": {
|
|
455
|
+
"enum": [
|
|
456
|
+
"main",
|
|
457
|
+
"branch"
|
|
458
|
+
]
|
|
428
459
|
}
|
|
429
460
|
}
|
|
430
461
|
}
|
|
@@ -435,6 +466,32 @@
|
|
|
435
466
|
"changed_at": {
|
|
436
467
|
"type": ["integer", "null"],
|
|
437
468
|
"description": "Unix time of the last change: the commit time on origin, or the file time in the working tree. null when unknown."
|
|
469
|
+
},
|
|
470
|
+
"overlay": {
|
|
471
|
+
"type": "object",
|
|
472
|
+
"required": [
|
|
473
|
+
"pr",
|
|
474
|
+
"draft",
|
|
475
|
+
"head_ref",
|
|
476
|
+
"also"
|
|
477
|
+
],
|
|
478
|
+
"properties": {
|
|
479
|
+
"pr": {
|
|
480
|
+
"type": "integer"
|
|
481
|
+
},
|
|
482
|
+
"draft": {
|
|
483
|
+
"type": "boolean"
|
|
484
|
+
},
|
|
485
|
+
"head_ref": {
|
|
486
|
+
"type": "string"
|
|
487
|
+
},
|
|
488
|
+
"also": {
|
|
489
|
+
"type": "array",
|
|
490
|
+
"items": {
|
|
491
|
+
"type": "integer"
|
|
492
|
+
}
|
|
493
|
+
}
|
|
494
|
+
}
|
|
438
495
|
}
|
|
439
496
|
}
|
|
440
497
|
},
|
|
@@ -37,6 +37,31 @@
|
|
|
37
37
|
}
|
|
38
38
|
]
|
|
39
39
|
},
|
|
40
|
+
"overlay": {
|
|
41
|
+
"type": "object",
|
|
42
|
+
"required": [
|
|
43
|
+
"state",
|
|
44
|
+
"reason",
|
|
45
|
+
"count"
|
|
46
|
+
],
|
|
47
|
+
"properties": {
|
|
48
|
+
"state": {
|
|
49
|
+
"enum": [
|
|
50
|
+
"on",
|
|
51
|
+
"off"
|
|
52
|
+
]
|
|
53
|
+
},
|
|
54
|
+
"reason": {
|
|
55
|
+
"type": [
|
|
56
|
+
"string",
|
|
57
|
+
"null"
|
|
58
|
+
]
|
|
59
|
+
},
|
|
60
|
+
"count": {
|
|
61
|
+
"type": "integer"
|
|
62
|
+
}
|
|
63
|
+
}
|
|
64
|
+
},
|
|
40
65
|
"plans": {
|
|
41
66
|
"type": "array",
|
|
42
67
|
"items": {
|
|
@@ -98,6 +123,12 @@
|
|
|
98
123
|
"done",
|
|
99
124
|
"moved"
|
|
100
125
|
]
|
|
126
|
+
},
|
|
127
|
+
"source": {
|
|
128
|
+
"enum": [
|
|
129
|
+
"main",
|
|
130
|
+
"branch"
|
|
131
|
+
]
|
|
101
132
|
}
|
|
102
133
|
}
|
|
103
134
|
}
|
|
@@ -108,6 +139,32 @@
|
|
|
108
139
|
"changed_at": {
|
|
109
140
|
"type": ["integer", "null"],
|
|
110
141
|
"description": "Unix time of the last change: the commit time on origin, or the file time in the working tree. null when unknown."
|
|
142
|
+
},
|
|
143
|
+
"overlay": {
|
|
144
|
+
"type": "object",
|
|
145
|
+
"required": [
|
|
146
|
+
"pr",
|
|
147
|
+
"draft",
|
|
148
|
+
"head_ref",
|
|
149
|
+
"also"
|
|
150
|
+
],
|
|
151
|
+
"properties": {
|
|
152
|
+
"pr": {
|
|
153
|
+
"type": "integer"
|
|
154
|
+
},
|
|
155
|
+
"draft": {
|
|
156
|
+
"type": "boolean"
|
|
157
|
+
},
|
|
158
|
+
"head_ref": {
|
|
159
|
+
"type": "string"
|
|
160
|
+
},
|
|
161
|
+
"also": {
|
|
162
|
+
"type": "array",
|
|
163
|
+
"items": {
|
|
164
|
+
"type": "integer"
|
|
165
|
+
}
|
|
166
|
+
}
|
|
167
|
+
}
|
|
111
168
|
}
|
|
112
169
|
}
|
|
113
170
|
},
|
|
@@ -38,7 +38,7 @@ What the keys mean:
|
|
|
38
38
|
| `deploy.never_health_path` | A path that looks healthy even when the API is dead. Never used as a health check. |
|
|
39
39
|
| `deploy.render_check` | How the PR's session checks a served page: 0 console errors and one value checked against its source. |
|
|
40
40
|
| `deploy.wait` | How to wait for the deploy run. No fixed sleep. |
|
|
41
|
-
| `owner_reserved` | Changes that only the owner may approve. |
|
|
41
|
+
| `owner_reserved` | Changes that only the owner may approve. The coordinator reads each class through the critical checklist (coordinator design, section 6): for example `permission change` means an EXISTING permission changes; a new permission is routine. A class that the checklist does not name is a rule reserved by name and always goes to the owner. |
|
|
42
42
|
| `stall.busy_silent_min` | Minutes a busy session may stay silent before the coordinator asks. |
|
|
43
43
|
| `stall.ready_no_ready_msg_min` | Minutes a green PR may wait for its session's ready message. |
|
|
44
44
|
| `quiet.coordination` | Quiet hours for merges (`none`: no quiet hours). |
|
|
@@ -80,8 +80,8 @@ What the keys mean:
|
|
|
80
80
|
"wait": "gh run watch"
|
|
81
81
|
},
|
|
82
82
|
"owner_reserved": [
|
|
83
|
-
"schema change or data write on prod",
|
|
84
|
-
"permission change",
|
|
83
|
+
"schema change or data write on prod (checklist items 1 and 2)",
|
|
84
|
+
"permission change (checklist item 3: an existing permission)",
|
|
85
85
|
"any open blocking review finding",
|
|
86
86
|
"<fill: a rule the owner reserved by name; one string per rule, or delete this line>"
|
|
87
87
|
],
|
|
@@ -352,7 +352,10 @@ Stalls (design 7.4): one nudge for a busy, silent session that holds a queue ite
|
|
|
352
352
|
python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_coordinate.py" ledger record --repo <R> --what '<gate>' --decision approve --by coordinator --window <N> --reason '<why it passes>' --json
|
|
353
353
|
```
|
|
354
354
|
2. The owner-only list (design 6, plus config `owner_reserved`) goes to the owner. Never approve it
|
|
355
|
-
yourself.
|
|
355
|
+
yourself. Decide with the design 6 critical checklist, and read each config `owner_reserved` class
|
|
356
|
+
through it (for example "permission change" is item 3: an EXISTING permission changes; a new one is
|
|
357
|
+
routine). When the diff shows clearly that every item is false, the change is routine: do step 1 with
|
|
358
|
+
the checklist item in `--reason`. When you cannot tell from the diff, ask the owner. Send it with:
|
|
356
359
|
```
|
|
357
360
|
recommendation: approve | hold
|
|
358
361
|
reason: <one or two sentences>
|
|
@@ -132,7 +132,8 @@ lists each wave member's phase, worktree, branch, last commit and next card.
|
|
|
132
132
|
|
|
133
133
|
**What finish prints.** `=== CHECKPOINT CHECKLIST ===` with the same 12 rows as Step 8, in the same order.
|
|
134
134
|
Rows 5, 6, 8, 9, 10 and 12 print `skipped: checkpoint tier`. Then it prints the RESUME block (Step 9) as its
|
|
135
|
-
last output. Print that block as it is, with
|
|
135
|
+
last output. Print that block as it is, with both labelled copy blocks and their labels unchanged and nothing
|
|
136
|
+
after it, then ask the owner for `/clear`.
|
|
136
137
|
|
|
137
138
|
**When finish fails** (exit 1):
|
|
138
139
|
- `CHECKPOINT: row 3 relay failed`: the relay is NOT written. A peer changed the relay after prepare: the
|
|
@@ -511,27 +512,39 @@ python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_fleet.py" resume-block --name <name
|
|
|
511
512
|
`<name>` is the workstream name from Step 3. It reads the relay's `## Resume prompt` block verbatim, and
|
|
512
513
|
the session name (`session-state/<session-id>.name` when `whoami` wrote it, else the first 8 characters of
|
|
513
514
|
the id). It prints, and you print its output as it is, with nothing after it:
|
|
514
|
-
|
|
515
|
+
````
|
|
515
516
|
Model for next session: <model>, effort <effort>
|
|
516
517
|
=== RESUME ===
|
|
517
518
|
Session: <session name> (<session id>)
|
|
518
519
|
Workstream: <name>
|
|
519
520
|
Repo: <absolute repo root>
|
|
520
|
-
|
|
521
|
-
|
|
521
|
+
After /clear in this window, paste this:
|
|
522
|
+
```text
|
|
523
|
+
<the resume prompt on one line> <the announce sentence>
|
|
524
|
+
```
|
|
525
|
+
In a new terminal, paste this:
|
|
526
|
+
```bash
|
|
522
527
|
cd "<absolute repo root>"; claude --model <model> --effort <effort> --name <role>-<MMDD>-<HH> '<the resume prompt on one line> <the announce sentence>'
|
|
523
528
|
```
|
|
529
|
+
````
|
|
530
|
+
Print BOTH fenced blocks, each under its label line, with the label text unchanged. Never merge them, reorder
|
|
531
|
+
them, drop one, or add colour. The owner picks by what they do next:
|
|
532
|
+
- **Same window, after `/clear`:** paste only the first block (the prompt). The window already has the folder, the
|
|
533
|
+
model and the name.
|
|
534
|
+
- **New terminal:** paste the second block (the whole line). It changes to the repo, starts claude with the
|
|
535
|
+
model, effort and name, and passes the same prompt.
|
|
524
536
|
`<model>` and `<effort>` come from `caddis_routing.py session` (Rules, "Model for the next session").
|
|
525
537
|
The `cd` makes the relay's repo-relative paths work from any terminal folder (`;`, not `&&`: Windows PowerShell 5.1 has no `&&`).
|
|
526
538
|
- **The announce sentence.** In a normal handoff the one-line start line also ends with a sentence that tells
|
|
527
539
|
the new session to run `caddis_fleet.py whoami` with its new name, then `caddis_fleet.py peers`, and to send
|
|
528
540
|
each named live peer in the same repo (the checkout and its worktrees) one `SendMessage`:
|
|
529
|
-
`<name> started in <folder>: <next action>. No reply needed.`
|
|
530
|
-
session
|
|
541
|
+
`<name> started in <folder>: <next action>. No reply needed.` Both copy blocks end with this sentence, so a
|
|
542
|
+
session started from either one announces itself. The sentence names the stable launcher
|
|
531
543
|
(`~/.caddis/bin/caddis_run.py`), because a new session cannot expand `${CLAUDE_PLUGIN_ROOT}` and a versioned
|
|
532
544
|
plugin path is gone after the next update.
|
|
533
545
|
- **Fleet close.** When this handoff runs because a peer sent `FLEET CLOSE from <coordinator>`, add
|
|
534
|
-
`--fleet`. The
|
|
546
|
+
`--fleet`. The block then holds the relay's prompt in one fenced block and ends with
|
|
547
|
+
`Start line: from the restart sheet`, with no copy blocks: the restart sheet is the only
|
|
535
548
|
start line in a fleet close, and `/caddis:fleet-open` already greets the peers, so it has no announce
|
|
536
549
|
sentence. The `FLEET-ACK` reply is a separate message and does not change.
|
|
537
550
|
- **Exit 1** (no `## Resume prompt` block, or no relay) prints nothing on stdout. The handoff is not
|
|
@@ -553,7 +566,7 @@ The `cd` makes the relay's repo-relative paths work from any terminal folder (`;
|
|
|
553
566
|
`python "${CLAUDE_PLUGIN_ROOT}/scripts/caddis_routing.py" session --role <role>` prints `<model> <effort>`.
|
|
554
567
|
The role is `orchestrator` to run an approved plan and `plan-writer` to write a plan or design.
|
|
555
568
|
`resume-block` (Step 9) reads the same table: it prints `Model for next session: <model>, effort <effort>`
|
|
556
|
-
as its first line and puts `--model <model> --effort <effort>` in the
|
|
569
|
+
as its first line and puts `--model <model> --effort <effort>` in the full line (the second copy block). Pass `--role plan-writer`
|
|
557
570
|
for plan or design work. Do not print a second model line.
|
|
558
571
|
- **One next action, by priority ladder.** `## Next step` names exactly ONE action — not a menu. Pick it in
|
|
559
572
|
order: (1) interrupted mid-phase work → finish + commit it; else (2) the active plan's next not-started
|