建造虛擬團隊系統

core/scripts/board_announce.py

def announce_claim(task_id):
    root = board_root(ROOT)
    tasks, errors = scan_tasks(root)
    task = next((t for t in tasks if t["id"] == task_id), None)
    if task is None:
        detail = "; ".join(errors) if errors else "no such live task"
        raise SystemExit(f"board-announce: {task_id}: {detail}")
    if not task["branch"]:
        raise SystemExit(f"board-announce: {task_id} has no branch recorded yet "
                         f"-- claim it (write branch + commit + push) before announcing")
    return (f"board claim {task_id}: branch {task['branch']}, "
            f"territory {territory_of(root, task)!r}, {checkout_location()}")

core/scripts/board_add.py

def allocate(prefix, trunks, tasks):
    """Return (id, trunk name) and bump the trunk's counter, under a file lock.

    Everything happens inside the lock, and the counter is only written once the
    id is known to be free, so a collision leaves the counter untouched instead
    of burning a number.
    """
    with trunks.open("r+", encoding="utf-8") as fh:
        fcntl.flock(fh, fcntl.LOCK_EX)
        lines = fh.read().splitlines(keepends=True)
        rows = [(i, m) for i, line in enumerate(lines)
                if (m := ROW_ANY.match(line)) and m.group("prefix") == prefix]
        if not rows:
            raise SystemExit(f"prefix '{prefix}' is not a trunk in {trunks}")
        if len(rows) > 1:
            raise SystemExit(f"prefix '{prefix}' has {len(rows)} rows in {trunks}, "
                             f"so the counter to bump is ambiguous; leave one")
        i, m = rows[0]
        raw = m.group("next")
        counter = raw.strip()
        if not counter.isdigit():
            raise SystemExit(f"trunk '{prefix}' in {trunks} has no usable next "
                             f"counter (found '{counter}'); set it to the number "
                             f"after the highest id that trunk has ever used")
        number = int(counter)
        task_id = f"{prefix}-{number:02d}"
        if (tasks / f"{task_id}.md").exists():
            raise SystemExit(f"{tasks / f'{task_id}.md'} already exists, so the "
                             f"next counter for '{prefix}' is behind reality; "
                             f"raise it past every id this trunk has used")
        lines[i] = line_with(lines[i], m, number + 1)
        fh.seek(0)
        fh.writelines(lines)
        fh.truncate()
        fh.flush()
        return task_id, m.group("trunk").strip()

core/scripts/board_doctor.py

        elif status in FINISHED_STATUSES:
            # [... 18 comment lines omitted ...]
            if status == "done" and not t["output"]:
                problems.append(f"{t['id']}: done but no output link")
            # [... a second problems.append omitted: it reports "<status> and still on the board" and asks to prune the file ...]

core/rules/review.md

4. One mechanical exception for a merge of main, all three conditions being
   commands rather than judgements: `git diff origin/main...HEAD` is character
   for character what it was at the end of the last round to run, whichever
   stage it belonged to; gates are still clean on the merged branch; the
   test suite's full suite tier (`core/rules/testing.md`) still passes on
   the merged branch. Fail any one and the merge
   restarts the round at adversarial.
[... rules 5 to 6 omitted ...]
7. Every candidate issue a reader raises is classified before it is reported,
   and the classification decides what it is allowed to do.
   1. **Finding**: names the specific clause of the architecture contract it
      violates, or shows an already-authorized behavior failing on a
      concrete path, with evidence: a file, a rule interaction, a repro, a
      test. A finding can block the stage that raised it and is fixed inside
      the task under rule 12.
   2. **Observation**: violates no frozen invariant. A different design, a
      capability the contract did not ask for, a wider interface, a style
      preference. An observation never blocks a stage from ending, never
      authorizes a change on its own, and is never filed as a new board task
      by the round that raised it (rule 13 already covers filing in
      general). It is recorded in the observation ledger on the task
      register:
   [... the observation ledger format and the rest of rule 7 omitted ...]