create-egregore 0.19.30 → 0.19.32

package/runtime/pi/bin/ingest.py

@@ -23,6 +23,11 @@ from datetime import datetime, timezone
 from pathlib import Path
 from xml.etree import ElementTree
 
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+import doc_segment  # noqa: E402  (same-directory module, path set above)
+import pdf_extract  # noqa: E402
+import source_profile  # noqa: E402
+
 
 ROOT = Path(__file__).resolve().parent.parent
 CONFIG = ROOT / "egregore.json"
@@ -99,31 +104,32 @@ def parse_boundaries(items: list[str]) -> dict[str, str]:
     return dict(sorted(result.items()))
 
 
-def read_text(path: Path) -> tuple[str | None, str | None, str | None]:
+def read_text(path: Path) -> tuple[str | None, str | None, str | None, dict | None]:
+    """Extract text. Returns (text, error, extractor, detail).
+
+    `detail` carries per-page extraction facts for formats that have pages, so the
+    manifest records which pages needed OCR and which remain sparse or blank.
+    """
     ext = path.suffix.lower()
     try:
         if ext in TEXT_EXTS:
-            return path.read_text(encoding="utf-8", errors="replace"), None, "builtin-text"
+            return path.read_text(encoding="utf-8", errors="replace"), None, "builtin-text", None
         if ext in HTML_EXTS:
             raw = path.read_text(encoding="utf-8", errors="replace")
             raw = re.sub(r"(?is)<(script|style).*?>.*?</\1>", " ", raw)
-            return html.unescape(re.sub(r"(?s)<[^>]+>", " ", raw)), None, "builtin-html"
+            return html.unescape(re.sub(r"(?s)<[^>]+>", " ", raw)), None, "builtin-html", None
         if ext == ".docx":
             with zipfile.ZipFile(path) as archive:
                 raw = archive.read("word/document.xml")
             root = ElementTree.fromstring(raw)
-            return "\n".join(t.text or "" for t in root.iter() if t.tag.endswith("}t")), None, "builtin-docx"
+            text = "\n".join(t.text or "" for t in root.iter() if t.tag.endswith("}t"))
+            return text, None, "builtin-docx", None
         if ext == ".pdf":
-            tool = shutil.which("pdftotext")
-            if not tool:
-                return None, "pdf requires a text-layer or runtime-native extraction", None
-            proc = subprocess.run([tool, str(path), "-"], check=False, capture_output=True, text=True)
-            if proc.returncode:
-                return None, f"pdftotext failed ({proc.returncode})", None
-            return proc.stdout, None, "pdftotext"
+            result = pdf_extract.extract(path)
+            return result.text, result.error, result.extractor, (result.report or None)
     except (OSError, ValueError, zipfile.BadZipFile, ElementTree.ParseError) as exc:
-        return None, str(exc), None
-    return None, f"unsupported extension {ext or '(none)'}", None
+        return None, str(exc), None, None
+    return None, f"unsupported extension {ext or '(none)'}", None, None
 
 
 def chunks(text: str, limit: int = 7000) -> list[str]:
@@ -146,6 +152,23 @@ def chunks(text: str, limit: int = 7000) -> list[str]:
     return result
 
 
+def publisher_profile() -> dict | None:
+    """Load the instance's publisher profile, if one is configured.
+
+    Resolution is recorded as evidence only. It never overrides a boundary the
+    operator set: deriving a region is an inference, and an inference must not
+    silently replace a stated fact.
+    """
+    override = os.environ.get("EGREGORE_PUBLISHER_PROFILE")
+    path = Path(override) if override else (metadata_root() / "publisher-profile.json")
+    if not path.is_file():
+        return None
+    try:
+        return json.loads(path.read_text(encoding="utf-8"))
+    except (OSError, json.JSONDecodeError):
+        return None
+
+
 def source_dir(source_id: str) -> Path:
     return metadata_root() / "sources" / slug(source_id)
 
@@ -200,6 +223,7 @@ def add_path(args: argparse.Namespace) -> dict:
     existing_manifest = load_manifest(directory)
     previous = {d["id"]: d for d in existing_manifest.get("documents", [])}
     now = datetime.now(timezone.utc).isoformat()
+    profile = publisher_profile()
     ingested = unchanged = metadata_updated = skipped = pruned = 0
     errors: list[dict] = []
     seen_paths: set[str] = set()
