@thxgg/steward 0.1.7 → 0.1.10

package/.output/server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@thxgg/steward-prod",
-  "version": "0.1.7",
+  "version": "0.1.10",
   "type": "module",
   "private": true,
   "dependencies": {

package/README.md

@@ -77,9 +77,7 @@ prd mcp
 Steward exposes one MCP tool: `execute`.
 
 ```js
-const reposList = await repos.list()
-const repo = reposList[0]
-if (!repo) return { error: 'No repos configured' }
+const repo = await repos.current()
 
 const prdList = await prds.list(repo.id)
 if (prdList.length === 0) return { repo: repo.name, prds: 0 }
@@ -92,6 +90,26 @@ return {
 }
 ```
 
+Every call returns a structured envelope:
+
+```json
+{
+  "ok": true,
+  "result": {},
+  "logs": [],
+  "error": null,
+  "meta": {
+    "timeoutMs": 30000,
+    "durationMs": 10,
+    "truncatedResult": false,
+    "truncatedLogs": false,
+    "resultWasUndefined": false
+  }
+}
+```
+
+Use `steward.help()` inside `execute` for runtime API signatures and examples.
+
 ## APIs
 
 Inside `execute`, these APIs are available:
@@ -99,7 +117,7 @@ Inside `execute`, these APIs are available:
 - `repos` - register/list/remove repos and refresh discovered git repos
 - `prds` - list/read PRD docs, tasks, progress, and task commit refs
 - `git` - commit metadata, diffs, file diffs, and file contents
-- `state` - direct PRD state get/upsert by repo id or path
+- `state` - direct PRD state get/upsert by repo id, path, or current repo
 
 Detailed API docs and examples: `docs/MCP.md`
 

package/dist/host/src/api/git.js

@@ -1,12 +1,5 @@
 import { getCommitDiff, getCommitInfo, getFileContent, getFileDiff, isGitRepo, validatePathInRepo } from '../../../server/utils/git.js';
-import { getRepoById } from '../../../server/utils/repos.js';
-async function requireRepo(repoId) {
-    const repo = await getRepoById(repoId);
-    if (!repo) {
-        throw new Error('Repository not found');
-    }
-    return repo;
-}
+import { requireRepo } from './repo-context.js';
 function resolveGitRepoPath(repo, repoPath) {
     if (!repoPath) {
         return repo.path;

package/dist/host/src/api/prds.js

@@ -1,8 +1,9 @@
 import { promises as fs } from 'node:fs';
 import { basename, join } from 'node:path';
 import { resolveCommitRepo } from '../../../server/utils/git.js';
-import { discoverGitRepos, getRepoById, getRepos, saveRepos } from '../../../server/utils/repos.js';
+import { discoverGitRepos, getRepos, saveRepos } from '../../../server/utils/repos.js';
 import { getPrdState, getPrdStateSummaries, migrateLegacyStateForRepo } from '../../../server/utils/prd-state.js';
+import { requireRepo } from './repo-context.js';
 function parseMetadata(content) {
     const metadata = {};
     const authorMatch = content.match(/\*{0,2}Author\*{0,2}:\*{0,2}\s*(.+?)(?:\n|$)/i);
@@ -30,13 +31,6 @@ function parseMetadata(content) {
     }
     return metadata;
 }
-async function requireRepo(repoId) {
-    const repo = await getRepoById(repoId);
-    if (!repo) {
-        throw new Error('Repository not found');
-    }
-    return repo;
-}
 async function readPrdFile(repo, prdSlug) {
     const prdPath = join(repo.path, 'docs', 'prd', `${prdSlug}.md`);
     try {

package/dist/host/src/api/repo-context.js

@@ -0,0 +1,60 @@
+import { resolve } from 'node:path';
+import { getRepoById, getRepos } from '../../../server/utils/repos.js';
+export class RepoLookupError extends Error {
+    code;
+    details;
+    constructor(message, code, details) {
+        super(message);
+        this.code = code;
+        this.details = details;
+        this.name = 'RepoLookupError';
+    }
+}
+function summarizeRepos(repos) {
+    return repos.map((repo) => ({
+        id: repo.id,
+        name: repo.name,
+        path: repo.path
+    }));
+}
+function formatKnownRepos(knownRepos) {
+    return knownRepos
+        .map((repo) => `${repo.id} (${repo.name}) ${repo.path}`)
+        .join('; ');
+}
+export async function requireRepo(repoId) {
+    const repo = await getRepoById(repoId);
+    if (repo) {
+        return repo;
+    }
+    const allRepos = await getRepos();
+    const knownRepos = summarizeRepos(allRepos);
+    if (knownRepos.length === 0) {
+        throw new RepoLookupError(`Unknown repoId "${repoId}". No repositories are registered. Use repos.add(path) first.`, 'NO_REPOS', { repoId, knownRepos });
+    }
+    throw new RepoLookupError(`Unknown repoId "${repoId}". Known repositories: ${formatKnownRepos(knownRepos)}`, 'REPO_NOT_FOUND', { repoId, knownRepos });
+}
+export async function requireRepoByPath(repoPath) {
+    const absolutePath = resolve(repoPath);
+    const allRepos = await getRepos();
+    const repo = allRepos.find((candidate) => resolve(candidate.path) === absolutePath);
+    if (repo) {
+        return repo;
+    }
+    const knownRepos = summarizeRepos(allRepos);
+    if (knownRepos.length === 0) {
+        throw new RepoLookupError(`No registered repository found for path: ${absolutePath}. No repositories are registered. Use repos.add(path) first.`, 'NO_REPOS', { repoPath: absolutePath, knownRepos });
+    }
+    throw new RepoLookupError(`No registered repository found for path: ${absolutePath}. Known repositories: ${formatKnownRepos(knownRepos)}`, 'REPO_PATH_NOT_FOUND', { repoPath: absolutePath, knownRepos });
+}
+export async function requireCurrentRepo() {
+    const allRepos = await getRepos();
+    if (allRepos.length === 1) {
+        return allRepos[0];
+    }
+    const knownRepos = summarizeRepos(allRepos);
+    if (knownRepos.length === 0) {
+        throw new RepoLookupError('No repositories are registered. Use repos.add(path) first.', 'NO_REPOS', { knownRepos });
+    }
+    throw new RepoLookupError(`Cannot resolve a current repository because ${knownRepos.length} repositories are registered. Use an explicit repoId or by-path API. Known repositories: ${formatKnownRepos(knownRepos)}`, 'AMBIGUOUS_REPO', { knownRepos });
+}

package/dist/host/src/api/repos.js

@@ -1,5 +1,6 @@
 import { addRepo, discoverGitRepos, getRepoById, getRepos, removeRepo, saveRepos, validateRepoPath } from '../../../server/utils/repos.js';
 import { migrateLegacyStateForRepo } from '../../../server/utils/prd-state.js';
+import { requireCurrentRepo, requireRepo } from './repo-context.js';
 export const repos = {
     async list() {
         return await getRepos();
@@ -7,6 +8,9 @@ export const repos = {
     async get(repoId) {
         return await getRepoById(repoId) ?? null;
     },
+    async current() {
+        return await requireCurrentRepo();
+    },
     async add(path, name) {
         const validation = await validateRepoPath(path);
         if (!validation.valid) {
@@ -17,6 +21,7 @@ export const repos = {
         return repo;
     },
     async remove(repoId) {
+        await requireRepo(repoId);
         const removed = await removeRepo(repoId);
         if (!removed) {
             throw new Error('Repository not found');
@@ -24,6 +29,7 @@ export const repos = {
         return { removed: true };
     },
     async refreshGitRepos(repoId) {
+        await requireRepo(repoId);
         const allRepos = await getRepos();
         const repoIndex = allRepos.findIndex((repo) => repo.id === repoId);
         if (repoIndex === -1) {

package/dist/host/src/api/state.js

@@ -1,22 +1,5 @@
-import { resolve } from 'node:path';
 import { getPrdState, getPrdStateSummaries, migrateLegacyStateForRepo, upsertPrdState } from '../../../server/utils/prd-state.js';
-import { getRepoById, getRepos } from '../../../server/utils/repos.js';
-async function requireRepo(repoId) {
-    const repo = await getRepoById(repoId);
-    if (!repo) {
-        throw new Error('Repository not found');
-    }
-    return repo;
-}
-async function findRepoByPath(repoPath) {
-    const absolutePath = resolve(repoPath);
-    const repos = await getRepos();
-    const repo = repos.find((candidate) => resolve(candidate.path) === absolutePath);
-    if (!repo) {
-        throw new Error(`No registered repository found for path: ${absolutePath}`);
-    }
-    return repo;
-}
+import { requireCurrentRepo, requireRepo, requireRepoByPath } from './repo-context.js';
 function mapStateUpdate(payload) {
     return {
         ...(payload.tasks !== undefined && { tasks: payload.tasks }),
@@ -34,7 +17,12 @@ export const state = {
         return await getPrdState(repo.id, slug);
     },
     async getByPath(repoPath, slug) {
-        const repo = await findRepoByPath(repoPath);
+        const repo = await requireRepoByPath(repoPath);
+        await migrateLegacyStateForRepo(repo);
+        return await getPrdState(repo.id, slug);
+    },
+    async getCurrent(slug) {
+        const repo = await requireCurrentRepo();
         await migrateLegacyStateForRepo(repo);
         return await getPrdState(repo.id, slug);
     },
@@ -45,7 +33,13 @@ export const state = {
         return mapSummaryMap(summaries);
     },
     async summariesByPath(repoPath) {
-        const repo = await findRepoByPath(repoPath);
+        const repo = await requireRepoByPath(repoPath);
+        await migrateLegacyStateForRepo(repo);
+        const summaries = await getPrdStateSummaries(repo.id);
+        return mapSummaryMap(summaries);
+    },
+    async summariesCurrent() {
+        const repo = await requireCurrentRepo();
         await migrateLegacyStateForRepo(repo);
         const summaries = await getPrdStateSummaries(repo.id);
         return mapSummaryMap(summaries);
@@ -56,7 +50,12 @@ export const state = {
         return { saved: true };
     },
     async upsertByPath(repoPath, slug, payload) {
-        const repo = await findRepoByPath(repoPath);
+        const repo = await requireRepoByPath(repoPath);
+        await upsertPrdState(repo.id, slug, mapStateUpdate(payload));
+        return { saved: true };
+    },
+    async upsertCurrent(slug, payload) {
+        const repo = await requireCurrentRepo();
         await upsertPrdState(repo.id, slug, mapStateUpdate(payload));
         return { saved: true };
     }

package/dist/host/src/executor.js

@@ -1,61 +1,215 @@
 import vm from 'node:vm';
 import { git, prds, repos, state } from './api/index.js';
+import { getStewardHelp } from './help.js';
 const MAX_OUTPUT_SIZE = 50_000;
 const EXECUTION_TIMEOUT_MS = 30_000;
 const MAX_TIMERS = 100;
+const MAX_LOG_ENTRIES = 200;
+const MAX_LOG_OUTPUT_SIZE = 20_000;
+const MAX_LOG_ENTRY_SIZE = 2_000;
 export class ExecutionError extends Error {
-    stackTrace;
-    constructor(message, stackTrace) {
+    options;
+    constructor(message, options) {
         super(message);
-        this.stackTrace = stackTrace;
+        this.options = options;
         this.name = 'ExecutionError';
     }
 }
-function truncateOutput(result) {
-    if (result === undefined) {
-        return undefined;
-    }
-    let json;
+function safeJsonStringify(value) {
+    const seen = new WeakSet();
     try {
-        json = JSON.stringify(result, null, 2);
+        return JSON.stringify(value, (_key, currentValue) => {
+            if (typeof currentValue === 'bigint') {
+                return `${currentValue}n`;
+            }
+            if (typeof currentValue === 'function') {
+                const functionName = currentValue.name ? ` ${currentValue.name}` : '';
+                return `[Function${functionName}]`;
+            }
+            if (typeof currentValue === 'symbol') {
+                return currentValue.toString();
+            }
+            if (typeof currentValue === 'object' && currentValue !== null) {
+                if (seen.has(currentValue)) {
+                    return '[Circular]';
+                }
+                seen.add(currentValue);
+            }
+            return currentValue;
+        });
     }
     catch {
+        return undefined;
+    }
+}
+function formatLogValue(value) {
+    if (typeof value === 'string') {
+        return value;
+    }
+    const json = safeJsonStringify(value);
+    if (json !== undefined) {
+        return json;
+    }
+    return String(value);
+}
+function truncateResult(result) {
+    if (result === undefined) {
         return {
-            _unserializable: true,
-            preview: String(result)
+            result: null,
+            truncatedResult: false,
+            resultWasUndefined: true
+        };
+    }
+    const json = safeJsonStringify(result);
+    if (json === undefined) {
+        return {
+            result: {
+                _unserializable: true,
+                preview: String(result)
+            },
+            truncatedResult: false,
+            resultWasUndefined: false
         };
     }
     if (json.length <= MAX_OUTPUT_SIZE) {
-        return result;
+        return {
+            result,
+            truncatedResult: false,
+            resultWasUndefined: false
+        };
     }
     return {
-        _truncated: true,
-        size: json.length,
-        preview: json.slice(0, MAX_OUTPUT_SIZE),
-        message: `Output truncated (${json.length} chars, showing first ${MAX_OUTPUT_SIZE})`
+        result: {
+            _truncated: true,
+            size: json.length,
+            preview: json.slice(0, MAX_OUTPUT_SIZE),
+            message: `Output truncated (${json.length} chars, showing first ${MAX_OUTPUT_SIZE})`
+        },
+        truncatedResult: true,
+        resultWasUndefined: false
+    };
+}
+function normalizeFailure(error) {
+    if (error instanceof ExecutionError) {
+        return {
+            code: error.options?.code || 'EXECUTION_ERROR',
+            message: error.message,
+            ...(error.options?.stackTrace && { stack: error.options.stackTrace }),
+            ...(error.options?.details !== undefined && { details: error.options.details })
+        };
+    }
+    if (error instanceof Error) {
+        const { code, details } = error;
+        return {
+            code: typeof code === 'string' ? code : 'EXECUTION_ERROR',
+            message: error.message,
+            ...(error.stack && { stack: error.stack }),
+            ...(details !== undefined && { details })
+        };
+    }
+    return {
+        code: 'EXECUTION_ERROR',
+        message: String(error)
     };
 }
 export async function execute(code) {
+    const startedAt = Date.now();
+    const logs = [];
+    let totalLogChars = 0;
+    let logsTruncated = false;
+    const appendLog = (level, args) => {
+        if (logs.length >= MAX_LOG_ENTRIES) {
+            logsTruncated = true;
+            return;
+        }
+        let message = args.map(formatLogValue).join(' ');
+        if (message.length > MAX_LOG_ENTRY_SIZE) {
+            message = `${message.slice(0, MAX_LOG_ENTRY_SIZE)}...`;
+            logsTruncated = true;
+        }
+        if (totalLogChars + message.length > MAX_LOG_OUTPUT_SIZE) {
+            logsTruncated = true;
+            return;
+        }
+        totalLogChars += message.length;
+        logs.push({
+            level,
+            message,
+            timestamp: new Date().toISOString()
+        });
+    };
+    const buildEnvelope = (params) => ({
+        ok: params.ok,
+        result: params.result,
+        logs,
+        error: params.error,
+        meta: {
+            timeoutMs: EXECUTION_TIMEOUT_MS,
+            durationMs: Date.now() - startedAt,
+            truncatedResult: params.truncatedResult,
+            truncatedLogs: logsTruncated,
+            resultWasUndefined: params.resultWasUndefined
+        }
+    });
     if (!code || !code.trim()) {
-        throw new ExecutionError('Code cannot be empty');
+        const error = normalizeFailure(new ExecutionError('Code cannot be empty', { code: 'EMPTY_CODE' }));
+        return buildEnvelope({
+            ok: false,
+            result: null,
+            error,
+            truncatedResult: false,
+            resultWasUndefined: false
+        });
     }
     const timers = new Set();
+    let executionTimeout = null;
+    let asyncCallbackError = null;
+    const wrapTimerHandler = (handler) => {
+        return () => {
+            try {
+                handler();
+            }
+            catch (error) {
+                const normalizedError = error instanceof Error
+                    ? error
+                    : new Error(String(error));
+                asyncCallbackError = normalizedError;
+                appendLog('error', ['Timer callback error:', normalizedError.message]);
+            }
+        };
+    };
+    const ensureTimerHandler = (handler) => {
+        if (typeof handler !== 'function') {
+            throw new ExecutionError('Timer handler must be a function', {
+                code: 'INVALID_TIMER_HANDLER'
+            });
+        }
+        return wrapTimerHandler(handler);
+    };
     const sandbox = {
         repos,
         prds,
         git,
         state,
+        steward: {
+            help: () => getStewardHelp()
+        },
         console: {
-            log: (...args) => console.log('[codemode]', ...args),
-            error: (...args) => console.error('[codemode]', ...args)
+            log: (...args) => appendLog('log', args),
+            info: (...args) => appendLog('info', args),
+            warn: (...args) => appendLog('warn', args),
+            error: (...args) => appendLog('error', args)
         },
         setTimeout: (handler, timeout) => {
             if (timers.size >= MAX_TIMERS) {
-                throw new Error(`Timer limit exceeded (max ${MAX_TIMERS})`);
+                throw new ExecutionError(`Timer limit exceeded (max ${MAX_TIMERS})`, {
+                    code: 'TIMER_LIMIT'
+                });
             }
+            const wrappedHandler = ensureTimerHandler(handler);
             const timer = setTimeout(() => {
                 timers.delete(timer);
-                handler();
+                wrappedHandler();
             }, timeout);
             timers.add(timer);
             return timer;
@@ -66,9 +220,12 @@ export async function execute(code) {
         },
         setInterval: (handler, timeout) => {
             if (timers.size >= MAX_TIMERS) {
-                throw new Error(`Timer limit exceeded (max ${MAX_TIMERS})`);
+                throw new ExecutionError(`Timer limit exceeded (max ${MAX_TIMERS})`, {
+                    code: 'TIMER_LIMIT'
+                });
             }
-            const timer = setInterval(handler, timeout);
+            const wrappedHandler = ensureTimerHandler(handler);
+            const timer = setInterval(wrappedHandler, timeout);
             timers.add(timer);
             return timer;
         },
@@ -88,18 +245,47 @@ export async function execute(code) {
             filename: 'codemode.js'
         });
         const context = vm.createContext(sandbox);
-        const result = await script.runInContext(context, {
+        const executionPromise = Promise.resolve(script.runInContext(context, {
             timeout: EXECUTION_TIMEOUT_MS
+        }));
+        const timeoutPromise = new Promise((_resolve, reject) => {
+            executionTimeout = setTimeout(() => {
+                reject(new ExecutionError(`Execution timed out after ${EXECUTION_TIMEOUT_MS}ms`, {
+                    code: 'TIMEOUT'
+                }));
+            }, EXECUTION_TIMEOUT_MS);
+        });
+        const rawResult = await Promise.race([executionPromise, timeoutPromise]);
+        if (asyncCallbackError instanceof Error) {
+            throw new ExecutionError(asyncCallbackError.message, {
+                code: 'ASYNC_CALLBACK_ERROR',
+                stackTrace: asyncCallbackError.stack
+            });
+        }
+        const truncated = truncateResult(rawResult);
+        return buildEnvelope({
+            ok: true,
+            result: truncated.result,
+            error: null,
+            truncatedResult: truncated.truncatedResult,
+            resultWasUndefined: truncated.resultWasUndefined
         });
-        return truncateOutput(result);
     }
     catch (error) {
-        if (error instanceof Error) {
-            throw new ExecutionError(error.message, error.stack);
-        }
-        throw new ExecutionError(String(error));
+        const failure = normalizeFailure(error);
+        appendLog('error', [`${failure.code}: ${failure.message}`]);
+        return buildEnvelope({
+            ok: false,
+            result: null,
+            error: failure,
+            truncatedResult: false,
+            resultWasUndefined: false
+        });
     }
     finally {
+        if (executionTimeout) {
+            clearTimeout(executionTimeout);
+        }
         timers.forEach((timer) => {
             clearTimeout(timer);
             clearInterval(timer);

package/dist/host/src/help.js

@@ -0,0 +1,124 @@
+const HELP = {
+    version: 1,
+    envelope: {
+        ok: 'true on success, false on failure',
+        result: 'returned value from your code, or null when no return value exists',
+        logs: 'captured console output entries from this execution',
+        error: 'null on success, otherwise { code, message, stack?, details? }',
+        meta: {
+            timeoutMs: 'execution timeout limit in milliseconds',
+            durationMs: 'elapsed runtime in milliseconds',
+            truncatedResult: 'true when result is truncated to output limit',
+            truncatedLogs: 'true when logs are truncated to output limit',
+            resultWasUndefined: 'true when code finished without an explicit return value'
+        }
+    },
+    apis: {
+        repos: [
+            { signature: 'repos.list()', description: 'List registered repositories' },
+            { signature: 'repos.get(repoId)', description: 'Get one repository by id' },
+            {
+                signature: 'repos.current()',
+                description: 'Resolve current repository when exactly one is registered'
+            },
+            { signature: 'repos.add(path, name?)', description: 'Register repository path' },
+            { signature: 'repos.remove(repoId)', description: 'Remove repository by id' },
+            {
+                signature: 'repos.refreshGitRepos(repoId)',
+                description: 'Refresh discovered nested git repositories'
+            }
+        ],
+        prds: [
+            { signature: 'prds.list(repoId)', description: 'List PRDs for repository' },
+            { signature: 'prds.getDocument(repoId, prdSlug)', description: 'Load PRD markdown document' },
+            { signature: 'prds.getTasks(repoId, prdSlug)', description: 'Load tasks state for PRD' },
+            { signature: 'prds.getProgress(repoId, prdSlug)', description: 'Load progress state for PRD' },
+            {
+                signature: 'prds.getTaskCommits(repoId, prdSlug, taskId)',
+                description: 'Resolve task commit references'
+            }
+        ],
+        git: [
+            { signature: 'git.getCommits(repoId, shas, repoPath?)', description: 'Load commit metadata' },
+            { signature: 'git.getDiff(repoId, commit, repoPath?)', description: 'Load full commit diff' },
+            {
+                signature: 'git.getFileDiff(repoId, commit, file, repoPath?)',
+                description: 'Load diff hunks for one file'
+            },
+            {
+                signature: 'git.getFileContent(repoId, commit, file, repoPath?)',
+                description: 'Load file content at commit'
+            }
+        ],
+        state: [
+            { signature: 'state.get(repoId, slug)', description: 'Load stored state by repo id' },
+            { signature: 'state.getByPath(repoPath, slug)', description: 'Load stored state by repo path' },
+            {
+                signature: 'state.getCurrent(slug)',
+                description: 'Load state for current repository when unambiguous'
+            },
+            { signature: 'state.summaries(repoId)', description: 'Load PRD state summaries by repo id' },
+            { signature: 'state.summariesByPath(repoPath)', description: 'Load PRD state summaries by path' },
+            {
+                signature: 'state.summariesCurrent()',
+                description: 'Load state summaries for current repository when unambiguous'
+            },
+            { signature: 'state.upsert(repoId, slug, payload)', description: 'Save tasks/progress/notes by repo id' },
+            {
+                signature: 'state.upsertByPath(repoPath, slug, payload)',
+                description: 'Save tasks/progress/notes by repo path'
+            },
+            {
+                signature: 'state.upsertCurrent(slug, payload)',
+                description: 'Save state in current repository when unambiguous'
+            }
+        ]
+    },
+    examples: [
+        {
+            title: 'List repos and PRDs',
+            code: `const allRepos = await repos.list()\n\nreturn await Promise.all(allRepos.map(async (repo) => ({\n  id: repo.id,\n  name: repo.name,\n  prds: await prds.list(repo.id)\n})))`
+        },
+        {
+            title: 'Use current repo helper',
+            code: `const repo = await repos.current()\nconst slug = 'prd-viewer'\n\nreturn {\n  repo,\n  tasks: await prds.getTasks(repo.id, slug),\n  progress: await prds.getProgress(repo.id, slug)\n}`
+        },
+        {
+            title: 'Upsert without repoId',
+            code: `await state.upsertCurrent('prd-viewer', {\n  notes: '# Updated from MCP'\n})\n\nreturn { saved: true }`
+        }
+    ]
+};
+function formatMethodList(methods) {
+    return methods
+        .map((method) => `- \`${method.signature}\` - ${method.description}`)
+        .join('\n');
+}
+export function getStewardHelp() {
+    return JSON.parse(JSON.stringify(HELP));
+}
+export function getExecuteToolDescription() {
+    return [
+        'Run codemode JavaScript with repos, prds, git, and state APIs.',
+        '',
+        'Execution always returns a structured JSON envelope:',
+        '`{ ok, result, logs, error, meta }`',
+        '',
+        'In-sandbox discovery helper:',
+        '- `steward.help()`',
+        '',
+        'Repository APIs:',
+        formatMethodList(HELP.apis.repos),
+        '',
+        'PRD APIs:',
+        formatMethodList(HELP.apis.prds),
+        '',
+        'Git APIs:',
+        formatMethodList(HELP.apis.git),
+        '',
+        'State APIs:',
+        formatMethodList(HELP.apis.state),
+        '',
+        'Use `return` in your code to set the envelope `result` field.'
+    ].join('\n');
+}