create-egregore 0.21.1 → 0.21.3

package/runtime/prime/bin/lib/dashboard-artifact.sh

@@ -121,7 +121,7 @@ mkdir -p /tmp
 } > "$_DB_MD" 2>/dev/null
 
 # --- Publish markdown → HTML → hosted URL ---
-# publish-artifact.sh handles HTML generation internally (npx egregore-artifacts)
+# publish-artifact.sh handles HTML generation with the provisioned renderer.
 # then uploads. Don't pre-generate HTML — that causes double-wrapping.
 # https:// URLs are universally cmd+clickable across all terminal emulators.
 #
@@ -233,7 +233,7 @@ else
   if [ -z "$DASHBOARD_URL" ]; then
     _DB_HTML="/tmp/egregore-artifacts/dashboard-${EGREGORE_SESSION_ID}.html"
     mkdir -p /tmp/egregore-artifacts
-    if npx egregore-artifacts@latest document "$_DB_MD" --output "$_DB_HTML" --no-open >/dev/null 2>&1 && [ -f "$_DB_HTML" ]; then
+    if bash "$SCRIPT_DIR/bin/artifact-renderer.sh" document "$_DB_MD" --output "$_DB_HTML" --no-open >/dev/null 2>&1 && [ -f "$_DB_HTML" ]; then
       DASHBOARD_URL="file://${_DB_HTML}"
     fi
   fi

package/runtime/prime/bin/lib/greeting.sh

@@ -481,19 +481,8 @@ bash "$SCRIPT_DIR/bin/telemetry.sh" emit "session_start" \
 # --- Health check-in (background, non-blocking) ---
 bash "$SCRIPT_DIR/bin/startup-check.sh" >/dev/null 2>&1 &
 
-# --- Warm npx cache for egregore-artifacts (background, throttled) ---
-# publish-artifact.sh spawns `npx egregore-artifacts` — first run in a
-# fresh npx cache pays a 5-10s npm download. Warmup is throttled to
-# once per hour via a marker file so we don't storm npm when a user
-# opens many tabs, and don't start runaway retry loops when offline.
-_WARM_TS_FILE="$HOME/.cache/egregore/npx-warm-ts"
-mkdir -p "$(dirname "$_WARM_TS_FILE")" 2>/dev/null
-_WARM_LAST=$(cat "$_WARM_TS_FILE" 2>/dev/null || echo 0)
-_WARM_NOW=$(date +%s)
-if [ $(( _WARM_NOW - _WARM_LAST )) -gt 3600 ]; then
-  (npx -y egregore-artifacts@latest --help >/dev/null 2>&1 \
-    && echo "$_WARM_NOW" > "$_WARM_TS_FILE" &) >/dev/null 2>&1
-fi
+# Artifact dependencies are provisioned during explicit setup/update. Startup
+# must not warm a floating npx cache that the offline renderer cannot resolve.
 
 # Clean up temp files
 rm -rf "$CTX_DIR"

package/runtime/prime/bin/pi-product-workflows.mjs

