delimit-cli 4.0.2 → 4.0.4

package/lib/continuity-resolver.js

@@ -0,0 +1,325 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const KNOWN_WORKSPACES_FILE = path.join(os.homedir(), '.delimit', 'known_workspaces.json');
+const WORKSPACE_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
+const ACTIVE_VENTURE_FILE = path.join(os.homedir(), '.delimit', 'active_venture.json');
+
+function resolveRepoRoot(startDir = process.cwd()) {
+    let current = path.resolve(startDir);
+    const seen = new Set();
+    const homeDir = os.homedir();
+
+    while (!seen.has(current)) {
+        seen.add(current);
+        if (
+            fs.existsSync(path.join(current, '.git'))
+            || (
+                current !== homeDir
+                && fs.existsSync(path.join(current, '.delimit', 'ledger', 'operations.jsonl'))
+            )
+        ) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return null;
+        }
+        current = parent;
+    }
+    return null;
+}
+
+function readGitHubIdentity(homeDir) {
+    const candidates = [
+        path.join(homeDir, '.config', 'gh', 'hosts.yml'),
+        path.join(homeDir, '.delimit', 'github-user.json')
+    ];
+
+    for (const candidate of candidates) {
+        if (!fs.existsSync(candidate)) {
+            continue;
+        }
+
+        const content = fs.readFileSync(candidate, 'utf8');
+        const loginMatch = content.match(/user:\s*([^\s]+)/) || content.match(/"login"\s*:\s*"([^"]+)"/);
+        if (loginMatch) {
+            return loginMatch[1];
+        }
+    }
+
+    return process.env.GITHUB_USER || process.env.GITHUB_ACTOR || null;
+}
+
+function sanitizeSegment(value, fallback) {
+    if (!value || typeof value !== 'string') {
+        return fallback;
+    }
+    const cleaned = value.trim().replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+    return cleaned || fallback;
+}
+
+function resolveLedgerRoot(repoGovernanceRoot, delimitHome) {
+    const repoLedgerRoot = repoGovernanceRoot ? path.join(repoGovernanceRoot, 'ledger') : null;
+    if (repoLedgerRoot && fs.existsSync(path.join(repoLedgerRoot, 'operations.jsonl'))) {
+        return {
+            ledgerRoot: repoLedgerRoot,
+            ledgerScope: 'repo',
+        };
+    }
+    return {
+        ledgerRoot: path.join(delimitHome, 'ledger'),
+        ledgerScope: 'global',
+    };
+}
+
+function readJson(filePath, fallback = null) {
+    try {
+        return JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    } catch {
+        return fallback;
+    }
+}
+
+function writeJson(filePath, value) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(value, null, 2) + '\n');
+}
+
+function countImmediateRepoLedgers(basePath) {
+    if (!fs.existsSync(basePath)) {
+        return 0;
+    }
+    let count = 0;
+    for (const child of ['ventures', 'apps', 'repos']) {
+        const childRoot = path.join(basePath, child);
+        if (!fs.existsSync(childRoot)) continue;
+        for (const entry of fs.readdirSync(childRoot, { withFileTypes: true })) {
+            if (!entry.isDirectory()) continue;
+            const ledgerFile = path.join(childRoot, entry.name, '.delimit', 'ledger', 'operations.jsonl');
+            if (fs.existsSync(ledgerFile)) {
+                count += 1;
+            }
+        }
+    }
+    return count;
+}
+
+function loadKnownWorkspaces() {
+    const data = readJson(KNOWN_WORKSPACES_FILE, { workspaces: [] });
+    const workspaces = Array.isArray(data?.workspaces) ? data.workspaces : [];
+    return workspaces.filter(item => item && typeof item.path === 'string');
+}
+
+function saveKnownWorkspace(candidate) {
+    const existing = loadKnownWorkspaces();
+    const now = new Date().toISOString();
+    const next = existing.filter(item => item.path !== candidate.path);
+    next.unshift({
+        path: candidate.path,
+        source: candidate.source,
+        score: candidate.score,
+        updatedAt: now,
+    });
+    writeJson(KNOWN_WORKSPACES_FILE, { workspaces: next.slice(0, 20) });
+}
+
+function loadActiveVenture() {
+    return readJson(ACTIVE_VENTURE_FILE, null);
+}
+
+function saveActiveVenture(entry) {
+    writeJson(ACTIVE_VENTURE_FILE, {
+        venture: entry.venture,
+        repoRoot: entry.repoRoot || null,
+        updatedAt: new Date().toISOString(),
+    });
+}
+
+function scoreWorkspaceCandidate(candidatePath) {
+    if (!candidatePath || !fs.existsSync(candidatePath)) {
+        return null;
+    }
+    const venturesPath = path.join(candidatePath, 'ventures');
+    const appsPath = path.join(candidatePath, 'apps');
+    const reposPath = path.join(candidatePath, 'repos');
+    const rootLedger = path.join(candidatePath, '.delimit', 'ledger', 'operations.jsonl');
+    const repoLedgerCount = countImmediateRepoLedgers(candidatePath);
+    const score =
+        (fs.existsSync(venturesPath) ? 40 : 0) +
+        (fs.existsSync(appsPath) ? 20 : 0) +
+        (fs.existsSync(reposPath) ? 20 : 0) +
+        (fs.existsSync(rootLedger) ? 10 : 0) +
+        Math.min(repoLedgerCount, 10) * 3;
+    return {
+        path: candidatePath,
+        score,
+        repoLedgerCount,
+        hasVentures: fs.existsSync(venturesPath),
+        hasApps: fs.existsSync(appsPath),
+        hasRepos: fs.existsSync(reposPath),
+        hasRootLedger: fs.existsSync(rootLedger),
+    };
+}
+
+function listVentureLedgers(repoBase, delimitHome) {
+    const results = [];
+    const seen = new Set();
+
+    const addLedger = (ledgerRoot, venture, repoRoot, scope) => {
+        const key = `${scope}:${ledgerRoot}`;
+        if (seen.has(key)) return;
+        seen.add(key);
+        results.push({ ledgerRoot, venture, repoRoot, scope });
+    };
+
+    const globalLedgerRoot = path.join(delimitHome, 'ledger');
+    if (fs.existsSync(path.join(globalLedgerRoot, 'operations.jsonl'))) {
+        addLedger(globalLedgerRoot, 'root', null, 'global');
+    }
+
+    const scanRoots = [repoBase];
+    for (const child of ['ventures', 'apps', 'repos']) {
+        const childRoot = path.join(repoBase, child);
+        if (fs.existsSync(childRoot)) {
+            scanRoots.push(childRoot);
+        }
+    }
+
+    for (const scanRoot of scanRoots) {
+        if (fs.existsSync(scanRoot)) {
+            for (const entry of fs.readdirSync(scanRoot, { withFileTypes: true })) {
+                if (!entry.isDirectory()) continue;
+                const repoRoot = path.join(scanRoot, entry.name);
+                const ledgerRoot = path.join(repoRoot, '.delimit', 'ledger');
+                const ventureName = path.relative(repoBase, repoRoot) || entry.name;
+                if (fs.existsSync(path.join(ledgerRoot, 'operations.jsonl'))) {
+                    addLedger(ledgerRoot, ventureName, repoRoot, 'repo');
+                }
+            }
+        }
+    }
+
+    return results;
+}
+
+function detectRepoBase(repoRoot) {
+    const explicit = process.env.DELIMIT_REPO_BASE;
+    if (explicit) {
+        return explicit;
+    }
+
+    const candidates = [];
+    const seen = new Set();
+    const pushCandidate = (candidatePath, source) => {
+        if (!candidatePath || seen.has(candidatePath)) return;
+        seen.add(candidatePath);
+        const scored = scoreWorkspaceCandidate(candidatePath);
+        if (scored && scored.score > 0) {
+            candidates.push({ ...scored, source });
+        }
+    };
+
+    if (repoRoot) {
+        let current = path.dirname(repoRoot);
+        const stopAt = path.parse(current).root;
+        while (current && current !== stopAt) {
+            pushCandidate(current, 'ancestor');
+            current = path.dirname(current);
+        }
+    }
+
+    for (const known of loadKnownWorkspaces()) {
+        const ageMs = Date.now() - new Date(known.updatedAt || 0).getTime();
+        if (ageMs < WORKSPACE_CACHE_TTL_MS) {
+            pushCandidate(known.path, 'cache');
+        }
+    }
+
+    const homeDir = os.homedir();
+    for (const candidate of [
+        path.join(homeDir, 'projects'),
+        path.join(homeDir, 'repos'),
+        path.join(homeDir, 'ventures'),
+        '/projects',
+        '/workspace',
+        '/workspaces',
+        os.homedir(),
+    ]) {
+        pushCandidate(candidate, 'heuristic');
+    }
+
+    candidates.sort((a, b) => b.score - a.score);
+    if (candidates.length > 0) {
+        saveKnownWorkspace(candidates[0]);
+        return candidates[0].path;
+    }
+
+    return repoRoot ? path.dirname(repoRoot) : homeDir;
+}
+
+function resolveContinuityContext(options = {}) {
+    const homeDir = process.env.DELIMIT_HOME || path.join(os.homedir(), '.delimit');
+    const repoRoot = resolveRepoRoot(options.cwd || process.cwd());
+    const repoBase = detectRepoBase(repoRoot);
+    const repoName = repoRoot ? path.basename(repoRoot) : 'no-repo';
+    const osUser = os.userInfo().username;
+    const githubUser = readGitHubIdentity(os.homedir());
+    const actor = sanitizeSegment(githubUser || osUser, 'unknown-user');
+    const requestedScope = sanitizeSegment(options.scope || process.env.DELIMIT_SCOPE || '', '');
+    const scope = requestedScope === 'all' ? 'all' : '';
+    const venture = scope === 'all'
+        ? 'portfolio'
+        : sanitizeSegment(options.venture || process.env.DELIMIT_VENTURE || repoName || 'global', 'global');
+    const continuityRoot = path.join(homeDir, 'continuity', actor, venture);
+    const repoGovernanceRoot = repoRoot ? path.join(repoRoot, '.delimit') : null;
+    const ledgerInfo = scope === 'all'
+        ? { ledgerRoot: path.join(homeDir, 'ledger'), ledgerScope: 'all' }
+        : resolveLedgerRoot(repoGovernanceRoot, homeDir);
+    const ventureLedgers = listVentureLedgers(repoBase, homeDir);
+
+    return {
+        actor,
+        osUser,
+        githubUser,
+        venture,
+        repoRoot,
+        repoName,
+        delimitHome: homeDir,
+        continuityRoot,
+        privateStateRoot: homeDir,
+        repoGovernanceRoot,
+        ledgerRoot: ledgerInfo.ledgerRoot,
+        ledgerScope: ledgerInfo.ledgerScope,
+        repoBase,
+        ventureLedgers,
+    };
+}
+
+function formatContinuityReport(context) {
+    return [
+        'Delimit continuity context:',
+        `  actor: ${context.actor}`,
+        `  osUser: ${context.osUser}`,
+        `  githubUser: ${context.githubUser || 'unresolved'}`,
+        `  venture: ${context.venture}`,
+        `  repoRoot: ${context.repoRoot || 'none'}`,
+        `  privateStateRoot: ${context.privateStateRoot}`,
+        `  continuityRoot: ${context.continuityRoot}`,
+        `  repoGovernanceRoot: ${context.repoGovernanceRoot || 'none'}`,
+        `  repoBase: ${context.repoBase}`,
+        `  ledgerRoot: ${context.ledgerRoot}`,
+        `  ledgerScope: ${context.ledgerScope}`,
+        `  ventures: ${context.ventureLedgers?.length || 0}`,
+    ].join('\n');
+}
+
+module.exports = {
+    resolveContinuityContext,
+    formatContinuityReport,
+    listVentureLedgers,
+    resolveRepoRoot,
+    loadActiveVenture,
+    saveActiveVenture,
+};

