@phyzess/pappra 0.1.0-beta.2 → 0.1.0-beta.3

package/README.md

@@ -27,14 +27,24 @@ npx @phyzess/pappra@beta doctor --json
 
 `examples/minimal-choices.json` is complete for a host-free, no-graph, single-directory workspace. The example intentionally has no repositories or optional hosts.
 
-`init --json` without `--config` fails closed because JSON mode does not open the interactive wizard; run `npx @phyzess/pappra@beta init` without `--json` in a TTY if you want to enter selections interactively. `--config` and `--json` never prompt.
+For a non-interactive derived setup, `npx @phyzess/pappra@beta init --yes --apply --json` derives repositories, knowledge sources, code engine, validation commands, excludes and hosts from discovery. `--print-choices` prints that `pappra/init-choices/1` document and writes nothing, and `init --json` without selections returns the discovery candidates plus the suggested document. JSON mode never prompts; only a TTY without selections opens the wizard.
 
 Development from a checkout works the same way: `pnpm install --frozen-lockfile`, `pnpm build`, then invoke `dist/cli/main.js` by absolute path from the target workspace.
 
-An apply result can be `ok:true` with `status:"external-actions-pending"` and a
-nonzero process exit. That is a successful, partial configuration write, not a
-claim that a runtime or external tool was installed. Inspect `pendingExternalActions`
-and run `doctor` before adding optional integrations.
+`init --apply` also installs a durable runtime copy of the executing package under the
+Pappra data directory and binds it in `machine.json`, so an npx/dlx bootstrap survives
+cache eviction and the command converges with exit code `0`. Pass `--no-runtime` to leave
+that action pending instead; the result is then `ok:true` with
+`status:"external-actions-pending"` and a nonzero exit, which is a partial configuration
+write rather than a claim that a runtime exists.
+
+The runtime copy can be managed directly:
+
+```sh
+npx @phyzess/pappra@beta runtime install --apply [--from self|tarball|registry]
+npx @phyzess/pappra@beta runtime status --json
+npx @phyzess/pappra@beta runtime verify --json
+```
 
 Optional examples have prerequisites rather than generated files: code-graph and
 host commands require the selected external CLI/support, and collaboration
@@ -46,7 +56,7 @@ requires an explicit controller. They are not needed for the core workflow above
 - **Knowledge:** workspace and private document catalogs with explicit preview/apply operations.
 - **Continuity:** private task checkpoints and bounded advisory resume packets. Resume never grants execution by itself.
 - **Code intelligence:** status, explicit preparation and bounded query for selected repositories. Text/structure fallback is available when the optional graph engine is absent.
-- **Host integrations:** optional Pi, Codex and Claude Code adapters that merge Pappra-owned entries without taking over user configuration.
+- **Host integrations:** optional Pi, Codex and Claude Code adapters that merge Pappra-owned entries without taking over user configuration. Hooks are copied as a dependency-free bundle into the host root; `host bundle` exports a native plugin/package directory without registering it.
 - **Bounded collaboration:** an optional, explicitly controlled one-request workflow. It is not a scheduler or daemon.
 
 ## Optional integrations and support
@@ -70,7 +80,7 @@ The check runs the source policy, type checks, formatting, deterministic tests a
 
 ## Status and limits
 
-Pappra is development software (`0.1.0-beta.2`) published as `@phyzess/pappra` under the `beta` dist-tag. Releases are published from GitHub Actions with npm trusted publishing (OIDC), so no npm token is stored in this repository. Pin either the moving `beta` tag or an exact version such as `@phyzess/pappra@0.1.0-beta.2`, because pre-release versions are never republished.
+Pappra is development software (`0.1.0-beta.3`) published as `@phyzess/pappra` under the `beta` dist-tag. Releases are published from GitHub Actions with npm trusted publishing (OIDC), so no npm token is stored in this repository. Pin either the moving `beta` tag or an exact version such as `@phyzess/pappra@0.1.0-beta.3`, because pre-release versions are never republished.
 
 The deterministic suite covers synthetic workspaces, fixtures and local process boundaries. It does not establish real-model behavior, native host callability on every platform, CodeGraph completeness, Windows/Linux parity or production performance. A host adapter version pin is an observed support claim, not proof that a particular native installation will load or run correctly.
 

package/dist/app/doctor.js

