@treeseed/sdk 0.12.62 → 0.13.0-rc.10

package/dist/scripts/generate-treedx-openapi-types.js

@@ -1,186 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, relative, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { parse, stringify } from 'yaml';
-const check = process.argv.includes('--check');
-const packageRoot = resolve(dirname(fileURLToPath(import.meta.url)), '..');
-const workspaceRoot = resolve(packageRoot, '../..');
-const workspaceOpenApiPath = resolve(workspaceRoot, 'docs/api/openapi.yaml');
-const packageOpenApiPath = resolve(packageRoot, 'docs/api/openapi.yaml');
-const openApiPath = existsSync(workspaceOpenApiPath) ? workspaceOpenApiPath : packageOpenApiPath;
-const workspaceOpenApiJsonPath = resolve(workspaceRoot, 'docs/api/openapi.json');
-const packageOpenApiJsonPath = resolve(packageRoot, 'docs/api/openapi.json');
-const outPath = resolve(packageRoot, 'src/treedx/generated/openapi-types.ts');
-const openApi = parse(readFileSync(openApiPath, 'utf8'));
-function refName(ref) {
-    return ref.split('/').pop() ?? ref;
-}
-function schemaRefType(ref) {
-    return `components['schemas']['${refName(ref)}']`;
-}
-function literal(value) {
-    return JSON.stringify(value);
-}
-function key(name) {
-    return /^[A-Za-z_$][\w$]*$/u.test(name) ? name : JSON.stringify(name);
-}
-function typeForSchema(schema) {
-    if (!schema || typeof schema !== 'object')
-        return 'unknown';
-    const s = schema;
-    if (typeof s.$ref === 'string')
-        return schemaRefType(s.$ref);
-    if ('const' in s)
-        return literal(s.const);
-    if (Array.isArray(s.enum))
-        return s.enum.map(literal).join(' | ') || 'never';
-    if (Array.isArray(s.oneOf))
-        return s.oneOf.map(typeForSchema).join(' | ') || 'unknown';
-    if (Array.isArray(s.anyOf))
-        return s.anyOf.map(typeForSchema).join(' | ') || 'unknown';
-    if (Array.isArray(s.allOf))
-        return s.allOf.map(typeForSchema).join(' & ') || 'unknown';
-    if (s.nullable === true)
-        return `${typeForSchema({ ...s, nullable: undefined })} | null`;
-    if (s.type === 'string')
-        return 'string';
-    if (s.type === 'integer' || s.type === 'number')
-        return 'number';
-    if (s.type === 'boolean')
-        return 'boolean';
-    if (s.type === 'null')
-        return 'null';
-    if (s.type === 'array')
-        return `${typeForSchema(s.items)}[]`;
-    if (s.type === 'object' || s.properties || s.additionalProperties !== undefined) {
-        const properties = (s.properties ?? {});
-        const required = new Set(Array.isArray(s.required) ? s.required.map(String) : []);
-        const parts = Object.entries(properties).map(([name, prop]) => {
-            const optional = required.has(name) ? '' : '?';
-            return `${key(name)}${optional}: ${typeForSchema(prop)};`;
-        });
-        if (s.additionalProperties === true) {
-            parts.push('[key: string]: unknown;');
-        }
-        else if (s.additionalProperties && typeof s.additionalProperties === 'object') {
-            parts.push(`[key: string]: ${typeForSchema(s.additionalProperties)};`);
-        }
-        return parts.length > 0 ? `{ ${parts.join(' ')} }` : 'Record<string, never>';
-    }
-    return 'unknown';
-}
-function parametersFor(operation, location) {
-    const params = Array.isArray(operation.parameters) ? operation.parameters : [];
-    const entries = params
-        .filter((param) => typeof param === 'object' && param !== null && param.in === location)
-        .map((param) => {
-        const name = String(param.name);
-        const optional = param.required === true ? '' : '?';
-        return `${key(name)}${optional}: ${typeForSchema(param.schema)};`;
-    });
-    return entries.length > 0 ? `{ ${entries.join(' ')} }` : 'never';
-}
-function requestBodyFor(operation) {
-    const body = operation.requestBody;
-    const content = body?.content ?? {};
-    const json = content['application/json']?.schema;
-    if (json)
-        return typeForSchema(json);
-    const octets = content['application/octet-stream']?.schema;
-    if (octets)
-        return 'ArrayBuffer | Uint8Array | Blob';
-    return 'never';
-}
-function responseFor(response) {
-    if (!response || typeof response !== 'object')
-        return 'unknown';
-    if (typeof response.$ref === 'string') {
-        const name = refName(response.$ref);
-        if (name === 'Error')
-            return "components['schemas']['TreeDxErrorEnvelope']";
-        if (name === 'Ok')
-            return "components['schemas']['TreeDxOkEnvelope']";
-    }
-    const r = response;
-    const content = r.content ?? {};
-    const json = content['application/json']?.schema;
-    if (json)
-        return typeForSchema(json);
-    const octets = content['application/octet-stream']?.schema;
-    if (octets)
-        return 'ArrayBuffer';
-    return 'unknown';
-}
-function operationType(operation) {
-    const responses = operation.responses ?? {};
-    const responseEntries = Object.entries(responses).map(([status, response]) => `${JSON.stringify(status)}: ${responseFor(response)};`);
-    return [
-        '{',
-        `parameters: { path: ${parametersFor(operation, 'path')}; query: ${parametersFor(operation, 'query')}; header: ${parametersFor(operation, 'header')}; };`,
-        `requestBody: ${requestBodyFor(operation)};`,
-        `responses: { ${responseEntries.join(' ')} };`,
-        '}',
-    ].join(' ');
-}
-const schemas = openApi.components?.schemas ?? {};
-const schemaLines = Object.entries(schemas)
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([name, schema]) => `${key(name)}: ${typeForSchema(schema)};`);
-const operationEntries = [];
-const pathLines = [];
-for (const [path, methods] of Object.entries(openApi.paths ?? {}).sort(([a], [b]) => a.localeCompare(b))) {
-    const methodLines = [];
-    for (const [method, operation] of Object.entries(methods).sort(([a], [b]) => a.localeCompare(b))) {
-        if (!operation?.operationId)
-            continue;
-        operationEntries.push([operation.operationId, operation]);
-        methodLines.push(`${method}: operations['${operation.operationId}'];`);
-    }
-    pathLines.push(`${JSON.stringify(path)}: { ${methodLines.join(' ')} };`);
-}
-const operationLines = operationEntries
-    .sort(([a], [b]) => a.localeCompare(b))
-    .map(([id, operation]) => `${key(id)}: ${operationType(operation)};`);
-const generated = `// Generated from docs/api/openapi.yaml. Do not edit by hand.
-
-export interface paths {
-${pathLines.map((line) => `\t${line}`).join('\n')}
-}
-
-export interface components {
-\tschemas: {
-${schemaLines.map((line) => `\t\t${line}`).join('\n')}
-\t};
-}
-
-export interface operations {
-${operationLines.map((line) => `\t${line}`).join('\n')}
-}
-`;
-const current = (() => {
-    try {
-        return readFileSync(outPath, 'utf8');
-    }
-    catch {
-        return null;
-    }
-})();
-if (check && current !== generated) {
-    console.error(`${relative(process.cwd(), outPath)} is not up to date. Run npm run treedx:generate-types.`);
-    process.exit(1);
-}
-if (!check) {
-    mkdirSync(dirname(outPath), { recursive: true });
-    writeFileSync(outPath, generated, 'utf8');
-    for (const target of [workspaceOpenApiJsonPath, packageOpenApiJsonPath]) {
-        mkdirSync(dirname(target), { recursive: true });
-        writeFileSync(target, `${JSON.stringify(openApi, null, 2)}\n`, 'utf8');
-    }
-    if (openApiPath === workspaceOpenApiPath) {
-        mkdirSync(dirname(packageOpenApiPath), { recursive: true });
-        writeFileSync(packageOpenApiPath, stringify(openApi), 'utf8');
-    }
-    console.log(`Wrote ${relative(process.cwd(), outPath)}`);
-    console.log(`Wrote ${relative(process.cwd(), workspaceOpenApiJsonPath)}`);
-    console.log(`Wrote ${relative(process.cwd(), packageOpenApiJsonPath)}`);
-}