package/lib/cross-model-hooks.js

@@ -24,6 +24,110 @@ const { getDelimitSection, getDelimitSectionCondensed } = require('./delimit-tem
 function getHome() { return process.env.HOME || os.homedir(); }
 function getDelimitHome() { return path.join(getHome(), '.delimit'); }
 
+function readJsonl(filePath) {
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    return fs.readFileSync(filePath, 'utf-8')
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean)
+        .map(line => {
+            try {
+                return JSON.parse(line);
+            } catch {
+                return null;
+            }
+        })
+        .filter(Boolean);
+}
+
+function readLatestSessionSummary(sessionDir) {
+    if (!fs.existsSync(sessionDir)) {
+        return null;
+    }
+    const files = fs.readdirSync(sessionDir)
+        .filter(name => name.endsWith('.json'))
+        .map(name => path.join(sessionDir, name))
+        .sort((a, b) => fs.statSync(b).mtimeMs - fs.statSync(a).mtimeMs);
+    if (files.length === 0) {
+        return null;
+    }
+    try {
+        const data = JSON.parse(fs.readFileSync(files[0], 'utf-8'));
+        return {
+            id: data.id || path.basename(files[0], '.json'),
+            timestamp: data.timestamp || null,
+            summary: data.summary || '',
+            blockers: Array.isArray(data.blockers) ? data.blockers : [],
+            itemsCompleted: Array.isArray(data.items_completed) ? data.items_completed : [],
+        };
+    } catch {
+        return null;
+    }
+}
+
+function buildLedgerState(ledgerDir) {
+    const opsPath = path.join(ledgerDir, 'operations.jsonl');
+    const entries = readJsonl(opsPath);
+    const latestById = new Map();
+    for (const entry of entries) {
+        if (!entry || !entry.id) continue;
+        const current = latestById.get(entry.id);
+        const nextTime = entry.updated_at || entry.created_at || '';
+        const currentTime = current ? (current.updated_at || current.created_at || '') : '';
+        if (!current || nextTime >= currentTime) {
+            latestById.set(entry.id, entry);
+        }
+    }
+    const items = Array.from(latestById.values());
+    const open = items
+        .filter(item => !['done', 'blocked'].includes(String(item.status || 'open')))
+        .sort((a, b) => {
+            const prio = { P0: 0, P1: 1, P2: 2 };
+            return (prio[a.priority] ?? 9) - (prio[b.priority] ?? 9);
+        });
+    return {
+        items,
+        open,
+        next: open[0] || null,
+    };
+}
+
+function getServiceState(serviceName) {
+    try {
+        const active = execSync(`systemctl is-active ${serviceName} 2>/dev/null`, { encoding: 'utf-8', timeout: 2000 }).trim();
+        const enabled = execSync(`systemctl is-enabled ${serviceName} 2>/dev/null`, { encoding: 'utf-8', timeout: 2000 }).trim();
+        return { active, enabled };
+    } catch {
+        const processPattern = serviceName.includes('social')
+            ? 'social_daemon.py'
+            : serviceName.includes('inbox')
+                ? 'inbox_daemon.py'
+                : '';
+        if (processPattern) {
+            try {
+                const matches = execSync(`ps -eo pid,cmd | grep ${JSON.stringify(processPattern)} | grep -v grep`, {
+                    encoding: 'utf-8',
+                    timeout: 2000,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                }).trim();
+                if (matches) {
+                    return { active: 'active', enabled: 'unknown' };
+                }
+            } catch { /* ignore */ }
+        }
+        return { active: 'inactive', enabled: 'unknown' };
+    }
+}
+
+function writeBootstrapState(continuityRoot, payload) {
+    fs.mkdirSync(continuityRoot, { recursive: true });
+    const statePath = path.join(continuityRoot, 'bootstrap-state.json');
+    fs.writeFileSync(statePath, JSON.stringify(payload, null, 2) + '\n');
+    return statePath;
+}
+
 // ---------------------------------------------------------------------------
 // Hook configuration (user-overridable via delimit.yml)
 // ---------------------------------------------------------------------------