@@ -106,10 +106,7 @@ export function parseViewRequest(root, rawArgs) {
 }
 
 function rendererCommand(root) {
-  const local = join(root, "packages", "egregore-artifacts", "bin", "cli.js");
-  const react = join(root, "packages", "egregore-artifacts", "node_modules", "react");
-  if (existsSync(local) && existsSync(react)) return { command: "node", prefix: [local] };
-  return { command: "npx", prefix: ["-y", "egregore-artifacts@latest"] };
+  return { command: "bash", prefix: [join(root, "bin", "artifact-renderer.sh")] };
 }
 
 function artifactPath(output) {

package/runtime/prime/bin/post-update.sh

@@ -10,6 +10,11 @@
 
 set -euo pipefail
 
+# This migration entry point is invoked by explicit /update, never startup.
+# The helper preserves a previous working install if provisioning fails.
+SCRIPT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+bash "$SCRIPT_DIR/bin/artifact-renderer-install.sh"
+
 MIGRATED=0
 
 # --- Migration: commands → skills (CC 2.0+) ---

package/runtime/prime/bin/publish-artifact.sh

@@ -242,34 +242,13 @@ else
     fi
   fi
 
-  # Prefer the in-repo package copy when it's present AND its dependencies
-  # have been installed — that way local edits to packages/egregore-artifacts
-  # are exercised without waiting for an npm release. Fall back to the
-  # published `npx egregore-artifacts` otherwise.
-  # Set EGREGORE_USE_PUBLISHED=1 to force the npm-published renderer even
-  # when a local install is present — useful in the upstream dev repo to
-  # dogfood what teammates and OSS users actually run.
-  LOCAL_CLI="$SCRIPT_DIR/packages/egregore-artifacts/bin/cli.js"
+  # Use the same provisioned renderer as previews and /view. Rendering never
+  # downloads a package; EGREGORE_USE_PUBLISHED skips the source checkout.
   RENDER_ERROR="/tmp/egregore-artifacts/render-error-$$.log"
-  if [ "${EGREGORE_USE_PUBLISHED:-0}" != "1" ] && [ -f "$LOCAL_CLI" ] && [ -d "$SCRIPT_DIR/packages/egregore-artifacts/node_modules/react" ]; then
-    if ! bash "$SCRIPT_DIR/bin/node-run.sh" "$LOCAL_CLI" "${RENDER_ARGS[@]}" >/dev/null 2>"$RENDER_ERROR"; then
-      sed -n '1,4p' "$RENDER_ERROR" >&2
-      rm -f "$RENDER_ERROR"
-      exit 5
-    fi
-  else
-    # Installed published renderer only — never npx/@latest: a hidden
-    # registry fetch of a floating version is not an acceptable renderer.
-    PUBLISHED_CLI="$(command -v egregore-artifacts || true)"
-    if [ -z "$PUBLISHED_CLI" ]; then
-      echo "no artifact renderer available: the checked-out packages/egregore-artifacts is unusable and no installed egregore-artifacts was found" >&2
-      exit 5
-    fi
-    if ! bash "$SCRIPT_DIR/bin/node-run.sh" "$PUBLISHED_CLI" "${RENDER_ARGS[@]}" >/dev/null 2>"$RENDER_ERROR"; then
-      sed -n '1,4p' "$RENDER_ERROR" >&2
-      rm -f "$RENDER_ERROR"
-      exit 5
-    fi
+  if ! bash "$SCRIPT_DIR/bin/artifact-renderer.sh" "${RENDER_ARGS[@]}" >/dev/null 2>"$RENDER_ERROR"; then
+    sed -n '1,4p' "$RENDER_ERROR" >&2
+    rm -f "$RENDER_ERROR"
+    exit 5
   fi
   rm -f "$RENDER_ERROR"
 fi

package/runtime/prime/bin/view-render.sh

@@ -49,19 +49,8 @@ _open() {
 }
 
 # --- Resolve the packaged deterministic renderer (never fetch, never npx) ---
-if [ -f "$SCRIPT_DIR/packages/egregore-artifacts/bin/cli.js" ] && [ -d "$SCRIPT_DIR/packages/egregore-artifacts/node_modules/react" ]; then
-  RENDER=(bash "$SCRIPT_DIR/bin/node-run.sh" "$SCRIPT_DIR/packages/egregore-artifacts/bin/cli.js")
-  RENDER_ID="$SCRIPT_DIR/packages/egregore-artifacts/bin/cli.js"
-elif [ -f "$SCRIPT_DIR/packages/egregore-artifacts/bin/cli.js" ]; then
-  echo "The checked-out artifact renderer is missing its local dependencies." >&2
-  exit 1
-elif command -v egregore-artifacts >/dev/null 2>&1; then
-  RENDER=(bash "$SCRIPT_DIR/bin/node-run.sh" "$(command -v egregore-artifacts)")
-  RENDER_ID="$(command -v egregore-artifacts)"
-else
-  echo "The local artifact renderer is not installed for this instance." >&2
-  exit 1
-fi
+RENDER_ID="$(bash "$SCRIPT_DIR/bin/artifact-renderer.sh" --resolve)" || exit 1
+RENDER=(bash "$SCRIPT_DIR/bin/node-run.sh" "$RENDER_ID")
 
 # --- Live surfaces render fresh every time (their data is the present) ------
 case "$TYPE" in

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)