package/dist/scripts/install-managed-dependencies.js

@@ -1,12 +0,0 @@
-import { formatTreeseedDependencyFailureDetails, installTreeseedDependencies } from '../managed-dependencies.js';
-const force = process.argv.includes('--force');
-const result = await installTreeseedDependencies({
-    tenantRoot: process.cwd(),
-    force,
-    env: process.env,
-});
-process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
-if (!result.ok) {
-    process.stderr.write(`Treeseed dependency initialization failed:\n- ${formatTreeseedDependencyFailureDetails(result)}\n`);
-    process.exit(1);
-}

package/dist/scripts/key-agent.js

@@ -1,165 +0,0 @@
-#!/usr/bin/env node
-import { createInterface } from 'node:readline';
-import { stdin as input, stdout as output } from 'node:process';
-import { assertTreeseedKeyAgentResponse, getTreeseedKeyAgentPaths, readWrappedMachineKeyFile, requestTreeseedKeyAgent, startTreeseedKeyAgentServer, TREESEED_KEY_AGENT_IDLE_TIMEOUT_MS, TreeseedKeyAgentError, TRESEED_MACHINE_KEY_PASSPHRASE_ENV, } from '../operations/services/key-agent.js';
-function parseArgs(argv) {
-    const [mode = 'request', ...rest] = argv;
-    const parsed = {
-        mode,
-        payload: '',
-        keyPath: '',
-        socketPath: '',
-        idleTimeoutMs: TREESEED_KEY_AGENT_IDLE_TIMEOUT_MS,
-        allowMigration: false,
-        createIfMissing: false,
-    };
-    while (rest.length > 0) {
-        const current = rest.shift();
-        if (!current) {
-            continue;
-        }
-        if (!parsed.payload && !current.startsWith('--')) {
-            parsed.payload = current;
-            continue;
-        }
-        if (current === '--key-path') {
-            parsed.keyPath = rest.shift() ?? '';
-            continue;
-        }
-        if (current === '--socket-path') {
-            parsed.socketPath = rest.shift() ?? '';
-            continue;
-        }
-        if (current === '--idle-timeout-ms') {
-            parsed.idleTimeoutMs = Number.parseInt(rest.shift() ?? String(TREESEED_KEY_AGENT_IDLE_TIMEOUT_MS), 10);
-            continue;
-        }
-        if (current === '--allow-migration') {
-            parsed.allowMigration = true;
-            continue;
-        }
-        if (current === '--create-if-missing') {
-            parsed.createIfMissing = true;
-            continue;
-        }
-    }
-    return parsed;
-}
-function writeJson(payload) {
-    process.stdout.write(`${JSON.stringify(payload)}\n`);
-}
-function prompt(question, secret = false) {
-    return new Promise((resolvePromise) => {
-        if (!secret) {
-            const rl = createInterface({ input, output });
-            rl.question(question, (answer) => {
-                rl.close();
-                resolvePromise(answer);
-            });
-            return;
-        }
-        const rl = createInterface({ input, output, terminal: true });
-        const previousWrite = rl._writeToOutput;
-        rl._writeToOutput = function _writeToOutput(text) {
-            if (text.trim()) {
-                output.write('*');
-            }
-        };
-        rl.question(question, (answer) => {
-            output.write('\n');
-            rl.close();
-            rl._writeToOutput = previousWrite;
-            resolvePromise(answer);
-        });
-    });
-}
-async function runInteractiveUnlock(parsed) {
-    const wrapped = readWrappedMachineKeyFile(parsed.keyPath);
-    if (wrapped.exists && !wrapped.wrapped && !wrapped.migrationRequired) {
-        throw new TreeseedKeyAgentError('corrupt_wrapped_key', 'Unable to read the existing Treeseed machine key file.');
-    }
-    const needsCreation = !wrapped.exists;
-    const needsMigration = wrapped.migrationRequired;
-    let passphrase = '';
-    if (needsCreation || needsMigration) {
-        const action = needsCreation ? 'Create a new Treeseed passphrase: ' : 'Create a new Treeseed passphrase to wrap the existing machine key: ';
-        const first = (await prompt(action, true)).trim();
-        if (!first) {
-            throw new TreeseedKeyAgentError('interactive_required', 'A non-empty passphrase is required.');
-        }
-        const second = (await prompt('Confirm passphrase: ', true)).trim();
-        if (first !== second) {
-            throw new TreeseedKeyAgentError('unlock_failed', 'The passphrase confirmation did not match.');
-        }
-        passphrase = first;
-    }
-    else {
-        passphrase = (await prompt('Treeseed passphrase: ', true)).trim();
-        if (!passphrase) {
-            throw new TreeseedKeyAgentError('interactive_required', 'A passphrase is required to unlock the Treeseed machine key.');
-        }
-    }
-    const response = await requestTreeseedKeyAgent({
-        command: 'unlock',
-        keyPath: parsed.keyPath,
-        socketPath: parsed.socketPath,
-        idleTimeoutMs: parsed.idleTimeoutMs,
-        passphrase,
-        createIfMissing: needsCreation || parsed.createIfMissing,
-        allowMigration: needsMigration || parsed.allowMigration,
-    });
-    assertTreeseedKeyAgentResponse(response);
-    writeJson(response);
-}
-async function main() {
-    const parsed = parseArgs(process.argv.slice(2));
-    const defaults = getTreeseedKeyAgentPaths();
-    parsed.socketPath ||= defaults.socketPath;
-    if (parsed.mode === 'serve') {
-        if (!parsed.keyPath) {
-            throw new Error('Missing --key-path for key-agent serve mode.');
-        }
-        await startTreeseedKeyAgentServer({
-            keyPath: parsed.keyPath,
-            socketPath: parsed.socketPath,
-            idleTimeoutMs: parsed.idleTimeoutMs,
-        });
-        await new Promise(() => { });
-        return;
-    }
-    if (parsed.mode === 'unlock-interactive') {
-        await runInteractiveUnlock(parsed);
-        return;
-    }
-    if (parsed.mode === 'unlock-from-env') {
-        const passphrase = String(process.env[TRESEED_MACHINE_KEY_PASSPHRASE_ENV] ?? '').trim();
-        if (!passphrase) {
-            throw new TreeseedKeyAgentError('interactive_required', `Set ${TRESEED_MACHINE_KEY_PASSPHRASE_ENV} before using unlock-from-env.`);
-        }
-        const response = await requestTreeseedKeyAgent({
-            command: 'unlock',
-            keyPath: parsed.keyPath,
-            socketPath: parsed.socketPath,
-            idleTimeoutMs: parsed.idleTimeoutMs,
-            passphrase,
-            createIfMissing: parsed.createIfMissing,
-            allowMigration: parsed.allowMigration,
-        });
-        assertTreeseedKeyAgentResponse(response);
-        writeJson(response);
-        return;
-    }
-    const payload = JSON.parse(parsed.payload);
-    const response = await requestTreeseedKeyAgent(payload);
-    writeJson(response);
-}
-main().catch((error) => {
-    const message = error instanceof Error ? error.message : String(error);
-    const code = error instanceof TreeseedKeyAgentError ? error.code : 'unlock_failed';
-    writeJson({
-        ok: false,
-        code,
-        message,
-    });
-    process.exit(1);
-});