@@ -224,8 +248,10 @@ def add_path(args: argparse.Namespace) -> dict:
             text, error = registered["text"], None
             extraction = {"kind": "runtime", "extractor": registered["extractor"]}
         else:
-            text, error, extractor = read_text(path)
+            text, error, extractor, detail = read_text(path)
             extraction = {"kind": "local", "extractor": extractor} if extractor else None
+            if extraction and detail:
+                extraction["pages"] = detail
         if error or text is None or not text.strip():
             skipped += 1
             errors.append({"path": relative, "error": error or "empty extracted text"})
@@ -255,13 +281,49 @@ def add_path(args: argparse.Namespace) -> dict:
         ):
             unchanged += 1
             continue
-        document_chunks = chunks(text)
+        # Segment before chunking so no passage straddles two works. A document
+        # holding a single work yields one segment, and chunking is unchanged.
+        segments = doc_segment.segment(text)
+        document_chunks: list[tuple[str, doc_segment.Segment]] = []
+        for seg in segments:
+            for piece in chunks(seg.text(text)):
+                document_chunks.append((piece, seg))
+
         chunk_rows = []
         body = []
-        for index, content in enumerate(document_chunks, 1):
+        for index, (content, seg) in enumerate(document_chunks, 1):
             chunk_id = f"{doc_id}-c{index:04d}-{digest(content, 8)}"
-            chunk_rows.append({"id": chunk_id, "index": index, "sha256": hashlib.sha256(content.encode()).hexdigest()})
+            row = {"id": chunk_id, "index": index, "sha256": hashlib.sha256(content.encode()).hexdigest()}
+            if seg.kind != "article" or seg.label:
+                row["segment"] = {"kind": seg.kind, **({"label": seg.label} if seg.label else {})}
+            chunk_rows.append(row)
             body.append(f"## Chunk {index:04d}\n\n<!-- ingest-chunk: {chunk_id} -->\n\n{content}")
+
+        structure = {
+            "segments": len([s for s in segments if s.kind == "article"]),
+            "summary": doc_segment.summarise(segments),
+        }
+        derived_year = doc_segment.publication_year(segments)
+        if derived_year:
+            structure["publication_year"] = derived_year
+            structure["year_source"] = "running_head"
+
+        # Fill in boundaries the operator left blank, when the instance supplies a
+        # profile that can work them out from where the document came from. People
+        # dumping a folder of documents will not type these in, and a boundary that
+        # is absent filters nothing. A derived value is marked as derived: anything
+        # downstream can tell it apart from one a person stated, and weigh it by the
+        # confidence recorded alongside. An operator's value is never overwritten.
+        provenance = None
+        doc_boundaries = dict(boundaries)
+        if profile:
+            resolved = source_profile.resolve(profile, filename=relative)
+            if resolved.publisher_class or resolved.notes:
+                provenance = resolved.as_dict()
+            key = source_profile.boundary_key(profile)
+            if key and resolved.zone and key not in doc_boundaries:
+                doc_boundaries[key] = resolved.zone
+                provenance = {**(provenance or {}), "applied_boundary": key, "derived": True}
         out_path = docs_dir / f"{doc_id}.md"
         frontmatter = {
             "id": doc_id,
@@ -274,8 +336,10 @@ def add_path(args: argparse.Namespace) -> dict:
             "normalized_content_hash": normalized_hash,
             "revision": content_hash[:16],
             "status": "unverified",
-            "boundaries": boundaries,
+            "boundaries": doc_boundaries,
             "extraction": extraction,
+            "structure": structure,
+            "provenance": provenance,
             "ingested_at": now,
         }
         yaml_lines = ["---"] + [f"{key}: {json.dumps(value, ensure_ascii=False)}" for key, value in frontmatter.items()] + ["---", ""]
@@ -292,7 +356,9 @@ def add_path(args: argparse.Namespace) -> dict:
             "bytes": size_bytes,
             "chunks": chunk_rows,
             "extraction": extraction,
-            "boundaries": boundaries,
+            "structure": structure,
+            "provenance": provenance,
+            "boundaries": doc_boundaries,
             "status": "unverified",
             "ingested_at": now,
         }

package/runtime/pi/bin/ingest.sh