package/runtime/prime/egregore_runtime/upgrade.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import json
 import os
 import re
+import signal
 import subprocess
 import sys
 import time
@@ -27,6 +28,8 @@ from typing import Any, Mapping
 from .adapters.qmd import QMD_VERSION, RERANKING_ENABLED, QmdLocalRetriever
 
 SCHEMA_VERSION = "egregore-runtime-upgrade/v1"
+_RENDERER_INSTALL_TIMEOUT_SECONDS = 180
+_RENDERER_TERMINATE_GRACE_SECONDS = 5
 
 # Stage keys in preparation order. Labels are the user-facing truth shown by
 # Settings; keep them in plain team language.
@@ -628,6 +631,54 @@ class UpgradeEngine:
         if probe.returncode != 0:
             self._fail(state, "node", "the selected Node runtime failed its version probe")
             return False
+        # Explicit Runtime preparation owns package provisioning. Preview and
+        # session startup only resolve installed renderers. Older candidates
+        # predate this helper and retain their original upgrade contract.
+        renderer_installer = (
+            Path(state.get("installed_path") or "")
+            / "runtime" / APPLY_TREE / "bin" / "artifact-renderer-install.sh"
+        )
+        if renderer_installer.is_file():
+            environment = {**os.environ, **self.retriever.environment}
+            environment["PATH"] = str(Path(node).parent) + os.pathsep + environment.get("PATH", "")
+            try:
+                with subprocess.Popen(
+                    ("bash", str(renderer_installer), "--root", str(self.repository_root)),
+                    stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True,
+                    cwd=self.repository_root, env=environment, start_new_session=True,
+                ) as renderer:
+                    try:
+                        stdout, stderr = renderer.communicate(timeout=_RENDERER_INSTALL_TIMEOUT_SECONDS)
+                    except subprocess.TimeoutExpired:
+                        # npm is a child of the installer shell. Stop the entire
+                        # group so its EXIT cleanup can run without an orphaned
+                        # package manager still writing into the staging tree.
+                        try:
+                            os.killpg(renderer.pid, signal.SIGTERM)
+                        except ProcessLookupError:
+                            pass
+                        try:
+                            renderer.communicate(timeout=_RENDERER_TERMINATE_GRACE_SECONDS)
+                        except subprocess.TimeoutExpired:
+                            pass
+                        finally:
+                            # A child may ignore TERM even after Bash exits.
+                            try:
+                                os.killpg(renderer.pid, signal.SIGKILL)
+                            except ProcessLookupError:
+                                pass
+                            renderer.communicate()
+                        raise
+            except subprocess.TimeoutExpired:
+                self._fail(state, "node", f"artifact renderer provisioning timed out after {_RENDERER_INSTALL_TIMEOUT_SECONDS} seconds; retry preparation")
+                return False
+            except OSError as exc:
+                self._fail(state, "node", f"artifact renderer provisioning failed: {exc}")
+                return False
+            if renderer.returncode != 0:
+                detail = (stderr or stdout).strip()
+                self._fail(state, "node", f"artifact renderer provisioning failed: {detail}")
+                return False
         self._mark(state, "node", "done", f"{probe.stdout.strip()} at instance-selected path")
         return True
 

package/runtime/prime/manifest.json

@@ -127,6 +127,8 @@
     "bin/agent.sh",
     "bin/api-call.sh",
     "bin/artifact-register.sh",
+    "bin/artifact-renderer-install.sh",
+    "bin/artifact-renderer.sh",
     "bin/artifact-writeback.sh",
     "bin/artifacts.sh",
     "bin/attendant.sh",
@@ -173,6 +175,8 @@
     "bin/issue.sh",
     "bin/knowledge.sh",
     "bin/lib/artifact-id.sh",
+    "bin/lib/artifact-renderer/dependencies-lock.json",
+    "bin/lib/artifact-renderer/dependencies.json",
     "bin/lib/config.sh",
     "bin/lib/context.sh",
     "bin/lib/dashboard-artifact.sh",