create-egregore 0.21.2 → 0.21.3

package/assets/egregore-launcher.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// egregore-launcher-version: 0.21.2
+// egregore-launcher-version: 0.21.3
 //
 // egregore — launch and browse Egregore instances from your terminal.
 // Installed by create-egregore. Reads ~/.egregore/instances.json.
@@ -35,7 +35,7 @@ const crypto = require("node:crypto");
 const { spawnSync, spawn } = require("node:child_process");
 const readline = require("node:readline");
 
-const VERSION = "0.21.2";
+const VERSION = "0.21.3";
 const REGISTRY = path.join(os.homedir(), ".egregore", "instances.json");
 const DEFAULT_FILE = path.join(os.homedir(), ".egregore", "default");
 const UPDATE_CACHE_FILE = path.join(os.homedir(), ".egregore", "update-check.json");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-egregore",
-  "version": "0.21.2",
+  "version": "0.21.3",
   "description": "Set up Egregore for your team in one command \u2014 installs the egregore launcher and your choice of Claude Code, Codex, or Pi.",
   "license": "MIT",
   "bin": {

package/runtime/claude/.claude/context/telemetry.md

@@ -153,51 +153,30 @@ On the first session where telemetry events are emitted, if `telemetry_noticed`
 
 Then set `telemetry_noticed: true` in the state file. Never repeat this notice.
 
-## Session Reports
-
-Separate from telemetry. Users can optionally share session reports during `/wrap` or via `/issue egregore:`. Reports are **opt-in per session** — the user is asked each time and must explicitly agree.
-
-### How it works
-
-`bin/session-report.sh` handles report submission. It POSTs directly to Supabase via the anon key (no API server needed). The agent generates a structured report from the session context inline — no separate LLM call.
-
-```bash
-# Submit a report (reads JSON from stdin)
-echo '{"topic":"...","summary":"..."}' | bash bin/session-report.sh submit
-
-# Check reporting status
-bash bin/session-report.sh status
-```
-
-### What is sent
-
-- AI-analyzed topic + summary (same as what's written to memory)
-- Gap analysis: `{type, detail}` where type is `missing_skill`, `missing_tool`, `repeated_failure`, `wrong_info`, or `confusing_ux`
-- User's own description (if provided)
-- System info: mode, platform, shell, framework version
-- Session duration and message count
-
-### What is NEVER sent
-
-- Code, file contents, or file paths
-- Conversation transcript or user prompts
-- Environment variables or secrets
-- Org-specific data (sanitized before sending — org names, person names, tokens replaced)
-
-### Opt-out
-
-- `EGREGORE_NO_REPORTS=1` in `.env`
-- `.egregore-state.json` → `"session_reports": false`
-- Simply answer "No thanks" when prompted during `/wrap`
-- `DO_NOT_TRACK=1` also disables reports
-
-### Transport
-
-- Direct to Supabase via anon key (INSERT-only RLS policy)
-- If network fails: saved locally to `~/.egregore/reports/` as fallback
-- Telegram notification to maintainers fires server-side via Supabase DB webhook
-- Optional: GitHub issue creation on `egregore-labs/egregore` (user chooses each time)
-
-### Configuration
-
-Reports require `report_url` and `report_key` in `egregore.json`. New OSS installations get these automatically via `create-egregore`. If missing, the report prompt is skipped entirely.
+## Framework support and legacy session feedback
+
+For an Egregore bug, including the historical `/issue egregore:` wording, use
+the [issue workflow](../skills/issue/SKILL.md). Connected instances prepare an
+exact private support preview and submit only after confirmation. Local users
+can explicitly choose a public upstream report. An internal issue stays within
+its organization's memory or configured tracker; it does not automatically
+reach Egregore support. `/wrap` does not collect or submit session feedback.
+
+The older `bin/session-report.sh` is a feedback-storage compatibility helper,
+not a support-reporting route. It inserts selected feedback into `session_reports`
+when `report_url` and `report_key` are configured. A `submitted` receipt means
+only that storage accepted the feedback: no GitHub issue was created and no
+Telegram message was sent. The authenticated database callback acknowledges
+storage without planning or dispatching a notification to a named teammate.
+Transport failure saves feedback locally under `~/.egregore/reports/`; that
+does not establish remote storage or delivery. Missing configuration skips
+submission.
+
+Never invoke legacy feedback automatically, generate it from a transcript, or
+use it as a fallback when private support fails. Only explicitly selected and
+reviewed content may be shared. The helper adds legacy user and organization
+labels; it does not guarantee anonymization or scrub arbitrary input.
+
+Legacy feedback can be disabled with `EGREGORE_NO_REPORTS=1` or
+`DO_NOT_TRACK=1` in the process environment, or `"session_reports": false` in
+`.egregore-state.json`. These switches do not grant consent to submit content.

package/runtime/claude/.claude/skills/issue/SKILL.md

@@ -67,6 +67,12 @@ its default recipient is **Egregore support, private**. Local/OSS users may
 explicitly choose `upstream` for a **public** report. Connected users can also
 choose public upstream explicitly. Never fall back from private to public.
 
+Treat the historical `egregore:` prefix as framework-support intent and use
+this reviewed reporting flow. Never route a framework bug through the
+legacy session-feedback helper: it only stores feedback and does not
+file a support issue or send a Telegram notification. Being Connected does not
+turn an internal issue in the customer's memory into a report to Egregore.
+
 Use `'{title}'` for the concise title derived from the user's report and
 `'{report}'` for the report text the user supplied or reviewed.
 Write an embedded single quote as `'\''` in each substituted value.
@@ -119,6 +125,13 @@ review the private issue in its Project/Archive. Keep a failed/uncertain report'
 request ID; no backend failure authorizes public publication or a fresh blind
 submission.
 
+Report the confirmed outcome precisely: a preview is not submitted; a local
+issue is saved within this organization; only a matching private receipt with
+`submission_state: filed` means filed with Egregore support. Other states need
+recovery using the same request ID. A filed issue does not prove Telegram
+delivery: `notification_state: unverified` must never be described as sent or
+received. Only a separate delivery receipt can establish that.
+
 Public reports use the reporter's GitHub authentication and return a public
 issue URL. Destination comes only from HTTPS GitHub `upstream_url`; absent means
 `egregore-labs/egregore`, `none` means no upstream. Do not infer it from remotes.

package/runtime/claude/egregore_runtime/issue_reporting.py

@@ -21,6 +21,26 @@ from .policy import scope_allows_path
 KINDS = {"bug", "improvement", "question"}
 AREAS = {"runtime", "onboarding", "connectors", "site", "other"}
 SEVERITIES = {"critical", "high", "normal"}
+SUPPORT_STATES = {"filed", "failed", "submitting", "uncertain"}
+
+
+def support_receipt(result, identifier):
+    """Accept only a receipt for this request; filing never proves notification."""
+    if (not isinstance(result, dict) or result.get('request_id') != identifier
+        or not isinstance(result.get('submission_state'), str)
+        or result['submission_state'] not in SUPPORT_STATES):
+        raise ValueError(f"private support returned an invalid receipt; keep request {identifier} and use report-status")
+    state = result['submission_state']
+    notices = {
+        'filed': 'Filed with Egregore support. Telegram delivery has not been verified.',
+        'failed': 'Report preserved; support filing failed. Retry this same request.',
+        'submitting': 'Report preserved; support filing is not confirmed. Keep this request ID and check report-status.',
+        'uncertain': 'Report preserved; support filing needs reconciliation. Keep this request ID and check report-status.',
+    }
+    return {'request_id': identifier, 'submission_state': state,
+            'retryable': state == 'failed',
+            'reconciliation_needed': state in {'submitting', 'uncertain'},
+            'notification_state': 'unverified', 'notice': notices[state]}
 
 
 def _scrub(value, *, public=False):
@@ -207,18 +227,29 @@ class FrameworkReporting:
                 return {'request_id':identifier,'status':result['status'],'github_url':result['github_url']}
             credential, _ = self._verified_credential(state['destination'],state['authenticated_org'])
             state['status'] = 'submitting'; GitHubIssues._save(path,state)
-            code, result = self.api(self.root,state['destination'],'/api/v1/support-reports',
-                {'request_id':identifier, **state['payload']},credential=credential)
-            if code >= 400:
+            try:
+                code, result = self.api(self.root,state['destination'],'/api/v1/support-reports',
+                    {'request_id':identifier, **state['payload']},credential=credential)
+            except OSError:
+                state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
+                raise OSError(f"private support response unavailable; keep request {identifier} and use report-status or confirm this same preview") from None
+            if not 200 <= code < 300:
                 state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
                 raise ValueError(f"private support request {identifier} needs recovery (HTTP {code}); use report-status or confirm this same preview")
-            state['status'] = result.get('submission_state','unknown'); GitHubIssues._save(path,state)
-            return result
+            try:
+                receipt = support_receipt(result, identifier)
+            except ValueError:
+                state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
+                raise
+            state['status'] = receipt['submission_state']; GitHubIssues._save(path,state)
+            if state['status'] != 'filed':
+                raise ValueError(f"private support request {identifier} needs recovery ({state['status']}); use report-status or confirm this same preview")
+            return receipt
 
     def status(self, identifier):
         path, state = self._load('report',identifier,write=False)
         credential, _ = self._verified_credential(state['destination'],state['authenticated_org'])
         code, result = self.api(self.root,state['destination'],f'/api/v1/support-reports/{identifier}',credential=credential)
-        if code >= 400:
+        if not 200 <= code < 300:
             raise ValueError(f"private support status unavailable (HTTP {code}); keep request {identifier}")
-        return result
+        return support_receipt(result, identifier)

package/runtime/codex/egregore_runtime/issue_reporting.py

@@ -21,6 +21,26 @@ from .policy import scope_allows_path
 KINDS = {"bug", "improvement", "question"}
 AREAS = {"runtime", "onboarding", "connectors", "site", "other"}
 SEVERITIES = {"critical", "high", "normal"}
+SUPPORT_STATES = {"filed", "failed", "submitting", "uncertain"}
+
+
+def support_receipt(result, identifier):
+    """Accept only a receipt for this request; filing never proves notification."""
+    if (not isinstance(result, dict) or result.get('request_id') != identifier
+        or not isinstance(result.get('submission_state'), str)
+        or result['submission_state'] not in SUPPORT_STATES):
+        raise ValueError(f"private support returned an invalid receipt; keep request {identifier} and use report-status")
+    state = result['submission_state']
+    notices = {
+        'filed': 'Filed with Egregore support. Telegram delivery has not been verified.',
+        'failed': 'Report preserved; support filing failed. Retry this same request.',
+        'submitting': 'Report preserved; support filing is not confirmed. Keep this request ID and check report-status.',
+        'uncertain': 'Report preserved; support filing needs reconciliation. Keep this request ID and check report-status.',
+    }
+    return {'request_id': identifier, 'submission_state': state,
+            'retryable': state == 'failed',
+            'reconciliation_needed': state in {'submitting', 'uncertain'},
+            'notification_state': 'unverified', 'notice': notices[state]}
 
 
 def _scrub(value, *, public=False):
@@ -207,18 +227,29 @@ class FrameworkReporting:
                 return {'request_id':identifier,'status':result['status'],'github_url':result['github_url']}
             credential, _ = self._verified_credential(state['destination'],state['authenticated_org'])
             state['status'] = 'submitting'; GitHubIssues._save(path,state)
-            code, result = self.api(self.root,state['destination'],'/api/v1/support-reports',
-                {'request_id':identifier, **state['payload']},credential=credential)
-            if code >= 400:
+            try:
+                code, result = self.api(self.root,state['destination'],'/api/v1/support-reports',
+                    {'request_id':identifier, **state['payload']},credential=credential)
+            except OSError:
+                state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
+                raise OSError(f"private support response unavailable; keep request {identifier} and use report-status or confirm this same preview") from None
+            if not 200 <= code < 300:
                 state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
                 raise ValueError(f"private support request {identifier} needs recovery (HTTP {code}); use report-status or confirm this same preview")
-            state['status'] = result.get('submission_state','unknown'); GitHubIssues._save(path,state)
-            return result
+            try:
+                receipt = support_receipt(result, identifier)
+            except ValueError:
+                state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
+                raise
+            state['status'] = receipt['submission_state']; GitHubIssues._save(path,state)
+            if state['status'] != 'filed':
+                raise ValueError(f"private support request {identifier} needs recovery ({state['status']}); use report-status or confirm this same preview")
+            return receipt
 
     def status(self, identifier):
         path, state = self._load('report',identifier,write=False)
         credential, _ = self._verified_credential(state['destination'],state['authenticated_org'])
         code, result = self.api(self.root,state['destination'],f'/api/v1/support-reports/{identifier}',credential=credential)
-        if code >= 400:
+        if not 200 <= code < 300:
             raise ValueError(f"private support status unavailable (HTTP {code}); keep request {identifier}")
-        return result
+        return support_receipt(result, identifier)

package/runtime/pi/egregore_runtime/issue_reporting.py

@@ -21,6 +21,26 @@ from .policy import scope_allows_path
 KINDS = {"bug", "improvement", "question"}
 AREAS = {"runtime", "onboarding", "connectors", "site", "other"}
 SEVERITIES = {"critical", "high", "normal"}
+SUPPORT_STATES = {"filed", "failed", "submitting", "uncertain"}
+
+
+def support_receipt(result, identifier):
+    """Accept only a receipt for this request; filing never proves notification."""
+    if (not isinstance(result, dict) or result.get('request_id') != identifier
+        or not isinstance(result.get('submission_state'), str)
+        or result['submission_state'] not in SUPPORT_STATES):
+        raise ValueError(f"private support returned an invalid receipt; keep request {identifier} and use report-status")
+    state = result['submission_state']
+    notices = {
+        'filed': 'Filed with Egregore support. Telegram delivery has not been verified.',
+        'failed': 'Report preserved; support filing failed. Retry this same request.',
+        'submitting': 'Report preserved; support filing is not confirmed. Keep this request ID and check report-status.',
+        'uncertain': 'Report preserved; support filing needs reconciliation. Keep this request ID and check report-status.',
+    }
+    return {'request_id': identifier, 'submission_state': state,
+            'retryable': state == 'failed',
+            'reconciliation_needed': state in {'submitting', 'uncertain'},
+            'notification_state': 'unverified', 'notice': notices[state]}
 
 
 def _scrub(value, *, public=False):
@@ -207,18 +227,29 @@ class FrameworkReporting:
                 return {'request_id':identifier,'status':result['status'],'github_url':result['github_url']}
             credential, _ = self._verified_credential(state['destination'],state['authenticated_org'])
             state['status'] = 'submitting'; GitHubIssues._save(path,state)
-            code, result = self.api(self.root,state['destination'],'/api/v1/support-reports',
-                {'request_id':identifier, **state['payload']},credential=credential)
-            if code >= 400:
+            try:
+                code, result = self.api(self.root,state['destination'],'/api/v1/support-reports',
+                    {'request_id':identifier, **state['payload']},credential=credential)
+            except OSError:
+                state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
+                raise OSError(f"private support response unavailable; keep request {identifier} and use report-status or confirm this same preview") from None
+            if not 200 <= code < 300:
                 state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
                 raise ValueError(f"private support request {identifier} needs recovery (HTTP {code}); use report-status or confirm this same preview")
-            state['status'] = result.get('submission_state','unknown'); GitHubIssues._save(path,state)
-            return result
+            try:
+                receipt = support_receipt(result, identifier)
+            except ValueError:
+                state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
+                raise
+            state['status'] = receipt['submission_state']; GitHubIssues._save(path,state)
+            if state['status'] != 'filed':
+                raise ValueError(f"private support request {identifier} needs recovery ({state['status']}); use report-status or confirm this same preview")
+            return receipt
 
     def status(self, identifier):
         path, state = self._load('report',identifier,write=False)
         credential, _ = self._verified_credential(state['destination'],state['authenticated_org'])
         code, result = self.api(self.root,state['destination'],f'/api/v1/support-reports/{identifier}',credential=credential)
-        if code >= 400:
+        if not 200 <= code < 300:
             raise ValueError(f"private support status unavailable (HTTP {code}); keep request {identifier}")
-        return result
+        return support_receipt(result, identifier)

package/runtime/prime/egregore_runtime/issue_reporting.py

@@ -21,6 +21,26 @@ from .policy import scope_allows_path
 KINDS = {"bug", "improvement", "question"}
 AREAS = {"runtime", "onboarding", "connectors", "site", "other"}
 SEVERITIES = {"critical", "high", "normal"}
+SUPPORT_STATES = {"filed", "failed", "submitting", "uncertain"}
+
+
+def support_receipt(result, identifier):
+    """Accept only a receipt for this request; filing never proves notification."""
+    if (not isinstance(result, dict) or result.get('request_id') != identifier
+        or not isinstance(result.get('submission_state'), str)
+        or result['submission_state'] not in SUPPORT_STATES):
+        raise ValueError(f"private support returned an invalid receipt; keep request {identifier} and use report-status")
+    state = result['submission_state']
+    notices = {
+        'filed': 'Filed with Egregore support. Telegram delivery has not been verified.',
+        'failed': 'Report preserved; support filing failed. Retry this same request.',
+        'submitting': 'Report preserved; support filing is not confirmed. Keep this request ID and check report-status.',
+        'uncertain': 'Report preserved; support filing needs reconciliation. Keep this request ID and check report-status.',
+    }
+    return {'request_id': identifier, 'submission_state': state,
+            'retryable': state == 'failed',
+            'reconciliation_needed': state in {'submitting', 'uncertain'},
+            'notification_state': 'unverified', 'notice': notices[state]}
 
 
 def _scrub(value, *, public=False):
@@ -207,18 +227,29 @@ class FrameworkReporting:
                 return {'request_id':identifier,'status':result['status'],'github_url':result['github_url']}
             credential, _ = self._verified_credential(state['destination'],state['authenticated_org'])
             state['status'] = 'submitting'; GitHubIssues._save(path,state)
-            code, result = self.api(self.root,state['destination'],'/api/v1/support-reports',
-                {'request_id':identifier, **state['payload']},credential=credential)
-            if code >= 400:
+            try:
+                code, result = self.api(self.root,state['destination'],'/api/v1/support-reports',
+                    {'request_id':identifier, **state['payload']},credential=credential)
+            except OSError:
+                state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
+                raise OSError(f"private support response unavailable; keep request {identifier} and use report-status or confirm this same preview") from None
+            if not 200 <= code < 300:
                 state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
                 raise ValueError(f"private support request {identifier} needs recovery (HTTP {code}); use report-status or confirm this same preview")
-            state['status'] = result.get('submission_state','unknown'); GitHubIssues._save(path,state)
-            return result
+            try:
+                receipt = support_receipt(result, identifier)
+            except ValueError:
+                state['status'] = 'reconciliation_needed'; GitHubIssues._save(path,state)
+                raise
+            state['status'] = receipt['submission_state']; GitHubIssues._save(path,state)
+            if state['status'] != 'filed':
+                raise ValueError(f"private support request {identifier} needs recovery ({state['status']}); use report-status or confirm this same preview")
+            return receipt
 
     def status(self, identifier):
         path, state = self._load('report',identifier,write=False)
         credential, _ = self._verified_credential(state['destination'],state['authenticated_org'])
         code, result = self.api(self.root,state['destination'],f'/api/v1/support-reports/{identifier}',credential=credential)
-        if code >= 400:
+        if not 200 <= code < 300:
             raise ValueError(f"private support status unavailable (HTTP {code}); keep request {identifier}")
-        return result
+        return support_receipt(result, identifier)