feat(orchestrator)!: S0 English everywhere, Sécurité, NATO hashes, ICAO digits

Requirement 001 phase 6, S0:

- Speech: the security class shows as "Sécurité" and is spoken as in
  maritime radio, "say-cure-ee-tay" three times. A hex run of 7 or more
  characters with a letter and a digit (commit, session, message ids) is
  spelled in the NATO alphabet; every other digit is spoken on its own
  in ICAO pronunciation (42305: four two tree zero fife). The spelling
  runs inside clip() before the length cut, so a phrase still fits
  SPEECH_LIMIT; the displayed text keeps its digits and hashes.
- English: every orchestrator label, tooltip, message, error, script
  output, document and test string is English (Regeln -> Firewall,
  Hierarchie -> Hierarchy, Steuerung -> Controls, Ausführen -> Run, ...);
  the page declares lang="en" and formats dates as en-GB. Task filter
  ids are English. German stays only in the skill trigger phrases that
  quote the operator, and as identifiers: the view keys (view=) and the
  leitstand id.
- tests/test_english.py scans every tracked text file for umlauts and
  German words, with an allowlist of the quoted trigger phrases.

BREAKING CHANGE: the Stream search tokens art: and seit: are now kind:
and since:; an old art: or seit: token counts as a plain word.

Evidence: make test 657 OK, ruff and markdownlint clean
(/tmp/s0-make-test-1.log); e2e 17 OK, none skipped (/tmp/s0-e2e-1.log);
MEDUSA 86 files, 24 findings on reworded strings accepted after an
independent skeptic (21 path:line, 0 rejected, no behaviour change in
signing, approving, rules, denying, offices, events), rescan 0 open.

🎯 Fix: 93 %
💥 Break: 4 %
💸 Cost: 100 %
⏱️ Time: –
🛡️ Security: 100 %
🏆 Score: 89
🚦 Gate: ✅ 90/5, cost and time <= 100, security 100 %

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Kevin Veen-BirkenbachandClaude Opus 5.5 committed 2026-11-08 17:26:51 +00:00
1 parent a388c6ef77
commit c035373518
86 files changed
+1027 -930

No files matched your search