package/dist/scripts/local-dev.js

@@ -1,129 +0,0 @@
-import { spawnSync } from 'node:child_process';
-import { corePackageRoot } from '../operations/services/runtime-tools.js';
-import { fixtureRoot } from '../operations/services/runtime-paths.js';
-import { prepareCloudflareLocalRuntime, startWranglerDev } from '../operations/services/local-dev.js';
-import { clearStagedBuildOutput, createWatchBuildPaths, createTenantWatchEntries, startPollingWatch, stopManagedProcess, swapStagedBuildOutput, writeDevReloadStamp, workspaceSdkRoot, } from '../operations/services/watch-dev.js';
-const cliArgs = process.argv.slice(2);
-const watchMode = cliArgs.includes('--watch');
-const wranglerArgs = cliArgs.filter((arg) => arg !== '--watch');
-let wranglerChild = null;
-let stopWatching = null;
-let isStoppingForRebuild = false;
-let shuttingDown = false;
-function runStep(command, args, { cwd = corePackageRoot, env = {}, fatal = true } = {}) {
-    const result = spawnSync(command, args, {
-        stdio: 'inherit',
-        cwd,
-        env: { ...process.env, ...env },
-    });
-    if (result.status !== 0 && fatal) {
-        process.exit(result.status ?? 1);
-    }
-    return result.status === 0;
-}
-function runFixtureBuildCycle({ includePackageBuild = false, includeSdkBuild = false, fatal = true, stagedOutput = false } = {}) {
-    if (includeSdkBuild) {
-        const sdkRoot = workspaceSdkRoot();
-        if (sdkRoot) {
-            const built = runStep('npm', ['run', 'build:dist'], { cwd: sdkRoot, fatal });
-            if (!built) {
-                return false;
-            }
-        }
-    }
-    if (includePackageBuild) {
-        const built = runStep('npm', ['run', 'build:dist'], { cwd: corePackageRoot, fatal });
-        if (!built) {
-            return false;
-        }
-    }
-    if (watchMode) {
-        writeDevReloadStamp(fixtureRoot);
-    }
-    try {
-        const outDir = stagedOutput ? createWatchBuildPaths(fixtureRoot).stagedDistRoot : undefined;
-        if (stagedOutput) {
-            clearStagedBuildOutput(fixtureRoot);
-        }
-        prepareCloudflareLocalRuntime({
-            envOverrides: watchMode ? { TREESEED_PUBLIC_DEV_WATCH_RELOAD: 'true' } : {},
-            outDir,
-        });
-        if (stagedOutput) {
-            swapStagedBuildOutput(fixtureRoot);
-        }
-        return true;
-    }
-    catch (error) {
-        if (fatal) {
-            throw error;
-        }
-        console.error(error instanceof Error ? error.message : String(error));
-        return false;
-    }
-}
-function startWrangler() {
-    const child = startWranglerDev(wranglerArgs, {
-        env: watchMode ? { TREESEED_PUBLIC_DEV_WATCH_RELOAD: 'true' } : {},
-        detached: process.platform !== 'win32',
-    });
-    wranglerChild = child;
-    child.on('exit', (code, signal) => {
-        if (child !== wranglerChild) {
-            return;
-        }
-        wranglerChild = null;
-        if (isStoppingForRebuild || shuttingDown) {
-            return;
-        }
-        if (stopWatching) {
-            stopWatching();
-        }
-        if (signal) {
-            process.kill(process.pid, signal);
-            return;
-        }
-        process.exit(code ?? 0);
-    });
-}
-async function shutdownAndExit(code = 0) {
-    shuttingDown = true;
-    if (stopWatching) {
-        stopWatching();
-    }
-    await stopManagedProcess(wranglerChild);
-    process.exit(code);
-}
-process.on('SIGINT', () => {
-    void shutdownAndExit(130);
-});
-process.on('SIGTERM', () => {
-    void shutdownAndExit(143);
-});
-runFixtureBuildCycle({ includeSdkBuild: true, includePackageBuild: true, fatal: true });
-startWrangler();
-if (watchMode) {
-    console.log('Starting fixture watch mode. Changes will rebuild the package fixture and refresh the browser.');
-    stopWatching = startPollingWatch({
-        watchEntries: createTenantWatchEntries(fixtureRoot),
-        onChange: async ({ changedPaths, packageChanged, sdkChanged }) => {
-            console.log(`Detected ${changedPaths.length} change${changedPaths.length === 1 ? '' : 's'}; rebuilding ${sdkChanged ? 'sdk, core, and fixture' : packageChanged ? 'core and fixture' : 'fixture'} output...`);
-            isStoppingForRebuild = true;
-            await stopManagedProcess(wranglerChild);
-            isStoppingForRebuild = false;
-            const ok = runFixtureBuildCycle({
-                includeSdkBuild: sdkChanged,
-                includePackageBuild: packageChanged || sdkChanged,
-                fatal: false,
-                stagedOutput: false,
-            });
-            if (ok) {
-                startWrangler();
-                console.log('Rebuild complete. Wrangler restarted with the updated fixture output.');
-            }
-            else {
-                console.error('Rebuild failed. Wrangler remains stopped until the next successful save.');
-            }
-        },
-    });
-}

