convene-cli 1.4.2 → 1.4.4

package/dist/cache.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.OVERRIDE_TTL_MS = exports.writeWatchHighWater = void 0;
+exports.OVERRIDE_TTL_MS = exports.writeWatchHighWater = exports.LIVE_SESSION_WINDOW_SEC = void 0;
 exports.readCache = readCache;
 exports.writeCache = writeCache;
 exports.ageSeconds = ageSeconds;
@@ -140,17 +140,46 @@ function ensureSessionInstance(slug) {
     return readSessionInstance(slug) || mintSessionInstance(slug);
 }
 /**
- * Count DISTINCT sessions that have touched this checkout within `maxAgeSec`, by
- * scanning the per-session local-state files for `<slug>` (`.json` cache, refreshed
- * each active prompt, + `.instance`). A bare slug and each `#<disc>` scope counts
- * once. `doctor` uses this to nudge toward one-worktree-per-session when several
- * agents share a checkout. Best-effort: any error → 0 (no nudge). The slug is
- * sanitized to `[A-Za-z0-9_-]` so it is already regex-safe to anchor.
+ * "Live session" window for the share-this-checkout nudge. It measures RECENT
+ * concurrent activity, not history: a session counts only if it fetched the feed
+ * within this window (see liveSessionCount). Tighter than the prior 15 min
+ * (practice-guard) / 30 min (doctor) windows so a long-closed session no longer
+ * lingers in the count, but long enough to still catch two agents both actively
+ * driving a shared checkout across multi-minute turns. 10 min is the balance
+ * point: shorter risks missing a concurrent agent mid-long-turn (its `.json`
+ * pulse only refreshes on a prompt); longer keeps just-closed/relaunched sessions
+ * counted longer (the relaunch-ghost below).
+ */
+exports.LIVE_SESSION_WINDOW_SEC = 10 * 60;
+/**
+ * Count DISTINCT *live* sessions sharing this checkout within `maxAgeSec`, where
+ * "live" = the session refreshed its feed cache (`<slug>[_<disc>].json`) within
+ * the window. The feed cache is rewritten by `convene fetch` on every active
+ * prompt, so its mtime is a per-session liveness pulse.
+ *
+ * We count ONLY `.json`, never `.instance`: the instance file is stamped ONCE at
+ * SessionStart and never refreshed, so a long-dead boot's `.instance` would
+ * otherwise masquerade as a live co-tenant. Excluding it (plus the tighter
+ * window) removes the STRUCTURAL onboarding false positives — an instance-ghost
+ * from a prior boot, and a one-off terminal `convene doctor`/`post` (which never
+ * writes a feed cache) — while a genuinely concurrent session (which fetches each
+ * prompt) is still counted.
+ *
+ * Two residual limits are inherent to a filesystem-only signal, not bugs: (1) the
+ * RELAUNCH-GHOST — a session closed then relaunched within the window still shows
+ * until the prior session's `.json` ages out, because a closed session's last
+ * `.json` is indistinguishable from an idle-but-live one (the window is the only
+ * lever); (2) an agent MID-LONG-TURN (> window since its last prompt, no
+ * intervening fetch) ages out of the count — a future refinement could also pulse
+ * the `.json` mtime on edit-hook activity. A bare slug and each `#<disc>` scope
+ * counts once. `doctor` / `practice-guard` use this to nudge toward one-worktree-
+ * per-session ONLY when sessions are concurrently active. Best-effort: any error →
+ * 0 (no nudge). The slug is sanitized to `[A-Za-z0-9_-]` so it is regex-safe.
  */
 function liveSessionCount(slug, maxAgeSec) {
     try {
         const san = slug.replace(/[^a-zA-Z0-9_-]/g, '_');
-        const re = new RegExp(`^${san}(_[a-z0-9-]+)?\\.(json|instance)$`);
+        const re = new RegExp(`^${san}(_[a-z0-9-]+)?\\.json$`);
         const cutoff = Date.now() - maxAgeSec * 1000;
         const scopes = new Set();
         for (const f of node_fs_1.default.readdirSync(config_1.CACHE_DIR)) {

package/dist/commands/auth.js

@@ -260,14 +260,18 @@ async function doctor(opts) {
     // working tree clobber each other's uncommitted files and (absent the
     // discriminator) collapse to one bus identity. Convene now auto-disambiguates
     // them, but a worktree apiece is the cleaner default — so nudge when ≥2 sessions
-    // have recently touched this checkout. Purely informational (never fails doctor).
+    // are CONCURRENTLY ACTIVE in this checkout (each has fetched within the short
+    // liveness window; see liveSessionCount). Purely informational (never fails
+    // doctor) — and deliberately NOT a one-off terminal command or a just-closed
+    // session, so it doesn't false-fire during onboarding.
     if (proj?.slug) {
-        const n = (0, cache_1.liveSessionCount)(proj.slug, 30 * 60); // active within the last 30 min
+        const n = (0, cache_1.liveSessionCount)(proj.slug, cache_1.LIVE_SESSION_WINDOW_SEC);
         if (n >= 2) {
+            const mins = Math.round(cache_1.LIVE_SESSION_WINDOW_SEC / 60);
             checks.push({
                 name: 'sessions',
                 ok: true,
-                detail: `${n} sessions share this checkout (last 30m) — prefer one git worktree each: \`convene worktree <branch>\``,
+                detail: `${n} sessions active in this checkout (last ${mins}m) — prefer one git worktree each: \`convene worktree <branch>\``,
             });
         }
     }

package/dist/commands/fetch.js

@@ -3,6 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.FEED_FAST_FAIL_MS = void 0;
+exports.fetchFeedResilient = fetchFeedResilient;
 exports.runFetch = runFetch;
 /**
  * `convene fetch` — the UserPromptSubmit hook.
@@ -31,6 +33,57 @@ const FETCH_TIMEOUT_MS = 4000;
 const WATCHDOG_MS = 6000;
 /** Catalog-version cache TTL for the behind-nudge — long enough to stay off the hot path. */
 const CATALOG_VERSION_TTL_SEC = 3600;
+// ── feed-fetch resilience (single transient blip → no loud DEGRADED) ──────────
+// The bus runs a SINGLE web task; a deploy rollout, task restart, or RDS
+// backup-window connection blip leaves a brief window where one feed fetch fails.
+// Without a retry that one failure renders the loud "DEGRADED — could not reach"
+// line on the very next prompt — alarming during onboarding even though the bus is
+// fine a second later. So we retry ONCE, but only when the first attempt failed
+// FAST with a likely-TRANSIENT class (a network error or a 5xx, NOT a full timeout
+// and NOT a 4xx — neither is cured by retrying), and ALWAYS within the SAME total
+// network budget. A genuine outage (a black-hole) still hits the budget and
+// surfaces DEGRADED just as fast. The WORST-CASE wall time is unchanged
+// (<= FEED_BUDGET_MS); the one deliberate trade is that the first-attempt timeout
+// is ~500ms tighter than the old single 4000ms attempt, so a pathologically
+// slow-but-alive server (responding in the 3.5–4s band) now degrades where it
+// previously squeaked through — an acceptable price for absorbing the common
+// fast blip, given the bus normally answers in ~0.15s.
+/** Total network budget for the feed fetch across all attempts (== FETCH_TIMEOUT_MS). */
+const FEED_BUDGET_MS = FETCH_TIMEOUT_MS;
+/** First-attempt timeout. ~500ms under FETCH_TIMEOUT_MS, leaving room for a retry. */
+const FEED_ATTEMPT_MS = 3500;
+/** A failure faster than this is treated as a transient blip worth one retry. */
+exports.FEED_FAST_FAIL_MS = 1200;
+/** Brief pause before the retry, to let a restarting task come back. */
+const FEED_RETRY_BACKOFF_MS = 250;
+/** Skip the retry if less than this much budget remains (defensive; binds only if FAST_FAIL is raised). */
+const FEED_MIN_RETRY_MS = 750;
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Fetch the feed with one within-budget retry for a FAST transient failure.
+ * Returns the (possibly still-failed) ApiResult — the caller renders DEGRADED on a
+ * non-ok result exactly as before. Worst-case wall time is FEED_BUDGET_MS, so a
+ * black-hole / sustained outage is surfaced no slower than the old single attempt.
+ */
+async function fetchFeedResilient(api, slug, q) {
+    const started = Date.now();
+    let res = await api.feed(slug, q, FEED_ATTEMPT_MS);
+    if (res.ok)
+        return res;
+    const elapsed = Date.now() - started;
+    // Retry ONLY a fast, likely-transient failure — a network error (status 0) or a
+    // 5xx (server momentarily down). A 4xx (auth / not-found) won't be cured by a
+    // retry, so don't burn the round-trip. Always within whatever budget remains.
+    const transient = res.status === 0 || res.status >= 500;
+    const retryMs = FEED_BUDGET_MS - elapsed - FEED_RETRY_BACKOFF_MS;
+    if (transient && elapsed < exports.FEED_FAST_FAIL_MS && retryMs >= FEED_MIN_RETRY_MS) {
+        await sleep(FEED_RETRY_BACKOFF_MS);
+        res = await api.feed(slug, q, retryMs);
+    }
+    return res;
+}
 /**
  * A single fail-soft nudge line iff the repo's adopted-practices manifest trails a
  * CACHED live catalog version. Reads only local state (the manifest + the catalog-
@@ -170,9 +223,10 @@ async function runFetch(opts = {}) {
             emitNudge();
             return done(0);
         }
-        // Slow path: bounded network fetch.
+        // Slow path: bounded network fetch, with one within-budget retry so a single
+        // transient blip doesn't render the loud DEGRADED line on the next prompt.
         const api = new api_1.ConveneApi(cfg.baseUrl, cfg.apiKey, session, cfg.tool);
-        const res = await api.feed(slug, { lookbackMin: lookback, max }, FETCH_TIMEOUT_MS);
+        const res = await fetchFeedResilient(api, slug, { lookbackMin: lookback, max });
         if (res.ok && res.json) {
             (0, cache_1.writeCache)(slug, res.json);
             renderData(res.json, { slug, member, session, lookback, syncedAgoSec: 0, json: opts.json });

package/dist/commands/init.js

@@ -552,15 +552,29 @@ function writeCoordinationBlocks(top, slug, member, baseUrl) {
  */
 function commitConveneFiles(top, message, label) {
     const paths = exports.CONVENE_PATHS.filter((p) => node_fs_1.default.existsSync(node_path_1.default.join(top, p)));
-    if (paths.length && (0, git_1.gitAddPaths)(paths, top)) {
-        const res = (0, git_1.gitCommit)(message, paths, top);
-        if (res.ok)
-            log(`✓ committed ${label} as one isolated commit${res.sha ? ` (${res.sha})` : ''} — only the convene files were staged.`);
-        else
-            log('· nothing committed (no staged changes).');
-    }
-    else if (paths.length) {
+    if (!paths.length)
+        return;
+    // Decide up front whether anything under the managed paths is actually pending
+    // (staged/unstaged/untracked). This makes `--commit` deterministic and TRANSPARENT:
+    // a clean re-render says "already up to date" instead of a vague no-op, and a tree
+    // dirtied by an EARLIER `--refresh-docs` (without `--commit`) still gets committed
+    // — the gotcha that previously left changes stranded.
+    const pending = (0, git_1.gitPendingPaths)(paths, top);
+    if (!pending.length) {
+        log(`· ${label}: managed files already committed — nothing to commit.`);
+        return;
+    }
+    if (!(0, git_1.gitAddPaths)(paths, top)) {
         log('⚠ could not stage the convene files — commit them manually.');
+        return;
+    }
+    const res = (0, git_1.gitCommit)(message, paths, top);
+    if (res.ok) {
+        log(`✓ committed ${label} as one isolated commit${res.sha ? ` (${res.sha})` : ''} — ${pending.length} convene file(s) staged, nothing else.`);
+    }
+    else {
+        // pending changes existed but the commit did not land — never silent.
+        log(`⚠ ${pending.length} convene file(s) are staged but the commit did not land — commit them manually (\`git commit\`).`);
     }
 }
 /**

package/dist/commands/practice-guard.js

@@ -263,7 +263,7 @@ async function run(opts, id) {
         case 'worktree-per-session': {
             // hook-soft: if >1 live session shares this checkout, nudge toward a worktree
             // (reuse the doctor signal). Best-effort; any uncertainty → no nudge.
-            const live = (0, cache_1.liveSessionCount)(slug, 15 * 60);
+            const live = (0, cache_1.liveSessionCount)(slug, cache_1.LIVE_SESSION_WINDOW_SEC);
             if (live > 1) {
                 note(`convene: ${live} live sessions share this checkout — worktree-per-session. ` +
                     `Run each concurrent agent in its own worktree (\`convene worktree <branch>\`) to avoid silent clobbering.` +

package/dist/git.js

@@ -26,6 +26,7 @@ exports.gitConfigUnsetLocal = gitConfigUnsetLocal;
 exports.pathIsTracked = pathIsTracked;
 exports.hasStagedChanges = hasStagedChanges;
 exports.gitAddPaths = gitAddPaths;
+exports.gitPendingPaths = gitPendingPaths;
 exports.gitCommit = gitCommit;
 exports.gitPathIsIgnored = gitPathIsIgnored;
 /** Cross-platform git helpers. No shell strings — spawn git directly (P0-XPLAT). */
@@ -305,6 +306,30 @@ function gitAddPaths(paths, cwd = process.cwd()) {
         return false;
     }
 }
+/**
+ * The subset of `paths` that have PENDING changes (staged, unstaged, or untracked),
+ * via `git status --porcelain -- <paths>`. Lets a caller decide whether there is
+ * anything to commit BEFORE running `git commit` — so an isolated-commit helper can
+ * say "already up to date" plainly instead of relying on a non-zero `git commit`
+ * exit. Returns [] on any error / clean tree (never throws).
+ */
+function gitPendingPaths(paths, cwd = process.cwd()) {
+    if (paths.length === 0)
+        return [];
+    try {
+        const r = (0, node_child_process_1.spawnSync)('git', ['status', '--porcelain', '--', ...paths], { cwd, encoding: 'utf8', timeout: 5000 });
+        if (r.status !== 0 || !r.stdout)
+            return [];
+        // Porcelain v1 line: "XY <path>"; we only need the count/names, not the status.
+        return r.stdout
+            .split('\n')
+            .map((l) => l.slice(3).trim())
+            .filter(Boolean);
+    }
+    catch {
+        return [];
+    }
+}
 /**
  * Commit ONLY the given pathspecs (`git commit -m <msg> -- <paths>`), leaving any
  * other staged changes untouched — the isolated-commit guarantee. Returns the short

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "convene-cli",
-  "version": "1.4.2",
+  "version": "1.4.4",
   "description": "Convene CLI — AI development coordination bus client + UserPromptSubmit hook. Install: npm i -g convene-cli; then `convene setup`.",
   "license": "MIT",
   "homepage": "https://dev.convene.live",