phenom/HarborFork
1
0 Fork 0
forked from Keelrleek/Harbor
Code Pull Requests Activity

Harbor as of 2026-10-05: the coordination hub for the Open Sea's decomp team

Browse Source 
Messages, threads, acknowledgements, claims, bands, tasks, review items and
stop flags for a team of AI agents; the chat page and board; host hooks and
MCP server; autopilot; tools/watch.py. Put under version control after the
weekend's changes so they have history and can be rolled back. Local only.
This commit is contained in:
KeelrLeek committed 2026-10-05 10:44:23 -05:00
commit dbfd1720c5
43 files changed
+12440
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tests/test_work.py
+224
View File
@@ -0,0 +1,224 @@
"""Tasks, handoffs, pins, the human's availability, corrections, due times, search filters, connections, doctor."""
import json
import os
import re
import shutil
import unittest
from helpers import HarborCase, make_home, temp_dir
from harbor import doctor, install
from harbor.core import Harbor, HarborError
class Tasks(HarborCase):
def test_next_takes_by_priority_and_dependencies(self):
low = self.h.add_task("Claude", "tidy names", priority="low")
first = self.h.add_task("Claude", "make 0x445310 readable", scope="fn:0x445310", priority="high")
after = self.h.add_task("Claude", "make its caller readable", scope="fn:0x445400", priority="urgent",
after=[first["id"]])
self.assertEqual(after["waiting_on"], [first["id"]])
took = self.h.next_task("DeepSeek")
self.assertEqual((took["id"], took["state"], took["assignee"]), (first["id"], "in_progress", "DeepSeek"))
self.assertEqual(self.h.active_claims(agent="DeepSeek")[0]["scope"], "fn:0x445310")
self.assertIn(f"task #{first['id']}", next(a for a in self.h.agents() if a["name"] == "DeepSeek")["doing"])
self.assertEqual(self.h.next_task("Codex")["id"], low["id"]) # the urgent one still waits
with self.assertRaises(HarborError):
self.h.take_task("OpenCode", after["id"])
self.h.update_task("DeepSeek", first["id"], "done", note="landed in abc")
self.assertEqual(self.h.active_claims(agent="DeepSeek"), []) # claim released
self.assertIsNone(next(a for a in self.h.agents() if a["name"] == "DeepSeek")["doing"])
self.assertEqual(self.h.next_task("OpenCode")["id"], after["id"])
self.assertIn("is done", self.h.inbox("Claude")[-1]["body"]) # the creator hears about it
def test_claims_and_bands_steer_next(self):
self.h.claim("Claude", "range:0x440000-0x47FFFF", kind="band", on_behalf_of="DeepSeek")
inside = self.h.add_task("Claude", "inside DeepSeek's band", scope="fn:0x450000")
held = self.h.add_task("Claude", "already drafted", scope="fn:0x490000")
self.h.claim("OpenCode", "fn:0x490000")
self.assertIsNone(self.h.next_task("Codex"))
self.assertEqual(self.h.next_task("DeepSeek")["id"], inside["id"])
self.assertEqual(self.h.next_task("OpenCode", take=False)["id"], held["id"])
assigned = self.h.add_task("Claude", "for Codex inside the band", scope="fn:0x451000", assignee="Codex")
self.assertEqual(self.h.next_task("Codex")["id"], assigned["id"]) # explicit assignment wins
self.assertEqual(self.h.inbox("Codex")[-1]["refs"]["task"], assigned["id"])
self.h.update_task("Codex", assigned["id"], "open", note="later") # handed back for now
self.assertEqual(self.h.task(assigned["id"])[0]["assignee"], "Codex") # still the coordinator's choice
self.assertEqual(self.h.next_task("Codex", take=False)["id"], assigned["id"])
def test_permissions_block_release_cancel(self):
with self.assertRaises(HarborError):
self.h.add_task("Codex", "for someone else", assignee="Kimi")
mine = self.h.add_task("Codex", "my own", assignee="Codex")
self.h.take_task("Codex", mine["id"])
with self.assertRaises(HarborError):
self.h.update_task("Codex", mine["id"], "blocked") # say why
with self.assertRaises(HarborError):
self.h.update_task("Kimi", mine["id"], "done")
self.h.update_task("Codex", mine["id"], "blocked", note="needs 0x4E2680 named first")
self.assertTrue(any(a["kind"] == "task_blocked" for a in self.h.attention()))
self.assertIn("blocked", self.h.inbox("Claude")[-1]["body"])
self.h.update_task("Codex", mine["id"], "open")
self.assertIsNone(self.h.task(mine["id"])[0]["assignee"]) # handed back
self.h.update_task("Claude", mine["id"], "cancelled", note="no longer needed")
self.h.update_task("Codex", mine["id"], "open") # the creator may reopen
with self.assertRaises(HarborError):
self.h.update_task("Codex", mine["id"], "review")
web = self.h.add_task("User", "from the board", origin="web", priority="urgent")
self.assertEqual(web["created_by"], "User")
with self.assertRaises(HarborError):
self.h.add_task("User", "pretend", origin="cli")
def test_review_items_drive_their_task(self):
task = self.h.next_task("DeepSeek") if False else self.h.add_task("Claude", "make 0x445310 readable",
scope="fn:0x445310")
self.h.take_task("DeepSeek", task["id"])
item = self.h.submit("DeepSeek", "RouteCellCost readable", commit="abc1234", task=task["id"])
self.assertEqual(self.h.task(task["id"])[0]["state"], "review")
self.assertEqual(self.h.item(item["id"])[0]["scope"], "fn:0x445310") # scope comes from the task
self.h.transition("Claude", item["id"], "changes_requested", note="signed read")
self.assertEqual(self.h.task(task["id"])[0]["state"], "in_progress")
self.h.transition("DeepSeek", item["id"], "submitted", commit="def5678")
self.assertEqual(self.h.task(task["id"])[0]["state"], "review")
self.h.transition("Claude", item["id"], "approved")
self.h.transition("Claude", item["id"], "landed", commit="b4b44f0")
done = self.h.task(task["id"])[0]
self.assertEqual((done["state"], done["item_id"]), ("done", item["id"]))
self.assertEqual(self.h.active_claims(agent="DeepSeek"), [])
with self.assertRaises(HarborError):
self.h.submit("Codex", "not mine", task=task["id"])
class Continuity(HarborCase):
def test_handoff_brief_and_restart_prompt(self):
with self.assertRaises(HarborError):
self.h.handoff("Kimi", " ")
self.h.handoff("Kimi", "Reviewed batch 48.\nIn flight: 0x406F60 VisitTavern, half the strings checked.\nNext: batch 49.")
brief = self.h.brief("Kimi")
self.assertIn("Your last handoff", brief)
self.assertIn("In flight: 0x406F60", brief)
self.h.add_task("Claude", "review 0x406F60", scope="fn:0x406F60", assignee="Kimi")
prompt = self.h.restart_prompt("Kimi")
for part in ("You are Kimi", "Team coordination (Harbor)", "Your tasks", "In flight: 0x406F60", "--as Kimi brief"):
self.assertIn(part, prompt)
self.h.set_flag("stop:Kimi", "on", "Claude", "cli")
self.assertIn("STOPPED", self.h.restart_prompt("Kimi"))
self.assertNotIn("Your last handoff", self.h.brief("Kimi")) # stopped: no nudge to continue
def test_pins_and_decisions(self):
rule = self.h.send("Claude", "All", "Main-thread float math is single precision.", kind="decision")
self.h.pin("Codex", rule["id"], note="single precision rule")
self.assertIn("single precision rule", self.h.brief("Kimi"))
self.assertEqual([m["id"] for m in self.h.decisions()], [rule["id"]])
self.h.unpin("Kimi", rule["id"])
self.assertEqual(self.h.pins(), [])
with self.assertRaises(HarborError):
self.h.pin("Kimi", 99999)
def test_human_availability(self):
with self.assertRaises(HarborError):
self.h.set_presence("User", "cli", "away")
with self.assertRaises(HarborError):
self.h.set_presence("Codex", "web", "away")
self.h.set_presence("User", "web", "away", until="2h", note="decide with Claude")
self.assertIn("User is away until", self.h.brief("Codex"))
question = self.h.send("Codex", ["User"], "Should I rename 0x445310?")
self.assertTrue(any(a["kind"] == "human_away" and a["message_id"] == question["id"] for a in self.h.attention()))
self.clock.t += 3 * 3600
self.assertEqual(self.h.presence()["status"], "here") # the away time ran out
self.assertNotIn("is away", self.h.brief("Codex"))
class Messages(HarborCase):
def test_corrections(self):
wrong = self.h.send("Codex", ["DeepSeek", "Kimi"], "0x445310 uses a signed read", thread="fn:0x445310")
fix = self.h.send("Codex", None, "It is unsigned (movzx), not signed.", corrects=wrong["id"])
self.assertEqual((fix["thread_id"], sorted(fix["targets"])), (wrong["thread_id"], ["DeepSeek", "Kimi"]))
self.assertEqual(self.h.message(fix["id"])["kind"], "retraction")
self.assertEqual(self.h.corrections_for([wrong["id"]]), {wrong["id"]: [fix["id"]]})
self.assertIn(f"corrects #{wrong['id']}", self.mirror.read_text(encoding="utf-8"))
with self.assertRaises(HarborError):
self.h.send("Kimi", None, "not yours", corrects=wrong["id"])
self.assertTrue(self.h.send("Claude", None, "coordinator correction", corrects=wrong["id"])["id"])
def test_due_times(self):
q = self.h.send("Claude", ["Kimi"], "Is 0x406F60 exact?", due="30m")
self.assertIn("Answers due from you", self.h.brief("Kimi"))
self.assertFalse(any(a["kind"] == "due_overdue" for a in self.h.attention()))
self.clock.t += 3600
self.assertTrue(any(a["kind"] == "due_overdue" and a["message_id"] == q["id"] for a in self.h.attention()))
self.h.ack("Kimi", [q["id"]], note="yes, exact")
self.assertFalse(any(a["kind"] == "due_overdue" for a in self.h.attention()))
with self.assertRaises(HarborError):
self.h.send("Claude", ["Kimi"], "x", due="whenever")
def test_search_filters_and_paging(self):
self.h.send("Codex", "All", "LayoutTextMesh glyph key", thread="fn:0x50A720")
self.h.send("Kimi", ["Claude"], "LayoutTextMesh reviewed", kind="decision")
self.h.send("Kimi", ["Codex"], "unrelated words")
self.assertEqual(len(self.h.search("LayoutTextMesh")), 2)
self.assertEqual([m["sender"] for m in self.h.search("LayoutTextMesh from:kimi")], ["Kimi"])
self.assertEqual(len(self.h.search("kind:decision")), 1)
self.assertEqual(len(self.h.search("thread:fn:0x50A720")), 1)
self.assertEqual(len(self.h.search("to:Codex")), 1) # not its own broadcast
self.assertEqual(len(self.h.search("since:1h LayoutTextMesh")), 2)
ids = [m["id"] for m in self.h.recent(10)]
self.assertEqual([m["id"] for m in self.h.messages_before(ids[-1], limit=1)], [ids[-2]])
def test_connections_and_activity(self):
self.h.connect("Codex", "mcp", "codex")
self.h.activity("Codex", "shell", "codex")
links = {(r["channel"], r["host"]) for r in self.h.connections()["Codex"]}
self.assertEqual(links, {("mcp", "codex"), ("hook", "codex")})
codex = next(a for a in self.h.agents() if a["name"] == "Codex")
self.assertTrue(self.h.working(codex))
self.assertEqual(codex["last_tool"], "shell")
self.clock.t += 600
self.assertFalse(self.h.working(next(a for a in self.h.agents() if a["name"] == "Codex")))
def test_opening_twice_does_not_rewrite(self):
before = self.h.conn.execute("SELECT value FROM meta WHERE key='signature'").fetchone()["value"]
again = Harbor(self.project, clock=self.clock)
self.assertEqual(again.conn.execute("SELECT value FROM meta WHERE key='signature'").fetchone()["value"], before)
again.close()
class Doctor(unittest.TestCase):
def test_reports_hosts_and_live_connections(self):
d = temp_dir()
home = d / "user"
(home / ".codex").mkdir(parents=True)
(home / ".codex" / "config.toml").write_text('model = "x"\n', encoding="utf-8")
harbor_home = d / "harbor-home"
project = make_home(harbor_home)["test"]
text = project.source.read_text(encoding="utf-8").replace('name = "Codex"\n', 'name = "Codex"\nhost = "codex"\n')
project.source.write_text(text, encoding="utf-8")
saved = {k: os.environ.get(k) for k in ("HARBOR_INSTALL_HOME", "HARBOR_HOME", "HARBOR_PROJECT")}
os.environ.update(HARBOR_INSTALL_HOME=str(home), HARBOR_HOME=str(harbor_home))
os.environ.pop("HARBOR_PROJECT", None)
try:
from harbor import projects
project = projects.load_named("test")
h = Harbor(project)
before = {(c["area"], c["check"]): c["status"] for c in doctor.run(project, h, port=8797)}
self.assertEqual(before[("Codex", "MCP server")], "fail")
self.assertEqual(before[("Database", "integrity")], "ok")
self.assertEqual(before[("Server", "http://127.0.0.1:8797")], "warn")
install.install("codex", python="py -3.12")
h.connect("Codex", "mcp", "codex")
after = {(c["area"], c["check"]): c["status"] for c in doctor.run(project, h, port=8797)}
self.assertEqual((after[("Codex", "MCP server")], after[("Codex", "hooks")]), ("ok", "ok"))
self.assertEqual(after[("Codex", "hooks trusted")], "warn")
self.assertEqual(after[("Codex", "live connection")], "ok")
self.assertIn("FAIL", doctor.render(doctor.run(project, h, port=8797)) + "FAIL")
h.close()
finally:
for k, v in saved.items():
if v is None:
os.environ.pop(k, None)
else:
os.environ[k] = v
shutil.rmtree(d, ignore_errors=True)
if __name__ == "__main__":
unittest.main()