convene-cli 1.5.1 → 1.7.0

package/dist/commands/worktree.js

@@ -3,7 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyWorktreeIncludes = copyWorktreeIncludes;
+exports.provisionWorktree = provisionWorktree;
 exports.worktree = worktree;
+exports.provisionAutoWorktree = provisionAutoWorktree;
 /**
  * `convene worktree <branch>` — create an isolated git worktree for a parallel
  * session. This is Convene's recommended default for running several coding agents
@@ -14,6 +17,10 @@ exports.worktree = worktree;
  *
  * DIE-LOUD like the other interactive verbs (stderr + non-zero exit on failure).
  * Pure git plumbing — does NOT require the repo to be on the Convene bus.
+ *
+ * The provisioning CORE (`provisionWorktree`) is factored out of the command so
+ * the auto-isolate SessionStart path (`provisionAutoWorktree`) can reuse the exact
+ * same git plumbing + `.worktreeinclude` copy — fail-OPEN there, die-LOUD here.
  */
 const node_child_process_1 = require("node:child_process");
 const node_path_1 = __importDefault(require("node:path"));
@@ -24,6 +31,88 @@ function refExists(ref, cwd) {
     const r = (0, node_child_process_1.spawnSync)('git', ['rev-parse', '--verify', '--quiet', ref], { cwd, encoding: 'utf8' });
     return r.status === 0;
 }