@@ -327,8 +431,8 @@ function installClaudeHooks(tool, hookConfig) {
 
         // 3. PreToolUse: security audit before deploy/publish/release commands
         if (hookConfig.deploy_audit !== false) {
-            const securityCmd = 'delimit-cli security-audit';
-            const existingSecurity = findClaudeHookGroup(config.hooks.PreToolUse, securityCmd);
+            const deployGateCmd = 'delimit-cli hook deploy-gate';
+            const existingSecurity = findClaudeHookGroup(config.hooks.PreToolUse, deployGateCmd);
             if (!existingSecurity) {
                 config.hooks.PreToolUse.push({
                     matcher: 'Bash',
@@ -799,6 +903,113 @@ async function hookSessionStart() {
     process.stdout.write(lines.join('\n') + '\n');
 }
 
+/**
+ * bootstrap: shared natural-language trigger handler.
+ * execute -> resume or launch governed work loop
+ * inspect -> show ledger/daemon/continuity state without executing
+ */
+async function hookBootstrap(mode = 'inspect', options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const lines = [];
+    const silent = Boolean(options.silent);
+    const normalizedMode = mode === 'execute' ? 'execute' : 'inspect';
+    const { resolveContinuityContext } = require('./continuity-resolver');
+    const context = resolveContinuityContext({ cwd, scope: options.scope });
+    const hasPolicy = fs.existsSync(path.join(cwd, 'delimit.yml'))
+        || fs.existsSync(path.join(cwd, '.delimit.yml'))
+        || fs.existsSync(path.join(cwd, '.delimit', 'policies.yml'));
+    const globalLedgerDir = context.ledgerRoot;
+    const sessionDir = path.join(getDelimitHome(), 'sessions');
+    const ledgerState = buildLedgerState(globalLedgerDir);
+    const latestSession = readLatestSessionSummary(sessionDir);
+    const inboxDaemon = getServiceState('delimit-inbox.service');
+    const socialDaemon = getServiceState('delimit-social-scan.service');
+
+    lines.push('[Delimit] Bootstrap');
+    lines.push(`[Delimit] Mode: ${normalizedMode}`);
+    lines.push(`[Delimit] Repo: ${cwd}`);
+    lines.push(`[Delimit] Actor: ${context.actor}`);
+    lines.push(`[Delimit] Venture: ${context.venture}`);
+    lines.push(`[Delimit] Continuity root: ${context.continuityRoot}`);
+    lines.push(`[Delimit] Ledger scope: ${context.ledgerScope}`);
+    lines.push(hasPolicy ? '[Delimit] Governance: active' : '[Delimit] Governance: repo policy missing');
+    lines.push(fs.existsSync(globalLedgerDir) ? '[Delimit] Ledger: available' : '[Delimit] Ledger: unavailable');
+    lines.push(fs.existsSync(sessionDir) ? '[Delimit] Continuity: session history available' : '[Delimit] Continuity: no saved sessions');
+    lines.push(`[Delimit] Inbox daemon: ${inboxDaemon.active}/${inboxDaemon.enabled}`);
+    lines.push(`[Delimit] Social daemon: ${socialDaemon.active}/${socialDaemon.enabled}`);
+
+    if (latestSession) {
+        lines.push(`[Delimit] Latest session: ${latestSession.id}`);
+        if (latestSession.summary) {
+            lines.push(`[Delimit] Latest summary: ${latestSession.summary}`);
+        }
+        if (latestSession.blockers.length > 0) {
+            lines.push(`[Delimit] Blockers: ${latestSession.blockers.join('; ')}`);
+        }
+    }
+
+    if (ledgerState.next) {
+        const next = ledgerState.next;
+        lines.push(`[Delimit] Next open item: ${next.id} ${next.title || '(untitled)'} [${next.priority || 'P?'}]`);
+    } else {
+        lines.push('[Delimit] Next open item: none');
+    }
+
+    if (normalizedMode === 'execute') {
+        const bootstrapState = {
+            timestamp: new Date().toISOString(),
+            actor: context.actor,
+            venture: context.venture,
+            repo: cwd,
+            mode: normalizedMode,
+            nextItem: ledgerState.next ? {
+                id: ledgerState.next.id,
+                title: ledgerState.next.title || '',
+                priority: ledgerState.next.priority || '',
+                status: ledgerState.next.status || 'open',
+            } : null,
+            daemons: {
+                inbox: inboxDaemon,
+                social: socialDaemon,
+            },
+            latestSession,
+            openItemCount: ledgerState.open.length,
+        };
+        const statePath = writeBootstrapState(context.continuityRoot, bootstrapState);
+        lines.push('[Delimit] Intent: resume or launch governed persistent loop');
+        lines.push(`[Delimit] Work order saved: ${statePath}`);
+        lines.push('[Delimit] Next tools: delimit session --build');
+    } else {
+        lines.push('[Delimit] Intent: inspect current state without executing');
+        lines.push('[Delimit] Next tools: delimit session --inspect');
+    }
+
+    const payload = {
+        mode: normalizedMode,
+        repo: cwd,
+        actor: context.actor,
+        venture: context.venture,
+        continuityRoot: context.continuityRoot,
+        ledgerRoot: context.ledgerRoot,
+        ledgerScope: context.ledgerScope,
+        hasPolicy,
+        ledgerAvailable: fs.existsSync(globalLedgerDir),
+        continuityAvailable: fs.existsSync(sessionDir),
+        daemons: {
+            inbox: inboxDaemon,
+            social: socialDaemon,
+        },
+        latestSession,
+        nextItem: ledgerState.next || null,
+        openItemCount: ledgerState.open.length,
+    };
+    if (!silent) {
+        lines.push('');
+        process.stdout.write(lines.join('\n') + '\n');
+    }
+    return payload;
+}
+
 /**
  * pre-tool: Check before file edits.
  * If editing an OpenAPI spec, run a quick lint.
@@ -1060,6 +1271,7 @@ module.exports = {
     removeGeminiHooks,
     loadHookConfig,
     hookSessionStart,
+    hookBootstrap,
     hookPreTool,
     hookPreCommit,
     hookDeployGate,

package/lib/delimit-template.js

@@ -31,6 +31,11 @@ The founder reviews and approves via email. The AI's job is to draft, send, and
 - **Session end or idle**: call \`delimit_session_handoff\` to preserve context for next session
 - If returning user, summarize what's pending. If new project, call \`delimit_scan\`.
 
+### Natural Language Triggers
+- \`think and build\`, \`keep building\`, \`resume building\`, \`run the swarm\`: route through native Delimit session/build behavior, equivalent to \`delimit session --build\`
+- \`ask delimit\`, \`what's next\`, \`check the ledger\`: route through native Delimit inspect behavior, equivalent to \`delimit session --inspect\` or \`delimit ask\`
+- Bootstrap behavior must be identical across Codex, Claude Code, Gemini, Grok, and Cursor: resolve user + venture + repo, load continuity/session state, check ledger, check daemon/swarm status, then either inspect or resume/launch the governed loop
+
 ### Code Development (debounced per edit batch)
 - After editing UI/CSS: call \`delimit_design_validate_responsive\`
 - After editing API specs: call \`delimit_lint\` + \`delimit_drift_check\`