@@ -204,8 +204,56 @@ cmd_search() {
     (.[] | "\n### " + (.title // .file) + "\n" + .file + "\n\n" + (.snippet // ""))'
 }
 
+cmd_select() {
+  # Stitch the Google sign-in into the picker itself: when the shim ships and
+  # no account is connected yet, pre-start the OAuth listener and hand its
+  # consent URL to the surface — clicking Google then continues the SAME tab
+  # into sign-in instead of bouncing through the terminal. Already connected:
+  # pass the account so the page says so honestly. Everything degrades to the
+  # terminal-guided flow when the URL isn't ready in time.
+  local auth_urls="{}" accounts="{}" auth_pid="" auth_log="" result status=0
+  if [ -x "$ROOT/bin/connector-google.sh" ]; then
+    local active_account
+    active_account="$(jq -r '.google_account // empty' "$ROOT/.egregore-state.json" 2>/dev/null)"
+    if [ -n "$active_account" ]; then
+      accounts="$(jq -cn --arg a "$active_account" '{google: $a}')"
+    else
+      auth_log="$(mktemp)"
+      bash "$ROOT/bin/connector-google.sh" auth --print-url > "$auth_log" 2>/dev/null &
+      auth_pid=$!
+      local waited=0 url=""
+      while [ "$waited" -lt 15 ]; do
+        url="$(head -1 "$auth_log" 2>/dev/null | jq -r '.auth_url // empty' 2>/dev/null)"
+        [ -n "$url" ] && break
+        sleep 1; waited=$((waited + 1))
+      done
+      if [ -n "$url" ]; then
+        auth_urls="$(jq -cn --arg u "$url" '{google: $u}')"
+      fi
+    fi
+  fi
+  result="$(EGREGORE_CONNECTOR_AUTH_URLS="$auth_urls" EGREGORE_CONNECTOR_ACCOUNTS="$accounts" python3 "$SURFACE" "$@")" || status=$?
+  if [ -n "$auth_pid" ]; then
+    if [ "$(printf '%s' "$result" | jq -r '.auth // empty' 2>/dev/null)" = "in-browser" ]; then
+      # The user is on Google's consent page in their tab; the listener
+      # finishes the token exchange. Wait for it and fold in the outcome.
+      if wait "$auth_pid" 2>/dev/null; then
+        result="$(printf '%s' "$result" | jq -c '. + {auth: "connected"}')"
+      else
+        result="$(printf '%s' "$result" | jq -c '. + {auth: "failed"}')"
+      fi
+    else
+      kill "$auth_pid" 2>/dev/null || true
+      wait "$auth_pid" 2>/dev/null || true
+    fi
+  fi
+  [ -n "$auth_log" ] && rm -f "$auth_log"
+  printf '%s\n' "$result"
+  return "$status"
+}
+
 case "${1:-}" in
-  select) shift; python3 "$SURFACE" "$@" ;;
+  select) shift; cmd_select "$@" ;;
   add) shift; cmd_add "$@" ;;
   add-selection) shift; cmd_add_selection "$@" ;;
   register-extraction) shift; python3 "$PY" register-extraction "$@" ;;

package/runtime/pi/bin/ingest_graph.py

@@ -13,9 +13,10 @@ from typing import Any
 
 ROOT = Path(__file__).resolve().parent.parent
 CORPUS_SCHEMA = "egregore-ingest-corpus/v1"
+CONNECTOR_SCHEMA = "egregore-connector-lifecycle/v1"
 KNOWLEDGE_SCHEMA = "egregore-knowledge-projection/v1"
 PLAN_SCHEMA = "egregore-ingest-graph-plan/v2"
