create-egregore 0.19.30 → 0.19.32

package/runtime/codex/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/codex/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"}'

package/runtime/codex/manifest.json

@@ -1,7 +1,7 @@
 {
   "source": "egregore-runtime",
   "policy": "available OSS components selected by capability-distribution.json; Connect is an authenticated additive overlay",
-  "skillCount": 41,
+  "skillCount": 43,
   "skills": [
     "activity",
     "announce",
@@ -10,6 +10,7 @@
     "checkup",
     "commit",
     "contribute",
+    "create-skill",
     "dark-mode",
     "dashboard",
     "deep-reflect",
@@ -32,6 +33,7 @@
     "reflect",
     "review-pr",
     "save",
+    "slack-connect",
     "summon",
     "sync-repos",
     "telegram-connect",
@@ -60,6 +62,7 @@
     ".codex/skills/checkup/SKILL.md",
     ".codex/skills/commit/SKILL.md",
     ".codex/skills/contribute/SKILL.md",
+    ".codex/skills/create-skill/SKILL.md",
     ".codex/skills/dark-mode/SKILL.md",
     ".codex/skills/dashboard/SKILL.md",
     ".codex/skills/deep-reflect/SKILL.md",
@@ -83,6 +86,7 @@
     ".codex/skills/reflect/SKILL.md",
     ".codex/skills/review-pr/SKILL.md",
     ".codex/skills/save/SKILL.md",
+    ".codex/skills/slack-connect/SKILL.md",
     ".codex/skills/summon/SKILL.md",
     ".codex/skills/sync-repos/SKILL.md",
     ".codex/skills/telegram-connect/SKILL.md",

package/runtime/pi/.codex/skills/create-skill/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: create-skill
+description: 'Create a skill your org owns — scaffolded in this Egregore, protected from framework updates, shared with teammates via /save.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore create-skill Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+1. Read `.claude/skills/create-skill/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/pi/.codex/skills/slack-connect/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: slack-connect
+description: 'Fallback Codex adapter for the Egregore slack-connect workflow.'
+---
+
+<!-- generated-by: bin/codex-sync-skills.sh -->
+
+# Egregore slack-connect Adapter
+
+This is fallback coverage for a long-tail Egregore workflow that has not been
+ported to a hand-written Codex-native skill yet.
+
+Use the project shell and filesystem directly. Do not invoke Claude Code
+commands. Translate interactive choices to structured Codex question tooling
+when it is available; otherwise render compact numbered choices with an
+`Other:` option and wait for the user.
+
+1. Read `.claude/skills/slack-connect/SKILL.md` for the workflow details.
+2. Run the referenced `bin/` scripts directly from Codex.
+3. Treat graph and publish steps as best-effort unless that workflow explicitly
+   says they are required.
+4. For every external notification, follow
+   `.claude/context/notification-consent.md`: plan without sending, then show
+   a separate exact Send / Edit / Cancel checkpoint. Never infer notification
+   consent from the workflow request or a batch approval.
+5. Keep local-mode behavior filesystem-first and avoid graph or notification
+   calls when `egregore.json` declares `"mode": "local"`.
+6. Never call the deprecated `egregore-handoff` CLI for Egregore project
+   handoffs.

package/runtime/pi/.codex/spec-manifest.json

@@ -29,7 +29,7 @@
     {
       "section": "On Launch — MANDATORY FIRST ACTION",
       "action": "replace",
-      "sourceHash": "3def4421213a",
+      "sourceHash": "233d160f9ca8",
       "note": "Claude SessionStart hook does not run on Codex; the egregore launcher renders the card via bin/codex-session-start.sh before the session. Greeting-replay instruction dropped (card is already on screen)."
     },
     {
@@ -41,7 +41,7 @@
     {
       "section": "Config Files",
       "action": "keep",
-      "sourceHash": "8d7f1bd0f2d9",
+      "sourceHash": "4ca75fe428ca",
       "note": "Kept verbatim — shell facts, runtime-neutral."
     },
     {
@@ -101,7 +101,7 @@
     {
       "section": "Command Awareness",
       "action": "keep",
-      "sourceHash": "d6fe47a75c00",
+      "sourceHash": "905ad739e18c",
       "note": "Prepended the Codex command surface (skill tokens, native vs adapter split, $save abstraction); disambiguation map kept with /x -> $x token rendering. Tokens with no Codex skill (e.g. /loop, a Claude Code harness feature) are left as-is."
     },
     {

package/runtime/pi/.pi/APPEND_SYSTEM.md

@@ -142,7 +142,7 @@ If the startup card output contains `onboarding_needed`, invoke the `/onboarding
 
 ## Config Files
 
-- **`egregore.json`** — committed. Non-secret org config: `org_name`, `github_org`, `memory_repo`, `slug`, `mode`. `api_url` is connected-mode only. Optional `boundary { posture, read[], locked }` sets the org's isolation posture (see Environment Isolation). **Never put secrets here.**
+- **`egregore.json`** — committed. Non-secret org config: `org_name`, `github_org`, `memory_repo`, `slug`, `mode`. `api_url` is connected-mode only. Optional `boundary { posture, read[], locked }` sets the org's isolation posture (see Environment Isolation). Optional `owned_skills[]` names org-authored skills in `.claude/skills/` that `/update` must never overwrite (created via `/create-skill`). **Never put secrets here.**
 - **`.env`** — gitignored. Personal secrets. Local mode: `GITHUB_TOKEN` only. Connected mode: `GITHUB_TOKEN` + `EGREGORE_API_KEY`. **Never use `source .env`** — use `grep '^KEY=' .env | cut -d'=' -f2-`.
 
 In connected mode, infrastructure credentials (Neo4j, Telegram) live on the API server only — `bin/graph.sh` and `bin/notify.sh` route through the API gateway.

package/runtime/pi/.pi/spec-manifest.json

@@ -1,8 +1,8 @@
 {
   "generatedBy": "bin/pi-render-spec.mjs",
   "source": "AGENTS.md generated Codex spec",
-  "sourceHash": "6247d8070669",
-  "outputHash": "117a6f3cafc3",
+  "sourceHash": "02c4d2d275db",
+  "outputHash": "dc9d961b8ce2",
   "adaptations": [
     "Pi project trust and APPEND_SYSTEM delivery",
     "Pi tool_call branch gate",

package/runtime/pi/AGENTS.md

@@ -216,7 +216,7 @@ If the startup card output contains `onboarding_needed`, invoke the `$onboarding
 
 ## Config Files
 
-- **`egregore.json`** — committed. Non-secret org config: `org_name`, `github_org`, `memory_repo`, `slug`, `mode`. `api_url` is connected-mode only. Optional `boundary { posture, read[], locked }` sets the org's isolation posture (see Environment Isolation). **Never put secrets here.**
+- **`egregore.json`** — committed. Non-secret org config: `org_name`, `github_org`, `memory_repo`, `slug`, `mode`. `api_url` is connected-mode only. Optional `boundary { posture, read[], locked }` sets the org's isolation posture (see Environment Isolation). Optional `owned_skills[]` names org-authored skills in `.claude/skills/` that `$update` must never overwrite (created via `$create-skill`). **Never put secrets here.**
 - **`.env`** — gitignored. Personal secrets. Local mode: `GITHUB_TOKEN` only. Connected mode: `GITHUB_TOKEN` + `EGREGORE_API_KEY`. **Never use `source .env`** — use `grep '^KEY=' .env | cut -d'=' -f2-`.
 
 In connected mode, infrastructure credentials (Neo4j, Telegram) live on the API server only — `bin/graph.sh` and `bin/notify.sh` route through the API gateway.
@@ -395,9 +395,10 @@ Invoke commands from user intent — don't wait for the slash. Each command file
 **Knowledge** — `$search` `$deep-reflect` `$archive` `$note` `$add` `$meeting` `$ingest` `$scroll` `$mock` `$audit`
 **Identity** — `$me` (view profile or set display name)
 **Coordination** — `$ask` `$quest` `$issue` `$invite` `$delete-user` `$announce`
-**Connectors** — `$telegram-connect` (Telegram group setup) `$teams-connect` (Microsoft Teams channel setup)
+**Connectors** — `$notion-connect` (Notion workspace) `$telegram-connect` (Telegram group setup) `$teams-connect` (Microsoft Teams channel setup)
 **Git** — `$branch` `$commit` `$push` `$pr` `$save` `$review-pr` `$contribute`
 **Spirits** — `$summon` (persistent agent processes)
+**Skills** — `$create-skill` (org-owned skill: scaffold, protect from updates, share)
 **Infra** — `$setup` `$update` `$pull` `$env` `$infra` `$sync-repos` `$release` `$checkup`
 
 **Disambiguation:**
@@ -410,11 +411,12 @@ Invoke commands from user intent — don't wait for the slash. Each command file
 - Tasks: `$todo` (personal) · `$quest` (team exploration) · `$issue` (something broken)
 - Questions: `$ask [person]` (async) · just ask (agent answers from context)
 - Ingestion: `$ingest <file-or-folder>` (org-scoped corpus intake) · `$ingest meeting` · `$ingest user-interview` · `$ingest google` · ambiguous → ask which type
-- Connectors: `$telegram-connect` (Telegram group) · `$teams-connect` (MS Teams channel) · `$ingest` (bring content in)
+- Connectors: `$notion-connect` (Notion workspace) · `$telegram-connect` (Telegram group) · `$teams-connect` (MS Teams channel) · `$ingest` (bring content in) · `$ingest notion` (promote Notion docs)
 - Identity: `$me` — "who am I", "call me oz"
 - People: `$invite` (add) · `$delete-user` (remove)
 - PRs: `$pr` (create) · `$review-pr` (review)
 - Contributing: `$contribute` (upstream framework) · `$save` (org repo) · `$issue` (report bug)
+- Skills: `$create-skill` (new org-owned skill) · `$contribute` (change a framework skill for everyone)
 - Agents: `$summon` (design through questions) · `/loop` (quick recurring schedule)
 - Announcements: `$announce` (broadcast to group) · `$handoff` (structured to a person) · `bin/notify.sh send` (DM one person)
 

package/runtime/pi/bin/ingest-surface.html

@@ -143,6 +143,14 @@ __EGREGORE_DESIGN_CSS__
     .button { border-radius: 99px; padding: 11px 18px; border: 1px solid var(--border); background: var(--card-bg); color: var(--dark); }
     .button.primary { border-color: var(--terracotta); background: var(--terracotta); color: var(--paper); }
     .button:disabled { cursor: not-allowed; color: var(--warm-gray); border-color: var(--border); background: var(--card-bg); }
+    .connectors { margin-top: 18px; padding-top: 16px; border-top: 1px solid var(--border); }
+    .connectors-head { display: flex; justify-content: space-between; align-items: baseline; }
+    .connectors-head h3 { font-size: 13px; font-weight: 600; color: var(--dark); }
+    .connector-row { display: flex; gap: 10px; margin-top: 10px; flex-wrap: wrap; }
+    .connector { display: flex; flex-direction: column; gap: 3px; text-align: left; border: 1px solid var(--border); border-radius: 12px; padding: 12px 16px; background: var(--card-bg); color: var(--dark); min-width: 180px; }
+    .connector:hover { border-color: var(--terracotta); }
+    .connector span { color: var(--muted); font-size: 12px; }
+    .connector-note { margin-top: 10px; color: var(--muted); font-size: 12px; line-height: 1.5; }
     .status { border-left: 2px solid var(--terracotta); padding: 10px 12px; color: var(--muted); font-size: 12px; line-height: 1.5; }
     .status.error { border-color: var(--danger); color: var(--danger); }
     .status.done { border-color: var(--success); color: var(--success); }
@@ -198,6 +206,11 @@ __EGREGORE_DESIGN_CSS__
         </div>
         <input id="file-input" type="file" multiple>
         <input id="folder-input" type="file" webkitdirectory multiple>
+        <div class="connectors hidden" id="connectors">
+          <div class="connectors-head"><h3>Or bring a connected source</h3><span class="step">guided setup</span></div>
+          <div class="connector-row" id="connector-row"></div>
+          <p class="connector-note">Setup continues in the terminal — the agent walks you through authorization, and your tokens stay on this machine.</p>
+        </div>
       </section>
 
       <section class="panel hidden" id="review-panel">
@@ -273,6 +286,59 @@ __EGREGORE_DESIGN_CSS__
       document.getElementById('completion').classList.remove('hidden');
       document.title = 'Return to the terminal — Egregore';
     }
+    var connectorMeta = {
+      google: { label: 'Google Workspace', detail: 'Gmail, Drive, Calendar — multiple accounts' },
+      notion: { label: 'Notion', detail: 'Pages and databases' }
+    };
+    function showConnectorCompletion(provider) {
+      var meta = connectorMeta[provider] || { label: provider };
+      var account = (capabilities.connector_accounts || {})[provider] || '';
+      document.getElementById('completion-kicker').textContent = account
+        ? 'Already connected'
+        : 'Guided setup continues in the terminal';
+      document.getElementById('completion-copy').textContent = account
+        ? meta.label + ' is already connected as ' + account + '. Back in the terminal, your agent can add another account or start bringing material in.'
+        : 'Your agent is waiting there to connect ' + meta.label + ' — it walks you through authorization step by step. Tokens stay on this machine.';
+      document.getElementById('completion-source').textContent = account || meta.label;
+      document.getElementById('completion-files').textContent = account ? 'connected' : 'connected source';
+      document.getElementById('completion-outcome').textContent = account ? meta.label : 'guided setup';
+      document.querySelector('.shell').classList.add('hidden');
+      document.getElementById('completion').classList.remove('hidden');
+      document.title = 'Return to the terminal — Egregore';
+    }
+    function chooseConnector(provider) {
+      if (busy) return;
+      busy = true;
+      post('/api/connector', {
+        method: 'POST',
+        headers: {'Content-Type': 'application/json'},
+        body: JSON.stringify({ provider: provider })
+      }).then(function (result) {
+        if (result.redirect) {
+          // The CLI pre-started the OAuth listener — continue this same tab
+          // straight into the sign-in page.
+          window.location.href = result.redirect;
+          return;
+        }
+        showConnectorCompletion(provider);
+      }).catch(function (err) {
+        busy = false;
+        setStatus(err.message, 'error');
+        statusBox.classList.remove('hidden');
+      });
+    }
+    (function renderConnectors() {
+      var list = (capabilities.connectors || []).filter(function (p) { return connectorMeta[p]; });
+      if (!list.length) return;
+      var row = document.getElementById('connector-row');
+      row.innerHTML = list.map(function (p) {
+        return '<button class="connector" type="button" data-provider="' + p + '"><strong>' + connectorMeta[p].label + '</strong><span>' + connectorMeta[p].detail + '</span></button>';
+      }).join('');
+      row.querySelectorAll('.connector').forEach(function (btn) {
+        btn.addEventListener('click', function () { chooseConnector(btn.dataset.provider); });
+      });
+      document.getElementById('connectors').classList.remove('hidden');
+    })();
     function choose(files) {
       var seen = new Set();
       selected = Array.from(files).filter(function (file) {