+11 -11
View File
@@ -81,7 +81,7 @@ class Approving:
try:
verifier.check(proof, item, "", trust, time.time())
except signing.Refused as error:
raise ToolError(f"nicht signiert: {error}") from None
raise ToolError(f"not signed: {error}") from None
return proof
def still_signed(self, proof: dict, item: dict) -> None:
@@ -94,7 +94,7 @@ class Approving:
raise signing.Refused("the signature does not list this item")
passkey.verify_assertion(proof["assertion"], proof["payload"], verifier.pinned(self.approvers), signing.origin_of(self.public_port))
except signing.Refused as error:
raise ToolError(f"nicht signiert: {error}") from None
raise ToolError(f"not signed: {error}") from None
def covered(self, proof: object, signed: list[dict], now: float) -> dict | None:
"""Args:
@@ -112,7 +112,7 @@ class Approving:
raise ToolError("proof must be null when no item needs a signature")
return None
if not isinstance(proof, dict):
raise ToolError("nicht signiert: an approval of an ask, review or operator command needs the passkey signature")
raise ToolError("not signed: an approval of an ask, review or operator command needs the passkey signature")
expect(proof, ("payload", "assertion"))
try:
payload = signing.checked_approval(proof["payload"], now)
@@ -136,15 +136,15 @@ class Approving:
item = {"kind": kind_name, "id": record["id"], "verb": "approve", "label": record.get("recommended", ""), "sha256": "", "title": shown(title)[:200], "gate": record.get("gate", ""), "signed": signed, "note": None}
batch = self.batches.add([item], f"rule:{rule['id']}", rule.get("proof"), self.apply)
words = f"{rule['kind']} {rule['tool']} {rule['pattern']}".replace(" ", " ")
self.log.add({"kind": "rule", "title": f"Regel gibt frei: {item['title']}", "text": words, "ref": {"rule": rule["id"], "batch": batch["id"], "item": item["id"]}})
self.log.add({"kind": "rule", "title": f"Rule grants: {item['title']}", "text": words, "ref": {"rule": rule["id"], "batch": batch["id"], "item": item["id"]}})
def apply(self, batch: dict) -> None:
for item in batch["items"]:
try:
outcome = self.settle_item(item, batch["proof"] if item["signed"] is not None else None)
except (OSError, ToolError) as error:
outcome = f"fehlgeschlagen: {error}"
verb = "Freigabe" if item["verb"] == "approve" else "Ablehnung"
outcome = f"failed: {error}"
verb = "Grant" if item["verb"] == "approve" else "Denial"
label = f" → {item['label']}" if item["label"] else ""
ref = {"kind": item["kind"], "id": item["id"], "verb": item["verb"], "source": batch["source"], "outcome": outcome}
self.log.add({"kind": "approval", "title": f"{verb} {item['kind']}: {item['title']}{label}", "text": f"{outcome} ({batch['source']})", "ref": ref})
@@ -158,15 +158,15 @@ class Approving:
if item["kind"] == "ask":
record = self.asks.get(item["id"])
if record is None or ask_state(record, time.time())["status"] == "expired":
return "abgelaufen"
return "expired"
record, changed = self.asks.decide(item["id"], {"status": "allowed" if approve else "denied", "proof": proof})
elif item["kind"] == "review":
record, changed = self.reviews.decide(item["id"], {"status": "approved" if approve else "rejected", "proof": proof})
else:
record, changed = self.decisions.decide(item["id"], {"status": "decided", "choice": item["label"]})
if record is None:
return "unbekannt"
return record["status"] if changed else f"schon {record['status']}"
return "unknown"
return record["status"] if changed else f"already {record['status']}"
def requester(self, raw: dict, who: str) -> str:
"""Returns:
@@ -216,7 +216,7 @@ class Approving:
raise ToolError("a decision is approved with one of its option labels")
label = raw["label"]
if kind_name == "rule":
return inbox_item(raw, "", f"Regel {request_words(record)}", "", request_signed(record), self.requester(raw, record["agent"]))
return inbox_item(raw, "", f"Rule {request_words(record)}", "", request_signed(record), self.requester(raw, record["agent"]))
title = {"review": record.get("title"), "ask": f"{record.get('tool')} {record.get('command')}", "decision": record.get("question")}[kind_name]
subject = {"review": review_signed, "ask": ask_signed}[kind_name](record) if kind_name != "decision" else None
return inbox_item(raw, label, title, record.get("gate", ""), subject, self.requester(raw, record["session"] if kind_name == "ask" else ""))
@@ -259,5 +259,5 @@ class Approving:
def undo(self, batch_id: str) -> dict:
batch = self.batches.undo(batch_id)
titles = ", ".join(item["title"][:80] for item in batch["items"])
self.log.add({"kind": "approval", "title": f"Rückgängig: {titles}", "text": batch["source"], "ref": {"batch": batch_id}})
self.log.add({"kind": "approval", "title": f"Undone: {titles}", "text": batch["source"], "ref": {"batch": batch_id}})
return {"id": batch_id, "status": "undone"}
+2 -2
View File
@@ -71,7 +71,7 @@ class Cleaning:
raise ToolError(f"items must be a list of 1 to {ITEM_LIMIT} objects")
scan = self.tree.get()
if scan.get("delete_ready") is not True:
raise ToolError(f"löschen gesperrt: {scan.get('delete_reason') or scan.get('error') or 'delete_ready ist false'}")
raise ToolError(f"delete blocked: {scan.get('delete_reason') or scan.get('error') or 'delete_ready is false'}")
known = offered(scan)
chosen = []
for entry in raw:
@@ -94,7 +94,7 @@ class Cleaning:
job = {"v": JOB_VERSION, "id": job_id, "created": stamp(), "items": [{key: item[key] for key in JOB_KEYS} for item in items], "proof": proof}
self.spool.put(job_id, job)
names = ", ".join(item["branch"] for item in items)
self.log.add({"kind": "run", "title": f"Löschen signiert: {names}"[:200], "text": "\n".join(f"{item['repository']} {item['branch']} @ {item['tip'][:12]}" for item in items), "ref": {"cleanup": job_id, "status": "queued"}})
self.log.add({"kind": "run", "title": f"Delete signed: {names}"[:200], "text": "\n".join(f"{item['repository']} {item['branch']} @ {item['tip'][:12]}" for item in items), "ref": {"cleanup": job_id, "status": "queued"}})
return {"id": job_id, "status": "queued", "items": job["items"]}
def cleanup_state(self, job_id: str) -> dict:
+2 -2
View File
@@ -9,7 +9,7 @@ from .records import epoch, read_json, shown
CRON_ACTIVE = 900
TIMER_KEYS = ("OnCalendar", "OnActiveSec", "OnBootSec", "OnStartupSec", "OnUnitActiveSec", "OnUnitInactiveSec")
CRON_LABELS = {"cron": "Cron", "wakeup": "Wakeup", "background": "Hintergrund", "timer": "Timer", "queue": "Queue"}
CRON_LABELS = {"cron": "Cron", "wakeup": "Wakeup", "background": "Background", "timer": "Timer", "queue": "Queue"}
def cron_state(cron: dict, beats: dict[str, float], now: float) -> dict:
@@ -59,7 +59,7 @@ def queue_entries(council: Path) -> list[tuple[dict, float]]:
def queue_rows(council: Path) -> list[dict]:
rows = []
for entry, created in queue_entries(council):
running = "läuft" if entry.get("status") == "active" else "wartet"
running = "running" if entry.get("status") == "active" else "waiting"
rows.append({
"key": f"queue:{shown(entry.get('id'))}", "type": "queue", "session": shown(entry.get("session")), "sub": "", "created": created,
"deleted": None, "until": None, "job": shown(entry.get("id")), "expression": f"{shown(entry.get('kind'))} · {running}",
+12 -12
View File
@@ -76,28 +76,28 @@ class Denying:
tasks = read_register(self.council / REGISTER)
row = next((row for row in operator_rows(tasks) if row["task"] == item["id"]), None)
if row is None or signing.denial_item(operator_signed(row), note["channel"], note["reason"], note["to"]) != item["signed"]:
return "verweigert: die Zeile hat sich seit der Ablehnung geändert"
return "refused: the row changed since the denial"
if item["id"] in self.open_jobs():
return "läuft schon"
return "already running"
run = self.scripts.run(RASCI, ["set", item["id"], "--status", "stopped"])
if run["code"] != 0:
return f"fehlgeschlagen: {run['command']} → {run['code']}"
return f"failed: {run['command']} → {run['code']}"
command, directory = row["command"][:200], row["directory"]
return f"gestoppt · {self.tell(item, proof, adder(tasks[item['id']]), f'operator command {command} in {directory}')}"
return f"stopped · {self.tell(item, proof, adder(tasks[item['id']]), f'operator command {command} in {directory}')}"
ledger = self.asks if item["kind"] == "ask" else self.rule_requests
record = ledger.get(item["id"])
if record is None:
return "unbekannt"
return "unknown"
now = time.time()
if (ask_state(record, now)["status"] if item["kind"] == "ask" else request_status(record, now)) == "expired":
return "abgelaufen"
return "expired"
record, changed = ledger.decide(item["id"], {"status": "denied", "proof": proof, **note})
if not changed:
return f"schon {record['status']}"
return f"already {record['status']}"
if item["kind"] == "ask":
tool, command = record["tool"], record["command"][:200]
return f"abgelehnt · {self.tell(item, proof, record['session'], f'ask {tool}: {command}')}"
return f"abgelehnt · {self.tell(item, proof, record['agent'], f'rule request {request_words(record)}')}"
return f"denied · {self.tell(item, proof, record['session'], f'ask {tool}: {command}')}"
return f"denied · {self.tell(item, proof, record['agent'], f'rule request {request_words(record)}')}"
def addressee(self, who: str) -> tuple[str, str]:
return requester_of(read_claims(self.council), who)
@@ -120,11 +120,11 @@ class Denying:
direct = channel in DIRECT
address = self.addressee(note["to"])[1] if direct else EVERYONE
if direct and not address:
return f"kein Empfänger für {channel}"
return f"no recipient for {channel}"
text = denial_text(what, self.addressee(who)[0], note["reason"])
where = f"{channel} an {address}" if direct else f"{channel} an alle"
where = f"{channel} to {address}" if direct else f"{channel} to all"
fields = {"to": note["to"], "address": address, "text": text, "upload": None, "voice": None, "voice_sha256": "", "class": channel}
record = self.messages.add({**fields, "denial": item["signed"], "proof": proof, "created_ts": time.time()})
targets = ["--to", address] if direct else []
run = self.scripts.run(RADIO, [*DENY_CHANNELS[channel], *targets, "--session", HUMAN, f"[kvb-orchestrator msg {record['id']}] {' '.join(text.split())}"])
return where if run["code"] == 0 else f"{where} fehlgeschlagen ({run['code']})"
return where if run["code"] == 0 else f"{where} failed ({run['code']})"
+17 -17
View File
@@ -17,18 +17,18 @@ from .register import status_of
from .transcripts import LOG_KEEP, STREAM_CUT, STREAM_KINDS
KINDS = (
("radio", "Funk"), ("review", "Reviews"), ("ask", "Asks"), ("decision", "Entscheidungen"), ("operator", "Operator"), ("register", "Register"),
("rename", "Namen"), ("cron", "Crons"), ("rule", "Regeln"), ("approval", "Freigaben"), ("run", "Runner"), ("transcript", "Transkripte"),
("radio", "Radio"), ("review", "Reviews"), ("ask", "Asks"), ("decision", "Decisions"), ("operator", "Operator"), ("register", "Register"),
("rename", "Names"), ("cron", "Crons"), ("rule", "Firewall"), ("approval", "Grants"), ("run", "Runner"), ("transcript", "Transcripts"),
)
EVENT_KINDS = tuple(name for name, _ in KINDS)
WORK = [name for name in EVENT_KINDS if name not in ("radio", "transcript")]
VIEWS = {
"fuer-dich": {"label": "Für dich", "kinds": ["radio", *WORK], "waiting": True},
"funk": {"label": "Funk", "kinds": ["radio"], "waiting": False},
"arbeit": {"label": "Arbeit", "kinds": WORK, "waiting": False},
"transkripte": {"label": "Transkripte", "kinds": ["transcript"], "waiting": False},
"fuer-dich": {"label": "For you", "kinds": ["radio", *WORK], "waiting": True},
"funk": {"label": "Radio", "kinds": ["radio"], "waiting": False},
"arbeit": {"label": "Work", "kinds": WORK, "waiting": False},
"transkripte": {"label": "Transcripts", "kinds": ["transcript"], "waiting": False},
}
ART = {word: name for name, label in KINDS for word in (name, label.lower())}
KIND_WORDS = {word: name for name, label in KINDS for word in (name, label.lower())}
SPAN = re.compile(r"(\d{1,4})([mhd])")
UNITS = {"m": 60, "h": 3600, "d": 86400}
@@ -44,14 +44,14 @@ def since_of(word: str, now: float) -> float:
try:
return datetime.datetime.fromisoformat(word).timestamp()
except ValueError:
raise ToolError("seit: takes 30m, 2h, 3d or a date like 2026-11-06 or 2026-11-06T08:30") from None
raise ToolError("since: takes 30m, 2h, 3d or a date like 2026-11-06 or 2026-11-06T08:30") from None
def search(text: str, now: float) -> dict:
"""Args:
text: the search line: words, `agent:<name>`, `art:<kind or label>`
and `seit:<span or date>`.
now: the clock `seit:` spans count back from.
text: the search line: words, `agent:<name>`, `kind:<kind or label>`
and `since:<span or date>`.
now: the clock `since:` spans count back from.
Returns:
The plain words as `q`, plus `agent`, `kinds` and `since` for each
@@ -60,16 +60,16 @@ def search(text: str, now: float) -> dict:
found: dict = {"q": []}
for word in text.split():
key, colon, value = word.partition(":")
if not colon or key not in ("agent", "art", "seit"):
if not colon or key not in ("agent", "kind", "since"):
found["q"].append(word)
elif not value:
raise ToolError(f"{key}: needs a value")
elif key == "agent":
found["agent"] = value
elif key == "art":
if value.lower() not in ART:
raise ToolError(f"art: takes one of {', '.join(EVENT_KINDS)}")
found.setdefault("kinds", set()).add(ART[value.lower()])
elif key == "kind":
if value.lower() not in KIND_WORDS:
raise ToolError(f"kind: takes one of {', '.join(EVENT_KINDS)}")
found.setdefault("kinds", set()).add(KIND_WORDS[value.lower()])
else:
found["since"] = since_of(value, now)
found["q"] = " ".join(found["q"]).lower()
@@ -128,7 +128,7 @@ def register_changes(before: dict[str, dict], after: dict[str, dict], now: float
continue
if old is None or new is None:
row = new if old is None else old
change = f"neu: {shown(row.get('title'))}" if old is None else "entfernt"
change = f"new: {shown(row.get('title'))}" if old is None else "removed"
else:
keys = sorted(key for key in set(old) | set(new) if old.get(key) != new.get(key))
change = "; ".join(f"{key}: {described(old.get(key))} → {described(new.get(key))}" for key in keys)
+3 -3
View File
@@ -54,12 +54,12 @@ class Jobs:
def queue_job(self, item: dict, proof: dict | None) -> str:
row = next((row for row in operator_rows(read_register(self.council / REGISTER)) if row["task"] == item["id"]), None)
if row is None or not runnable(row) or operator_signed(row) != item["signed"]:
return "verweigert: die Zeile hat sich seit der Freigabe geändert"
return "refused: the row changed since the grant"
if item["id"] in self.open_jobs():
return "läuft schon"
return "already running"
job = {"task": row["task"], "command": row["command"], "directory": row["directory"], "sha256": item["sha256"], "status": "queued", "proof": proof}
self.jobs.add({**job, "code": None, "output": "", "created_ts": time.time(), "started": None, "finished": None, "dismissed": False})
return "an den Runner übergeben"
return "handed to the runner"
def runner_jobs(self) -> dict:
return {"jobs": [runner_job(job) for job in self.jobs.listed() if job["status"] == "queued"]}
+7 -7
View File
@@ -87,36 +87,36 @@ def nl_action(raw: object, items: dict[str, dict], agents: list[str]) -> dict:
raise ToolError("that operator row holds no command to run")
chosen = [nl_item(item, "approve" if name == "approve" else "reject", item["recommended"] if item["kind"] == "decision" else "") for item in picked]
lines = [f"{item['kind']} {item['id']}: {item['command'] if item['kind'] == 'operator' else item['title']}" for item in picked]
verb = "Freigeben" if name == "approve" else "Ablehnen"
verb = "Grant" if name == "approve" else "Deny"
return {"name": name, "summary": f"{verb}:\n" + "\n".join(lines), "args": {"items": chosen}}
if name == "choose":
item = items.get(arguments["id"]) if isinstance(arguments["id"], str) else None
if item is None or item["kind"] != "decision" or arguments["label"] not in [option["label"] for option in item["options"]]:
raise ToolError("choose takes a decision id and one of its option labels")
return {"name": name, "summary": f"Entscheiden: {item['title']} → {arguments['label']}", "args": {"items": [nl_item(item, "approve", arguments["label"])]}}
return {"name": name, "summary": f"Decide: {item['title']} → {arguments['label']}", "args": {"items": [nl_item(item, "approve", arguments["label"])]}}
if name in ("snooze", "pin"):
picked = nl_ids(arguments, items)
hours = arguments.get("hours")
if name == "snooze" and (isinstance(hours, bool) or not isinstance(hours, int | float) or not 1 <= hours <= 192):
raise ToolError("hours must be between 1 and 192")
keys = [{"kind": item["kind"], "id": item["id"]} for item in picked]
words = f"Zurückstellen ({hours} h)" if name == "snooze" else "Anheften"
words = f"Snooze ({hours} h)" if name == "snooze" else "Pin"
return {"name": name, "summary": f"{words}: " + ", ".join(item["title"][:80] for item in picked), "args": {"keys": keys, "hours": hours}}
if name == "view":
if arguments["name"] not in VIEWS:
raise ToolError("unknown view")
return {"name": name, "summary": f"Ansicht: {VIEWS[arguments['name']]['label']}", "args": {"name": arguments["name"]}}
return {"name": name, "summary": f"View: {VIEWS[arguments['name']]['label']}", "args": {"name": arguments["name"]}}
if name == "open":
if arguments["view"] not in SCREENS:
raise ToolError("unknown screen")
return {"name": name, "summary": f"Öffnen: {arguments['view']}", "args": {"view": arguments["view"]}}
return {"name": name, "summary": f"Open: {arguments['view']}", "args": {"view": arguments["view"]}}
if name == "message":
text = message_text(arguments, "text")
if arguments["to"] not in agents:
raise ToolError("to must name a known agent")
return {"name": name, "summary": f"Funk an {arguments['to']}: {text}", "args": {"to": arguments["to"], "text": text}}
return {"name": name, "summary": f"Radio to {arguments['to']}: {text}", "args": {"to": arguments["to"], "text": text}}
query = bounded(arguments, "q", 200)
return {"name": name, "summary": f"Suchen: {query}", "args": {"q": query}}
return {"name": name, "summary": f"Search: {query}", "args": {"q": query}}
def nl_actions(reply: str, items: list[dict], agents: list[str]) -> dict:
+2 -2
View File
@@ -75,8 +75,8 @@ class Directory:
if begin <= after["first_seen"] <= end:
found.append(event({
"id": f"rename:{session}:{after['first_seen']}", "ts": after["first_seen"], "kind": "rename", "agent": after["name"],
"now": self.now(session), "session": session, "title": f"{before['name']} heißt jetzt {after['name']}",
"text": f"Quelle: {after['source']}", "ref": {"before": before["name"], "after": after["name"], "source": after["source"]},
"now": self.now(session), "session": session, "title": f"{before['name']} is now called {after['name']}",
"text": f"Source: {after['source']}", "ref": {"before": before["name"], "after": after["name"], "source": after["source"]},
}))
return found
+2 -2
View File
@@ -11,7 +11,7 @@ from .signed import signing
ITEM_LIMIT = 20
JOB_VERSION = 1
LABELS = {"appoint": "besetzt", "takeover": "übergeben", "recall": "abberufen"}
LABELS = {"appoint": "appointed", "takeover": "handed over", "recall": "recalled"}
def office_request(raw: object) -> bool:
@@ -77,7 +77,7 @@ class Offices:
self.office_spool.put(job_id, job)
names = ", ".join(f"{item['office']} {LABELS[item['action']]}" for item in items)
lines = "\n".join(f"{item['action']} {item['office']}: {item['holder'] or '-'} -> {item['session'] or '-'}" for item in items)
self.log.add({"kind": "run", "title": f"Amt signiert: {names}"[:200], "text": lines, "ref": {"offices": job_id, "status": "queued"}})
self.log.add({"kind": "run", "title": f"Office signed: {names}"[:200], "text": lines, "ref": {"offices": job_id, "status": "queued"}})
return {"id": job_id, "status": "queued", "items": job["items"]}
def office_state(self, job_id: str) -> dict:
+24 -2
View File
@@ -8,16 +8,38 @@ SPEECH_LIMIT = 1000
SPOKEN_TEXT = 500
SPOKEN_NAME = 60
SPOKEN_GROUP = 120
ALARM_WORDS = {"pan-pan": "PAN-PAN", "security": "SECURITE"}
ALARM_WORDS = {"pan-pan": "PAN-PAN", "security": "say-cure-ee-tay"}
ADDRESSED = ("post", "call", "receipt")
CALLS = re.compile(r"^(?:(?:MAYDAY|PAN[ -]?PAN|SECURIT[EÉY])\b[\s:,.;!-]*)+", re.IGNORECASE)
HUB_MARK = re.compile(r"\[kvb-orchestrator msg [0-9a-f]{16}\]")
HUB_FILE = re.compile(r"\s+file: /\S*$")
SPOKEN_LINE = re.compile(LINE.format(SPEECH_LIMIT))
HASH = re.compile(r"\b(?=[0-9a-f]*[a-f])(?=[0-9a-f]*[0-9])[0-9a-f]{7,}\b|[0-9]", re.IGNORECASE)
NATO = dict(zip("abcdef", ("alfa", "bravo", "charlie", "delta", "echo", "foxtrot")))
ICAO = dict(zip("0123456789", ("zero", "one", "two", "tree", "four", "fife", "six", "seven", "eight", "niner")))
def pronounced(text: str) -> str:
"""Args:
text: a radio text as displayed.
Returns:
The text with each hex run of 7 or more characters holding a letter
and a digit spelled in the NATO alphabet and every other digit
spoken on its own in ICAO pronunciation.
"""
return HASH.sub(spelled, text)
def spelled(found: re.Match) -> str:
start, end = found.span()
before = " " if start and found.string[start - 1].isalnum() else ""
after = " " if end < len(found.string) and found.string[end].isalnum() else ""
return before + " ".join(NATO.get(char) or ICAO[char] for char in found[0].lower()) + after
def clip(text: str, limit: int) -> str:
words = " ".join(text.split())
words = " ".join(pronounced(text).split())
if len(words) <= limit:
return words
return words[:limit].rsplit(" ", 1)[0] or words[:limit]
+3 -3
View File
@@ -49,7 +49,7 @@ class Requesting:
raise ToolError(f"{name} already has {AGENT_CAP} pending rule requests; wait for their answer with rule_request_wait")
record = self.rule_requests.add_checked({**fields, "agent": name, "why": why, "status": "pending", "rule": None, "reason": "", "channel": "", "proof": None, "decided": None, "created_ts": now}, capped)
self.log.add({"kind": "rule", "title": f"Regelwunsch von {name}: {request_words(record)}", "text": why, "ref": {"request": record["id"]}})
self.log.add({"kind": "rule", "title": f"Rule request from {name}: {request_words(record)}", "text": why, "ref": {"request": record["id"]}})
return {"id": record["id"], "status": record["status"], "url": self.url()}
def rule_request_wait(self, arguments: dict) -> dict:
@@ -78,7 +78,7 @@ class Requesting:
items = []
for record in self.open_requests(now):
rule = {key: record[key] for key in RULE_FIELDS}
fields = {"title": f"Regel: {request_words(record)}", "agent": record["agent"], "to": requester_of(claims, record["agent"])[0], "detail": record["why"], "rule": rule, "dry_run": self.dry_run(record, now), "deniable": True}
fields = {"title": f"Rule: {request_words(record)}", "agent": record["agent"], "to": requester_of(claims, record["agent"])[0], "detail": record["why"], "rule": rule, "dry_run": self.dry_run(record, now), "deniable": True}
items.append({**base, "kind": "rule", "id": record["id"], "ts": record["created_ts"], **fields})
return items
@@ -113,5 +113,5 @@ class Requesting:
if not changed:
raise Conflict(request_state(decided, now))
self.store_rule(rule, fields, proof, True, now)
self.log.add({"kind": "rule", "title": f"Regelwunsch angenommen: {request_words(record)}", "text": f"von {record['agent']}", "ref": {"request": request_id, "rule": rule["id"]}})
self.log.add({"kind": "rule", "title": f"Rule request accepted: {request_words(record)}", "text": f"from {record['agent']}", "ref": {"request": request_id, "rule": rule["id"]}})
return request_state(decided, now)
+1 -1
View File
@@ -72,7 +72,7 @@ class Rules:
try:
passkey.verify_assertion(assertion, rule, verifier.pinned(self.approvers), signing.origin_of(self.public_port))
except signing.Refused as error:
raise ToolError(f"nicht signiert: {error}") from None
raise ToolError(f"not signed: {error}") from None
return {"payload": rule, "assertion": assertion}
def store_rule(self, rule: dict, fields: dict, proof: dict, enabled: bool, now: float) -> dict:
+1 -1
View File
@@ -66,5 +66,5 @@ class Tasking:
fields = {"kind": TASK_JOB, "task": item["id"], "argv": item["argv"], "command": shown_command(item["argv"]), "directory": "", "sha256": "", "status": "queued", "proof": proof}
ids.append(self.jobs.add({**fields, "code": None, "output": "", "created_ts": time.time(), "started": None, "finished": None})["id"])
commands = [shown_command(item["argv"]) for item in items]
self.log.add({"kind": "run", "title": f"Aufgabe signiert geändert: {', '.join(item['id'] for item in items)}"[:200], "text": "\n".join(commands), "ref": {"jobs": ids, "status": "queued"}})
self.log.add({"kind": "run", "title": f"Task change signed: {', '.join(item['id'] for item in items)}"[:200], "text": "\n".join(commands), "ref": {"jobs": ids, "status": "queued"}})
return {"jobs": ids, "status": "queued"}
+1 -1
View File
@@ -53,7 +53,7 @@ class Timeline:
rows = []
for index, row in enumerate(radio_rows(radio, begin, end)):
alarm = row["class"] in ("mayday", "pan-pan") and row["ts"] >= end - MAYDAY_ACTIVE
title = f"{row['from'] or '?'} → {', '.join(row['to']) or 'alle'}"
title = f"{row['from'] or '?'} → {', '.join(row['to']) or 'all'}"
source = directory.key(row["from"], row["ts"])
who = {"agent": directory.at(source, row["ts"]) or row["from"], "now": directory.now(source), "session": source}
ref = {"to": row["to"], "class": row["class"], "targets": [directory.key(name, row["ts"]) for name in row["to"]]}
+6 -6
View File
@@ -73,19 +73,19 @@ def dry_run(item: dict) -> list[str]:
always stays.
"""
tip = (item["local_sha"] or item["head"] or "")[:12]
merged = f", gemergt durch {item['merged_by']}" if item["merged_by"] else ""
merged = f", merged by {item['merged_by']}" if item["merged_by"] else ""
lines = [f"{item['branch']} @ {tip}: {item['state']}{merged}"]
for action in item["actions"]:
if action == "worktree":
lines.append(f"entfernt den Worktree {item['worktree']}")
lines.append(f"removes the worktree {item['worktree']}")
elif action == "local-branch":
lines.append(f"löscht den lokalen Branch {item['branch']}")
lines.append(f"deletes the local branch {item['branch']}")
elif action.startswith("remote"):
lines.append(f"bleibt: {action} (nur lokal)")
lines.append(f"stays: {action} (local only)")
else:
lines.append(action)
lines += [f"stoppt den Compose-Stack {name} ohne -v" for name in item["compose_projects"]]
lines += [f"entfernt das Image {name}" for name in item["images"]]
lines += [f"stops the Compose stack {name} without -v" for name in item["compose_projects"]]
lines += [f"removes the image {name}" for name in item["images"]]
return lines