[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_2329":2330,"_2331":62,"_2332":18,"_2333":18,"_2334":18,"_2335":62,"_2336":18,"_2337":18,"_2338":18,"_2339":18,"_2340":-5,"_2341":2342},"routes/s.$postId",{"_9":10,"_11":12,"_13":-7,"_14":-7,"_15":16,"_17":18,"_19":18,"_20":-5,"_21":22},"kind","post_with_profile","postWithProfile",{"_23":24,"_25":26},"messagingRoomId","referrer","imagegenOgImagePolicy","current_wide","preferIntrinsicAspectRatioForOgImage",false,"enforceRenderedOgImg","ogImageVariantOverride","defaultOgDescription","ChatGPT helps you get answers, find inspiration, and be more productive.","post",{"_45":46,"_47":48,"_49":-5,"_50":-5,"_51":-5,"_52":-5,"_53":54,"_55":56,"_38":57,"_58":59,"_60":18},"profile",{"_27":28,"_29":28,"_30":31,"_32":-5,"_33":-5,"_34":35,"_36":18,"_37":-5,"_38":-5,"_39":-5,"_40":18,"_41":-5,"_42":-5,"_43":-5,"_44":18},"user_id","anonymous","username","profile_picture_url","https://cdn.openai.com/sora/images/profile_placeholder_v4.png","profile_picture_id","is_default_profile_picture","follower_count",0,"is_following","display_name","permalink","can_cameo","verified","character_count","owner_profile","social_context","follows_you","id","cd_6a7cfdae6c80819198ae74559c3ee48f","posted_at",1786576302.423976,"text","og_title","og_description","og_image_variant","attachments",[68],"preview_image_url","https://ogimg.chatgpt.com/?postId=cd_6a7cfdae6c80819198ae74559c3ee48f","https://chatgpt.com/s/cd_6a7cfdae6c80819198ae74559c3ee48f","permissions",{"_61":62,"_63":18,"_64":18,"_65":62,"_66":67},"use_experimental_unfurl","can_read",true,"can_write","can_delete","can_remix","share_setting","public",{"_45":69,"_70":71,"_9":72,"_73":74,"_75":76,"_77":78,"_79":-5,"_80":81,"_82":-5},"cd_6a7cfdae6c80819198ae74559c3ee48f-attachment-0","tags",[],"codex","task",{"_45":2285,"_121":2286,"_265":2287,"_2288":62,"_85":86,"_2289":18,"_2290":2291,"_227":62,"_2292":2293,"_2294":-5,"_2295":2296},"current_user_turn",{"_95":278,"_45":87,"_99":278,"_2174":2275,"_2176":2276,"_2178":2179,"_134":-5,"_121":2180},"current_assistant_turn",{"_95":96,"_45":86,"_97":-5,"_98":-5,"_99":96,"_100":2222,"_102":2223,"_104":105,"_106":-5,"_107":-5,"_108":2224,"_110":2225,"_112":2226,"_114":115,"_116":-5,"_117":118,"_119":2227,"_121":122,"_123":-5,"_124":125,"_126":2228,"_128":129,"_130":131,"_132":-5,"_133":-5,"_134":87,"_135":2229,"_137":-5,"_138":-5,"_139":18,"_140":141,"_142":-5},"current_diff_task_turn","turns",{"_83":84,"_85":86},"example_task_info","turn_mapping",{"_87":88,"_86":89},"current_turn_id","task_e_6a7cfdac9c74832586b47ff8adc4cdaf~assttrn_e_6a7cfdadcc948325baaa0498cf8a033f","task_e_6a7cfdac9c74832586b47ff8adc4cdaf~usertrn_e_6a7cfdad95d483259b504eca718734a0",{"_45":87,"_90":2172,"_92":2173,"_94":-5},{"_45":86,"_90":91,"_92":93,"_94":87},"turn",{"_95":96,"_45":86,"_97":-5,"_98":-5,"_99":96,"_100":101,"_102":103,"_104":105,"_106":-5,"_107":-5,"_108":109,"_110":111,"_112":113,"_114":115,"_116":-5,"_117":118,"_119":120,"_121":122,"_123":-5,"_124":125,"_126":127,"_128":129,"_130":131,"_132":-5,"_133":-5,"_134":87,"_135":136,"_137":-5,"_138":-5,"_139":18,"_140":141,"_142":-5},"children",[],"parent","type","assistant","sibling_turn_ids","attempt_placement","role","output_items",[293,294],"child_turns",[],"conversation_id","None","error","latest_event","worklog",{"_291":292},"app_server_events",{"_288":290},"thread_events",{"_288":289},"turn_status","completed","cancellation_requested_at","pull_request_status","externally_created","pull_request_data",{"_257":258,"_248":259,"_260":261,"_262":62,"_263":18,"_264":18,"_265":266,"_267":268,"_269":219,"_270":129,"_271":272,"_273":131,"_274":275,"_276":-5,"_277":-5,"_278":279,"_280":281,"_282":190,"_283":284,"_285":286},"created_at",1786576301.799249,"internal_only_rollouts","environment_id","6a73d2e276408191bd8f6dc3c872725f","environment",{"_45":125,"_163":164,"_165":166,"_167":18,"_168":169,"_170":171,"_172":173,"_174":-5,"_175":176,"_177":18,"_178":179,"_180":169,"_181":169,"_182":183,"_184":185,"_186":187,"_188":-5,"_189":190,"_191":192,"_193":194,"_195":196,"_58":-5,"_121":197,"_198":199,"_200":201,"_202":203,"_204":18,"_205":18},"branch","fix/st-k6z-refresh-lock","base_commit_sha","da1af901d7a17410d349854c335714d89462ab26","branch_name","direct_push_pushed_commit_sha","previous_turn_id","logs",{"_135":143},"proxy_events","debug_metadata","discarded","model_version","gpt-5.6-sol","languages",[144,145,146],{"_147":159,"_149":160},{"_147":155,"_149":156},{"_147":148,"_149":150},"key",{"_151":152,"_95":153,"_121":154},"value","file_00000000d75c822f811b3392b391004b","name","setup_autodetect","UserSetupScript","2026-08-12T23:05:15.371940",{"_151":157,"_95":153,"_121":158},"file_00000000d164822f8870a8f1643cede0","warm_up_git_repo_1786576303","2026-08-12T23:11:43.625567",{"_151":161,"_95":153,"_121":162},"file_000000006540822fa110d87c4d91e746","auto_setup","2026-08-12T23:05:19.387674","machine_id","wham-public/wham-universal","label","strand","is_pinned","description","","workspace_dir","/workspace","agent_network_access",{"_250":251,"_252":-5,"_253":-5,"_254":-5,"_255":-5,"_256":-5},"codex_github_direct","github_connector_id","connector_76869538009648d5b282a4bb21c3d157","enable_gitlab_webhooks","repos",[209],"setup","maintenance_setup","repo_map",{"_209":210},"env_vars",{},"secrets",{},"secrets_with_domains","task_count",4,"creator_id","user-BlU1r6nIXrSYCW8LpMySWegD","share_settings","workspace","share_targets",[],1785975522.840164,"auto_setup_settings",{"_208":62},"cache_settings",{"_206":62,"_207":169},"etag","\"d202669a-0000-0200-0000-6a7cfc110000\"","enable_authtranslator","enable_docker_in_docker","post_setup_cache_enabled","cache_invalidation_key","use_auto_setup","github-1275543734",{"_45":211,"_151":166,"_212":213,"_214":215,"_216":217,"_218":219,"_220":221,"_222":223,"_224":225,"_226":67,"_227":18,"_228":18,"_229":62,"_230":62,"_231":62,"_232":18,"_233":-5,"_234":235,"_236":-5,"_58":237},"1275543734","owner",{"_242":243,"_45":244,"_95":245,"_246":247,"_248":249},"repository_full_name","dkoosis/strand","clone_url","https://github.com/dkoosis/strand.git","default_branch","main","git_commits_url","https://api.github.com/repos/dkoosis/strand/git/commits{/sha}","git_refs_url","https://api.github.com/repos/dkoosis/strand/git/refs{/sha}","git_url","git://github.com/dkoosis/strand.git","visibility","archived","allow_auto_merge","allow_merge_commit","allow_rebase_merge","allow_squash_merge","allow_update_branch","language","size",9823,"master_branch",{"_238":62,"_239":62,"_240":62,"_241":62},"admin","maintain","push","pull","login","dkoosis",1538542,"User","avatar_url","https://avatars.githubusercontent.com/u/1538542?v=4","url","https://api.github.com/users/dkoosis","mode","off","preset_allowlist","allowlist_domains","allowlist_rules","denylist_domains","safe_methods_only","number",109,"https://github.com/dkoosis/strand/pull/109","state","closed","merged","mergeable","draft","title","fix(st-k6z): serialize the counts refresh read-modify-write across processes","body","Closes the lost-update race CodeRabbit raised on #108 and deferred as out of scope.\n\n## The bug\n`atomicfile.WriteFile` (#108) stopped torn writes, not lost updates. Three writers race the same two files:\n- launchd's `strand counts --all`\n- a manual `strand counts [dir...]`\n- the server's per-write `strand counts ` spawn (`defaultRefreshCounts`, fired on every bead write)\n\nEach reads `counts.json` + `counts-mtimes`, computes, then atomically replaces both. Whichever finishes last wins wholesale, silently dropping the others' rows. `writeState`'s merge-on-write narrows its own window but does not close it — the merge read is itself unserialized.\n\n## The fix\nAn advisory `flock` on `/.refresh.lock`, held for the whole `refresh` — opened **before** the first read, since the reads are the R of the read-modify-write. `refresh` now does `MkdirAll` + lock; the old body is `refreshLocked`.\n\nTaken non-blocking on a 50ms poll rather than a blocking `LOCK_EX`, so both ctx cancellation and a 2-minute wait cap stay honored: a wedged holder makes the run fail loudly instead of accumulating blocked refreshers behind launchd's every-minute fire. flock is kernel-side and per-fd, so a crashed holder releases automatically (no stale-marker problem) and it serializes goroutines in one process as well as separate processes.\n\nThe two `NOTE (RMW race…)` comments #108 left behind are retired — replaced by a pointer to where the serialization now lives.\n\n## Tests\n- `TestRefreshSerializesConcurrentRuns` — two refreshes over disjoint repos, overlapping in time via a gated source; both repos must land in `counts.json` and `counts-mtimes`. **Mutation-checked**: reverting `refresh` to call `refreshLocked` directly fails it (`no counts.json row for repo-b`).\n- `TestRefreshLockTimesOutOnWedgedHolder` — a held lock makes a second `withLock` return an error without running `fn` (cancelled ctx stands in for the 2-minute deadline).\n\n## Gate\n`make check` green: `go vet`, `golangci-lint` 0 issues, `go test -race -count=1 ./...` all packages. `pack-drift` skipped — upstream unreachable, pre-existing.\n\nbead: st-k6z\n\n@codex review\n\n\n\n## Summary by CodeRabbit\n\n* **Bug Fixes**\n * Improved reliability when multiple count refreshes run concurrently.\n * Prevented overlapping refreshes from overwriting cached count data.\n * Added timeout and cancellation handling when a refresh lock cannot be acquired.\n\n* **Tests**\n * Added coverage for concurrent refreshes and stalled lock holders.\n\n","base","head","base_sha","0ad4c4b6b1b728c924ef824cb581a8ca3d8878a5","head_sha","merge_commit_sha","5343751c3db39c5740fa91ae1457d0ee7632e32c","comments","diff","user",{"_242":243,"_151":243,"_287":-5,"_246":247,"_45":244},"commits",2,"changed_files","additions",271,"deletions",19,"email","events",[],[],"messages",[],{"_95":2151,"_99":96,"_312":2152},{"_95":295,"_296":297},"partial_repo_snapshot","files",[298,299,300],{"_301":1916,"_303":-5,"_304":1917,"_306":-5},{"_301":433,"_303":-5,"_304":434,"_306":-5},{"_301":302,"_303":-5,"_304":305,"_306":-5},"path","internal/counts/lock_test.go","contents","line_range_contents",[307],"missing_reason",{"_308":309,"_310":311,"_312":313,"_314":62},"line_range_start",1,"line_range_end",159,"content",[315,169,316,317,318,319,320,321,322,323,324,169,325,326,327,169,328,329,330,331,332,333,334,335,169,336,337,338,339,340,341,335,169,342,343,344,345,346,347,348,349,350,351,169,352,353,354,355,356,357,358,359,356,360,361,362,356,169,363,364,169,365,366,367,368,356,369,370,371,372,373,169,374,375,376,377,378,379,380,381,382,356,169,383,384,385,386,382,356,387,388,389,356,384,390,391,382,356,335,169,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,340,335,169,411,412,413,414,349,415,169,416,417,418,169,419,420,421,340,422,423,356,335,169,424,425,426,427,349,415,169,428,429,430,420,421,340,431,432,356,335],"contains_end_of_file","package counts","import (","\t\"context\"","\t\"errors\"","\t\"os\"","\t\"path/filepath\"","\t\"strings\"","\t\"sync\"","\t\"testing\"","\t\"time\"","\t\"github.com/dkoosis/strand/internal/bd\"","\t\"github.com/dkoosis/strand/internal/bdcounts\"",")","// gatedSource is a source whose first read parks until released, so a test can hold","// one refresh mid-compute while a second one starts against the same cache dir.","type gatedSource struct {","\tfakeSource","\tentered chan struct{} // closed when the read starts","\trelease chan struct{} // the read returns once this is closed","\tonce sync.Once","}","func (g *gatedSource) List(ctx context.Context, opts bd.ListOpts) ([]bd.Issue, error) {","\tg.once.Do(func() {","\t\tclose(g.entered)","\t\t<-g.release","\t})","\treturn g.fakeSource.List(ctx, opts)","// TestRefreshSerializesConcurrentRuns is the st-k6z regression: two refreshes over","// disjoint repos, overlapping in time, must both land their rows in counts.json and","// their gate entries in counts-mtimes. Atomic writes alone do not give this — before","// the cache-dir lock, the second run read the base while the first was still computing","// and then replaced the file, silently dropping the first run's repo.","func TestRefreshSerializesConcurrentRuns(t *testing.T) {","\tprojects := t.TempDir()","\tcache := t.TempDir()","\ta := mkRepo(t, projects, \"repo-a\")","\tb := mkRepo(t, projects, \"repo-b\")","\tgate := &gatedSource{","\t\tfakeSource: fakeSource{issues: []bd.Issue{{ID: \"x\", Status: bd.StatusOpen}}},","\t\tentered: make(chan struct{}),","\t\trelease: make(chan struct{}),","\t}","\tslow := config{","\t\tcacheDir: cache, projects: projects, mode: modeExplicit, targets: []string{a},","\t\tnewSource: func(string) source { return gate },","\tfast := config{","\t\tcacheDir: cache, projects: projects, mode: modeExplicit, targets: []string{b},","\t\tnewSource: func(string) source { return oneOpenBead() },","\terrs := make(chan error, 2)","\tgo func() { errs <- refresh(context.Background(), &slow) }()","\tselect {","\tcase <-gate.entered:","\tcase <-time.After(5 * time.Second):","\t\tt.Fatal(\"slow refresh never reached its first read\")","\tgo func() { errs <- refresh(context.Background(), &fast) }()","\t// Give the second run time to reach the lock (and, unlocked, to read the base and","\t// race ahead) before the first is allowed to finish.","\ttime.Sleep(100 * time.Millisecond)","\tclose(gate.release)","\tfor range 2 {","\t\tselect {","\t\tcase err := <-errs:","\t\t\tif err != nil {","\t\t\t\tt.Fatalf(\"refresh: %v\", err)","\t\t\t}","\t\tcase <-time.After(10 * time.Second):","\t\t\tt.Fatal(\"refresh did not return — lock not released?\")","\t\t}","\tr := bdcounts.NewReaderAt(filepath.Join(cache, \"counts.json\"))","\tfor _, root := range []string{a, b} {","\t\tif _, ok := r.Lookup(root); !ok {","\t\t\tt.Errorf(\"no counts.json row for %s — a concurrent refresh dropped it\", root)","\tstate, err := os.ReadFile(filepath.Join(cache, \"counts-mtimes\"))","\tif err != nil {","\t\tt.Fatalf(\"read state: %v\", err)","\t\tif !strings.Contains(string(state), root+\"\\t\") {","\t\t\tt.Errorf(\"no counts-mtimes entry for %s — a concurrent refresh dropped it\", root)","// holdLock parks an exclusive holder on dir and returns once it is held; the cleanup","// releases it.","func holdLock(t *testing.T, dir string) {","\tt.Helper()","\theld := make(chan struct{})","\tholding := make(chan struct{})","\tdone := make(chan struct{})","\tgo func() {","\t\tdefer close(done)","\t\t_ = withLock(context.Background(), dir, func() error {","\t\t\tclose(holding)","\t\t\t<-held","\t\t\treturn nil","\t\t})","\t}()","\t<-holding","\tt.Cleanup(func() {","\t\tclose(held)","\t\t<-done","// TestRefreshLockGivesUpOnWedgedHolder: a holder that never releases must not hang a","// refresh forever — past lockWait the run fails with errLockBusy, so launchd's next","// fire does not pile up blocked refreshers behind it.","func TestRefreshLockGivesUpOnWedgedHolder(t *testing.T) {","\tholdLock(t, cache)","\torig := lockWait","\tlockWait = 150 * time.Millisecond // the real 2 minutes, without a 2-minute test","\tt.Cleanup(func() { lockWait = orig })","\terr := withLock(context.Background(), cache, func() error {","\t\tt.Error(\"fn ran while another holder had the lock\")","\t\treturn nil","\tif !errors.Is(err, errLockBusy) {","\t\tt.Fatalf(\"withLock error = %v, want errLockBusy\", err)","// TestRefreshLockHonorsContextCancel: the wait for the lock ends when the caller's","// context does — the server's post-write refresh runs under goBackground's 10s","// timeout and Server.Stop, neither of which may be pinned behind lockWait.","func TestRefreshLockHonorsContextCancel(t *testing.T) {","\tctx, cancel := context.WithCancel(context.Background())","\tcancel()","\terr := withLock(ctx, cache, func() error {","\tif !errors.Is(err, context.Canceled) {","\t\tt.Fatalf(\"withLock error = %v, want context.Canceled\", err)","internal/server/server.go",[435],{"_308":309,"_310":436,"_312":437,"_314":62},2194,[438,439,440,441,169,316,442,317,318,443,444,445,446,319,320,447,448,321,322,324,169,325,326,449,450,451,452,453,454,455,456,327,169,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,327,169,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,335,169,498,499,500,501,502,503,504,480,482,484,335,169,505,506,507,508,509,460,510,511,512,327,169,513,514,515,516,517,169,518,519,520,521,169,522,523,524,525,526,527,528,529,530,531,532,533,534,535,536,537,169,538,539,540,541,542,543,544,169,545,546,547,548,549,550,551,552,553,554,555,556,557,169,558,559,560,561,562,563,564,565,566,567,568,569,570,571,572,573,574,335,169,575,576,577,578,579,580,169,581,582,583,584,169,585,586,587,588,589,590,591,356,335,169,592,593,594,595,596,597,598,599,600,601,602,603,604,605,606,607,335,169,608,609,610,169,611,612,613,614,615,616,617,618,619,356,620,335,169,621,622,623,624,625,626,627,628,629,630,631,632,633,634,382,635,636,340,335,169,637,638,639,640,641,642,643,644,645,646,647,648,649,650,651,652,653,654,382,340,335,169,655,656,657,658,659,660,661,662,663,335,169,664,665,666,667,375,668,669,670,671,672,673,674,675,676,677,678,379,382,356,335,169,679,680,681,682,683,684,685,686,687,688,689,690,691,692,693,382,694,695,356,696,335,169,697,698,699,700,687,688,701,702,693,382,375,703,704,382,356,335,169,705,706,618,707,708,356,709,710,711,712,713,714,715,716,717,718,719,720,721,722,356,723,724,725,687,726,727,728,729,730,667,375,731,669,732,669,733,734,735,382,356,335,169,736,737,738,739,740,741,742,743,618,744,356,745,746,747,748,749,750,335,169,751,752,753,754,755,756,757,758,759,760,761,762,763,764,765,766,767,768,769,770,771,772,773,774,775,776,777,778,779,780,781,782,783,784,785,786,787,788,789,335,169,790,791,792,793,794,335,169,795,796,797,335,169,798,799,800,801,802,803,804,335,169,805,806,807,808,809,810,811,812,813,814,815,816,817,818,819,820,821,822,823,824,825,826,827,828,335,169,829,830,831,832,833,834,835,836,837,838,839,840,841,842,843,844,845,846,847,848,849,850,335,169,851,852,853,854,855,856,857,858,859,860,861,862,863,864,335,169,865,866,867,868,869,870,871,872,873,874,875,876,877,878,879,880,881,882,883,884,885,886,887,888,382,356,889,890,891,892,893,894,895,896,897,898,356,899,900,901,902,903,904,905,906,907,908,909,910,911,912,913,914,915,356,916,335,169,917,918,919,920,921,922,923,924,382,356,925,335,169,926,927,928,929,930,931,932,933,934,935,936,937,938,939,940,618,941,708,356,942,388,943,708,356,944,945,946,947,948,949,950,951,952,953,954,955,956,957,958,652,959,340,960,961,962,963,964,965,966,967,968,969,633,970,971,972,973,974,975,976,382,356,977,978,979,980,981,982,983,984,340,335,169,985,986,987,646,988,989,990,991,992,993,994,995,996,997,998,999,927,928,940,618,708,356,1000,335,169,1001,1002,1003,1004,1005,1006,1007,1008,1009,356,1010,1011,335,169,1012,1013,1014,1015,1016,1017,356,1018,335,169,1019,927,928,940,618,1020,708,356,1021,1022,1023,1024,1025,1026,1027,1028,1029,1030,1031,1032,669,382,1033,708,356,1034,1035,1031,1032,669,382,1033,708,356,942,388,943,708,356,1036,1037,335,169,1038,1039,1040,1041,1042,1043,1044,1045,1046,1047,388,1048,356,1049,1050,1051,1052,1053,1054,1055,1056,1057,1058,693,382,1059,1060,1061,1062,382,356,1063,1064,1065,335,169,1066,1067,1068,1069,1070,1071,1072,1073,1074,1075,1076,1077,1078,1079,335,169,1080,1081,1082,1083,1084,1085,335,169,1086,1087,1088,1089,1090,1091,356,1092,1093,1094,1095,1096,1097,1098,1099,1100,1101,1102,1103,1104,356,1105,335,169,1106,1107,1108,1109,1110,1111,1112,1113,1114,1115,1116,1117,1118,1119,1120,633,1121,382,1122,1123,356,388,1048,356,1124,388,1048,356,1063,1125,335,169,1126,1127,1128,1129,1130,1131,1132,1133,1031,1134,382,912,1135,1136,1137,1138,379,382,1139,356,1050,1051,1140,1062,382,356,1141,335,169,1142,1143,1144,1145,1146,1147,1148,356,1149,1051,1150,356,1151,388,1152,356,1153,335,169,1154,1155,1156,1157,1158,1159,1160,1161,1162,1163,356,1164,1165,356,1166,1167,1168,382,356,1169,1170,1168,382,356,1171,335,169,1172,1173,1174,1175,1176,1177,379,382,356,1178,335,169,1179,1180,1174,1181,1182,1183,1184,382,356,1178,335,169,1185,1186,1187,1188,1189,1190,1191,356,1192,1174,1193,356,1194,1174,1195,1196,356,1197,335,169,1198,1199,1200,1201,1202,1174,1175,1203,1204,1205,1206,678,379,1207,1208,379,1209,1210,1211,1212,1213,382,356,1197,335,169,1214,1215,1216,1217,1218,1219,1220,1221,335,169,1222,1223,1224,1225,1226,1227,1228,1229,1230,1231,1232,1233,1234,1235,1236,1237,382,1238,1239,1240,1241,335,169,1242,1243,1244,169,1245,1246,1247,1248,356,1249,335,169,1250,1251,1252,1253,1254,1255,1256,1257,335,169,1258,1259,1260,1261,1262,1263,335,169,1264,927,928,940,618,1265,708,356,1266,1267,1268,1269,388,943,708,356,1025,1270,1271,1272,943,708,356,1273,335,169,1274,1275,1276,1277,1278,1279,1280,421,356,1281,1282,1283,356,1151,388,1284,356,1285,1282,1286,1287,356,1288,335,169,1289,1290,1291,1292,1293,1294,1295,1296,1297,1298,356,335,169,1299,1300,1301,1302,356,1192,1303,1304,356,1305,1303,1306,356,1307,335,169,1308,1309,1310,1311,1312,356,1313,335,169,1314,1315,1316,1317,1318,1319,1320,1321,1322,356,1323,1324,1325,1326,1327,1328,1329,382,1330,356,1331,335,169,1332,1333,1334,1335,1247,1336,1337,382,356,1338,335,169,1339,1340,1341,1342,1343,1344,927,928,940,618,1345,708,356,1346,1347,388,1348,708,356,1349,1350,1351,1032,669,382,356,1352,1353,1354,1355,1356,1357,1358,1359,1360,1361,1362,1363,1364,1365,633,1366,382,356,1367,335,169,1368,1369,1370,1371,1372,1373,646,1374,1375,1376,1377,1378,1379,927,928,940,618,1345,708,356,1380,1381,1382,708,356,169,942,388,943,708,356,1383,169,1384,1385,1386,1387,1388,1389,1390,1391,1392,1393,1394,379,1395,669,382,356,169,1396,1397,708,356,1011,335,169,1398,1399,1400,1401,1254,1402,335,169,1403,1404,1405,1406,1407,927,928,940,618,1408,708,356,1269,388,943,708,356,1025,1270,1409,388,943,708,356,1410,335,169,1411,1412,1413,1414,1415,1416,1417,1418,1419,1420,169,1421,1422,1423,1424,1425,382,1426,1427,1428,382,356,1429,335,169,1430,1431,1432,646,1433,1434,1435,1436,1437,1438,1439,1440,1441,1442,1443,1444,1445,1446,335,169,1447,927,928,1448,618,1345,708,356,1449,388,943,708,356,1450,335,169,1451,1452,1453,1454,1455,1456,1457,1458,1459,1460,1461,335,169,1462,1463,1464,1465,1466,646,1467,1468,1469,1470,1471,1472,927,928,940,618,1345,708,356,1449,388,943,708,356,1473,1474,708,356,1475,1476,1477,1478,1479,1480,1481,405,1482,708,356,1483,1484,1485,1486,1487,1488,669,382,1489,1490,708,356,1491,1492,1493,1494,1495,340,335,169,1496,1497,1498,1499,1500,1501,388,1502,356,1503,1504,1505,1506,1507,1508,1509,1510,1511,1512,1513,340,388,1514,356,1515,335,169,1516,1517,1518,1519,1520,1521,1522,1523,356,899,1136,1524,1525,379,382,356,1526,1527,356,1018,335,169,1528,1529,1530,1047,388,421,356,1531,1051,1532,1533,382,356,1197,335,169,1534,1535,1536,1537,1538,1539,618,1523,356,1540,1541,356,1018,335,169,1542,1543,1544,1545,1473,1546,1547,1548,1474,708,356,1549,1550,1551,1552,356,1553,1554,356,1555,1556,356,1557,335,169,1558,1559,1560,1561,1562,1563,1564,1565,1566,382,356,1567,335,169,1568,1569,1346,1570,1571,1572,1573,340,335,169,1574,1575,1346,1571,1576,1577,340,335,169,1578,1579,1346,1580,1571,1581,1582,340,335,169,1583,1584,1585,1346,1571,1586,1587,340,335,169,1588,1589,1590,1591,421,356,1592,335,169,1593,1594,1595,1596,1597,1598,1599,927,928,940,618,1345,708,356,1600,1601,1602,1603,1604,1605,1606,356,1607,1608,1609,1610,669,382,1611,356,1612,335,169,1613,1614,1615,1616,1617,1346,1618,1571,1619,340,335,169,1620,1621,1622,1623,1346,1624,1571,1625,340,335,169,1626,1627,1346,1624,1571,1628,340,335,169,1629,1630,1631,1632,1633,1346,1634,1571,1635,340,335,169,1636,1637,1346,1638,1571,1639,340,335,169,1640,1641,1642,1643,1644,1645,1646,1647,382,1648,356,1649,335,169,1650,1651,1652,1653,1654,1655,1656,1657,1658,1659,1660,327,169,1661,1662,1663,1664,1665,1666,335,169,1667,1668,1669,1670,1671,1672,927,928,1673,1674,1675,356,1676,335,169,1677,1678,1679,1680,1681,1047,388,421,356,1682,1051,1683,356,1684,335,169,1685,1686,1687,1688,1689,1690,1691,1692,1693,1694,1695,1696,335,169,1697,1698,1699,1700,927,928,940,618,1345,708,356,1701,1702,1703,1704,1705,1706,1707,356,1708,1709,1710,1675,1711,356,169,1712,388,1713,708,356,169,1714,1715,1716,356,1717,388,1718,1719,1720,708,356,1349,1721,1450,335,169,1722,1723,1724,1725,1726,1727,1728,1729,1730,1731,1732,1733,1734,1735,1736,1737,1738,382,1739,1031,1740,382,1741,1122,1742,356,335,169,1743,1744,1745,1746,1747,1748,1749,1750,388,1751,356,1752,1753,356,1754,335,169,1755,1756,1757,1758,1759,1760,1761,1762,1763,1764,1765,1766,356,1767,928,1768,1769,356,1770,335,169,1771,1772,1773,1774,1775,1776,1777,1778,1779,1780,335,169,1781,1782,169,1783,1784,1785,169,1786,1787,1788,1789,1790,927,928,1791,1674,1792,1793,1794,382,356,1795,335,169,1796,1797,1798,1799,1047,388,421,356,1800,1051,1801,1802,1803,1804,1805,693,382,1806,356,1684,335,169,1807,1808,1809,1810,1811,927,928,1448,618,1345,708,356,1812,1813,1814,1815,356,1709,1710,1792,1816,356,1817,1818,708,356,1819,388,1713,708,356,1820,1821,1822,1720,708,356,1721,1823,388,943,708,356,1450,335,169,1824,1825,1826,1827,1828,1829,1830,1831,1736,1832,1833,382,1834,1031,1740,382,1741,1732,1835,1122,1836,356,335,169,1837,1838,1839,1840,927,928,1448,618,1345,708,356,1346,1841,388,943,708,356,1842,335,169,1843,1844,1845,1846,335,169,1847,1848,1849,927,928,1448,618,1345,708,356,1850,943,708,356,1721,1851,335,169,1852,1853,1854,1855,1856,1857,1858,1047,388,1859,356,1860,335,169,1861,1862,1863,1864,1865,1866,1867,1868,1869,1870,335,169,1871,1872,1873,1874,1875,1876,1877,1878,1879,356,1880,335,169,1881,1882,1883,943,356,335,169,1884,1885,1886,1887,1888,1889,1890,356,1891,1892,1893,1288,335,169,1894,1895,1896,1897,1898,1899,1900,1901,356,335,169,1902,1903,1904,1905,1906,1117,1907,1908,1909,1910,1911,1912,1913,1914,1122,1915,356,335],"// Package server is strand's HTTP layer: it renders the embedded web UI as HTML","// (html/template) and swaps fragments over htmx. It reads beads through a small","// issue source so the bd CLI stays the only data path (spec D8).","package server","\t\"bytes\"","\t\"fmt\"","\t\"html/template\"","\t\"log\"","\t\"net/http\"","\t\"slices\"","\t\"strconv\"","\t\"github.com/dkoosis/strand/internal/counts\"","\t\"github.com/dkoosis/strand/internal/insight\"","\t\"github.com/dkoosis/strand/internal/jtbd\"","\t\"github.com/dkoosis/strand/internal/llm\"","\t\"github.com/dkoosis/strand/internal/registry\"","\t\"github.com/dkoosis/strand/internal/strand\"","\t\"github.com/dkoosis/strand/internal/strandmd\"","\t\"github.com/dkoosis/strand/internal/suggest\"","// errNoRepo means no beads workspace is active. The landing turns it into an","// actionable empty state (spec R1); other handlers shouldn't reach it, since the","// UI offers no bead links until a repo is active.","var (","\terrNoRepo = errors.New(\"no active repo\")","\terrNoIssue = errors.New(\"no issue to display\")","\t// errNoParent rejects a create with no deliberate parent choice — the","\t// forced-parent contract (str-6k0.6.2): pick an existing parent, choose","\t// no epic, or mint one inline, but never create a bead parentless by","\t// omission.","\terrNoParent = errors.New(\"pick a parent, choose no epic, or create a new parent\")","\t// errNoParentTitle rejects the inline new-parent path with an empty title.","\terrNoParentTitle = errors.New(\"new parent needs a title\")","\t// errEpicMint covers a Create that returns neither an epic nor an error (a","\t// bd-contract violation): the inline mint produced nothing to hang the child or","\t// story under. Shared by the create and attach inline-new-epic paths.","\terrEpicMint = errors.New(\"could not create the new epic\")","// IssueSource is the slice of bd.Client the server needs: reads plus the V1","// writes. An interface keeps the handlers testable with a stub and the bd CLI","// behind one seam (spec Q0). Writes go through the write-client (spec D6) so the","// bare-`bd update` footgun stays impossible. It is exported because the active","// repo is resolved per request through a SourceFunc the command wires.","type IssueSource interface {","\tList(ctx context.Context, opts bd.ListOpts) ([]bd.Issue, error)","\tStats(ctx context.Context) (bd.Stats, error)","\tDeps(ctx context.Context, ids ...string) ([]bd.DepEdge, error)","\tShow(ctx context.Context, id string) (*bd.Issue, error)","\tComments(ctx context.Context, id string) ([]bd.Comment, error)","\tUpdate(ctx context.Context, id, field, value string) (*bd.Issue, error)","\tClaim(ctx context.Context, id string) (*bd.Issue, error)","\tClose(ctx context.Context, id, reason string) (*bd.Issue, error)","\tSetRank(ctx context.Context, id string, rank float64) (*bd.Issue, error)","\tSetParent(ctx context.Context, id, parent bd.ID) (*bd.Issue, error)","\tComment(ctx context.Context, id, text string) error","\tDepAdd(ctx context.Context, id, dependsOn bd.ID) error","\tDepRemove(ctx context.Context, id, dependsOn bd.ID) error","\tLabelAdd(ctx context.Context, id, label string) error","\tLabelRemove(ctx context.Context, id, label string) error","\tCreate(ctx context.Context, opts *bd.CreateOpts) (*bd.Issue, error)","\tDeletePreview(ctx context.Context, id string) (string, error)","\tDelete(ctx context.Context, id string) error","// readSource is the read-only slice of IssueSource the pure-read helpers need:","// the full-repo List (buildStrand), the dependency edges (insightsModel,","// renderDrawer), and the comment thread (renderDrawer). Narrowing the read paths","// to this seam keeps the write methods (Update/Claim/SetRank/…) out of reach where","// only reads happen, so a read helper can't grow a stray write. Any IssueSource —","// the real *bd.Client, the caching wrapper, a test stub — satisfies it for free.","type readSource interface {","// Compile-time proof the fat source and its caching wrapper still satisfy the","// narrow read seam, so the read helpers accept whatever source() hands back. The","// caching wrapper also satisfies closedReader, so pulseListView's closed cut always","// takes the folded path in production — a signature drift breaks the build here, not","// just the runtime type-assertion.","\t_ readSource = (IssueSource)(nil)","\t_ readSource = (*cachingSource)(nil)","\t_ closedReader = (*cachingSource)(nil)","// SourceFunc builds the bd-backed issue source for a repo. It is the seam the","// command wires (a real bd.Client scoped to the repo's path) and tests stub (an","// in-memory fake), so switching the active repo re-scopes every read and write","// without the server knowing how a source is made.","type SourceFunc func(registry.Repo) IssueSource","// writeFunc runs one bd write through the request's issue source and hands back","// the fresh issue (or nil) plus any error. Named so the write handlers and","// writeAndRefresh share one scannable contract instead of respelling it inline.","type writeFunc func(context.Context, IssueSource) (*bd.Issue, error)","// Server renders the strand landing and its htmx fragments over the active repo's","// issue source. The active repo (and the known-repo registry) live in reg;","// srcFor turns the active repo into the source each request reads through.","type Server struct {","\tsrcFor SourceFunc","\treg *registry.Registry","\ttmpl *template.Template","\tstatic http.Handler","\tsyn strand.Synthesis","\tshutdown func() // raised by POST /shutdown; a test seam over the interrupt hook","\tnow func() time.Time // clock for the stale cutoff; a test seam (default time.Now)","\tcache *snapshotCache // per-repo in-process read cache (strand-9s6)","\t// counts reads the shared bead-count cache the off-render agent writes, so the","\t// masthead pulse and the Claude Code status line report one number (st-p1f). A","\t// repo the agent hasn't recorded falls back to strand's own bd-derived spread.","\tcounts *bdcounts.Reader","\t// refreshCounts kicks off the counts.json rewrite for one repo after strand's","\t// own write lands (st-2fy.4), so the masthead's next poll and the status line","\t// agree with the write within seconds instead of waiting for the next","\t// mtime-triggered launchd cycle. Default is the real counts.Run spawn; tests","\t// swap in a spy so the write-path tests don't shell out to bd (the newSource/","\t// suggestLLM seam style already used in this file).","\trefreshCounts func(repo registry.Repo)","\t// Drawer-assist seams. suggestLLM builds the key-gated model client (default","\t// defaultSuggestLLM over llm.New); tests swap it for a stub so assist never","\t// touches the network. It is also the gate that decides whether the drawer","\t// renders an assist button at all. homeDir roots both the global STRAND.md load","\t// and the canonical bead-fmt prompt lookup (default os.UserHomeDir); tests point","\t// it at a temp dir so an assist call never initializes the real ~/.strand.","\tsuggestLLM func() (suggest.Completer, bool)","\thomeDir string","\t// noKeyOnce logs the \"assist disabled — no API key\" warning a single time. Without","\t// it, a server running with no ANTHROPIC_API_KEY looks identical to a run of","\t// already-conformant beads — but logging per request would spam every drawer open,","\t// so it fires once per process.","\tnoKeyOnce sync.Once","\t// Lifecycle for detached background work (the Insights deps prefetch). bgCtx","\t// roots every goBackground context so Stop can cancel them; bgWG tracks the","\t// goroutines so Stop can wait them out. The HTTP drain covers request handlers","\t// only — these outlive their request and would otherwise escape it (str-47z).","\tbgCtx context.Context //nolint:containedctx // the server owns the lifecycle of its detached goroutines; bgCtx IS that lifecycle, cancelled by Stop.","\tbgCancel context.CancelFunc","\tbgWG sync.WaitGroup","\teventsMu sync.Mutex","\t// events maps each open SSE channel to the repo it is scoped to (the same","\t// registry.Repo resolved for its request, incl. an ephemeral unregistered","\t// one — st-55q). reconcileLoop watches the distinct set of these repos","\t// instead of only registry.Active(), and broadcastChange filters delivery","\t// to the channels scoped to the repo that actually changed (st-6i1): a tab","\t// deep-linked to repo B no longer needs repo A to go quiet to get its own","\t// live-refresh signal, and repo A's churn no longer wakes repo B's tab.","\tevents map[chan struct{}]registry.Repo","\tstartOnce sync.Once","// Version is the strand binary version, stamped into counts.json's liveness meta by","// the in-process post-write refresh (defaultRefreshCounts) so it matches the launchd","// `strand counts` run's stamp — one binary, one version, whether the refresh came from","// the server or the agent. main sets it from its own ldflags-stamped Version at startup;","// the \"dev\" default matches an unstamped build.","var Version = \"dev\"","// externalFreshnessBound is the maximum idle time before the authoritative JSON","// snapshot is checked. Detection additionally takes one serialized bd list","// command. Browsers are notified by SSE; they do not poll.","const externalFreshnessBound = 2 * time.Second","// defaultShutdown raises os.Interrupt at strand's own process, so the Quit button","// flows through the same graceful path Ctrl-C does (signal.NotifyContext →","// httpSrv.Shutdown in main) rather than a hard exit. os.Interrupt keeps this","// portable (no syscall import); main already listens for it. Tests replace it.","func defaultShutdown() {","\tif p, err := os.FindProcess(os.Getpid()); err == nil {","\t\t_ = p.Signal(os.Interrupt)","// New builds a Server. srcFor resolves the active repo to its bd source and reg","// holds the registry + active selection. tmpl holds the parsed UI templates and","// static serves the embedded assets, both wired in by the caller so package","// server stays free of embed. syn is the human-shaped synthesis layer (north","// star); the project label follows the active repo.","func New(srcFor SourceFunc, reg *registry.Registry, tmpl *template.Template, static http.Handler, syn strand.Synthesis) *Server {","\ts := &Server{srcFor: srcFor, reg: reg, tmpl: tmpl, static: static, syn: syn, shutdown: defaultShutdown, now: time.Now}","\ts.cache = newSnapshotCache(func() time.Time { return s.now() })","\ts.counts = bdcounts.NewReader()","\ts.refreshCounts = s.defaultRefreshCounts","\ts.bgCtx, s.bgCancel = context.WithCancel(context.Background()) //nolint:forbidigo // server-owned background root, cancelled at shutdown via bgCancel — the st-47z fix (goBackground) hangs off this","\ts.events = make(map[chan struct{}]registry.Repo)","\ts.cache.onChange = func(repo string) { s.broadcastChange(repo) }","\ts.suggestLLM = defaultSuggestLLM","\ts.homeDir, _ = os.UserHomeDir()","\treturn s","// Start begins the authoritative background reconciler. It is separate from New","// so construction-only tests do not leak goroutines; production calls it once.","func (s *Server) Start() { s.startOnce.Do(func() { s.goBackground(0, s.reconcileLoop) }) }","// defaultSuggestLLM is the production model gate: it builds the key-gated llm","// client, reporting unavailable (so the drawer renders no assist button) when no","// API key is set. It adapts *llm.Client to the suggest.Completer seam and returns a","// nil interface — not a typed-nil — when unavailable, so the caller's ok-check is","// the only gate (mirrors `bd find-duplicates --ai`).","func defaultSuggestLLM() (suggest.Completer, bool) {","\tc, ok := llm.New()","\tif !ok {","\t\treturn nil, false","\treturn c, true","// goBackground runs fn in a tracked goroutine on a server-owned context, so work","// that must outlive its request — the Insights deps prefetch (str-udl) — dies with","// the server instead of escaping the shutdown drain (str-47z). The context is","// detached from the request (the request ctx dies the moment the handler returns)","// but rooted in bgCtx, which Stop cancels; the WaitGroup lets Stop block until the","// goroutine lands, so no bd spawn or snapshot-cache write outlives shutdown.","func (s *Server) goBackground(timeout time.Duration, fn func(context.Context)) {","\ts.bgWG.Go(func() {","\t\tvar ctx context.Context","\t\tvar cancel context.CancelFunc","\t\tif timeout > 0 {","\t\t\tctx, cancel = context.WithTimeout(s.bgCtx, timeout)","\t\t} else {","\t\t\tctx, cancel = context.WithCancel(s.bgCtx)","\t\tdefer cancel()","\t\tfn(ctx)","// defaultRefreshCounts is the production refreshCounts: it reruns `strand counts`","// for exactly this repo (modeExplicit — always recomputes, ignoring the","// mtime-changed skip, since the write that triggered this call just changed the","// mtime and there's no reason to depend on winning that race) in a goroutine","// tracked by goBackground, so counts.json — and therefore the masthead's next","// poll and the status line (st-p1f) — catch up with strand's own write within","// seconds. A failure is logged, not surfaced: the write itself already","// succeeded, and a stale count self-heals on the next poll or the next launchd","// cycle either way.","//","// It runs on goBackground's context, not a detached one: a refresh waits on the","// cross-process counts lock (st-k6z), so without cancellation a slow holder would keep","// every queued post-write goroutine alive past the 10s timeout and pin Stop's bgWG","// wait behind it.","func (s *Server) defaultRefreshCounts(repo registry.Repo) {","\ts.goBackground(10*time.Second, func(ctx context.Context) {","\t\tif err := counts.RunContext(ctx, []string{repo.Path}, Version); err != nil {","\t\t\tlog.Printf(\"strand: post-write counts refresh for %s: %v\", repo.Path, err)","// Stop cancels in-flight background work (goBackground) and waits for it to land.","// httpSrv.Shutdown drains request handlers only; the detached prefetch goroutines","// outlive it, so main calls Stop AFTER the HTTP drain to guarantee nothing is","// still spawning bd or writing the snapshot cache once the process exits (str-47z).","// Cancellation makes the wait short — an in-flight `bd dep list` is killed via its","// context rather than run to its 10s timeout. Idempotent.","func (s *Server) Stop() {","\ts.bgCancel()","\ts.bgWG.Wait()","func (s *Server) reconcileLoop(ctx context.Context) {","\tt := time.NewTicker(externalFreshnessBound)","\tdefer t.Stop()","\tfor {","\t\tcase <-ctx.Done():","\t\t\treturn","\t\tcase <-t.C:","\t\t\tfor _, repo := range s.watchedRepos() {","\t\t\t\tsrc := s.srcFor(repo)","\t\t\t\trefreshCtx, cancel := context.WithTimeout(ctx, 10*time.Second)","\t\t\t\t_, err := s.cache.refreshList(refreshCtx, repo.Path, src, true)","\t\t\t\tcancel()","\t\t\t\tif err != nil && ctx.Err() == nil {","\t\t\t\t\tlog.Printf(\"strand: snapshot refresh for %s: %v\", repo.Path, err)","\t\t\t\t}","// watchedRepos returns the distinct repos with at least one open SSE channel,","// deduped by path. Only those repos need the background force-refresh: a repo","// with no open tab has nobody to notify, and its next request re-primes the","// cache itself (st-6i1) — this replaces the old single registry.Active() watch.","// A connection whose ?repo= didn't resolve is registered with a zero Repo","// (Path == \"\") so broadcastChange/cleanup still work; it's excluded here so","// reconcileLoop never force-refreshes a non-repo (st-6i1 follow-up).","func (s *Server) watchedRepos() []registry.Repo {","\ts.eventsMu.Lock()","\tdefer s.eventsMu.Unlock()","\tseen := make(map[string]bool, len(s.events))","\trepos := make([]registry.Repo, 0, len(s.events))","\tfor _, repo := range s.events {","\t\tif repo.Path == \"\" || seen[repo.Path] {","\t\t\tcontinue","\t\tseen[repo.Path] = true","\t\trepos = append(repos, repo)","\treturn repos","// broadcastChange notifies only the SSE channels scoped to the repo that","// changed, so a tab deep-linked to repo B doesn't wake for repo A's churn and","// vice versa (st-6i1).","func (s *Server) broadcastChange(repo string) {","\tfor ch, r := range s.events {","\t\tif r.Path != repo {","\t\tcase ch <- struct{}{}:","\t\tdefault:","func (s *Server) handleEvents(w http.ResponseWriter, r *http.Request) {","\tflusher, ok := w.(http.Flusher)","\t\thttp.Error(w, \"streaming unavailable\", http.StatusInternalServerError)","\t\treturn","\t// Scope this connection to the same repo a page/fragment request would","\t// resolve to (registry.Resolve — honors ?repo=, incl. an ephemeral","\t// unregistered repo, st-55q), so reconcileLoop knows to watch it and","\t// broadcastChange knows which tabs care when it changes (st-6i1). No","\t// resolvable repo means nothing to watch; the stream still opens (a","\t// deep-link to a bad path degrades to \"connected, no live-refresh\" rather","\t// than a hard error, matching this handler's other no-repo behavior).","\trepo, _ := s.reg.Resolve(r.URL.Query().Get(\"repo\"))","\t// http.Server.WriteTimeout is a fixed deadline from request start, not reset","\t// per write — an idle SSE stream would otherwise be killed on that clock","\t// (dropping every open tab and forcing an EventSource reconnect) even though","\t// the connection is healthy. Clear it for this handler only.","\tif rc := http.NewResponseController(w); rc != nil {","\t\t_ = rc.SetWriteDeadline(time.Time{})","\tw.Header().Set(\"Content-Type\", \"text/event-stream\")","\tw.Header().Set(\"Cache-Control\", \"no-cache\")","\tch := make(chan struct{}, 1)","\ts.events[ch] = repo","\ts.eventsMu.Unlock()","\tdefer func() { s.eventsMu.Lock(); delete(s.events, ch); s.eventsMu.Unlock() }()","\t_, _ = fmt.Fprint(w, \": connected\\n\\n\")","\tflusher.Flush()","\t\tcase <-r.Context().Done():","\t\tcase <-s.bgCtx.Done():","\t\tcase <-ch:","\t\t\t_, _ = fmt.Fprint(w, \"event: beads\\ndata: changed\\n\\n\")","\t\t\tflusher.Flush()","// source resolves this request's repo and its issue source. A `?repo=` query","// param scopes THIS request only — via registry.Resolve, which never mutates","// the registry or writes repos.json (st-ga4: the deep-link that used to","// re-point the global active repo on a plain GET). No param falls back to the","// persistent active repo. ok is false when neither resolves, which the","// landing renders as the empty state.","func (s *Server) source(r *http.Request) (IssueSource, registry.Repo, bool) {","\trepo, ok := s.reg.Resolve(r.URL.Query().Get(\"repo\"))","\t\treturn nil, registry.Repo{}, false","\t// Wrap the bd source in the snapshot cache, keyed by the resolved repo's","\t// path. Reads (List/Deps) are served from the per-repo snapshot; writes pass","\t// through and drop that repo's snapshot. Keying on the path makes scoping a","\t// different repo a natural cache miss — a repo with no entry yet — so a","\t// deep-link re-scopes for free without touching any other repo's snapshot.","\treturn &cachingSource{IssueSource: s.srcFor(repo), cache: s.cache, repo: repo.Path}, repo, true","// Routes returns the mux: the strand page, its htmx fragments, and static assets.","// Every mutating route (POST/PATCH/DELETE) is registered through mutate, which","// wraps the handler in the cross-site guard; the GET reads stay open so the same","// guard can never break a plain navigation (spec: gate writes, not reads).","func (s *Server) Routes() http.Handler {","\tmux := http.NewServeMux()","\tmux.HandleFunc(\"GET /{$}\", s.handleHome)","\tmux.HandleFunc(\"GET /list\", s.handleList)","\tmux.HandleFunc(\"GET /pulse\", s.handlePulse)","\tmux.HandleFunc(\"GET /events\", s.handleEvents)","\tmux.HandleFunc(\"GET /board\", s.handleBoard)","\tmux.HandleFunc(\"GET /insights\", s.handleInsights)","\tmux.HandleFunc(\"GET /bead/{id}\", s.handleBead)","\tmux.HandleFunc(\"GET /bead/{id}/assist\", s.handleAssist)","\ts.mutate(mux, \"PATCH /bead/{id}\", s.handleEdit)","\ts.mutate(mux, \"POST /bead/{id}/move\", s.handleMove)","\ts.mutate(mux, \"POST /bead/{id}/rank\", s.handleRank)","\ts.mutate(mux, \"POST /bead/{id}/claim\", s.handleClaim)","\ts.mutate(mux, \"POST /bead/{id}/close\", s.handleClose)","\ts.mutate(mux, \"POST /bead/{id}/reopen\", s.handleReopen)","\ts.mutate(mux, \"POST /bead/{id}/comment\", s.handleComment)","\ts.mutate(mux, \"POST /bead/{id}/dep\", s.handleDepAdd)","\ts.mutate(mux, \"POST /bead/{id}/dep/remove\", s.handleDepRemove)","\ts.mutate(mux, \"POST /bead/{id}/label\", s.handleLabelAdd)","\ts.mutate(mux, \"POST /bead/{id}/label/remove\", s.handleLabelRemove)","\ts.mutate(mux, \"POST /bead/{id}/delete\", s.handleDeletePreview)","\ts.mutate(mux, \"DELETE /bead/{id}\", s.handleDelete)","\tmux.HandleFunc(\"GET /new\", s.handleNewForm)","\ts.mutate(mux, \"POST /new\", s.handleCreate)","\tmux.HandleFunc(\"GET /attach-epic\", s.handleAttachForm)","\ts.mutate(mux, \"POST /attach-epic\", s.handleAttachEpic)","\ts.mutate(mux, \"POST /refresh\", s.handleRefresh)","\tmux.HandleFunc(\"GET /repos\", s.handleRepos)","\ts.mutate(mux, \"POST /repos/rescan\", s.handleRescan)","\ts.mutate(mux, \"POST /repo\", s.handleSwitchRepo)","\ts.mutate(mux, \"POST /repo/add\", s.handleAddRepo)","\ts.mutate(mux, \"POST /shutdown\", s.handleShutdown)","\tmux.Handle(\"GET /static/\", s.static)","\treturn mux","// mutate registers a state-changing handler behind the cross-site guard. Every","// non-GET route goes through here so the check lives in one place — a new write","// route is guarded by construction, not by remembering to wrap it.","func (s *Server) mutate(mux *http.ServeMux, pattern string, h http.HandlerFunc) {","\tmux.Handle(pattern, s.guardCrossSite(h))","// reqContext bounds every bd shell-out so a hung CLI can't wedge a request.","func reqContext(r *http.Request) (context.Context, context.CancelFunc) {","\treturn context.WithTimeout(r.Context(), 10*time.Second)","// handleShutdown stops strand from the UI: it answers with the stopped fragment,","// then raises the shutdown hook. The answer is written first and the real hook","// only signals (non-blocking) — the graceful drain in main lets this response","// flush before the listener closes. Local-only tool, so no confirm or auth guard.","func (s *Server) handleShutdown(w http.ResponseWriter, _ *http.Request) {","\ts.render(w, \"shutdown\", nil)","\ts.shutdown()","// listView is the bead-list pane: an epic, optionally narrowed to one story.","type listView struct {","\tEpic strand.Epic","\tStory strand.Story","\tHasStory bool // false = show the whole epic","\tHasEpic bool // true only for a genuine single-epic scope (not \"everything\"/bugs/story)","\t// ScopeID is the bd id of the bead this scope names — a story (Story.ID) or a","\t// real epic (Epic.Key). Empty when the scope has no editable bead behind it","\t// (\"everything\", \"bugs\", the off-epic catch-all). The pane-head title's","\t// open-drawer affordance keys off this, so an epic or story edits through the","\t// same gesture the leaf rows already use (str-scn).","\tScopeID string","\t// EpicBeadID is the bd id of the story's epic, or \"\" when the story is off-epic.","\t// The story-scoped head's breadcrumb keys off it: a real id renders a crumb that","\t// navigates up to the epic; \"\" renders the \"No epic\" attach affordance (str-o74).","\t// Precomputed here because BeadID is a pointer method the template can't call on","\t// the non-addressable Epic value.","\tEpicBeadID string","\t// Flat marks a masthead-pulse status cut: a flat, repo-wide bead list with no","\t// epic/story structure (the beads come straight from a status fetch). The list","\t// template renders FlatTitle as the head and Story.Beads as one table — no","\t// breadcrumb, no per-story groups. Story.Open carries the count.","\tFlat bool","\tFlatTitle string","// pageData is the full landing render: the strand, the list pane, and the repo","// selector chrome (the active repo's name and the known repos). Empty is true","// when no repo is active, switching the landing to its actionable empty state.","type pageData struct {","\tStrand strand.Model","\tList listView","\tPulse Pulse","\tRepos repoMenu","\t// RepoPath is this page's scoped repo (registry.Repo.Path — empty when no","\t// repo resolved). The page carries it on every htmx fragment it fires via","\t// an inherited hx-vals, and on the SSE EventSource URL via data-repo, so a","\t// `?repo=` deep-link scopes the whole page's lifetime, not just this one","\t// render (st-ga4).","\tRepoPath string","\tEmpty bool","\tAsOf string // \"data as of HH:MM\" for the refresh readout; empty when no snapshot","\t// ActiveFilter is the pulse cut the landing opened with — the token from a","\t// deep-link `/?filter=` (the status line's OSC 8 links land here). It","\t// renders onto #viewport's data-filter so the client's syncChrome() lights the","\t// matching pulse cell and active-cut chip on cold load, and the List pane below","\t// is already the cut's list. \"\" for a plain landing (no filter, or an unknown one).","\tActiveFilter string","// Pulse is the masthead's repo-wide bead-status spread — the bead half of the","// Claude Code status line, mirrored into the page. Each field is a glyph cell:","// ◆ Waiting, ○ Open, ◐ InProgress, ● Blocked, ✓ Closed, ❄ Deferred. The counts","// come from the shared counts.json cache — the same file the status line reads —","// so the two surfaces agree by construction (st-p1f); a repo the off-render agent","// hasn't recorded falls back to strand's own bd-derived spread. A nonzero cell is","// a click-to-list filter (handleList's pulse cuts).","type Pulse struct {","\tWaiting, Open, InProgress, Blocked, Closed, Deferred int","\t// Stale is true when the shared counts cache's last refresh is older than 2× the","\t// refresher's interval — the launchd agent is dead or wedged, so these numbers may","\t// be silently frozen (st-18l). The masthead renders a subtle stale badge; it does not","\t// suppress the counts, which are still the last-good spread.","\tStale bool","// computePulse builds the masthead spread for the active repo. It first reads the","// shared counts.json the off-render agent writes (bdcounts) — the ONE source the","// status line reads too, so the masthead and the status line can never disagree","// (st-p1f). Only that miss — a repo the agent hasn't recorded — falls through to","// the bd-derived spread below: `bd stats` for the raw status counts plus the","// insight.Lanes partition for the three derived lanes. In the fallback the counts","// agree with the cut each clicks through to (st-88o, st-x66); reading from","// counts.json instead trades that internal agreement for agreement with the status","// line, the coherence dk asked for. A failed read degrades to zero counts rather","// than failing the whole page — the pulse is ambient, not load-bearing.","func (s *Server) computePulse(ctx context.Context, src IssueSource, repo registry.Repo) Pulse {","\t// Staleness is a property of the shared cache's liveness (its meta stamp), not of any","\t// one repo's row, so it's read the same whether this repo hits counts.json or falls","\t// back to bd. ok=false (no stamp / unreadable) leaves Stale false — no false alarm.","\tstale, _ := s.counts.Stale(time.Now())","\tif b, ok := s.counts.Lookup(repo.Path); ok {","\t\treturn Pulse{","\t\t\tWaiting: b.Waiting,","\t\t\tOpen: b.Open,","\t\t\tInProgress: b.InProgress,","\t\t\tBlocked: b.Blocked,","\t\t\tClosed: b.Closed,","\t\t\tDeferred: b.Deferred,","\t\t\tStale: stale,","\tp := Pulse{Stale: stale}","\tif st, err := src.Stats(ctx); err == nil {","\t\t// bd stats seeds the degraded (List-failed) baseline for the raw status counts.","\t\t// ● is deliberately NOT seeded here: bd's blocked_issues is a DIFFERENT metric than","\t\t// the ● lane — bd counts an in-progress bead with an unmet blocker as blocked (and","\t\t// again as in_progress), but the ● cut lists only LaneBlocked (stored-blocked +","\t\t// open-held). Seeding ● from bd stats renders a nonzero ● that clicks through to an","\t\t// empty pane, so ● is derived from the lane partition below and nowhere else.","\t\tp.Open, p.InProgress = st.Open, st.InProgress","\t\tp.Closed, p.Deferred = st.Closed, st.Deferred","\tif issues, err := src.List(ctx, bd.ListOpts{}); err == nil {","\t\t// Every masthead count must agree with the cut it clicks through to, so all three","\t\t// derived lanes come from the ONE insight.Lanes partition — the same truth the ●,","\t\t// ○, and ◆ cuts (and the board's Classify) share. Count and list can't drift: both","\t\t// derive from Lanes over the same issues+deps (st-88o, st-x66). Deps are read from","\t\t// the warm cache only — the masthead never pays a deps spawn on the landing path","\t\t// (str-47z). Cold, no bead is dependency-blocked, so all three lanes show their","\t\t// best-effort: ○ and ◆ are list-path exact, and ● counts stored-blocked beads (which","\t\t// laneOf classifies without deps) but not yet the open-held ones — a cold undercount,","\t\t// never an overcount into an empty cut. It does NOT self-heal on its own: the deps","\t\t// prefetch fires no event. The masthead's one-shot `load` re-fetch of /pulse (page.html,","\t\t// st-01z) closes the gap — it lands after the prefetch warms deps, so ● comes back exact.","\t\tdeps, _ := s.cache.liveDeps(repo.Path)","\t\tlanes := insight.Lanes(issues, deps)","\t\tp.Open = countLane(lanes, insight.LaneOpen)","\t\tp.Waiting = countLane(lanes, insight.LaneWaiting)","\t\tp.Blocked = countLane(lanes, insight.LaneBlocked)","\treturn p","// countLane tallies the beads insight.Lanes put in one lane — the masthead's count","// for that glyph. The matching cut lists the same lane's members (pulseBeads), so","// count == len(list) by construction.","func countLane(lanes map[string]insight.Lane, l insight.Lane) int {","\tn := 0","\tfor _, v := range lanes {","\t\tif v == l {","\t\t\tn++","\treturn n","func (s *Server) handleHome(w http.ResponseWriter, r *http.Request) {","\tctx, cancel := reqContext(r)","\tdefer cancel()","\t// A deep-link may name the repo it wants shown (`/?repo=`): the status","\t// line's OSC 8 links carry the line's own repo path so a click lands on THAT","\t// repo, not whatever was last active. source(r) resolves it per-request —","\t// via registry.Resolve, covering an already-registered repo, an unregistered","\t// but valid one (st-55q: e.g. itzy, never added but has a working .beads),","\t// or falling back to the persistent active repo — without mutating the","\t// registry or writing repos.json (st-ga4: a GET must not have that side","\t// effect; that was the CSRF vector CodeRabbit flagged on #102, and it also","\t// leaked the deep-link's repo into every other open tab). The scope lives","\t// only in this request's query param and, via source(r), threads through","\t// buildStrand, the pulse, and every htmx fragment the page fires.","\tsrc, repo, ok := s.source(r)","\t\ts.render(w, \"page\", pageData{Empty: true, Repos: s.repoMenu(registry.Repo{}, false, \"\")})","\tf, _, err := s.buildStrand(ctx, src, repo)","\t\ts.renderError(w, err)","\t// computePulse runs before the deps prefetch launches: its Stats call is a bd","\t// spawn that serializes on package bd's execMu, so kicking off the background","\t// `dep list` first would queue the masthead's stats read behind it and stall the","\t// landing. Compute the pulse (List is already warm from buildStrand, so this is","\t// one Stats spawn), then warm deps in the background.","\tpulse := s.computePulse(ctx, src, repo)","\t// Open warms every view, not just this one: buildStrand warmed the List","\t// snapshot, so prefetch the repo-wide Deps too — that makes the first Insights","\t// click (the one view needing edges) hit memory instead of paying a cold `dep","\t// list` spawn (str-udl). Warm it in the background, detached from the request","\t// (the landing must not block on a ~0.5s spawn the user may never need, and the","\t// request ctx dies the moment handleHome returns) but bound to the server via","\t// goBackground, so shutdown drains it instead of letting it escape (str-47z). A","\t// prefetch failure is non-fatal — the landing renders and Insights fetches its","\t// own deps on demand.","\t\t_, _ = src.Deps(ctx)","\t// A deep-link `/?filter=` (the status line's OSC 8 links) opens the","\t// landing with a masthead-pulse cut already applied to the List pane — the same","\t// cut a click on that pulse cell would swap in, but resolved server-side so the","\t// pane is right on first paint and works without JS. An unknown filter falls","\t// through to the whole-strand list, exactly as the empty landing renders.","\tlist := listViewFor(f, \"\", \"\", \"\")","\tactive := \"\"","\tif cut, ok := pulseCutFor(r.URL.Query().Get(\"filter\")); ok {","\t\tif v, err := s.pulseListView(ctx, src, cut); err == nil {","\t\t\tlist, active = v, r.URL.Query().Get(\"filter\")","\t\t\t// A bd spawn failure here must not vanish silently: the click path","\t\t\t// (handleList) surfaces the identical error via renderError, so a","\t\t\t// deep-link hitting the same transient failure should be visible too,","\t\t\t// not just fall through to the whole-strand list with no trace (st-2fy.6).","\t\t\t// Logs cut.title (pulseCutFor's own fixed enum), not the raw query","\t\t\t// param, so an attacker-controlled ?filter= can't inject into the log.","\t\t\tlog.Printf(\"strand: deep-link filter=%s: %v\", cut.title, err)","\ts.render(w, \"page\", pageData{","\t\tStrand: f,","\t\tList: list,","\t\tPulse: pulse,","\t\tRepos: s.repoMenu(repo, true, \"\"),","\t\tRepoPath: repo.Path,","\t\tAsOf: s.asOf(repo),","\t\tActiveFilter: active,","// handlePulse re-renders just the masthead spread. The page wires it to the","// refreshList event so an in-app create/edit/close keeps the counts honest","// without a full reload; with no active repo it renders nothing.","// It also doubles as the proactive-rebuild trigger (st-2fy.5): st-2fy.4's htmx","// poll already calls this on a fixed interval for every open landing, so it's","// the cheapest place to notice an out-of-band bd write (fleet agent, bare bd","// CLI) without standing up a separate watcher. checkStale peeks the snapshot","// cache's mtime gate; on a miss the store hasn't moved and nothing else","// happens. On a hit the entry is already evicted (checkStale's side effect,","// mirroring the lazy path's own eviction) and a background rebuild is kicked","// via goBackground, so the snapshot is warm again by the time the user's next","// filter switch would otherwise pay the cold `bd list` spawn on the request","// path. computePulse never touches the snapshot cache (it reads counts.json),","// so this check can't delay the pulse render itself.","func (s *Server) handlePulse(w http.ResponseWriter, r *http.Request) {","\ts.render(w, \"pulse\", s.computePulse(ctx, src, repo))","// handleRefresh drops the active repo's snapshot and tells htmx to reload the","// page. With no time-based expiry (str-udl), a plain reload would serve the warm","// snapshot — so seeing an out-of-band edit (a fleet agent or bd CLI touching the","// same store) needs this deliberate invalidate. The HX-Refresh response header","// makes htmx do a full document reload, which re-runs handleHome and re-warms List","// + Deps from bd's truth. No active repo is a no-op reload.","func (s *Server) handleRefresh(w http.ResponseWriter, r *http.Request) {","\tif _, repo, ok := s.source(r); ok {","\t\ts.cache.invalidate(repo.Path)","\tw.Header().Set(\"HX-Refresh\", \"true\")","\tw.WriteHeader(http.StatusNoContent)","// asOf formats the active snapshot's fetch time as \"HH:MM\" for the refresh","// readout, or \"\" when no snapshot is warm (the readout then shows nothing rather","// than a misleading zero time).","func (s *Server) asOf(repo registry.Repo) string {","\tif at, ok := s.cache.stampedAt(repo.Path); ok {","\t\treturn at.Format(\"15:04\")","\treturn \"\"","func (s *Server) handleList(w http.ResponseWriter, r *http.Request) {","\t\ts.render(w, \"list\", listView{})","\t// A masthead-pulse cut (filter=open|in_progress|blocked|closed|deferred|waiting)","\t// is a repo-wide status slice, not a strand scope — it can include closed and","\t// deferred beads the strand drops, so it renders from its own fetch, before the","\t// strand is built.","\tq := r.URL.Query()","\t// A text search (q=) is a whole-strand cut like a pulse filter — it wins over","\t// story/epic scope and over filter=, since typing a query is the more specific","\t// ask. It renders from its own fetch, same as a pulse cut.","\tif query := strings.TrimSpace(q.Get(\"q\")); query != \"\" {","\t\tview, err := s.searchListView(ctx, src, query)","\t\tif err != nil {","\t\t\ts.renderError(w, err)","\t\ts.render(w, \"list\", view)","\tif cut, ok := pulseCutFor(q.Get(\"filter\")); ok {","\t\tview, err := s.pulseListView(ctx, src, cut)","\t// story= narrows the pane to a single story; absent means the whole epic.","\ts.render(w, \"list\", listViewFor(f, q.Get(\"story\"), q.Get(\"epic\"), q.Get(\"filter\")))","// searchListView gathers every live bead whose title or description contains","// query (case-insensitive) into a flat list scope, mirroring pulseListView. It","// reads the snapshot bd list defaults to (closed already dropped) and filters","// deferred the way the strand does, so search scope matches the live view rather","// than leaking parked work. Comments aren't","// searched: bd has no bulk comment-search primitive, and fetching every bead's","// comments per keystroke would serialize behind execMu (client.go) on a","// snapshot this size.","func (s *Server) searchListView(ctx context.Context, src IssueSource, query string) (listView, error) {","\tissues, err := src.List(ctx, bd.ListOpts{})","\t\treturn listView{}, err","\tneedle := strings.ToLower(query)","\tvar beads []strand.Bead","\tfor i := range issues {","\t\tid := strings.ToLower(issues[i].ID)","\t\t// An id match is a jump-to-bead: honour it even for a deferred bead the strand","\t\t// otherwise drops, so `tx-kbrv` lands its target rather than silently emptying.","\t\tidHit := needle != \"\" && strings.Contains(id, needle)","\t\t// bd list drops closed on its own but still hands back deferred, which the","\t\t// strand treats as out of motion — filter it the same way buildStrand does.","\t\tif !idHit && !strand.Openish(issues[i].Status) {","\t\tif idHit ||","\t\t\tstrings.Contains(strings.ToLower(issues[i].Title), needle) ||","\t\t\tstrings.Contains(strings.ToLower(issues[i].Description), needle) {","\t\t\tbeads = append(beads, strand.NewBead(&issues[i]))","\tstrand.SortBeads(beads)","\ttitle := fmt.Sprintf(\"Search: %q (%d)\", query, len(beads))","\treturn listView{Flat: true, FlatTitle: title, Story: strand.Story{Beads: beads, Open: len(beads)}}, nil","// pulseCut is one masthead-pulse drill-down: the pane title and the predicate","// selecting its beads. closed marks the one cut whose beads bd's default list omits","// (`bd list` drops closed): it reads the snapshot's folded closed set instead of the","// open list. Deferred needs no such flag — deferred beads already ride the open-list","// snapshot, so its cut filters memory like the live cuts.","type pulseCut struct {","\ttitle string","\tclosed bool // read the snapshot's folded closed set, not the open list","\t// lane marks a derived-trio cut (○/●/◆): pulseBeads lists exactly the beads","\t// insight.Lanes puts in this lane, so the list agrees with the masthead count by","\t// construction (st-88o, st-x66). LaneNone means a plain status cut (in_progress /","\t// closed / deferred), which lists by match.","\tlane insight.Lane","\tmatch func(*bd.Issue) bool","// closedReader is the narrow seam pulseListView uses to read the repo's closed beads","// from the snapshot fold: the caching wrapper satisfies it; any other source falls","// back to an uncached `--status closed` read. A narrow interface (like readSource)","// keeps Closed off the fat 18-method IssueSource and out of every test fake.","type closedReader interface {","\tClosed(ctx context.Context) ([]bd.Issue, error)","// pulseCutFor maps a filter token to its cut, or reports false for any other","// filter (so \"bugs\" and the empty/scope filters fall through to listViewFor). The","// three derived lanes carry a Lane and no match; the raw status cuts carry a match.","func pulseCutFor(filter string) (pulseCut, bool) {","\tstatusIs := func(st bd.Status) func(*bd.Issue) bool {","\t\treturn func(i *bd.Issue) bool { return i.Status == st }","\tswitch filter {","\tcase \"waiting\":","\t\treturn pulseCut{title: \"Waiting on you\", lane: insight.LaneWaiting}, true","\tcase \"open\":","\t\treturn pulseCut{title: \"Open\", lane: insight.LaneOpen}, true","\tcase \"in_progress\":","\t\treturn pulseCut{title: \"In progress\", match: statusIs(bd.StatusInProgress)}, true","\tcase \"blocked\":","\t\treturn pulseCut{title: \"Blocked\", lane: insight.LaneBlocked}, true","\tcase \"closed\":","\t\treturn pulseCut{title: \"Closed\", closed: true, match: statusIs(bd.StatusClosed)}, true","\tcase \"deferred\":","\t\treturn pulseCut{title: \"Deferred\", match: statusIs(bd.StatusDeferred)}, true","\treturn pulseCut{}, false","// pulseListView gathers a status cut's beads into a flat list scope. Every cut but","// closed reads the cached open snapshot (deferred beads ride it too); the closed cut","// reads the snapshot's folded closed set through the caching wrapper (closedReader),","// falling back to an uncached `--status closed` read for any source that isn't the","// wrapper. The match predicate is applied in every case (pulseBeads), so the cut is","// correct even when the source returns an unfiltered list.","func (s *Server) pulseListView(ctx context.Context, src IssueSource, cut pulseCut) (listView, error) {","\tvar (","\t\tissues []bd.Issue","\t\terr error","\t)","\tswitch {","\tcase cut.closed:","\t\tif cr, ok := src.(closedReader); ok {","\t\t\tissues, err = cr.Closed(ctx)","\t\t\tissues, err = src.List(ctx, bd.ListOpts{Status: bd.StatusClosed})","\tdefault:","\t\tissues, err = src.List(ctx, bd.ListOpts{})","\tbeads, err := s.pulseBeads(ctx, src, cut, issues)","\treturn listView{Flat: true, FlatTitle: cut.title, Story: strand.Story{Beads: beads, Open: len(beads)}}, nil","// pulseBeads selects a cut's beads from the snapshot. A derived-lane cut (○/●/◆)","// lists exactly the beads insight.Lanes assigns to cut.lane — fetching the repo-wide","// deps the partition classifies over — so the list is the same set the masthead count","// tallied (count == len(list)); st-88o and st-x66 were this list/count drift, now","// unrepresentable. A raw status cut (in_progress/closed/deferred) lists by its match.","func (s *Server) pulseBeads(ctx context.Context, src IssueSource, cut pulseCut, issues []bd.Issue) ([]strand.Bead, error) {","\tif cut.lane != insight.LaneNone {","\t\tdeps, err := s.pulseDeps(ctx, src, issues)","\t\t\treturn nil, err","\t\tvar beads []strand.Bead","\t\tfor i := range issues {","\t\t\tif lanes[issues[i].ID] == cut.lane {","\t\t\t\tbeads = append(beads, strand.NewBead(&issues[i]))","\t\treturn beads, nil","\t\tif cut.match(&issues[i]) {","\treturn beads, nil","// pulseDeps fetches the repo-wide dependency edges the pulse lanes classify over. The","// list path (unlike the masthead render) may pay this spawn — str-47z governs only the","// landing render's cache-only read. A blocker can sit outside any one scope, so deps are","// fetched over the whole snapshot; an empty snapshot needs none.","func (s *Server) pulseDeps(ctx context.Context, src IssueSource, issues []bd.Issue) ([]bd.DepEdge, error) {","\tif len(issues) == 0 {","\t\treturn nil, nil","\tids := make([]string, len(issues))","\t\tids[i] = issues[i].ID","\tdeps, err := src.Deps(ctx, ids...)","\t\treturn nil, fmt.Errorf(\"pulse deps: %w\", err)","\treturn deps, nil","// listViewFor builds the bead-list pane from the strand. Scope precedence:","// filter==\"bugs\" gathers every bug across all epics; else storyID narrows to one","// story; else epicKey narrows to one epic; else the default is the whole strand","// (every epic flattened — \"everything\"). Story and epic are both searched across","// all epics. An empty strand yields an empty view. The full-page render and the","// htmx swaps all go through here, so the panes, board, and insights can't","// diverge.","func listViewFor(f strand.Model, storyID, epicKey, filter string) listView {","\tif len(f.Epics) == 0 {","\t\treturn listView{}","\tif filter == \"bugs\" {","\t\treturn listView{Epic: bugEpic(f)}","\tif storyID != \"\" {","\t\tif v, ok := findStory(f, storyID); ok {","\t\t\treturn v","\tif epicKey != \"\" {","\t\tif v, ok := findEpic(f, epicKey); ok {","\treturn listView{Epic: everythingEpic(f)}","// findStory locates the story with the given id and returns the view scoped to it.","func findStory(f strand.Model, storyID string) (listView, bool) {","\tfor _, e := range f.Epics {","\t\tfor _, st := range e.Stories {","\t\t\tif st.ID == storyID {","\t\t\t\treturn listView{Epic: e, Story: st, HasStory: true, ScopeID: st.ID, EpicBeadID: e.BeadID()}, true","\treturn listView{}, false","// findEpic locates the epic with the given key and returns the view scoped to it.","func findEpic(f strand.Model, epicKey string) (listView, bool) {","\t\tif e.Key == epicKey {","\t\t\t// The off-epic catch-all has no bead behind it, so its title stays","\t\t\t// inert; a real epic carries its bd id as the editable scope (str-scn).","\t\t\treturn listView{Epic: e, HasEpic: true, ScopeID: e.BeadID()}, true","// everythingEpic flattens every top-level epic into one synthetic scope named","// \"Everything\", so the unscoped list/board/insights show all live work, not just","// the largest epic. A single-epic strand is returned as-is (it keeps its own","// name — a no-epic project reads as the project, not \"Everything\").","func everythingEpic(f strand.Model) strand.Epic {","\tif len(f.Epics) == 1 {","\t\treturn f.Epics[0]","\ttotal := 0","\t\ttotal += len(e.Stories)","\tout := strand.Epic{Name: \"Everything\", Color: f.Epics[0].Color, Stories: make([]strand.Story, 0, total)}","\t\tout.Stories = append(out.Stories, e.Stories...)","\t\tout.Open += e.Open","\treturn out","// bugEpic gathers every bug-type bead across all epics into one synthetic scope","// named \"Bugs\", keeping each bug under its own story (stories with no bug drop","// out). It is the list-side companion to the map's bug dot.","func bugEpic(f strand.Model) strand.Epic {","\tout := strand.Epic{Name: \"Bugs\", Color: f.Epics[0].Color}","\t\t\tvar bugs []strand.Bead","\t\t\tfor bi := range st.Beads {","\t\t\t\tif st.Beads[bi].Type == \"bug\" {","\t\t\t\t\tbugs = append(bugs, st.Beads[bi])","\t\t\tif len(bugs) == 0 {","\t\t\t\tcontinue","\t\t\tscoped := st","\t\t\tscoped.Beads = bugs","\t\t\tscoped.Open = len(bugs)","\t\t\tout.Stories = append(out.Stories, scoped)","\t\t\tout.Open += len(bugs)","// pivotField is one kanban axis: its name (the bd field a drop writes), the","// canonical ordered columns that always exist as drop targets, and how to read a","// bead's value for it. Co-locating all three means a new pivot is added in one","// place, not spread across a name list, a seed map, and a value switch.","type pivotField struct {","\tName string","\tSeeds []boardColumn","\tvalue func(*strand.Bead) string","// pivotFields are the fields the kanban can pivot on, in pivot-bar order (the","// first is the default). Type is omitted: bd has no `update --type`, so a type","// column couldn't accept a drag. The seeds give canonical, ordered columns so","// empty drop targets exist (e.g. an empty \"in progress\" to drag into); values bd","// reports that aren't seeded (a named assignee) are appended. The assignee","// \"unassigned\" column writes an empty value — dropping there clears the field.","var pivotFields = []pivotField{","\t{\"status\", []boardColumn{{Key: string(bd.StatusOpen), Label: \"open\"}, {Key: string(bd.StatusInProgress), Label: \"in progress\"}, {Key: string(bd.StatusBlocked), Label: \"blocked\"}, {Key: string(bd.StatusClosed), Label: \"closed\"}}, func(b *strand.Bead) string {","\t\t// Effective status: an open bead held by an unmet blocker shows in the blocked","\t\t// column though bd still stores it \"open\" (a dependency-blocked bead is never","\t\t// auto-promoted to status=blocked). Without this the blocked column only ever","\t\t// catches hand-set beads and reads as empty. Human-gated beads stay in their","\t\t// real column and carry a ◆ badge instead — \"waiting\" is no bd status, so it","\t\t// can't be a drop target that handleMove writes.","\t\tif b.Blocked {","\t\t\treturn string(bd.StatusBlocked)","\t\treturn string(b.Status)","\t}},","\t{\"priority\", []boardColumn{{Key: \"0\", Label: \"P0\"}, {Key: \"1\", Label: \"P1\"}, {Key: \"2\", Label: \"P2\"}, {Key: \"3\", Label: \"P3\"}, {Key: \"4\", Label: \"P4\"}}, func(b *strand.Bead) string { return strconv.Itoa(b.Priority) }},","\t{\"assignee\", []boardColumn{{Key: \"\", Label: \"unassigned\"}}, func(b *strand.Bead) string { return b.Assignee }},","// boardPivots is the pivot bar's name order, derived from pivotFields so the two","// can't drift. The first name is the default pivot.","var boardPivots = pivotNames()","func pivotNames() []string {","\tnames := make([]string, len(pivotFields))","\tfor i := range pivotFields {","\t\tnames[i] = pivotFields[i].Name","\treturn names","// boardView is the kanban render: the same scope the table shows (an epic or one","// story, embedded so the head reuses the list's scope markup), pivoted into","// columns by Pivot. Pivots drives the pivot bar.","type boardView struct {","\tlistView","\tPivot string","\tPivots []string","\tColumns []boardColumn","// boardColumn is one kanban column: Key is the field value a drop writes (e.g.","// \"in_progress\", \"2\", or \"\" to clear an assignee); Label is its caption.","type boardColumn struct {","\tKey string","\tLabel string","\tBeads []strand.Bead","func (s *Server) handleBoard(w http.ResponseWriter, r *http.Request) {","\t\ts.render(w, \"board\", boardView{Pivots: boardPivots, Pivot: boardPivots[0]})","\t// List once: strand.Build folds the issues into the scope, and the attention","\t// classifier reuses the same list for its blocker/gate index (a blocker can live","\t// outside the visible scope), so the board and the dashboard read one truth.","\tf, issues, err := s.buildStrand(ctx, src, repo)","\tview := listViewFor(f, q.Get(\"story\"), q.Get(\"epic\"), q.Get(\"filter\"))","\tscope := scopeBeads(&view)","\tif err := s.markAttention(ctx, src, scope, issues); err != nil {","\ts.render(w, \"board\", buildBoard(&view, q.Get(\"pivot\"), scope))","// markAttention flags each scope bead Blocked or Waiting for the board, fetching the","// scope's dependency edges and classifying via insight (the precedence the dashboard","// triage already uses). A deps-read error fails the render rather than degrading","// silently — a blocked bead shown as plain open is exactly the bug this fixes. The","// scope slice is mutated in place; it is the same backing the board buckets.","func (s *Server) markAttention(ctx context.Context, src readSource, scope []strand.Bead, issues []bd.Issue) error {","\tif len(scope) == 0 {","\tids := make([]string, len(scope))","\tfor i := range scope {","\t\tids[i] = scope[i].ID","\t\treturn fmt.Errorf(\"board deps: %w\", err)","\tblocked, waiting := insight.Classify(scope, issues, deps)","\t\tscope[i].Blocked = blocked[scope[i].ID]","\t\tscope[i].Waiting = waiting[scope[i].ID]","\treturn nil","// buildBoard pivots the scope's (attention-marked) beads into columns. Both the","// whole-epic and single-story scopes flow through here, so the board can't diverge","// from the table.","func buildBoard(v *listView, pivot string, beads []strand.Bead) boardView {","\tpivot = pivotOrDefault(pivot)","\treturn boardView{","\t\tlistView: *v,","\t\tPivot: pivot,","\t\tPivots: boardPivots,","\t\tColumns: boardColumns(pivot, beads),","// scopeBeads flattens the view's beads: one story's, or every story's in the epic.","func scopeBeads(v *listView) []strand.Bead {","\tif v.HasStory {","\t\treturn v.Story.Beads","\tfor i := range v.Epic.Stories {","\t\ttotal += len(v.Epic.Stories[i].Beads)","\tall := make([]strand.Bead, 0, total)","\t\tall = append(all, v.Epic.Stories[i].Beads...)","\treturn all","// pivotOrDefault clamps an arbitrary query value to a known pivot, defaulting to","// the first so a bad ?pivot= never yields an empty board.","func pivotOrDefault(p string) string {","\tif slices.Contains(boardPivots, p) {","\t\treturn p","\treturn boardPivots[0]","// boardColumns buckets beads into the pivot's columns: the seeded columns first","// (in order), then any unseeded value bd reports, appended. Every bead lands in","// exactly one column. pivot must be a known field (callers pass pivotOrDefault).","func boardColumns(pivot string, beads []strand.Bead) []boardColumn {","\tfield := pivotByName(pivot)","\tcols := append([]boardColumn(nil), field.Seeds...)","\tidx := make(map[string]int, len(cols))","\tfor i := range cols {","\t\tidx[cols[i].Key] = i","\tfor i := range beads {","\t\tkey := field.value(&beads[i])","\t\tcol, ok := idx[key]","\t\tif !ok {","\t\t\tcol = len(cols)","\t\t\tcols = append(cols, boardColumn{Key: key, Label: key})","\t\t\tidx[key] = col","\t\tcols[col].Beads = append(cols[col].Beads, beads[i])","\treturn cols","// pivotByName returns the field for a known pivot name. Callers gate on","// pivotOrDefault, so an unknown name (only from a bad caller) falls back to the","// first field rather than a zero value with a nil reader.","func pivotByName(name string) pivotField {","\t\tif pivotFields[i].Name == name {","\t\t\treturn pivotFields[i]","\treturn pivotFields[0]","// handleMove writes the pivot field of a dragged card (SortableJS onEnd posts","// field+value) through the same Update path the drawer edits use, then returns the","// refreshed card so the board shows bd's truth. A write error renders the error","// fragment at a non-2xx status, which the client reads as the signal to revert the","// card to its old column (spec R0 V2: optimistic move, revert on error).","func (s *Server) handleMove(w http.ResponseWriter, r *http.Request) {","\t\ts.renderError(w, errNoRepo)","\tid := r.PathValue(\"id\")","\tissue, err := src.Update(ctx, id, r.FormValue(\"field\"), r.FormValue(\"value\"))","\t\ts.renderError(w, wrapWrite(\"move\", err))","\ts.refreshCounts(repo) // st-2fy.4 — keep counts.json current with this write","\tif issue == nil { // bd wrote silently; re-read so the card reflects the change","\t\tif issue, err = src.Show(ctx, id); err != nil {","\tb := strand.NewBead(issue)","\tb.ResolveJTBD(issue.Description, jtbd.Load(repo.Path))","\t// Recompute the moved card's attention flags (st-03i). markAttention runs only on","\t// the full /board render, so this single-card refresh would otherwise drop the ◆","\t// waiting badge and Blocked state until the next full board load. Best-effort: a","\t// read error degrades to the unflagged card rather than failing the move — the","\t// write already landed, and a non-2xx here would wrongly tell the client to revert","\t// a change bd has already stored.","\tif issues, lerr := src.List(ctx, bd.ListOpts{}); lerr != nil {","\t\tlog.Printf(\"strand: move %s attention recompute skipped: %v\", id, lerr)","\t} else {","\t\tscope := []strand.Bead{b}","\t\tif aerr := s.markAttention(ctx, src, scope, issues); aerr != nil {","\t\t\tlog.Printf(\"strand: move %s attention recompute skipped: %v\", id, aerr)","\t\t\tb = scope[0]","\ts.render(w, \"boardCard\", b)","// handleRank persists a drag-to-reorder of the V1 bead list. SortableJS posts only","// the post-drop order (comma-separated ids of the affected story group); the server","// is authoritative — it re-reads ranks from bd, computes the minimal write, and","// stores it back as bd metadata (D5). The client keeps its optimistic DOM, so on","// success the response is 204 (no swap, no Sortable re-init churn); a write error","// renders the error fragment at a non-2xx status, the client's revert signal.","// Two write paths preserve the pure-rank-after-seed invariant (strand.SortBeads):","// a group with no manual rank yet is seeded with dense ranks 1..N over the new","// order; an already-ranked group moves one bead to the midpoint of its new","// neighbors (or just past an edge), renormalizing the whole group only when float","// space between neighbors is exhausted.","func (s *Server) handleRank(w http.ResponseWriter, r *http.Request) {","\torder := splitIDs(r.FormValue(\"order\"))","\tif len(order) <= 1 {","\t\tw.WriteHeader(http.StatusNoContent) // nothing to order","\tranks, present, allRanked := groupRanks(f, order)","\t// A wholly-ranked group with a representable gap moves the one dragged bead with a","\t// single SetRank and returns. Every other case — an unseeded group, or a move that","\t// exhausts the midpoint gap (renorm) — falls through to the shared seed-and-204","\t// tail, which reseeds dense ranks 1..M over the live ids.","\tif allRanked {","\t\tmoved := movedID(order, ranks)","\t\tnewRank, renorm := rankFor(order, ranks, moved)","\t\tif !renorm {","\t\t\tif _, err := src.SetRank(ctx, moved, newRank); err != nil {","\t\t\t\ts.renderError(w, wrapWrite(\"rank\", err))","\t\t\t\treturn","\t\t\tw.WriteHeader(http.StatusNoContent)","\tif err := seedRanks(ctx, src, order, present); err != nil {","\t\ts.renderError(w, err) // seedRanks already wraps with wrapWrite","// insightsView wraps the scope chrome (so the fragment reuses the list/board","// head) with the computed dashboard. The analytics math lives in internal/insight;","// this view-DTO pairs the scope chrome with the domain model the template binds.","type insightsView struct {","\tInsights insight.Model","// handleInsights renders the V4 dashboard for the active scope (an epic or one","// story), mirroring handleBoard. No repo or an empty scope renders the same empty","// pane the other views use. It lists once and reuses the issues for both the strand","// (scope) and the metric/triage computation.","func (s *Server) handleInsights(w http.ResponseWriter, r *http.Request) {","\t\ts.render(w, \"insights\", insightsView{})","\tmodel, err := s.insightsModel(ctx, src, &view, issues)","\ts.render(w, \"insights\", insightsView{listView: view, Insights: model})","// insightsModel computes the dashboard for a scope. issues is the full repo list","// (for labels and timestamps the strand drops); the scope's beads come from the","// view. It fetches the scope's dependency edges, then hands the plain data to","// internal/insight — the analytics seam that owns the triage/leaderboard/graph","// math, so the server stays transport-only and no longer depends on the graph","// package directly (insight is its sole importer now).","func (s *Server) insightsModel(ctx context.Context, src readSource, v *listView, issues []bd.Issue) (insight.Model, error) {","\t// Epics are containers, not actionable work: the dashboard is about the queue","\t// and the structure of real tasks, so it drops them.","\tbeads := insight.Actionable(scopeBeads(v))","\tvar deps []bd.DepEdge","\tif len(beads) > 0 {","\t\tids := make([]string, len(beads))","\t\tfor i := range beads {","\t\t\tids[i] = beads[i].ID","\t\tvar err error","\t\tif deps, err = src.Deps(ctx, ids...); err != nil {","\t\t\treturn insight.Model{}, fmt.Errorf(\"insights deps: %w\", err)","\treturn insight.Compute(beads, issues, deps, s.now()), nil","// drawerData is the detail panel: a bead, its comments, and an optional write","// error. Embedding promotes the issue's fields, so the template reads .Title etc.","// directly; .Err carries a bd write failure to show inline (spec Q2).","// Priority shadows the embedded *bd.Issue.Priority (now *int) with the render-side","// int the priority