shift-ax 0.3.0

package/dist/platform/codex/upstream/worktree/imported/managed-worktree.js

@@ -0,0 +1,208 @@
+import { execFile as execFileCb, spawnSync } from 'node:child_process';
+import { existsSync, mkdirSync, realpathSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { promisify } from 'node:util';
+const execFilePromise = promisify(execFileCb);
+const BRANCH_IN_USE_PATTERN = /already checked out|already used by worktree|is already checked out/i;
+function readGit(repoRoot, args) {
+    const result = spawnSync('git', args, {
+        cwd: repoRoot,
+        encoding: 'utf-8',
+        windowsHide: true,
+    });
+    if (result.status === 0) {
+        return (result.stdout || '').trim();
+    }
+    const stderr = (result.stderr || '').trim();
+    throw new Error(stderr || `git ${args.join(' ')} failed`);
+}
+function branchExists(repoRoot, branchName) {
+    const result = spawnSync('git', ['show-ref', '--verify', '--quiet', `refs/heads/${branchName}`], {
+        cwd: repoRoot,
+        encoding: 'utf-8',
+        windowsHide: true,
+    });
+    return result.status === 0;
+}
+function isWorktreeDirty(worktreePath) {
+    const result = spawnSync('git', ['status', '--porcelain'], {
+        cwd: worktreePath,
+        encoding: 'utf-8',
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        const stderr = (result.stderr || '').trim();
+        throw new Error(stderr || `worktree_status_failed:${worktreePath}`);
+    }
+    return (result.stdout || '').trim() !== '';
+}
+function listWorktrees(repoRoot) {
+    const raw = readGit(repoRoot, ['worktree', 'list', '--porcelain']);
+    if (!raw)
+        return [];
+    return raw
+        .split(/\n\n+/)
+        .map((chunk) => chunk.trim())
+        .filter(Boolean)
+        .map((chunk) => {
+        const lines = chunk
+            .split(/\r?\n/)
+            .map((line) => line.trim())
+            .filter(Boolean);
+        const worktreeLine = lines.find((line) => line.startsWith('worktree '));
+        const headLine = lines.find((line) => line.startsWith('HEAD '));
+        const branchLine = lines.find((line) => line.startsWith('branch '));
+        if (!worktreeLine || !headLine)
+            return null;
+        return {
+            path: resolve(worktreeLine.slice('worktree '.length)),
+            head: headLine.slice('HEAD '.length).trim(),
+            branchRef: branchLine ? branchLine.slice('branch '.length).trim() : null,
+            detached: lines.includes('detached') || !branchLine,
+        };
+    })
+        .filter((entry) => Boolean(entry));
+}
+function findWorktreeByPath(entries, worktreePath) {
+    const resolvedPath = canonicalizePath(worktreePath);
+    return entries.find((entry) => canonicalizePath(entry.path) === resolvedPath) || null;
+}
+function hasBranchInUse(entries, branchName, worktreePath) {
+    const expectedRef = `refs/heads/${branchName}`;
+    const resolvedPath = canonicalizePath(worktreePath);
+    return entries.some((entry) => entry.branchRef === expectedRef && canonicalizePath(entry.path) !== resolvedPath);
+}
+function resolveGitCommonDir(cwd) {
+    const result = spawnSync('git', ['rev-parse', '--git-common-dir'], {
+        cwd,
+        encoding: 'utf-8',
+        windowsHide: true,
+    });
+    if (result.status !== 0)
+        return null;
+    const value = (result.stdout || '').trim();
+    return value ? resolve(cwd, value) : null;
+}
+function readWorktreeEntryFromPath(repoRoot, worktreePath) {
+    if (!existsSync(worktreePath))
+        return null;
+    const repoCommonDir = resolveGitCommonDir(repoRoot);
+    const worktreeCommonDir = resolveGitCommonDir(worktreePath);
+    if (!repoCommonDir || !worktreeCommonDir || repoCommonDir !== worktreeCommonDir) {
+        return null;
+    }
+    const headResult = spawnSync('git', ['rev-parse', 'HEAD'], {
+        cwd: worktreePath,
+        encoding: 'utf-8',
+        windowsHide: true,
+    });
+    if (headResult.status !== 0)
+        return null;
+    const head = (headResult.stdout || '').trim();
+    if (!head)
+        return null;
+    const branchResult = spawnSync('git', ['symbolic-ref', '-q', 'HEAD'], {
+        cwd: worktreePath,
+        encoding: 'utf-8',
+        windowsHide: true,
+    });
+    const branchRef = branchResult.status === 0 ? (branchResult.stdout || '').trim() : null;
+    return {
+        path: canonicalizePath(worktreePath),
+        head,
+        branchRef: branchRef || null,
+        detached: !branchRef,
+    };
+}
+function canonicalizePath(path) {
+    if (existsSync(path)) {
+        try {
+            return realpathSync(path);
+        }
+        catch {
+            return resolve(path);
+        }
+    }
+    return resolve(path);
+}
+export function ensureCodexManagedWorktree(plan) {
+    const allWorktrees = listWorktrees(plan.repoRoot);
+    const existingAtPath = findWorktreeByPath(allWorktrees, plan.worktreePath) ??
+        readWorktreeEntryFromPath(plan.repoRoot, plan.worktreePath);
+    const expectedBranchRef = `refs/heads/${plan.branchName}`;
+    if (existingAtPath) {
+        if (existingAtPath.branchRef !== expectedBranchRef) {
+            throw new Error(`worktree_target_mismatch:${plan.worktreePath}`);
+        }
+        if (isWorktreeDirty(plan.worktreePath)) {
+            throw new Error(`worktree_dirty:${plan.worktreePath}`);
+        }
+        return {
+            repoRoot: plan.repoRoot,
+            worktreePath: canonicalizePath(plan.worktreePath),
+            branchName: plan.branchName,
+            created: false,
+            reused: true,
+            createdBranch: false,
+        };
+    }
+    if (existsSync(plan.worktreePath)) {
+        throw new Error(`worktree_path_conflict:${plan.worktreePath}`);
+    }
+    if (hasBranchInUse(allWorktrees, plan.branchName, plan.worktreePath)) {
+        throw new Error(`branch_in_use:${plan.branchName}`);
+    }
+    mkdirSync(dirname(plan.worktreePath), { recursive: true });
+    const branchAlreadyExisted = branchExists(plan.repoRoot, plan.branchName);
+    const addArgs = branchAlreadyExisted
+        ? ['worktree', 'add', plan.worktreePath, plan.branchName]
+        : ['worktree', 'add', '-b', plan.branchName, plan.worktreePath, plan.baseRef];
+    const result = spawnSync('git', addArgs, {
+        cwd: plan.repoRoot,
+        encoding: 'utf-8',
+        windowsHide: true,
+    });
+    if (result.status !== 0) {
+        const stderr = (result.stderr || '').trim();
+        if (BRANCH_IN_USE_PATTERN.test(stderr)) {
+            throw new Error(`branch_in_use:${plan.branchName}`);
+        }
+        throw new Error(stderr || `worktree_add_failed:${addArgs.join(' ')}`);
+    }
+    return {
+        repoRoot: plan.repoRoot,
+        worktreePath: canonicalizePath(plan.worktreePath),
+        branchName: plan.branchName,
+        created: true,
+        reused: false,
+        createdBranch: !branchAlreadyExisted,
+    };
+}
+export async function removeCodexManagedWorktree(result) {
+    await execFilePromise('git', ['worktree', 'remove', '--force', result.worktreePath], {
+        cwd: result.repoRoot,
+        encoding: 'utf-8',
+    });
+    const entriesAfterRemove = listWorktrees(result.repoRoot);
+    const stillCheckedOut = hasBranchInUse(entriesAfterRemove, result.branchName, result.worktreePath);
+    if (stillCheckedOut) {
+        return;
+    }
+    try {
+        await execFilePromise('git', ['branch', '-D', result.branchName], {
+            cwd: result.repoRoot,
+            encoding: 'utf-8',
+        });
+    }
+    catch (error) {
+        if (branchExists(result.repoRoot, result.branchName)) {
+            const err = error;
+            const stderr = typeof err.stderr === 'string'
+                ? err.stderr.trim()
+                : err.stderr instanceof Buffer
+                    ? err.stderr.toString('utf-8').trim()
+                    : '';
+            throw new Error(stderr || `delete_branch:${result.branchName}`);
+        }
+    }
+}

package/dist/platform/codex/upstream/worktree/imported/resolve-repo-root.js

@@ -0,0 +1,14 @@
+import { execFileSync } from 'node:child_process';
+/**
+ * Imported from oh-my-codex.
+ * Source: oh-my-codex/src/cli/autoresearch.ts
+ * Commit: fabb3ce0b96e42c20feb2940c74f2aa5addb8cee
+ */
+export function resolveCodexRepoRoot(cwd) {
+    return execFileSync('git', ['rev-parse', '--show-toplevel'], {
+        cwd,
+        encoding: 'utf-8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+    }).trim();
+}

package/dist/platform/codex/worktree.js

@@ -0,0 +1,99 @@
+import { dirname, join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { planTopicWorktree, recordTopicWorktreeCreate, recordTopicWorktreeRemove, resolveTopicWorktreeTarget, } from '../../core/topics/worktree-runtime.js';
+import { readImportedUpstreamSlice } from '../upstream-imports.js';
+import { ensureCodexManagedWorktree, removeCodexManagedWorktree, } from './upstream/worktree/imported/managed-worktree.js';
+const HERE = dirname(fileURLToPath(import.meta.url));
+function command(name) {
+    return ['shift-ax', name];
+}
+export function getCodexWorktreeRuntime(rootDir) {
+    const importRoot = join(rootDir, 'platform', 'codex', 'upstream', 'worktree');
+    return {
+        support: 'available',
+        entrypoint_style: 'cli',
+        topic_artifacts: {
+            plan: 'worktree-plan.json',
+            state: 'worktree-state.json',
+        },
+        operations: {
+            plan: {
+                command: command('worktree-plan'),
+                topic_flag: '--topic',
+            },
+            create: {
+                command: command('worktree-create'),
+                topic_flag: '--topic',
+                additional_flags: ['--base'],
+            },
+            remove: {
+                command: command('worktree-remove'),
+                topic_flag: '--topic',
+            },
+        },
+        upstream_boundary: {
+            import_root: importRoot,
+            provenance_doc: join(rootDir, 'platform', 'codex', 'upstream', 'worktree', 'provenance.md'),
+            planned_upstream_modules: [
+                'oh-my-codex/src/team/worktree.ts',
+                'oh-my-codex/src/team/state-root.ts',
+            ],
+            active_imports: [
+                readImportedUpstreamSlice(join(HERE, 'upstream', 'worktree', 'imported', 'provenance.json')),
+                readImportedUpstreamSlice(join(HERE, 'upstream', 'worktree', 'imported', 'managed-worktree.provenance.json')),
+            ],
+        },
+    };
+}
+export async function planCodexTopicWorktree(input) {
+    return planTopicWorktree(input);
+}
+export async function createCodexTopicWorktree(input) {
+    const target = await resolveTopicWorktreeTarget(input);
+    const baseRef = ensureBaseRef(target.rootDir, target.baseBranch);
+    const result = ensureCodexManagedWorktree({
+        repoRoot: target.rootDir,
+        worktreePath: target.worktreePath,
+        branchName: target.branchName,
+        baseRef,
+    });
+    return recordTopicWorktreeCreate(target, {
+        created: result.created,
+        reused: result.reused,
+    });
+}
+export async function removeCodexTopicWorktree(input) {
+    const target = await resolveTopicWorktreeTarget(input);
+    if (existsSync(target.worktreePath)) {
+        await removeCodexManagedWorktree({
+            repoRoot: target.rootDir,
+            worktreePath: target.worktreePath,
+            branchName: target.branchName,
+            created: false,
+            reused: false,
+            createdBranch: true,
+        });
+    }
+    else {
+        try {
+            execFileSync('git', ['branch', '-D', target.branchName], {
+                cwd: target.rootDir,
+                encoding: 'utf8',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+        }
+        catch {
+            // Branch may already be absent.
+        }
+    }
+    return recordTopicWorktreeRemove(target, !existsSync(target.worktreePath));
+}
+function ensureBaseRef(rootDir, baseBranch) {
+    return execFileSync('git', ['rev-parse', baseBranch], {
+        cwd: rootDir,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+}

package/dist/platform/index.js

@@ -0,0 +1,10 @@
+export { codexScaffoldTemplateFiles, getCodexBootstrapAssets, renderCodexAgentsBootstrap, } from './codex/bootstrap.js';
+export { claudeCodeScaffoldTemplateFiles, getClaudeCodeBootstrapAssets, renderClaudeCodeSessionStartContext, } from './claude-code/bootstrap.js';
+import { getClaudeCodeBootstrapAssets } from './claude-code/bootstrap.js';
+import { getCodexBootstrapAssets } from './codex/bootstrap.js';
+export function getPlatformBootstrapAssets(platform, rootDir, locale = 'en') {
+    if (platform === 'codex') {
+        return getCodexBootstrapAssets(rootDir, locale);
+    }
+    return getClaudeCodeBootstrapAssets(rootDir, locale);
+}

package/dist/platform/product-shell-commands.js

@@ -0,0 +1,17 @@
+export const SHIFT_AX_PRODUCT_SHELL_COMMANDS = [
+    'onboard',
+    'request',
+    'export-context',
+    'doctor',
+    'status',
+    'topics',
+    'resume',
+    'review',
+];
+export function buildProductShellAssets({ platform, commandBasePath, renderTemplate, }) {
+    return SHIFT_AX_PRODUCT_SHELL_COMMANDS.map((name) => ({
+        path: `${commandBasePath}/${name}.md`,
+        description: `Shift AX ${platform === 'codex' ? 'Codex' : 'Claude Code'} product-shell command: ${platform === 'codex' ? '$' : '/'}${name}`,
+        content: renderTemplate(name),
+    }));
+}

package/dist/platform/scaffold.js

@@ -0,0 +1,16 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { getPlatformBootstrapAssets } from './index.js';
+export async function scaffoldPlatformBuild({ platform, rootDir, }) {
+    const assets = getPlatformBootstrapAssets(platform, rootDir);
+    await Promise.all(assets.map(async (asset) => {
+        const absolutePath = join(rootDir, asset.path);
+        await mkdir(dirname(absolutePath), { recursive: true });
+        await writeFile(absolutePath, asset.content, 'utf8');
+    }));
+    return {
+        platform,
+        rootDir,
+        written: assets.map((asset) => asset.path),
+    };
+}

package/dist/platform/upstream-imports.js

@@ -0,0 +1,5 @@
+import { readFileSync } from 'node:fs';
+export function readImportedUpstreamSlice(provenancePath) {
+    const raw = readFileSync(provenancePath, 'utf8');
+    return JSON.parse(raw);
+}

package/dist/scripts/ax-approve-plan.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { recordPlanReviewDecision } from '../core/planning/plan-review.js';
+function usage() {
+    process.stderr.write('Usage: ax-approve-plan --topic DIR --reviewer NAME --decision <approve|reject> [--notes "<text>"]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const topicDir = readArg('--topic');
+const reviewer = readArg('--reviewer');
+const decision = readArg('--decision');
+const notes = readArg('--notes');
+if (!topicDir || !reviewer || !decision) {
+    usage();
+    process.exit(1);
+}
+if (decision !== 'approve' && decision !== 'reject') {
+    usage();
+    process.exit(1);
+}
+const result = await recordPlanReviewDecision({
+    topicDir,
+    reviewer,
+    status: decision === 'approve' ? 'approved' : 'changes_requested',
+    notes,
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-bootstrap-assets.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { getPlatformBootstrapAssets } from '../platform/index.js';
+function usage() {
+    process.stderr.write('Usage: ax-bootstrap-assets --platform <codex|claude-code> [--root DIR]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const platform = readArg('--platform');
+const rootDir = readArg('--root') || process.cwd();
+if (platform !== 'codex' && platform !== 'claude-code') {
+    usage();
+    process.exit(1);
+}
+const assets = getPlatformBootstrapAssets(platform, rootDir);
+process.stdout.write(`${JSON.stringify(assets, null, 2)}\n`);

package/dist/scripts/ax-bootstrap-topic.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env node
+import { bootstrapTopic } from '../core/topics/bootstrap.js';
+function usage() {
+    process.stderr.write('Usage: ax-bootstrap-topic --request "<text>" [--summary "<text>"] [--root DIR]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const request = readArg('--request');
+const summary = readArg('--summary');
+const rootDir = readArg('--root') || process.cwd();
+if (!request) {
+    usage();
+    process.exit(1);
+}
+const result = await bootstrapTopic({
+    rootDir,
+    request,
+    summary,
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-build-context-bundle.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { buildContextBundle } from '../core/context/context-bundle.js';
+function usage() {
+    process.stderr.write('Usage: ax-build-context-bundle [--root DIR] [--topic DIR] --query "<text>" [--max-chars N] [--output PATH]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root');
+const topicDir = readArg('--topic');
+const query = readArg('--query');
+const outputPath = readArg('--output');
+const maxChars = Number(readArg('--max-chars') || '6000');
+if (!query || (!rootDir && !topicDir)) {
+    usage();
+    process.exit(1);
+}
+const result = outputPath
+    ? (await import('../core/context/context-bundle.js')).writeContextBundle({
+        ...(rootDir ? { rootDir } : {}),
+        ...(topicDir ? { topicDir } : {}),
+        query,
+        outputPath,
+        maxChars: Number.isFinite(maxChars) && maxChars > 0 ? maxChars : 6000,
+    }).then(({ bundle, output_path }) => ({ ...bundle, output_path }))
+    : await buildContextBundle({
+        ...(rootDir ? { rootDir } : {}),
+        ...(topicDir ? { topicDir } : {}),
+        query,
+        maxChars: Number.isFinite(maxChars) && maxChars > 0 ? maxChars : 6000,
+    });
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-checkpoint-context.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { writeTopicSummaryCheckpoint } from '../core/memory/summary-checkpoints.js';
+function usage() {
+    process.stderr.write('Usage: ax-checkpoint-context --topic DIR --summary "<text>"\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const topicDir = readArg('--topic');
+const summary = readArg('--summary');
+if (!topicDir || !summary) {
+    usage();
+    process.exit(1);
+}
+const result = await writeTopicSummaryCheckpoint({
+    topicDir,
+    summary,
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-consolidate-memory.js

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { consolidateMemory } from '../core/memory/consolidation.js';
+const rootDir = process.argv.includes('--root')
+    ? process.argv[process.argv.indexOf('--root') + 1]
+    : process.cwd();
+const result = await consolidateMemory({ rootDir });
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-context-health.js

@@ -0,0 +1,26 @@
+#!/usr/bin/env node
+import { assessContextHealth } from '../core/observability/context-health.js';
+function usage() {
+    process.stderr.write('Usage: ax-context-health [--root DIR] [--topic DIR] --query "<text>" [--max-chars N]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root');
+const topicDir = readArg('--topic');
+const query = readArg('--query');
+const maxChars = Number(readArg('--max-chars') || '6000');
+if (!query || (!rootDir && !topicDir)) {
+    usage();
+    process.exit(1);
+}
+const result = await assessContextHealth({
+    ...(rootDir ? { rootDir } : {}),
+    ...(topicDir ? { topicDir } : {}),
+    query,
+    maxChars: Number.isFinite(maxChars) && maxChars > 0 ? maxChars : 6000,
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-decisions.js

@@ -0,0 +1,32 @@
+#!/usr/bin/env node
+import { listDecisionRecords, searchDecisionMemory } from '../core/memory/decision-register.js';
+function usage() {
+    process.stderr.write('Usage: ax-decisions [--root DIR] [--query "<text>"] [--active-at YYYY-MM-DD] [--limit N]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root') || process.cwd();
+const query = readArg('--query');
+const activeAt = readArg('--active-at');
+const limit = Number(readArg('--limit') || '5');
+if (process.argv.includes('--help')) {
+    usage();
+    process.exit(0);
+}
+const result = query
+    ? await searchDecisionMemory({
+        rootDir,
+        query,
+        activeAt,
+        limit: Number.isFinite(limit) && limit > 0 ? limit : 5,
+    })
+    : await listDecisionRecords({
+        rootDir,
+        query,
+        activeAt,
+    });
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-doctor.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { runDoctor } from '../core/diagnostics/doctor.js';
+function usage() {
+    process.stderr.write('Usage: ax-doctor [--root DIR] [--topic DIR] [--platform <codex|claude-code>]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root') || process.cwd();
+const topicDir = readArg('--topic');
+const platformArg = readArg('--platform');
+if (platformArg && platformArg !== 'codex' && platformArg !== 'claude-code') {
+    usage();
+    process.exit(1);
+}
+const platform = platformArg;
+const report = await runDoctor({
+    rootDir,
+    ...(topicDir ? { topicDir } : {}),
+    ...(platform ? { platform } : {}),
+});
+process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);

package/dist/scripts/ax-entity-memory.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { buildEntityMemoryView } from '../core/memory/entity-memory.js';
+function usage() {
+    process.stderr.write('Usage: ax-entity-memory --root DIR --entity NAME\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const rootDir = readArg('--root') || process.cwd();
+const entity = readArg('--entity');
+if (!entity) {
+    usage();
+    process.exit(1);
+}
+const result = await buildEntityMemoryView({ rootDir, entity });
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);

package/dist/scripts/ax-export-context.js

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+import { getGlobalContextHome } from '../core/settings/global-context-home.js';
+const home = getGlobalContextHome();
+process.stdout.write(JSON.stringify({
+    share_root: home.root,
+    index_path: home.indexPath,
+    message: `Share ${home.root} with teammates who do similar work and tell them to place it at the same location on their machine.`,
+}, null, 2) + '\n');

package/dist/scripts/ax-finalize-commit.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { readFile } from 'node:fs/promises';
+import { finalizeTopicCommit } from '../core/finalization/commit-workflow.js';
+function usage() {
+    process.stderr.write('Usage: ax-finalize-commit --topic DIR [--message-file PATH]\n');
+}
+function readArg(flag) {
+    const index = process.argv.indexOf(flag);
+    if (index === -1)
+        return undefined;
+    return process.argv[index + 1];
+}
+const topicDir = readArg('--topic');
+const messageFile = readArg('--message-file');
+if (!topicDir) {
+    usage();
+    process.exit(1);
+}
+const result = await finalizeTopicCommit({
+    topicDir,
+    message: messageFile ? await readFile(messageFile, 'utf8') : undefined,
+});
+process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);