+/**
+ * The `.worktreeinclude` format (read from `<top>/.worktreeinclude`):
+ *   - one relative path per line, resolved against the SOURCE worktree's toplevel;
+ *   - lines beginning with `#` are comments; blank/whitespace-only lines are ignored;
+ *   - a leading `!` or absolute path or `..` traversal is rejected (never escapes <top>);
+ *   - each entry may be a file OR a directory (copied recursively);
+ *   - a missing entry is silently skipped (gitignored config that just isn't present).
+ *
+ * Purpose: carry gitignored local config (e.g. `.env`, `.envrc`, `.claude/settings.local.json`)
+ * from the source checkout into a freshly-provisioned worktree, since git itself
+ * only materializes TRACKED files. Best-effort: any per-entry error is swallowed so
+ * a copy failure can never wedge worktree creation (critical on the auto-isolate path).
+ */
+function copyWorktreeIncludes(top, dest) {
+    let raw;
+    try {
+        raw = node_fs_1.default.readFileSync(node_path_1.default.join(top, '.worktreeinclude'), 'utf8');
+    }
+    catch {
+        return; // no include file → nothing to carry
+    }
+    for (const line of raw.split('\n')) {
+        const entry = line.trim();
+        if (!entry || entry.startsWith('#'))
+            continue;
+        // Reject anything that could escape <top>: leading '!', absolute, or any '..' segment.
+        if (entry.startsWith('!') || node_path_1.default.isAbsolute(entry))
+            continue;
+        const rel = node_path_1.default.normalize(entry);
+        if (rel === '..' || rel.startsWith('..' + node_path_1.default.sep) || rel.split(node_path_1.default.sep).includes('..'))
+            continue;
+        const src = node_path_1.default.join(top, rel);
+        const dst = node_path_1.default.join(dest, rel);
+        try {
+            if (!node_fs_1.default.existsSync(src))
+                continue; // skip missing entries
+            node_fs_1.default.mkdirSync(node_path_1.default.dirname(dst), { recursive: true });
+            node_fs_1.default.cpSync(src, dst, { recursive: true });
+        }
+        catch {
+            /* best-effort per entry — never let a copy failure wedge provisioning */
+        }
+    }
+}
+/**
+ * Hard ceiling on `git worktree add` (a full working-tree checkout). On the AUTO
+ * path this runs SYNCHRONOUSLY inside SessionStart, and the boot's async 6s
+ * watchdog cannot interrupt synchronous work — so a large/slow repo could stall the
+ * boot. A bounded spawnSync caps that: a timeout kills git and we fail-open.
+ */
+const WORKTREE_ADD_TIMEOUT_MS = 20_000;
+/**
+ * The reusable provisioning core: resolve the branch (existing local / existing
+ * remote-only / new), run `git worktree add`, then copy `.worktreeinclude` config
+ * into the new tree. Returns {dest, branch} on success or null on ANY failure —
+ * the caller decides whether to die-loud (interactive) or fail-open (auto).
+ */
+function provisionWorktree(args) {
+    const { top, branch, dest, fromRef, quiet } = args;
+    if (node_fs_1.default.existsSync(dest))
+        return null;
+    const localExists = refExists(`refs/heads/${branch}`, top);
+    const remoteExists = !localExists && refExists(`refs/remotes/origin/${branch}`, top);
+    // Existing local branch → check it out; existing remote-only branch → create a
+    // local tracking branch; otherwise → new branch from fromRef (or HEAD).
+    const gitArgs = localExists
+        ? ['worktree', 'add', dest, branch]
+        : remoteExists
+            ? ['worktree', 'add', '-b', branch, dest, `origin/${branch}`]
+            : ['worktree', 'add', '-b', branch, dest, fromRef || 'HEAD'];
+    const r = (0, node_child_process_1.spawnSync)('git', gitArgs, {
+        cwd: top,
+        stdio: quiet ? 'ignore' : 'inherit',
+        timeout: WORKTREE_ADD_TIMEOUT_MS,
+    });
+    if (r.status !== 0)
+        return null;
+    // Carry gitignored local config (e.g. .env) into the new tree — best-effort.
+    copyWorktreeIncludes(top, dest);
+    const branchNote = localExists ? '' : remoteExists ? ` (new, tracking origin/${branch})` : ' (new)';
+    return { dest, branch, branchNote };
+}
 function worktree(branch, opts = {}) {
     const top = (0, git_1.gitToplevel)();
     if (!top)
@@ -35,29 +124,78 @@ function worktree(branch, opts = {}) {
     const dest = node_path_1.default.resolve(opts.path || node_path_1.default.join(node_path_1.default.dirname(top), `${base}-${safeBranch}`));
     if (node_fs_1.default.existsSync(dest))
         (0, ctx_1.die)(`destination already exists: ${dest}`);
-    const localExists = refExists(`refs/heads/${branch}`, top);
-    const remoteExists = !localExists && refExists(`refs/remotes/origin/${branch}`, top);
-    // Existing local branch → check it out; existing remote-only branch → create a
-    // local tracking branch; otherwise → new branch from --from (or HEAD).
-    const args = localExists
-        ? ['worktree', 'add', dest, branch]
-        : remoteExists
-            ? ['worktree', 'add', '-b', branch, dest, `origin/${branch}`]
-            : ['worktree', 'add', '-b', branch, dest, opts.from || 'HEAD'];
-    const r = (0, node_child_process_1.spawnSync)('git', args, { cwd: top, stdio: 'inherit' });
-    if (r.status !== 0)
-        (0, ctx_1.die)(`git worktree add failed (exit ${r.status ?? '?'})`);
-    const branchNote = localExists ? '' : remoteExists ? ` (new, tracking origin/${branch})` : ' (new)';
+    const res = provisionWorktree({ top: top, branch, dest, fromRef: opts.from });
+    if (!res)
+        (0, ctx_1.die)(`git worktree add failed`);
     process.stdout.write([
         ``,
-        `✓ worktree ready: ${dest}`,
-        `  branch: ${branch}${branchNote}`,
+        `✓ worktree ready: ${res.dest}`,
+        `  branch: ${branch}${res.branchNote}`,
         ``,
         `Start a FRESH agent session inside it so it gets its own Convene identity:`,
-        `  cd ${dest}`,
+        `  cd ${res.dest}`,
         `  # install deps for this package if needed, then launch your agent (e.g. \`claude\`)`,
         ``,
-        `Remove it when done:  git worktree remove ${dest}`,
+        `Remove it when done:  git worktree remove ${res.dest}`,
         ``,
     ].join('\n'));
 }
+/** A safe, filesystem-friendly token from an arbitrary string (for branch/dir names). */
+function safeToken(s) {
+    return s.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 24) || 'sess';
+}
+/**
+ * The AUTO-ISOLATE provisioning entry point used by SessionStart when a session
+ * boots into a checkout that already has a live sibling. FAIL-OPEN end-to-end:
+ * returns {dest, branch} on success or null on ANY error — the boot proceeds
+ * normally on null.
+ *
+ * Strategy:
+ *   1. Best-effort refresh the base (`git fetch origin main`) so the new tree is
+ *      based on fresh upstream, not a stale local tip. A fetch failure is ignored.
+ *   2. Pick the base ref: the current branch's upstream if it has one, else
+ *      `origin/main` (falling back to `HEAD` only if neither resolves).
+ *   3. Compute a NON-colliding branch name `auto/<disc-or-member>-<short>` and a
+ *      NON-colliding sibling destination, bumping a counter on collision.
+ *   4. provisionWorktree(...) (which also copies `.worktreeinclude`).
+ */
+function provisionAutoWorktree(top, slug) {
+    try {
+        // 1. Best-effort refresh of the canonical base.
+        (0, git_1.gitFetch)('main', 'origin', top);
+        // 2. Base ref: current branch's upstream, else origin/main, else HEAD.
+        let fromRef = 'origin/main';
+        if (!refExists('refs/remotes/origin/main', top))
+            fromRef = 'HEAD';
+        const cur = (0, git_1.currentBranch)(top);
+        if (cur) {
+            const up = (0, node_child_process_1.spawnSync)('git', ['rev-parse', '--abbrev-ref', '--symbolic-full-name', `${cur}@{upstream}`], {
+                cwd: top,
+                encoding: 'utf8',
+            });
+            const upstream = up.status === 0 ? (up.stdout || '').trim() : '';
+            if (upstream && refExists(`refs/remotes/${upstream}`, top))
+                fromRef = upstream;
+        }
+        // 3. Non-colliding branch name + destination.
+        const disc = (0, git_1.sessionDiscriminator)();
+        const tag = safeToken(disc || slug);
+        const base = (0, git_1.worktreeBasename)(top);
+        const parent = node_path_1.default.dirname(top);
+        let branch = `auto/${tag}`;
+        let dest = node_path_1.default.join(parent, `${base}-auto-${tag}`);
+        let n = 1;
+        while (refExists(`refs/heads/${branch}`, top) || node_fs_1.default.existsSync(dest)) {
+            n += 1;
+            branch = `auto/${tag}-${n}`;
+            dest = node_path_1.default.join(parent, `${base}-auto-${tag}-${n}`);
+            if (n > 50)
+                return null; // pathological — give up rather than spin
+        }
+        const res = provisionWorktree({ top, branch, dest, fromRef, quiet: true });
+        return res ? { dest: res.dest, branch: res.branch } : null;
+    }
+    catch {
+        return null; // fail-open: any error → no relocation, boot proceeds
+    }
+}