-SOURCE_KINDS = {"meeting", "interview", "google", "corpus", "document"}
+SOURCE_KINDS = {"meeting", "interview", "google", "notion", "corpus", "document"}
 SOURCE_RELATIONS = {"INVOLVES", "CONDUCTED_BY"}
 ARTIFACT_RELATIONS = {"RELATES_TO", "SUPERSEDES"}
 ARTIFACT_LABELS = {
@@ -438,6 +439,8 @@ def source_shape(kind: str) -> tuple[str, str]:
         return "Interview:KnowledgeSource", "FROM_INTERVIEW"
     if kind == "google":
         return "Artifact:KnowledgeSource", "DERIVED_FROM"
+    if kind == "notion":
+        return "Artifact:KnowledgeSource", "DERIVED_FROM"
     if kind == "corpus":
         return "IngestSource:KnowledgeSource", "DERIVED_FROM"
     return "IngestDocument:Document:KnowledgeSource", "DERIVED_FROM"
@@ -728,7 +731,84 @@ RETURN a.id""",
     }
 
 
+def connector_manifest(value: dict[str, Any]) -> bool:
+    return value.get("schema") == CONNECTOR_SCHEMA
+
+
+def connector_plan(value: dict[str, Any], path: Path) -> dict[str, Any]:
+    """Project connector lifecycle: which providers this org has connected,
+    which accounts are authorized on each, and which ingest sources arrived
+    through which account. Connected mode only — the plan is executed by the
+    same runner as corpus plans and is idempotent (MERGE throughout)."""
+    provider = required_string(value.get("provider"), "provider")
+    if provider not in ("google", "notion"):
+        raise ContractError(f"unsupported connector provider: {provider}")
+    accounts = value.get("accounts")
+    if not isinstance(accounts, list) or not accounts:
+        raise ContractError("accounts must be a non-empty list")
+    recorded = required_string(value.get("recorded_at"), "recorded_at")
+    source_id = str(value.get("source_id") or "")
+    queries: list[dict[str, Any]] = []
+    queries.append(
+        query(
+            """MERGE (c:Connector {id: $provider})
+SET c.provider = $provider,
+    c.updatedAt = datetime($recorded)
+RETURN c.id""",
+            {"provider": provider, "recorded": recorded},
+        )
+    )
+    for entry in accounts:
+        if not isinstance(entry, dict):
+            raise ContractError("each account must be an object")
+        email = required_string(entry.get("email"), "accounts[].email")
+        status = str(entry.get("status") or "authorized")
+        if status not in ("authorized", "revoked"):
+            raise ContractError(f"unsupported account status: {status}")
+        account_id = f"{provider}:{email.lower()}"
+        queries.append(
+            query(
+                """MERGE (a:SourceAccount {id: $id})
+SET a.email = $email,
+    a.provider = $provider,
+    a.status = $status,
+    a.updatedAt = datetime($recorded)
+FOREACH (_ IN CASE WHEN $status = 'authorized' AND a.authorizedAt IS NULL THEN [1] ELSE [] END |
+  SET a.authorizedAt = datetime($recorded)
+)
+WITH a
+MATCH (c:Connector {id: $provider})
+MERGE (a)-[:ON]->(c)
+WITH a
+OPTIONAL MATCH (s:IngestSource {id: $sourceId})
+FOREACH (_ IN CASE WHEN s IS NULL OR $sourceId = '' THEN [] ELSE [1] END |
+  MERGE (s)-[v:VIA_ACCOUNT]->(a)
+  SET v.recordedAt = datetime($recorded)
+)
+RETURN a.id""",
+                {
+                    "id": account_id,
+                    "email": email,
+                    "provider": provider,
+                    "status": status,
+                    "recorded": recorded,
+                    "sourceId": source_id,
+                },
+            )
+        )
+    return {
+        "schema": PLAN_SCHEMA,
+        "schema_family": "connector-lifecycle",
+        "manifest_id": f"connector:{provider}",
+        "source": {"kind": "connector", "id": provider},
+        "query_count": len(queries),
+        "queries": queries,
+    }
+
+
 def build_plan(value: dict[str, Any], path: Path) -> dict[str, Any]:
+    if connector_manifest(value):
+        return connector_plan(value, path)
     if corpus_manifest(value):
         return corpus_plan(value, path)
     return knowledge_plan(value, path)

package/runtime/pi/bin/ingest_surface.py

@@ -232,6 +232,39 @@ class SelectionState:
             self.done.set()
             return self.result
 
+    def choose_connector(self, payload: dict) -> dict:
+        # A connector choice ends the local-selection flow. When the CLI
+        # pre-started an OAuth listener, the browser response carries its
+        # consent URL so THIS tab continues straight into Google's sign-in;
+        # otherwise the agent guides authorization from the terminal. No bytes
+        # are staged and no source contract is collected here.
+        with self.lock:
+            if self.done.is_set():
+                raise ValueError("selection already finished")
+            provider = str(payload.get("provider", "")).strip().lower()
+            if provider not in available_connectors():
+                raise ValueError(f"unknown connector: {provider or '(empty)'}")
+            redirect = connector_auth_urls().get(provider, "")
+            account = connector_accounts().get(provider, "")
+            self.result = {
+                "connector": provider,
+                "receipt_url": self.receipt_url,
+            }
+            if redirect:
+                self.result["auth"] = "in-browser"
+            elif account:
+                self.result["account"] = account
+            self.receipt = {
+                **self.result,
+                "status": "processing",
+                "message": "The agent is walking you through connecting this source in the terminal.",
+            }
+            self.done.set()
+            response = dict(self.result)
+            if redirect:
+                response["redirect"] = redirect
+            return response
+
     def finish_receipt(self, payload: dict) -> dict:
         with self.lock:
             if not self.done.is_set() or self.cancelled:
@@ -252,10 +285,53 @@ class SelectionState:
         shutil.rmtree(self.session_root, ignore_errors=True)
 
 
+def available_connectors() -> list[str]:
+    # A connector is offered when its runtime shim ships with this instance.
+    # Authorization state is NOT checked here — the button's job is to route
+    # the user into the guided setup, which handles both fresh and connected.
+    here = Path(__file__).parent
+    providers = []
+    if (here / "connector-google.sh").exists():
+        providers.append("google")
+    if (here / "connector-notion.sh").exists():
+        providers.append("notion")
+    return providers
+
+
+def _env_json_map(name: str) -> dict[str, str]:
+    try:
+        value = json.loads(os.environ.get(name, "") or "{}")
+    except json.JSONDecodeError:
+        return {}
+    if not isinstance(value, dict):
+        return {}
+    return {str(k): str(v) for k, v in value.items() if isinstance(v, (str, int))}
+
+
+def connector_auth_urls() -> dict[str, str]:
+    # Consent URLs pre-fetched by the CLI (listener already running) so a
+    # connector click can redirect this same tab straight into sign-in.
+    # Only loopback/HTTPS URLs are accepted.
+    urls = {}
+    for provider, url in _env_json_map("EGREGORE_CONNECTOR_AUTH_URLS").items():
+        if url.startswith("https://") or url.startswith("http://127.0.0.1") or url.startswith("http://localhost"):
+            urls[provider] = url
+    return urls
+
+
+def connector_accounts() -> dict[str, str]:
+    # Already-connected account per provider, for honest completion copy.
+    return _env_json_map("EGREGORE_CONNECTOR_ACCOUNTS")
+
+
 def handler_class(state: SelectionState, token: str, expected_origin: str, preference_file: Path | None = None):
     html_template = HTML_PATH.read_text(encoding="utf-8")
     design_css = DESIGN_CSS_PATH.read_text(encoding="utf-8")
-    capabilities = {"pdftotext": bool(shutil.which("pdftotext"))}
+    capabilities = {
+        "pdftotext": bool(shutil.which("pdftotext")),
+        "connectors": available_connectors(),
+        "connector_accounts": connector_accounts(),
+    }
     preferences = load_preferences(preference_file or preferences_path())
     page = (
         html_template.replace("__EGREGORE_DESIGN_CSS__", design_css)
@@ -349,6 +425,10 @@ def handler_class(state: SelectionState, token: str, expected_origin: str, prefe
                     result = state.confirm(self.read_json())
                     self.send_json(200, result)
                     return
+                if path == "/api/connector":
+                    result = state.choose_connector(self.read_json())
+                    self.send_json(200, result)
+                    return
                 if path == "/api/cancel":
                     state.cancel()
                     self.send_json(200, {"cancelled": True})

package/runtime/pi/bin/notify.sh

@@ -35,6 +35,7 @@ chmod 700 "$STATE_DIR" 2>/dev/null || true
 if [ -f "$SCRIPT_DIR/.env" ]; then
   EGREGORE_API_URL="${EGREGORE_API_URL:-$(grep '^EGREGORE_API_URL=' "$SCRIPT_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
   EGREGORE_API_KEY="${EGREGORE_API_KEY:-$(grep '^EGREGORE_API_KEY=' "$SCRIPT_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
+  SLACK_BOT_TOKEN="${SLACK_BOT_TOKEN:-$(grep '^SLACK_BOT_TOKEN=' "$SCRIPT_DIR/.env" 2>/dev/null | cut -d'=' -f2- || true)}"
 fi
 API_URL="${EGREGORE_API_URL:-$(jq -r '.api_url // empty' "$CONFIG" 2>/dev/null)}"
 API_KEY="${EGREGORE_API_KEY:-}"
@@ -178,6 +179,8 @@ write_plan() {
   }' "$path"
 }
 
+# Channel-generic despite the name: reads any field from .egregore-state.json
+# with egregore.json as the legacy fallback (telegram_*, slack_*, …).
 read_local_telegram_config() {
   local field="$1"
   local state_file="$SCRIPT_DIR/.egregore-state.json"
@@ -220,24 +223,38 @@ plan_local() {
     die "direct messages are unavailable in local mode; no group fallback was sent"
   fi
 
-  local chat_id group_link destination
+  local chat_id group_link slack_channel deliveries
   chat_id="$(read_local_telegram_config telegram_chat_id)"
   group_link="$(read_local_telegram_config telegram_group_link)"
-  [ -n "$chat_id" ] || [ -n "$group_link" ] ||
-    die "no Telegram group is configured"
-  destination="${group_link:-$chat_id}"
+  slack_channel="$(read_local_telegram_config slack_channel_id)"
+
+  deliveries="[]"
+  if [ -n "$chat_id" ] || [ -n "$group_link" ]; then
+    deliveries="$(printf '%s' "$deliveries" | jq -c \
+      --arg destination "${group_link:-$chat_id}" \
+      '. + [{channel:"telegram", destination:$destination, kind:"group"}]')"
+  fi
+  # Slack is local-direct (the org owns the app and token): plan it only when
+  # both halves of the config exist, so a half-configured Slack fails soft.
+  if [ -n "$slack_channel" ] && [ -n "${SLACK_BOT_TOKEN:-}" ]; then
+    deliveries="$(printf '%s' "$deliveries" | jq -c \
+      --arg destination "$slack_channel" \
+      '. + [{channel:"slack", destination:$destination, kind:"group"}]')"
+  fi
+  [ "$deliveries" != "[]" ] ||
+    die "no group notification channel is configured"
 
   local response
   response="$(jq -nc \
     --arg slug "$ORG_SLUG" \
     --arg org "$ORG_NAME" \
-    --arg destination "$destination" \
+    --argjson deliveries "$deliveries" \
     '{
       status:"planned",
       org_slug:$slug,
       org_name:$org,
-      channels:["telegram"],
-      deliveries:[{channel:"telegram", destination:$destination, kind:"group"}],
+      channels:($deliveries | map(.channel)),
+      deliveries:$deliveries,
       no_fallback:true
     }')"
   write_plan "$response" "$kind" "$recipient" "$message"
@@ -342,11 +359,12 @@ dispatch_connected() {
   printf '%s\n' "$response"
 }
 
-dispatch_local() {
-  local path="$1"
-  local message destination chat_id group_link plan_slug plan_org response
-  message="$(jq -r '.message' "$path")"
-  destination="$(jq -r '.deliveries[0].destination' "$path")"
+dispatch_local_telegram() {
+  local destination="$1"
+  local message="$2"
+  local plan_slug="$3"
+  local plan_org="$4"
+  local chat_id group_link
   case "$destination" in
     https://t.me/*)
       chat_id=""
@@ -357,9 +375,7 @@ dispatch_local() {
       group_link=""
       ;;
   esac
-  plan_slug="$(jq -r '.org_slug' "$path")"
-  plan_org="$(jq -r '.org_name' "$path")"
-  response="$(curl -sS -X POST "${RELAY_URL}/api/notify/relay" \
+  curl -sS -X POST "${RELAY_URL}/api/notify/relay" \
     -H "Content-Type: application/json" \
     -d "$(jq -nc \
       --arg chat_id "$chat_id" \
@@ -368,12 +384,84 @@ dispatch_local() {
       --arg slug "$plan_slug" \
       --arg org_name "$plan_org" \
       '{chat_id:$chat_id,group_link:$group_link,message:$message,slug:$slug,org_name:$org_name}')" \
-    --max-time 10)" || return 1
-  printf '%s' "$response" | jq -e '.status == "sent"' >/dev/null 2>&1 || {
-    printf '%s\n' "$response"
-    return 1
+    --max-time 10
+}
+
+# Local-direct: the org owns the Slack app and token, so the message goes
+# straight from this machine to Slack — never through the Egregore relay.
+dispatch_local_slack() {
+  local destination="$1"
+  local message="$2"
+  if [ -z "${SLACK_BOT_TOKEN:-}" ]; then
+    jq -nc '{status:"error",detail:"SLACK_BOT_TOKEN is missing from .env"}'
+    return 0
+  fi
+  local response
+  response="$(curl -sS -X POST "https://slack.com/api/chat.postMessage" \
+    -H "Authorization: Bearer $SLACK_BOT_TOKEN" \
+    -H "Content-Type: application/json; charset=utf-8" \
+    -d "$(jq -nc \
+      --arg channel "$destination" \
+      --arg text "$message" \
+      '{channel:$channel,text:$text,unfurl_links:false}')" \
+    --max-time 10)" || {
+    jq -nc '{status:"error",detail:"Slack request failed"}'
+    return 0
   }
-  printf '%s\n' "$response"
+  if printf '%s' "$response" | jq -e '.ok == true' >/dev/null 2>&1; then
+    jq -nc '{status:"sent"}'
+  else
+    jq -nc \
+      --arg detail "$(printf '%s' "$response" | jq -r '.error // "unknown"' 2>/dev/null || echo unknown)" \
+      '{status:"error",detail:$detail}'
+  fi
+}
+
+dispatch_local() {
+  local path="$1"
+  local message plan_slug plan_org count i channel destination result
+  message="$(jq -r '.message' "$path")"
+  plan_slug="$(jq -r '.org_slug' "$path")"
+  plan_org="$(jq -r '.org_name' "$path")"
+  count="$(jq -r '.deliveries | length' "$path")"
+
+  # One platform failing must not mask another succeeding (mirror of the
+  # server-side send_group semantics).
+  local results="{}"
+  i=0
+  while [ "$i" -lt "$count" ]; do
+    channel="$(jq -r ".deliveries[$i].channel" "$path")"
+    destination="$(jq -r ".deliveries[$i].destination" "$path")"
+    case "$channel" in
+      telegram)
+        result="$(dispatch_local_telegram "$destination" "$message" "$plan_slug" "$plan_org")" ||
+          result='{"status":"error","detail":"relay request failed"}'
+        printf '%s' "$result" | jq -e . >/dev/null 2>&1 ||
+          result='{"status":"error","detail":"relay returned an unreadable response"}'
+        ;;
+      slack)
+        result="$(dispatch_local_slack "$destination" "$message")"
+        ;;
+      *)
+        result='{"status":"error","detail":"Unsupported channel"}'
+        ;;
+    esac
+    results="$(printf '%s' "$results" | jq -c --arg ch "$channel" --argjson r "$result" '. + {($ch): $r}')"
+    i=$((i + 1))
+  done
+
+  local sent
+  sent="$(printf '%s' "$results" | jq -c '[to_entries[] | select(.value.status == "sent") | .key]')"
+  if [ "$sent" = "[]" ]; then
+    printf '%s\n' "$results"
+    return 1
+  fi
+  printf '%s' "$results" | jq -c --argjson sent "$sent" \
+    '{status:"sent", platforms:$sent}
+     + ([to_entries[] | select(.value.status != "sent")] as $f
+        | if ($f | length) > 0
+          then {failed: ($f | map({(.key): (.value.detail // "unknown")}) | add)}
+          else {} end)'
 }
 
 dispatch_plan() {
@@ -469,12 +557,14 @@ test_connection() {
       -H "Authorization: Bearer $API_KEY" \
       --max-time 10
   elif [ "$MODE" = "local" ]; then
-    local group_link
+    local group_link slack_channel
     group_link="$(read_local_telegram_config telegram_group_link)"
-    if [ -n "$group_link" ]; then
+    slack_channel="$(read_local_telegram_config slack_channel_id)"
+    if [ -n "$group_link" ] ||
+       { [ -n "$slack_channel" ] && [ -n "${SLACK_BOT_TOKEN:-}" ]; }; then
       echo '{"status":"configured","mode":"local"}'
     else
-      echo '{"status":"offline","reason":"no_telegram_group"}'
+      echo '{"status":"offline","reason":"no_notification_channel"}'
     fi
   else
     echo '{"status":"offline","reason":"no_api_key"}'