@@ -259,7 +259,7 @@ function runtimeCheck(targetVersion, machineRuntime, passive, machinePath, obser
                 source: machinePath ?? dataDir,
                 observedAt,
                 nextActions: [
-                    'Run an explicit pappra init --apply --install-runtime with a chosen local tarball or exact version when authorized.',
+                    'Run pappra runtime install --apply (from self, tarball, or an exact version) or pappra init --apply when authorized.',
                 ],
             });
         }
@@ -335,7 +335,7 @@ function runtimeCheck(targetVersion, machineRuntime, passive, machinePath, obser
                 ]
                 : [],
             nextActions: [
-                'Run an explicit pappra init --apply --install-runtime with a chosen local tarball or exact version when authorized.',
+                'Run pappra runtime install --apply (from self, tarball, or an exact version) or pappra init --apply when authorized.',
             ],
         });
     }

package/dist/app/init.d.ts

@@ -14,6 +14,8 @@ export interface InitFailure {
     readonly message: string;
     readonly diagnostics: readonly Diagnostic[];
     readonly nextAction: string | null;
+    /** Machine-readable payload for callers that cannot prompt. */
+    readonly details?: Readonly<Record<string, unknown>>;
 }
 export interface InitRootResolution {
     readonly requestedRoot: string;
@@ -130,6 +132,30 @@ export declare function inspectInitContext(rootPath: string): Promise<InitContex
 export declare function listRepositoryCandidates(discovery: WorkspaceDiscovery): readonly RepositoryCandidate[];
 /** Lists knowledge source choices derived only from current discovery. */
 export declare function listKnowledgeCandidates(discovery: WorkspaceDiscovery): readonly KnowledgeCandidate[];
+export interface InitChoiceRule {
+    readonly field: string;
+    readonly value: string;
+    readonly reason: string;
+}
+export interface InitChoiceCandidates {
+    readonly repositories: readonly string[];
+    readonly knowledge: readonly string[];
+    readonly validation: readonly string[];
+    readonly hosts: readonly string[];
+}
+export interface DerivedInitChoices {
+    readonly choices: InitChoices;
+    readonly rules: readonly InitChoiceRule[];
+    readonly candidates: InitChoiceCandidates;
+}
+/**
+ * Derives deterministic init selections from discovery alone. Every value is
+ * reported with the rule that produced it so a caller can audit the choice
+ * before applying it; nothing here writes, installs or prompts.
+ */
+export declare function deriveInitChoices(discovery: WorkspaceDiscovery, options?: {
+    readonly pathEnv?: string;
+}): Promise<DerivedInitChoices>;
 /**
  * Produces a strict plan and exact in-memory writes. No target file is created
  * or modified by this function.

package/dist/app/init.js

@@ -3,11 +3,14 @@ import { basename, dirname, join, resolve } from 'node:path';
 import { mkdir, open, readFile, rm, rmdir } from 'node:fs/promises';
 import { createDiagnostic, hasErrors, pointer, } from '../schemas/diagnostics.js';
 import { diagnosticCodes } from '../schemas/errors.js';
-import { initPlanSchema, parseInitChoices, } from '../schemas/init.js';
+import { INIT_CHOICES_SCHEMA, initPlanSchema, parseInitChoices, } from '../schemas/init.js';
 import { machineConfigSchema } from '../schemas/machine.js';
 import { isExternalRepositoryPath, isPathInside, isPortableRelativePath, normalizePortableRelativePath, resolvePortableRelativePath, samePath, } from '../schemas/paths.js';
 import { WORKSPACE_SCHEMA, validateWorkspaceConfigSemantics, workspaceConfigSchema, } from '../schemas/workspace.js';
 import { getPackageInfo } from '../package-info.js';
+import { spawnSync } from 'node:child_process';
+import { executableOnPath } from '../hosts/detect.js';
+import { HOST_SUPPORT } from '../hosts/integration/support.js';
 import { observePath, resolveRealpath, sha256Digest } from '../infra/fs.js';
 import { inspectMachineConfig, inspectWorkspaceConfig, } from '../workspace/config.js';
 import { discoverWorkspace, } from '../workspace/discover.js';
@@ -239,6 +242,164 @@ export function listKnowledgeCandidates(discovery) {
     }
     return [...candidates.values()].sort((left, right) => left.path.localeCompare(right.path));
 }
+const derivedExcludes = [
+    'node_modules',
+    'dist',
+    'coverage',
+    'tmp',
+    'test-results',
+];
+const derivedValidationScripts = ['lint', 'typecheck', 'test'];
+function detectedHostVersion(command, pathEnv) {
+    const executable = executableOnPath(command, pathEnv);
+    if (executable === null)
+        return null;
+    const probe = spawnSync(executable, ['--version'], {
+        encoding: 'utf8',
+        shell: false,
+        timeout: 3_000,
+        maxBuffer: 256 * 1024,
+    });
+    if (probe.error !== undefined || probe.status !== 0)
+        return null;
+    const output = `${probe.stdout ?? ''}\n${probe.stderr ?? ''}`;
+    const match = /(\d+\.\d+\.\d+)/.exec(output);
+    return match?.[1] ?? null;
+}
+/**
+ * Derives deterministic init selections from discovery alone. Every value is
+ * reported with the rule that produced it so a caller can audit the choice
+ * before applying it; nothing here writes, installs or prompts.
+ */
+export async function deriveInitChoices(discovery, options = {}) {
+    const pathEnv = options.pathEnv ?? process.env['PATH'] ?? '';
+    const rules = [];
+    const repositories = discovery.repositories.map((repository) => {
+        const path = repositoryKey(repository);
+        const access = samePath(repository.root, discovery.root)
+            ? 'write'
+            : 'read';
+        rules.push({
+            field: 'repositories',
+            value: path,
+            reason: access === 'write'
+                ? 'workspace-root checkout is selected for write access'
+                : 'discovered checkout outside the workspace root is read-only',
+        });
+        return { path, access };
+    });
+    const knowledgeCandidates = listKnowledgeCandidates(discovery);
+    const rootRuleFiles = ['AGENTS.md', 'CLAUDE.md'];
+    const knowledgeSources = [];
+    for (const name of rootRuleFiles) {
+        const candidate = knowledgeCandidates.find((entry) => entry.path.toLowerCase() === name.toLowerCase());
+        if (candidate === undefined)
+            continue;
+        knowledgeSources.push(candidate.path);
+        rules.push({
+            field: 'knowledge.sources',
+            value: candidate.path,
+            reason: 'workspace-root rule file reported by discovery',
+        });
+    }
+    const docs = knowledgeCandidates.find((entry) => entry.path === 'docs');
+    if (docs !== undefined) {
+        knowledgeSources.push(docs.path);
+        rules.push({
+            field: 'knowledge.sources',
+            value: docs.path,
+            reason: 'documentation directory reported by discovery',
+        });
+    }
+    const codegraphDetected = executableOnPath('codegraph', pathEnv) !== null &&
+        (await Promise.all(discovery.repositories.map(async (repository) => observePath(join(repository.root, '.codegraph'))))).some((observation) => observation.kind !== 'missing');
+    const graph = codegraphDetected ? 'codegraph' : 'none';
+    rules.push({
+        field: 'code.graph',
+        value: graph,
+        reason: codegraphDetected
+            ? 'codegraph executable and .codegraph index were both observed'
+            : 'no codegraph executable plus .codegraph index pair was observed',
+    });
+    rules.push({
+        field: 'code.symbols',
+        value: 'auto',
+        reason: 'symbol providers are detected passively at use time',
+    });
+    rules.push({
+        field: 'code.prepare',
+        value: 'on-demand',
+        reason: 'index preparation stays an explicit, bounded action',
+    });
+    const validation = [];
+    for (const script of derivedValidationScripts) {
+        const candidate = discovery.validationCandidates.find((entry) => entry.id.endsWith(`:${script}`) && !validation.includes(entry.id));
+        if (candidate === undefined)
+            continue;
+        validation.push(candidate.id);
+        rules.push({
+            field: 'validation',
+            value: candidate.id,
+            reason: `package script "${script}" reported by discovery`,
+        });
+    }
+    rules.push({
+        field: 'excludes',
+        value: derivedExcludes.join(', '),
+        reason: 'built-in defaults keep generated and dependency trees out of scope',
+    });
+    const hosts = [];
+    for (const host of ['claude', 'codex', 'pi']) {
+        const command = host;
+        const version = detectedHostVersion(command, pathEnv);
+        if (version === null || version !== HOST_SUPPORT[host].version) {
+            rules.push({
+                field: 'hosts',
+                value: host,
+                reason: version === null
+                    ? 'host executable was not observed on PATH'
+                    : `observed version ${version} is outside the pinned support matrix`,
+            });
+            continue;
+        }
+        hosts.push(host);
+        rules.push({
+            field: 'hosts',
+            value: host,
+            reason: `host executable reports the pinned version ${version}`,
+        });
+    }
+    const name = basename(discovery.root);
+    rules.push({
+        field: 'name',
+        value: name,
+        reason: 'workspace name derived from the workspace root directory',
+    });
+    const choices = {
+        schema: INIT_CHOICES_SCHEMA,
+        name,
+        repositories,
+        knowledge: {
+            sources: knowledgeSources,
+            newDocuments: '.pappra/knowledge',
+            taskVisibility: 'private',
+        },
+        code: { graph, symbols: 'auto', prepare: 'on-demand' },
+        validation,
+        excludes: [...derivedExcludes],
+        hosts,
+    };
+    return {
+        choices,
+        rules,
+        candidates: {
+            repositories: listRepositoryCandidates(discovery).map((candidate) => candidate.key),
+            knowledge: knowledgeCandidates.map((candidate) => candidate.path),
+            validation: discovery.validationCandidates.map((candidate) => candidate.id),
+            hosts,
+        },
+    };
+}
 function selectRepositories(choices, discovery, root) {
     const diagnostics = [];
     const byKey = new Map();

package/dist/cli/commands/host.d.ts

@@ -4,10 +4,11 @@ export declare const hostUsage: string;
 export interface HostCommandOptions {
     readonly cwd: string;
     readonly json: boolean;
-    readonly action: 'detect' | 'describe' | 'plan' | 'install' | 'verify' | null;
+    readonly action: 'detect' | 'describe' | 'plan' | 'install' | 'verify' | 'bundle' | null;
     readonly host: HostName | null;
     readonly hostRoot: string | null;
     readonly hostVersion: string | null;
     readonly apply: boolean;
+    readonly out: string | null;
 }
 export declare function runHostCommand(options: HostCommandOptions, output: CliOutput): Promise<number>;

package/dist/cli/commands/host.js

@@ -1,8 +1,14 @@
 import { homedir } from 'node:os';
 import { resolve } from 'node:path';
 import { HostIntegrationService } from '../../hosts/integration/service.js';
-export const hostUsage = 'pappra host <detect|describe|plan|install|verify> --host <pi|codex|claude>\n' +
-    '  [--host-root <dir>] [--host-version <version>] [--apply] [--json]';
+import { exportHostPluginBundle } from '../../hosts/integration/bundle-export.js';
+import { HOST_SUPPORT, isSupportedVersion, } from '../../hosts/integration/support.js';
+import { getPackageInfo } from '../../package-info.js';
+export const hostUsage = 'pappra host <detect|describe|plan|install|verify|bundle> --host <pi|codex|claude>\n' +
+    '  [--host-root <dir>] [--host-version <version>] [--out <dir>] [--apply] [--json]\n' +
+    '\n' +
+    'bundle exports a host-native plugin/package directory and never registers it or\n' +
+    'claims host callability.';
 function printDiagnostics(output, diagnostics) {
     for (const entry of diagnostics) {
         if (typeof entry === 'object' &&
@@ -110,6 +116,46 @@ export async function runHostCommand(options, output) {
         }
         return diagnosticStatus(result.status);
     }
+    if (options.action === 'bundle') {
+        if (options.out === null) {
+            output.stderr('pappra host bundle requires --out <dir>.\n');
+            return 2;
+        }
+        if (!isSupportedVersion(options.host, options.hostVersion)) {
+            output.stderr(`Host ${options.host} version ${options.hostVersion ?? '(unknown)'} is outside the pinned ${HOST_SUPPORT[options.host].version} support matrix.\n`);
+            return 1;
+        }
+        try {
+            const exported = await exportHostPluginBundle({
+                host: options.host,
+                hostVersion: options.hostVersion ?? HOST_SUPPORT[options.host].version,
+                outDir: options.out,
+                packageVersion: getPackageInfo().version,
+            });
+            if (options.json) {
+                output.stdout(`${JSON.stringify({ ok: true, command: 'host', action: 'bundle', ...exported })}\n`);
+            }
+            else {
+                output.stdout(`Exported ${exported.host} bundle to ${exported.outDir}\n`);
+                for (const file of exported.files)
+                    output.stdout(`  ${file}\n`);
+                for (const hint of exported.registration)
+                    output.stdout(`  note: ${hint}\n`);
+                output.stdout('Registration and host callability remain unverified.\n');
+            }
+            return 0;
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (options.json) {
+                output.stdout(`${JSON.stringify({ ok: false, command: 'host', action: 'bundle', message })}\n`);
+            }
+            else {
+                output.stderr(`pappra host bundle: ${message}\n`);
+            }
+            return 1;
+        }
+    }
     const result = await service.verify(options.host, target);
     if (options.json) {
         output.stdout(`${JSON.stringify(result)}\n`);

package/dist/cli/commands/init.d.ts

@@ -32,6 +32,12 @@ export interface InitCommandOptions {
     readonly installRuntime?: boolean;
     readonly runtimeTarball?: string | null;
     readonly runtimeVersion?: string | null;
+    /** Derives deterministic selections from discovery instead of prompting. */
+    readonly yes?: boolean;
+    /** Prints the derived selections and writes nothing. */
+    readonly printChoices?: boolean;
+    /** Leaves the runtime action pending instead of installing a durable copy. */
+    readonly noRuntime?: boolean;
 }
 export interface RuntimeFlowResult {
     readonly ok: boolean;

package/dist/cli/commands/init.js

@@ -2,11 +2,12 @@ import { basename, resolve } from 'node:path';
 import * as prompts from '@clack/prompts';
 import { diagnosticCodes } from '../../schemas/errors.js';
 import { INIT_CHOICES_SCHEMA, parseInitChoices, } from '../../schemas/init.js';
-import { readTextFileBounded } from '../../infra/fs.js';
-import { getPackageInfo } from '../../package-info.js';
+import { observePath, readTextFileBounded } from '../../infra/fs.js';
+import { getPackageInfo, getPackageRoot } from '../../package-info.js';
 import { installRuntime, } from '../../install/runtime.js';
 import { updateMachineRuntime } from '../../install/apply.js';
-import { applyInitPlan, inspectInitContext, listKnowledgeCandidates, listRepositoryCandidates, planWorkspaceInit, } from '../../app/init.js';
+import { inspectMachineConfig } from '../../workspace/config.js';
+import { applyInitPlan, inspectInitContext, listKnowledgeCandidates, deriveInitChoices, listRepositoryCandidates, planWorkspaceInit, } from '../../app/init.js';
 export const clackWizardUi = {
     intro: (message) => prompts.intro(message),
     outro: (message) => prompts.outro(message),
@@ -249,6 +250,84 @@ function runtimeOptionsFailure(message, nextAction) {
         nextAction,
     };
 }
+async function bindAndRecordRuntime(root, installed) {
+    if (!installed.ok || installed.manifest === null) {
+        return {
+            ok: false,
+            completion: false,
+            runtime: installed,
+            diagnostics: installed.diagnostics,
+        };
+    }
+    const updated = await updateMachineRuntime(root, installed.manifest);
+    if (!updated.ok) {
+        return {
+            ok: false,
+            completion: false,
+            runtime: installed,
+            diagnostics: updated.diagnostics,
+        };
+    }
+    const followUp = await planWorkspaceInit({ root });
+    if (!followUp.ok) {
+        return {
+            ok: false,
+            completion: false,
+            runtime: installed,
+            diagnostics: followUp.diagnostics,
+        };
+    }
+    if (followUp.bundle.plan.files.length > 0 ||
+        followUp.bundle.plan.externalActions.length > 0) {
+        return {
+            ok: false,
+            completion: false,
+            runtime: installed,
+            diagnostics: [
+                {
+                    code: diagnosticCodes.initRuntimeSourceRequired,
+                    severity: 'error',
+                    message: 'Runtime installation succeeded but init still has pending file or external actions.',
+                    source: 'init runtime',
+                    pointer: null,
+                    hint: 'Run pappra init again to review the remaining plan; initialization is not complete.',
+                },
+            ],
+        };
+    }
+    return {
+        ok: true,
+        completion: true,
+        runtime: installed,
+        diagnostics: [],
+    };
+}
+/**
+ * Converges the runtime binding by installing a durable copy of the package that
+ * is currently executing. Reusing an already verified copy is cheap: the install
+ * machinery short-circuits before packing.
+ */
+async function ensureDefaultRuntime(root, targetVersion) {
+    const machine = await inspectMachineConfig(root);
+    const binding = machine.value?.runtime ?? null;
+    if (binding !== null && binding.version === targetVersion) {
+        const executable = await observePath(binding.executable);
+        if (executable.kind === 'file') {
+            return {
+                ok: true,
+                completion: true,
+                runtime: null,
+                diagnostics: [],
+            };
+        }
+    }
+    const installed = await installRuntime({
+        version: targetVersion,
+        source: { kind: 'self', path: getPackageRoot() },
+        packageName: getPackageInfo().name,
+    });
+    return bindAndRecordRuntime(root, installed);
+}
 async function installAndRecordRuntime(root, targetVersion, options) {
     const tarball = options.runtimeTarball ?? null;
     const requestedVersion = options.runtimeVersion ?? null;
@@ -385,6 +464,7 @@ function writeFailure(output, options, failure) {
             message: failure.message,
             nextAction: failure.nextAction,
             diagnostics: failure.diagnostics,
+            ...(failure.details ?? {}),
         })}\n`);
     }
     else {
@@ -520,7 +600,11 @@ function planJson(bundle) {
  * exactly one JSON document. Interactive selection is injected for tests.
  */
 export async function runInitCommand(options, output, deps = {}) {
+    const yes = options.yes === true;
+    const printChoices = options.printChoices === true;
     const interactive = !options.json &&
+        !yes &&
+        !printChoices &&
         options.configPath === null &&
         (deps.interactive ??
             (process.stdin.isTTY === true && process.stdout.isTTY === true));
@@ -542,29 +626,82 @@ export async function runInitCommand(options, output, deps = {}) {
         options.runtimeVersion !== undefined) {
         return writeFailure(output, options, runtimeOptionsFailure('Use either --runtime-tarball or --runtime-version, not both.', 'Choose one explicit runtime source.'));
     }
+    if (printChoices &&
+        (options.configPath !== null ||
+            options.apply ||
+            wantsRuntime ||
+            hasRuntimeSource)) {
+        return writeFailure(output, options, {
+            ok: false,
+            status: 'invalid',
+            code: diagnosticCodes.initInvalidInput,
+            message: '--print-choices cannot be combined with --config, --apply, or runtime flags.',
+            diagnostics: [],
+            nextAction: 'Run pappra init --print-choices on its own to print the derived selections.',
+        });
+    }
+    if (yes && options.configPath !== null) {
+        return writeFailure(output, options, {
+            ok: false,
+            status: 'invalid',
+            code: diagnosticCodes.initInvalidInput,
+            message: 'Use either --config or --yes, not both.',
+            diagnostics: [],
+            nextAction: 'Pass explicit selections with --config, or derive them with --yes.',
+        });
+    }
     const contextResult = await inspectInitContext(options.cwd);
     if (!contextResult.ok) {
         return writeFailure(output, options, contextResult);
     }
     const context = contextResult.context;
     let choices = null;
+    if (printChoices) {
+        const derived = await deriveInitChoices(context.discovery);
+        if (options.json) {
+            output.stdout(`${JSON.stringify({
+                ok: true,
+                command: 'init',
+                mode: 'choices',
+                choices: derived.choices,
+                rules: derived.rules,
+                candidates: derived.candidates,
+            })}\n`);
+        }
+        else {
+            output.stdout(`${JSON.stringify(derived.choices, null, 2)}\n`);
+            for (const rule of derived.rules) {
+                output.stderr(`  ${rule.field} = ${rule.value} (${rule.reason})\n`);
+            }
+        }
+        return 0;
+    }
     if (options.configPath !== null) {
         const loaded = await loadChoices(options.configPath);
         if (!loaded.ok)
             return writeFailure(output, options, loaded.failure);
         choices = loaded.choices;
     }
+    else if (yes) {
+        choices = (await deriveInitChoices(context.discovery)).choices;
+    }
     else {
         const needsChoices = context.discovery.configState !== 'valid' ||
             context.discovery.machineState !== 'valid';
         if (needsChoices && !interactive) {
+            const derived = await deriveInitChoices(context.discovery);
             return writeFailure(output, options, {
                 ok: false,
                 status: 'needs_input',
                 code: diagnosticCodes.initNoTty,
                 message: 'Missing init selections in a non-interactive session.',
                 diagnostics: context.diagnostics,
-                nextAction: 'Provide --config with pappra/init-choices/1, or run in a TTY for the interactive wizard.',
+                nextAction: 'Rerun with --yes to apply the derived selections, provide --config with pappra/init-choices/1, or run in a TTY for the interactive wizard.',
+                details: {
+                    candidates: derived.candidates,
+                    suggestedChoices: derived.choices,
+                    rules: derived.rules,
+                },
             });
         }
         if (needsChoices && interactive) {
@@ -592,13 +729,16 @@ export async function runInitCommand(options, output, deps = {}) {
             return 0;
         }
         const applied = await applyInitPlan(bundle);
-        const runtimeFlow = wantsRuntime && applied.ok && applied.residualPaths.length === 0
-            ? await installAndRecordRuntime(bundle.scope.workspaceRoot, bundle.scope.runtimeVersion, options)
+        const runtimeRequested = wantsRuntime || options.noRuntime !== true;
+        const runtimeFlow = runtimeRequested && applied.ok && applied.residualPaths.length === 0
+            ? wantsRuntime
+                ? await installAndRecordRuntime(bundle.scope.workspaceRoot, bundle.scope.runtimeVersion, options)
+                : await ensureDefaultRuntime(bundle.scope.workspaceRoot, bundle.scope.runtimeVersion)
             : null;
         const initComplete = runtimeFlow?.completion === true;
         const ok = applied.ok &&
             applied.residualPaths.length === 0 &&
-            (!wantsRuntime || (runtimeFlow?.ok === true && initComplete));
+            (!runtimeRequested || (runtimeFlow?.ok === true && initComplete));
         output.stdout(`${JSON.stringify({
             ok,
             command: 'init',
@@ -615,7 +755,7 @@ export async function runInitCommand(options, output, deps = {}) {
         })}\n`);
         if (!applied.ok || applied.residualPaths.length > 0)
             return 1;
-        if (wantsRuntime)
+        if (runtimeRequested)
             return ok ? 0 : 1;
         return applied.status === 'external-actions-pending' ? 1 : 0;
     }
@@ -632,7 +772,7 @@ export async function runInitCommand(options, output, deps = {}) {
         }
     }
     const applied = await applyInitPlan(bundle);
-    printApply(output, applied, wantsRuntime);
+    printApply(output, applied, wantsRuntime || options.noRuntime !== true);
     if (!applied.ok) {
         return applied.status === 'failed' ? 3 : 1;
     }
@@ -658,6 +798,24 @@ export async function runInitCommand(options, output, deps = {}) {
         output.stdout('Runtime installed and verified. Initialization complete for P04 scope; provider/index preferences were not executed.\n');
         return 0;
     }
+    if (options.noRuntime !== true) {
+        const runtimeFlow = await ensureDefaultRuntime(bundle.scope.workspaceRoot, bundle.scope.runtimeVersion);
+        if (runtimeFlow.runtime !== null) {
+            output.stdout(`Runtime: ${runtimeFlow.runtime.status} ${runtimeFlow.runtime.version}${runtimeFlow.runtime.runtimeRoot === null
+                ? ''
+                : ` at ${runtimeFlow.runtime.runtimeRoot}`}\n`);
+            if (runtimeFlow.runtime.residualPaths.length > 0) {
+                output.stderr(`Runtime residual paths: ${runtimeFlow.runtime.residualPaths.join(', ')}\n`);
+            }
+        }
+        if (!runtimeFlow.ok || !runtimeFlow.completion) {
+            output.stderr(`${diagnosticLines(runtimeFlow.diagnostics)}\n`);
+            output.stderr('The durable runtime copy could not be installed or bound. Initialization is not complete; --no-runtime leaves this action pending intentionally.\n');
+            return 1;
+        }
+        output.stdout('Durable runtime copy installed and bound. Initialization complete.\n');
+        return 0;
+    }
     return applied.status === 'external-actions-pending' ? 1 : 0;
 }
 export const initUsage = 'pappra init [--config <file>] [--apply] [--json]\n' +

package/dist/cli/commands/runtime.d.ts

@@ -0,0 +1,14 @@
+import type { CliOutput } from '../output.js';
+export declare const runtimeUsage: string;
+export interface RuntimeCommandOptions {
+    readonly cwd: string;
+    readonly action: 'install' | 'status' | 'verify' | 'remove' | null;
+    readonly json: boolean;
+    readonly from: 'self' | 'tarball' | 'registry' | null;
+    readonly tarball: string | null;
+    readonly version: string | null;
+    readonly apply: boolean;
+    readonly bind: boolean;
+    readonly force: boolean;
+}
+export declare function runRuntimeCommand(options: RuntimeCommandOptions, output: CliOutput): Promise<number>;