package/dist/config.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CACHE_DIR = exports.CONFIG_FILE = exports.CONFIG_DIR = void 0;
 exports.homeBase = homeBase;
+exports.resolveFetchTimeoutMs = resolveFetchTimeoutMs;
+exports.resolveWatchMaxMs = resolveWatchMaxMs;
 exports.isWorldReadable = isWorldReadable;
 exports.loadFileConfig = loadFileConfig;
 exports.loadProjectConfig = loadProjectConfig;
@@ -28,6 +30,34 @@ const brand_1 = require("./brand");
 function homeBase() {
     return process.env.CONVENE_HOME_OVERRIDE || node_os_1.default.homedir();
 }
+/**
+ * Network fetch timeout (ms) for the hook/catch-up paths. Overridable via
+ * CONVENE_FETCH_TIMEOUT_MS so the fail-open/timeout tests can drive the path
+ * deterministically with a small value instead of relying on the real 4s
+ * wall-clock — which, under full-suite serial load, collides with process-spawn
+ * + GC jitter and intermittently blows the latency-budget assertion. A garbage or
+ * non-positive value falls back to the default. Production default unchanged (4000).
+ */
+function resolveFetchTimeoutMs(fallback = 4000) {
+    const raw = process.env.CONVENE_FETCH_TIMEOUT_MS;
+    const n = raw ? Number(raw) : NaN;
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
+/**
+ * Hard ceiling (ms) on a single `convene watch` daemon's total lifetime — the
+ * absolute-runtime half of the leak fix (the other half is idle exit; see
+ * watch.ts). A detached watcher self-terminates once it has run this long so an
+ * orphaned daemon can never live forever (the 145-leaked-watchers bug). Mirrors
+ * resolveFetchTimeoutMs: a positive finite CONVENE_WATCH_MAX_MS wins (floored),
+ * else the fallback. Tests drive it tiny for a deterministic exit; the production
+ * default is 12h — comfortably longer than any real heads-down turn, and a fresh
+ * watcher is relaunched at the next SessionStart regardless.
+ */
+function resolveWatchMaxMs(fallback = 12 * 60 * 60 * 1000) {
+    const raw = process.env.CONVENE_WATCH_MAX_MS;
+    const n = raw ? Number(raw) : NaN;
+    return Number.isFinite(n) && n > 0 ? Math.floor(n) : fallback;
+}
 exports.CONFIG_DIR = node_path_1.default.join(homeBase(), brand_1.BRAND.configDir);
 exports.CONFIG_FILE = node_path_1.default.join(exports.CONFIG_DIR, 'config.json');
 exports.CACHE_DIR = node_path_1.default.join(exports.CONFIG_DIR, 'cache');

package/dist/index.js

@@ -57,9 +57,11 @@ const lane_1 = require("./commands/lane");
 const deploy_1 = require("./commands/deploy");
 const guard_1 = require("./commands/guard");
 const gate_push_1 = require("./commands/gate-push");
+const beat_1 = require("./commands/beat");
 const practice_guard_1 = require("./commands/practice-guard");
 const override_1 = require("./commands/override");
 const watch_1 = require("./commands/watch");
+const watch_reap_1 = require("./commands/watch-reap");
 const explain_1 = require("./commands/explain");
 const practices_1 = require("./commands/practices");
 const update_1 = require("./commands/update");
@@ -168,12 +170,22 @@ program
     .option('--reason <text>', 'why the gate is being overridden (required; attributed to the bus)')
     .option('--project <slug>')
     .action((id, opts) => (0, override_1.override)(id, opts));
+program
+    .command('beat')
+    .description('PostToolUse hook: debounced session activity-beat (presence), fail-open + fast')
+    .option('--stdin', 'read the PostToolUse JSON payload from stdin (to derive the coarse area)')
+    .action((opts) => (0, beat_1.beat)(opts));
 program
     .command('watch')
     .description('SessionStart-launched detached long-poll for directed halts (fail-open, self-healing)')
     .option('--notify', 'best-effort desktop notification per surfaced halt')
     .option('--project <slug>')
     .action((opts) => (0, watch_1.watch)(opts));
+program
+    .command('watch-reap')
+    .description('reap orphaned (PID-1) detached `convene watch` daemons (POSIX-only, fail-open)')
+    .option('--dry-run', 'list reapable watchers; kill nothing')
+    .action((opts) => (0, watch_reap_1.watchReap)({ dryRun: opts.dryRun }));
 program
     .command('notify-push')
     .description('git pre-push hook: post a [STATUS] summarizing the push (fail-silent)')

package/dist/render.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SESSION_OPEN_TAG = exports.UNTRUSTED_LABEL = void 0;
+exports.RELOCATE_TAG = exports.SESSION_OPEN_TAG = exports.UNTRUSTED_LABEL = void 0;
 exports.inertToken = inertToken;
 exports.renderHealthLine = renderHealthLine;
 exports.renderRecentLine = renderRecentLine;
 exports.renderOpenItem = renderOpenItem;
 exports.renderChannelBlock = renderChannelBlock;
 exports.renderSessionOpenBlock = renderSessionOpenBlock;
+exports.renderRelocateBlock = renderRelocateBlock;
 /**
  * The `<convene-channel>` render contract (P0-RENDER) + untrusted-prompt fencing
  * (P0-PROMPT). This is the ONE place the agent-facing text grammar is produced,
@@ -176,6 +177,31 @@ function renderLaneHaltSection(L, lanes, halts) {
         L.push('');
     }
 }
+/** Compact "Active sessions" block — a faint pulse of who else is working now. */
+function renderPresenceSection(L, presence) {
+    if (!presence.length)
+        return;
+    L.push('Active sessions (working now):');
+    for (const p of presence.slice(0, 8)) {
+        const bits = [inertToken(p.session, 64)];
+        if (p.area)
+            bits.push(inertToken(p.area, 32));
+        if (p.edits)
+            bits.push(`${p.edits} edit${p.edits === 1 ? '' : 's'}`);
+        if (p.ageSec != null && Number.isFinite(p.ageSec))
+            bits.push(presenceAge(p.ageSec));
+        L.push('  · ' + bits.join(' · '));
+    }
+    L.push('');
+}
+function presenceAge(sec) {
+    const s = Math.max(0, Math.round(sec));
+    if (s < 60)
+        return `${s}s ago`;
+    if (s < 3600)
+        return `${Math.round(s / 60)}m ago`;
+    return `${Math.round(s / 3600)}h ago`;
+}
 function renderChannelBlock(input) {
     const { slug, member, session, lookbackMin, openItems, recent, health } = input;
     const lanes = input.lanes ?? [];
@@ -204,6 +230,7 @@ function renderChannelBlock(input) {
     // High-priority interrupts + active deploy lanes, above Open items (DEGRADED
     // suppresses these structurally — the caller passes empty arrays).
     renderLaneHaltSection(L, lanes, halts);
+    renderPresenceSection(L, input.presence ?? []);
     L.push('Open items for you:');
     if (openItems.length === 0) {
         L.push('  (none)');
@@ -295,3 +322,20 @@ function renderSessionOpenBlock(input) {
     L.push(`</${exports.SESSION_OPEN_TAG}>`);
     return L.join('\n');
 }
+// ── <convene-relocate> (auto-isolate) ────────────────────────────────────────
+exports.RELOCATE_TAG = 'convene-relocate';
+/**
+ * The `<convene-relocate>` block emitted at SessionStart when this session booted
+ * into a checkout that already has a live sibling and a clean isolated worktree was
+ * provisioned for it. It is an IMPERATIVE, NON-alarming instruction the agent acts
+ * on — framed as "a tree is ready, move there", not a warning. Deliberately no
+ * "WARNING"; the move is the recommended, friction-free path.
+ */
+function renderRelocateBlock(input) {
+    const { dest, branch } = input;
+    return (`<${exports.RELOCATE_TAG}>\n` +
+        `Another live session is active in this checkout. A clean isolated worktree is ready for you ` +
+        `at ${dest} (branch ${branch}, based on fresh origin/main, gitignored config copied). ` +
+        `To avoid clobbering the other session's files, relocate now: run \`cd ${dest}\` and continue your work there.\n` +
+        `</${exports.RELOCATE_TAG}>`);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "convene-cli",
-  "version": "1.5.1",
+  "version": "1.7.0",
   "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",