package/dist/scripts/migrate-journey-csv-to-guarantees.js

@@ -1,140 +0,0 @@
-import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { dirname, resolve } from 'node:path';
-import { stringify as stringifyYaml } from 'yaml';
-import { normalizeTreeseedGuaranteeTaxonomy, slugifyTreeseedGuaranteeJourney, } from '../guarantees/index.js';
-function argValue(name) {
-    const index = process.argv.indexOf(name);
-    return index >= 0 ? process.argv[index + 1] : undefined;
-}
-function hasArg(name) {
-    return process.argv.includes(name);
-}
-function parseCsv(source) {
-    const rows = [];
-    let row = [];
-    let field = '';
-    let quoted = false;
-    for (let index = 0; index < source.length; index += 1) {
-        const char = source[index];
-        const next = source[index + 1];
-        if (quoted) {
-            if (char === '"' && next === '"') {
-                field += '"';
-                index += 1;
-            }
-            else if (char === '"')
-                quoted = false;
-            else
-                field += char;
-        }
-        else if (char === '"')
-            quoted = true;
-        else if (char === ',') {
-            row.push(field);
-            field = '';
-        }
-        else if (char === '\n') {
-            row.push(field.replace(/\r$/u, ''));
-            rows.push(row);
-            row = [];
-            field = '';
-        }
-        else
-            field += char;
-    }
-    if (field || row.length > 0) {
-        row.push(field.replace(/\r$/u, ''));
-        rows.push(row);
-    }
-    return rows.filter((entry) => entry.some(Boolean));
-}
-function ownerPackage(type, subtype) {
-    if (['marketplace', 'checkout', 'service', 'capacity-discovery', 'feedback', 'commons', 'public-profile'].includes(type))
-        return '@treeseed/market';
-    if (type === 'marketplace-seller')
-        return '@treeseed/admin';
-    if (type === 'host' && subtype === 'reconciliation')
-        return '@treeseed/api';
-    if (type === 'capacity' && ['assignment', 'usage', 'provider'].includes(subtype))
-        return '@treeseed/api';
-    if (type === 'project' && subtype === 'treedx')
-        return '@treeseed/api';
-    if (type === 'workday' && ['diagnostics', 'artifacts', 'decision'].includes(subtype))
-        return '@treeseed/api';
-    return '@treeseed/admin';
-}
-function ownerRoot(workspace, owner) {
-    return owner === '@treeseed/market' ? workspace : resolve(workspace, 'packages', owner.replace('@treeseed/', ''));
-}
-function guaranteeId(type, subtype, journey, index) {
-    return `guarantee.${type}.${subtype}.${slugifyTreeseedGuaranteeJourney(journey)}.${String(index).padStart(3, '0')}`;
-}
-const csv = argValue('--csv');
-const workspace = resolve(argValue('--workspace') ?? process.cwd());
-const writePlan = argValue('--write-plan');
-const write = hasArg('--write');
-if (!csv) {
-    console.error('Usage: node --import tsx packages/sdk/scripts/migrate-journey-csv-to-guarantees.ts --csv <path> [--workspace <root>] [--write-plan <path>] [--write]');
-    process.exit(1);
-}
-const rows = parseCsv(readFileSync(csv, 'utf8'));
-const header = rows[0] ?? [];
-const records = rows.slice(1).map((row) => Object.fromEntries(header.map((key, index) => [key, row[index] ?? ''])));
-const indexed = new Map(records.map((record) => [Number(record.Index), record]));
-const outputs = records.map((record) => {
-    const index = Number(record.Index);
-    const type = normalizeTreeseedGuaranteeTaxonomy(String(record.Type));
-    const subtype = normalizeTreeseedGuaranteeTaxonomy(String(record['Sub-Type']));
-    const journey = String(record.Journey);
-    const owner = ownerPackage(type, subtype);
-    const journeySlug = slugifyTreeseedGuaranteeJourney(journey);
-    const dependencies = String(record.Dependencies ?? '').split(/[;, ]+/u).filter(Boolean).map(Number);
-    const dependencyGuarantees = dependencies.map((dependency) => {
-        const dep = indexed.get(dependency);
-        if (!dep)
-            return null;
-        return guaranteeId(normalizeTreeseedGuaranteeTaxonomy(String(dep.Type)), normalizeTreeseedGuaranteeTaxonomy(String(dep['Sub-Type'])), String(dep.Journey), dependency);
-    }).filter(Boolean);
-    const packageRoot = ownerRoot(workspace, owner);
-    const guaranteePath = resolve(packageRoot, 'guarantees', type, subtype, `${journeySlug}.guarantee.yaml`);
-    const manifest = {
-        schemaVersion: 'treeseed.guarantee/v1',
-        id: guaranteeId(type, subtype, journey, index),
-        journeyIndex: index,
-        type,
-        subtype,
-        journey,
-        ownerPackage: owner,
-        summary: String(record.Notes || `Guarantee migrated from journey ${index}.`),
-        status: 'planned',
-        dependencies: { journeys: dependencies, guarantees: dependencyGuarantees },
-        actors: { allowed: ['owner'], forbidden: ['unauthorized_user'] },
-        devices: { required: ['desktop_chromium'] },
-        gates: ['core', 'release'],
-        preconditions: { fixtures: [] },
-        scene: { required: true, manifest: `./scenes/${journeySlug}.scene.yaml` },
-        api: { required: true, verifierRefs: [`todo.${type}.${subtype}.${journeySlug}.api`] },
-        evidence: { required: ['playwright_trace', 'api_verification_log'] },
-        notes: [String(record.Notes || '').trim()].filter(Boolean),
-    };
-    return { index, type, subtype, journey, ownerPackage: owner, guaranteePath, manifest };
-});
-const plan = {
-    schemaVersion: 'treeseed.guarantee-migration-plan/v1',
-    sourceCsv: resolve(csv),
-    workspace,
-    count: outputs.length,
-    outputs: outputs.map(({ manifest, ...entry }) => ({ ...entry, id: manifest.id })),
-};
-if (writePlan) {
-    const target = resolve(writePlan);
-    mkdirSync(dirname(target), { recursive: true });
-    writeFileSync(target, `${JSON.stringify(plan, null, 2)}\n`);
-}
-if (write) {
-    for (const output of outputs) {
-        mkdirSync(dirname(output.guaranteePath), { recursive: true });
-        writeFileSync(output.guaranteePath, stringifyYaml(output.manifest, { lineWidth: 0 }));
-    }
-}
-console.log(JSON.stringify(plan, null, 2));

package/dist/scripts/operations-runner-smoke.js

@@ -1,16 +0,0 @@
-import { runTreeseedOperationsRunnerSmoke } from '../operations/services/operations-runner-smoke.js';
-function arg(name) {
-    const index = process.argv.indexOf(name);
-    return index >= 0 ? process.argv[index + 1] : null;
-}
-const environment = (arg('--environment') ?? 'staging') === 'prod' ? 'prod' : 'staging';
-const report = await runTreeseedOperationsRunnerSmoke({
-    tenantRoot: process.cwd(),
-    environment,
-    baseUrl: arg('--base-url'),
-    timeoutMs: arg('--timeout-ms') ? Number(arg('--timeout-ms')) : undefined,
-});
-console.log(JSON.stringify(report, null, 2));
-if (!report.ok) {
-    process.exitCode = 1;
-}